/src/xpdf-4.04/xpdf/Zoox.h
Line | Count | Source (jump to first uncovered line) |
1 | | //======================================================================== |
2 | | // |
3 | | // Zoox.h |
4 | | // |
5 | | //======================================================================== |
6 | | |
7 | | #ifndef ZOOX_H |
8 | | #define ZOOX_H |
9 | | |
10 | | #include <aconf.h> |
11 | | |
12 | | #ifdef USE_GCC_PRAGMAS |
13 | | #pragma interface |
14 | | #endif |
15 | | |
16 | | #include "gtypes.h" |
17 | | |
18 | | class GString; |
19 | | class GList; |
20 | | class GHash; |
21 | | |
22 | | class ZxAttr; |
23 | | class ZxDocTypeDecl; |
24 | | class ZxElement; |
25 | | class ZxXMLDecl; |
26 | | |
27 | | //------------------------------------------------------------------------ |
28 | | |
29 | | typedef bool (*ZxWriteFunc)(void *stream, const char *data, int length); |
30 | | |
31 | | //------------------------------------------------------------------------ |
32 | | |
33 | | class ZxNode { |
34 | | public: |
35 | | |
36 | | ZxNode(); |
37 | | virtual ~ZxNode(); |
38 | | |
39 | 0 | virtual bool isDoc() { return false; } |
40 | 4.09k | virtual bool isXMLDecl() { return false; } |
41 | 3.84k | virtual bool isDocTypeDecl() { return false; } |
42 | 0 | virtual bool isComment() { return false; } |
43 | 0 | virtual bool isPI() { return false; } |
44 | 1.27k | virtual bool isElement() { return false; } |
45 | 0 | virtual bool isElement(const char *type) { return false; } |
46 | 0 | virtual bool isCharData() { return false; } |
47 | 0 | virtual ZxNode *getFirstChild() { return firstChild; } |
48 | 0 | virtual ZxNode *getNextChild() { return next; } |
49 | | ZxNode *getParent() { return parent; } |
50 | | ZxNode *deleteChild(ZxNode *child); |
51 | | void appendChild(ZxNode *child); |
52 | | void insertChildAfter(ZxNode *child, ZxNode *prev); |
53 | | ZxElement *findFirstElement(const char *type); |
54 | | ZxElement *findFirstChildElement(const char *type); |
55 | | GList *findAllElements(const char *type); |
56 | | GList *findAllChildElements(const char *type); |
57 | | virtual void addChild(ZxNode *child); |
58 | | |
59 | | virtual bool write(ZxWriteFunc writeFunc, void *stream) = 0; |
60 | | |
61 | | protected: |
62 | | |
63 | | void findAllElements(const char *type, GList *results); |
64 | | |
65 | | ZxNode *next; |
66 | | ZxNode *parent; |
67 | | ZxNode *firstChild, |
68 | | *lastChild; |
69 | | }; |
70 | | |
71 | | //------------------------------------------------------------------------ |
72 | | |
73 | | class ZxDoc: public ZxNode { |
74 | | public: |
75 | | |
76 | | ZxDoc(); |
77 | | |
78 | | // Parse from memory. Returns NULL on error. |
79 | | static ZxDoc *loadMem(const char *data, Guint dataLen); |
80 | | |
81 | | // Parse from disk. Returns NULL on error. |
82 | | static ZxDoc *loadFile(const char *fileName); |
83 | | |
84 | | virtual ~ZxDoc(); |
85 | | |
86 | | // Write to disk. Returns false on error. |
87 | | bool writeFile(const char *fileName); |
88 | | |
89 | 0 | virtual bool isDoc() { return true; } |
90 | | ZxXMLDecl *getXMLDecl() { return xmlDecl; } |
91 | | ZxDocTypeDecl *getDocTypeDecl() { return docTypeDecl; } |
92 | | ZxElement *getRoot() { return root; } |
93 | | virtual void addChild(ZxNode *node); |
94 | | |
95 | | virtual bool write(ZxWriteFunc writeFunc, void *stream); |
96 | | |
97 | | private: |
98 | | |
99 | | bool parse(const char *data, Guint dataLen); |
100 | | void parseXMLDecl(ZxNode *par); |
101 | | void parseDocTypeDecl(ZxNode *par); |
102 | | void parseElement(ZxNode *par); |
103 | | ZxAttr *parseAttr(); |
104 | | void parseContent(ZxElement *par); |
105 | | void parseCharData(ZxElement *par); |
106 | | void appendUTF8(GString *s, unsigned int c); |
107 | | void parseCDSect(ZxNode *par); |
108 | | void parseMisc(ZxNode *par); |
109 | | void parseComment(ZxNode *par); |
110 | | void parsePI(ZxNode *par); |
111 | | GString *parseName(); |
112 | | GString *parseQuotedString(); |
113 | | void parseSpace(); |
114 | | bool match(const char *s); |
115 | | |
116 | | ZxXMLDecl *xmlDecl; // may be NULL |
117 | | ZxDocTypeDecl *docTypeDecl; // may be NULL |
118 | | ZxElement *root; // may be NULL |
119 | | |
120 | | const char *parsePtr; |
121 | | const char *parseEnd; |
122 | | }; |
123 | | |
124 | | //------------------------------------------------------------------------ |
125 | | |
126 | | class ZxXMLDecl: public ZxNode { |
127 | | public: |
128 | | |
129 | | ZxXMLDecl(GString *versionA, GString *encodingA, bool standaloneA); |
130 | | virtual ~ZxXMLDecl(); |
131 | | |
132 | 829 | virtual bool isXMLDecl() { return true; } |
133 | | GString *getVersion() { return version; } |
134 | | GString *getEncoding() { return encoding; } |
135 | | bool getStandalone() { return standalone; } |
136 | | |
137 | | virtual bool write(ZxWriteFunc writeFunc, void *stream); |
138 | | |
139 | | private: |
140 | | |
141 | | GString *version; |
142 | | GString *encoding; // may be NULL |
143 | | bool standalone; |
144 | | }; |
145 | | |
146 | | //------------------------------------------------------------------------ |
147 | | |
148 | | class ZxDocTypeDecl: public ZxNode { |
149 | | public: |
150 | | |
151 | | ZxDocTypeDecl(GString *nameA); |
152 | | virtual ~ZxDocTypeDecl(); |
153 | | |
154 | 253 | virtual bool isDocTypeDecl() { return true; } |
155 | | GString *getName() { return name; } |
156 | | |
157 | | virtual bool write(ZxWriteFunc writeFunc, void *stream); |
158 | | |
159 | | private: |
160 | | |
161 | | GString *name; |
162 | | }; |
163 | | |
164 | | //------------------------------------------------------------------------ |
165 | | |
166 | | class ZxComment: public ZxNode { |
167 | | public: |
168 | | |
169 | | ZxComment(GString *textA); |
170 | | virtual ~ZxComment(); |
171 | | |
172 | 0 | virtual bool isComment() { return true; } |
173 | | GString *getText() { return text; } |
174 | | |
175 | | virtual bool write(ZxWriteFunc writeFunc, void *stream); |
176 | | |
177 | | private: |
178 | | |
179 | | GString *text; |
180 | | }; |
181 | | |
182 | | //------------------------------------------------------------------------ |
183 | | |
184 | | class ZxPI: public ZxNode { |
185 | | public: |
186 | | |
187 | | ZxPI(GString *targetA, GString *textA); |
188 | | virtual ~ZxPI(); |
189 | | |
190 | 0 | virtual bool isPI() { return true; } |
191 | | GString *getTarget() { return target; } |
192 | | GString *getText() { return text; } |
193 | | |
194 | | virtual bool write(ZxWriteFunc writeFunc, void *stream); |
195 | | |
196 | | private: |
197 | | |
198 | | GString *target; |
199 | | GString *text; |
200 | | }; |
201 | | |
202 | | //------------------------------------------------------------------------ |
203 | | |
204 | | class ZxElement: public ZxNode { |
205 | | public: |
206 | | |
207 | | ZxElement(GString *typeA); |
208 | | virtual ~ZxElement(); |
209 | | |
210 | 2.56k | virtual bool isElement() { return true; } |
211 | | virtual bool isElement(const char *typeA); |
212 | 1.09M | GString *getType() { return type; } |
213 | | ZxAttr *findAttr(const char *attrName); |
214 | | ZxAttr *getFirstAttr() { return firstAttr; } |
215 | | void addAttr(ZxAttr *attr); |
216 | | |
217 | | virtual bool write(ZxWriteFunc writeFunc, void *stream); |
218 | | |
219 | | private: |
220 | | |
221 | | void appendEscapedAttrValue(GString *out, GString *s); |
222 | | |
223 | | GString *type; |
224 | | GHash *attrs; // [ZxAttr] |
225 | | ZxAttr *firstAttr, *lastAttr; |
226 | | }; |
227 | | |
228 | | //------------------------------------------------------------------------ |
229 | | |
230 | | class ZxAttr { |
231 | | public: |
232 | | |
233 | | ZxAttr(GString *nameA, GString *valueA); |
234 | | ~ZxAttr(); |
235 | | |
236 | 851k | GString *getName() { return name; } |
237 | | GString *getValue() { return value; } |
238 | 0 | ZxAttr *getNextAttr() { return next; } |
239 | | ZxNode *getParent() { return parent; } |
240 | | |
241 | | private: |
242 | | |
243 | | GString *name; |
244 | | GString *value; |
245 | | ZxElement *parent; |
246 | | ZxAttr *next; |
247 | | |
248 | | friend class ZxElement; |
249 | | }; |
250 | | |
251 | | //------------------------------------------------------------------------ |
252 | | |
253 | | class ZxCharData: public ZxNode { |
254 | | public: |
255 | | |
256 | | ZxCharData(GString *dataA, bool parsedA); |
257 | | virtual ~ZxCharData(); |
258 | | |
259 | 0 | virtual bool isCharData() { return true; } |
260 | | GString *getData() { return data; } |
261 | | bool isParsed() { return parsed; } |
262 | | |
263 | | virtual bool write(ZxWriteFunc writeFunc, void *stream); |
264 | | |
265 | | private: |
266 | | |
267 | | GString *data; // in UTF-8 format |
268 | | bool parsed; |
269 | | }; |
270 | | |
271 | | #endif |