A fork of https://github.com/crosspoint-reader/crosspoint-reader
refactor: Added shared XML parser teardown helper (#1438)
## Summary
**What is the goal of this PR?**
Added `destroyXmlParser()` helper to replace the repeated 4-line parser
cleanup block (stop, clear callbacks, free, null) that was copyied
across 6 XML parser files.
---
### AI Usage
While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.
Did you use AI tools to help write this code? _**PARTIALLY**_
authored by
Zach Nelson
and committed by
GitHub
ce1756e3
3b12c083
+48
-94
+11
-18
lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
+11
-18
lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
···
5
5
#include <HalStorage.h>
6
6
#include <Logging.h>
7
7
#include <Utf8.h>
8
+
#include <XmlParserUtils.h>
8
9
#include <expat.h>
9
10
10
11
#include "../../Epub.h"
···
996
997
paragraphAlignmentBlockStyle.alignment = align;
997
998
startNewTextBlock(paragraphAlignmentBlockStyle);
998
999
999
-
const XML_Parser parser = XML_ParserCreate(nullptr);
1000
+
XML_Parser parser = XML_ParserCreate(nullptr);
1000
1001
int done;
1001
1002
1002
1003
if (!parser) {
···
1010
1011
1011
1012
FsFile file;
1012
1013
if (!Storage.openFileForRead("EHP", filepath, file)) {
1013
-
XML_ParserFree(parser);
1014
+
destroyXmlParser(parser);
1014
1015
return false;
1015
1016
}
1016
1017
···
1029
1030
void* const buf = XML_GetBuffer(parser, PARSE_BUFFER_SIZE);
1030
1031
if (!buf) {
1031
1032
LOG_ERR("EHP", "Couldn't allocate memory for buffer");
1032
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
1033
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
1034
-
XML_SetCharacterDataHandler(parser, nullptr);
1035
-
XML_ParserFree(parser);
1033
+
destroyXmlParser(parser);
1034
+
file.close();
1036
1035
return false;
1037
1036
}
1038
1037
···
1040
1039
1041
1040
if (len == 0 && file.available() > 0) {
1042
1041
LOG_ERR("EHP", "File read error");
1043
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
1044
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
1045
-
XML_SetCharacterDataHandler(parser, nullptr);
1046
-
XML_ParserFree(parser);
1042
+
destroyXmlParser(parser);
1043
+
file.close();
1047
1044
return false;
1048
1045
}
1049
1046
···
1052
1049
if (XML_ParseBuffer(parser, static_cast<int>(len), done) == XML_STATUS_ERROR) {
1053
1050
LOG_ERR("EHP", "Parse error at line %lu:\n%s", XML_GetCurrentLineNumber(parser),
1054
1051
XML_ErrorString(XML_GetErrorCode(parser)));
1055
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
1056
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
1057
-
XML_SetCharacterDataHandler(parser, nullptr);
1058
-
XML_ParserFree(parser);
1052
+
destroyXmlParser(parser);
1053
+
file.close();
1059
1054
return false;
1060
1055
}
1061
1056
} while (!done);
1062
1057
LOG_DBG("EHP", "Time to parse and build pages: %lu ms", millis() - chapterStartTime);
1063
1058
1064
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
1065
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
1066
-
XML_SetCharacterDataHandler(parser, nullptr);
1067
-
XML_ParserFree(parser);
1059
+
destroyXmlParser(parser);
1060
+
file.close();
1068
1061
1069
1062
// Process last page if there is still text
1070
1063
if (currentTextBlock) {
+4
-8
lib/Epub/Epub/parsers/ContainerParser.cpp
+4
-8
lib/Epub/Epub/parsers/ContainerParser.cpp
···
1
1
#include "ContainerParser.h"
2
2
3
3
#include <Logging.h>
4
+
#include <XmlParserUtils.h>
4
5
5
6
bool ContainerParser::setup() {
6
7
parser = XML_ParserCreate(nullptr);
···
14
15
return true;
15
16
}
16
17
17
-
ContainerParser::~ContainerParser() {
18
-
if (parser) {
19
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
20
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
21
-
XML_ParserFree(parser);
22
-
parser = nullptr;
23
-
}
24
-
}
18
+
ContainerParser::~ContainerParser() { destroyXmlParser(parser); }
25
19
26
20
size_t ContainerParser::write(const uint8_t data) { return write(&data, 1); }
27
21
···
35
29
void* const buf = XML_GetBuffer(parser, 1024);
36
30
if (!buf) {
37
31
LOG_DBG("CTR", "Couldn't allocate buffer");
32
+
destroyXmlParser(parser);
38
33
return 0;
39
34
}
40
35
···
43
38
44
39
if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
45
40
LOG_ERR("CTR", "Parse error: %s", XML_ErrorString(XML_GetErrorCode(parser)));
41
+
destroyXmlParser(parser);
46
42
return 0;
47
43
}
48
44
+4
-17
lib/Epub/Epub/parsers/ContentOpfParser.cpp
+4
-17
lib/Epub/Epub/parsers/ContentOpfParser.cpp
···
3
3
#include <FsHelpers.h>
4
4
#include <Logging.h>
5
5
#include <Serialization.h>
6
+
#include <XmlParserUtils.h>
6
7
7
8
#include "../BookMetadataCache.h"
8
9
···
26
27
}
27
28
28
29
ContentOpfParser::~ContentOpfParser() {
29
-
if (parser) {
30
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
31
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
32
-
XML_SetCharacterDataHandler(parser, nullptr);
33
-
XML_ParserFree(parser);
34
-
parser = nullptr;
35
-
}
30
+
destroyXmlParser(parser);
36
31
if (tempItemStore) {
37
32
tempItemStore.close();
38
33
}
···
55
50
56
51
if (!buf) {
57
52
LOG_ERR("COF", "Couldn't allocate memory for buffer");
58
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
59
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
60
-
XML_SetCharacterDataHandler(parser, nullptr);
61
-
XML_ParserFree(parser);
62
-
parser = nullptr;
53
+
destroyXmlParser(parser);
63
54
return 0;
64
55
}
65
56
···
69
60
if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
70
61
LOG_DBG("COF", "Parse error at line %lu: %s", XML_GetCurrentLineNumber(parser),
71
62
XML_ErrorString(XML_GetErrorCode(parser)));
72
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
73
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
74
-
XML_SetCharacterDataHandler(parser, nullptr);
75
-
XML_ParserFree(parser);
76
-
parser = nullptr;
63
+
destroyXmlParser(parser);
77
64
return 0;
78
65
}
79
66
+4
-19
lib/Epub/Epub/parsers/TocNcxParser.cpp
+4
-19
lib/Epub/Epub/parsers/TocNcxParser.cpp
···
2
2
3
3
#include <FsHelpers.h>
4
4
#include <Logging.h>
5
+
#include <XmlParserUtils.h>
5
6
6
7
#include "../BookMetadataCache.h"
7
8
···
18
19
return true;
19
20
}
20
21
21
-
TocNcxParser::~TocNcxParser() {
22
-
if (parser) {
23
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
24
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
25
-
XML_SetCharacterDataHandler(parser, nullptr);
26
-
XML_ParserFree(parser);
27
-
parser = nullptr;
28
-
}
29
-
}
22
+
TocNcxParser::~TocNcxParser() { destroyXmlParser(parser); }
30
23
31
24
size_t TocNcxParser::write(const uint8_t data) { return write(&data, 1); }
32
25
···
40
33
void* const buf = XML_GetBuffer(parser, 1024);
41
34
if (!buf) {
42
35
LOG_DBG("TOC", "Couldn't allocate memory for buffer");
43
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
44
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
45
-
XML_SetCharacterDataHandler(parser, nullptr);
46
-
XML_ParserFree(parser);
47
-
parser = nullptr;
36
+
destroyXmlParser(parser);
48
37
return 0;
49
38
}
50
39
···
54
43
if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
55
44
LOG_DBG("TOC", "Parse error at line %lu: %s", XML_GetCurrentLineNumber(parser),
56
45
XML_ErrorString(XML_GetErrorCode(parser)));
57
-
XML_StopParser(parser, XML_FALSE); // Stop any pending processing
58
-
XML_SetElementHandler(parser, nullptr, nullptr); // Clear callbacks
59
-
XML_SetCharacterDataHandler(parser, nullptr);
60
-
XML_ParserFree(parser);
61
-
parser = nullptr;
46
+
destroyXmlParser(parser);
62
47
return 0;
63
48
}
64
49
+8
-13
lib/OpdsParser/OpdsParser.cpp
+8
-13
lib/OpdsParser/OpdsParser.cpp
···
1
1
#include "OpdsParser.h"
2
2
3
3
#include <Logging.h>
4
+
#include <XmlParserUtils.h>
4
5
5
6
#include <cstring>
6
7
···
12
13
}
13
14
}
14
15
15
-
OpdsParser::~OpdsParser() {
16
-
if (parser) {
17
-
XML_StopParser(parser, XML_FALSE);
18
-
XML_SetElementHandler(parser, nullptr, nullptr);
19
-
XML_SetCharacterDataHandler(parser, nullptr);
20
-
XML_ParserFree(parser);
21
-
parser = nullptr;
22
-
}
23
-
}
16
+
OpdsParser::~OpdsParser() { destroyXmlParser(parser); }
24
17
25
18
size_t OpdsParser::write(uint8_t c) { return write(&c, 1); }
26
19
···
39
32
void* const buf = XML_GetBuffer(parser, chunkSize);
40
33
if (!buf) {
41
34
errorOccured = true;
42
-
XML_ParserFree(parser);
35
+
LOG_DBG("OPDS", "Couldn't allocate memory for buffer");
36
+
destroyXmlParser(parser);
43
37
return length;
44
38
}
45
39
···
48
42
49
43
if (XML_ParseBuffer(parser, static_cast<int>(toRead), 0) == XML_STATUS_ERROR) {
50
44
errorOccured = true;
51
-
XML_ParserFree(parser);
45
+
LOG_DBG("OPDS", "Parse error at line %lu: %s", XML_GetCurrentLineNumber(parser),
46
+
XML_ErrorString(XML_GetErrorCode(parser)));
47
+
destroyXmlParser(parser);
52
48
return length;
53
49
}
54
50
currentPos += toRead;
···
60
56
void OpdsParser::flush() {
61
57
if (XML_Parse(parser, nullptr, 0, XML_TRUE) != XML_STATUS_OK) {
62
58
errorOccured = true;
63
-
XML_ParserFree(parser);
64
-
parser = nullptr;
59
+
destroyXmlParser(parser);
65
60
}
66
61
}
67
62
+13
lib/XmlParserUtils/XmlParserUtils.h
+13
lib/XmlParserUtils/XmlParserUtils.h
···
1
+
#pragma once
2
+
3
+
#include <expat.h>
4
+
5
+
// Safely tear down an expat parser: stop processing, clear callbacks, free, and null the pointer.
6
+
inline void destroyXmlParser(XML_Parser& parser) {
7
+
if (!parser) return;
8
+
XML_StopParser(parser, XML_FALSE);
9
+
XML_SetElementHandler(parser, nullptr, nullptr);
10
+
XML_SetCharacterDataHandler(parser, nullptr);
11
+
XML_ParserFree(parser);
12
+
parser = nullptr;
13
+
}