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 class ZxNode {
30 public:
31 
32   ZxNode();
33   virtual ~ZxNode();
34 
isDoc()35   virtual bool isDoc() { return false; }
isXMLDecl()36   virtual bool isXMLDecl()  { return false; }
isDocTypeDecl()37   virtual bool isDocTypeDecl() { return false; }
isComment()38   virtual bool isComment() { return false; }
isPI()39   virtual bool isPI() { return false; }
isElement()40   virtual bool isElement() { return false; }
isElement(const char * type)41   virtual bool isElement(const char *type) { return false; }
isCharData()42   virtual bool isCharData() { return false; }
getFirstChild()43   virtual ZxNode *getFirstChild() { return firstChild; }
getNextChild()44   virtual ZxNode *getNextChild() { return next; }
45   ZxElement *findFirstElement(const char *type);
46   ZxElement *findFirstChildElement(const char *type);
47   GList *findAllElements(const char *type);
48   GList *findAllChildElements(const char *type);
49   virtual void addChild(ZxNode *child);
50 
51 protected:
52 
53   void findAllElements(const char *type, GList *results);
54 
55   ZxNode *next;
56   ZxNode *parent;
57   ZxNode *firstChild,
58          *lastChild;
59 };
60 
61 //------------------------------------------------------------------------
62 
63 class ZxDoc: public ZxNode {
64 public:
65 
66   ZxDoc();
67 
68   // Parse from memory.  Returns NULL on error.
69   static ZxDoc *loadMem(const char *data, Guint dataLen);
70 
71   // Parse from disk.  Returns NULL on error.
72   static ZxDoc *loadFile(const char *fileName);
73 
74   virtual ~ZxDoc();
75 
isDoc()76   virtual bool isDoc() { return true; }
getXMLDecl()77   ZxXMLDecl *getXMLDecl() { return xmlDecl; }
getDocTypeDecl()78   ZxDocTypeDecl *getDocTypeDecl() { return docTypeDecl; }
getRoot()79   ZxElement *getRoot() { return root; }
80   virtual void addChild(ZxNode *node);
81 
82 private:
83 
84   bool parse(const char *data, Guint dataLen);
85   void parseXMLDecl(ZxNode *par);
86   void parseDocTypeDecl(ZxNode *par);
87   void parseElement(ZxNode *par);
88   ZxAttr *parseAttr();
89   void parseContent(ZxElement *par);
90   void parseCharData(ZxElement *par);
91   void appendUTF8(GString *s, int c);
92   void parseCDSect(ZxNode *par);
93   void parseMisc(ZxNode *par);
94   void parseComment(ZxNode *par);
95   void parsePI(ZxNode *par);
96   GString *parseName();
97   GString *parseQuotedString();
98   void parseSpace();
99   bool match(const char *s);
100 
101   ZxXMLDecl *xmlDecl;		// may be NULL
102   ZxDocTypeDecl *docTypeDecl;	// may be NULL
103   ZxElement *root;		// may be NULL
104 
105   const char *parsePtr;
106   const char *parseEnd;
107 };
108 
109 //------------------------------------------------------------------------
110 
111 class ZxXMLDecl: public ZxNode {
112 public:
113 
114   ZxXMLDecl(GString *versionA, GString *encodingA, bool standaloneA);
115   virtual ~ZxXMLDecl();
116 
isXMLDecl()117   virtual bool isXMLDecl() { return true; }
getVersion()118   GString *getVersion() { return version; }
getEncoding()119   GString *getEncoding() { return encoding; }
getStandalone()120   bool getStandalone() { return standalone; }
121 
122 private:
123 
124   GString *version;
125   GString *encoding;		// may be NULL
126   bool standalone;
127 };
128 
129 //------------------------------------------------------------------------
130 
131 class ZxDocTypeDecl: public ZxNode {
132 public:
133 
134   ZxDocTypeDecl(GString *nameA);
135   virtual ~ZxDocTypeDecl();
136 
isDocTypeDecl()137   virtual bool isDocTypeDecl() { return true; }
getName()138   GString *getName() { return name; }
139 
140 private:
141 
142   GString *name;
143 };
144 
145 //------------------------------------------------------------------------
146 
147 class ZxComment: public ZxNode {
148 public:
149 
150   ZxComment(GString *textA);
151   virtual ~ZxComment();
152 
isComment()153   virtual bool isComment() { return true; }
getText()154   GString *getText() { return text; }
155 
156 private:
157 
158   GString *text;
159 };
160 
161 //------------------------------------------------------------------------
162 
163 class ZxPI: public ZxNode {
164 public:
165 
166   ZxPI(GString *targetA, GString *textA);
167   virtual ~ZxPI();
168 
isPI()169   virtual bool isPI() { return true; }
getTarget()170   GString *getTarget() { return target; }
getText()171   GString *getText() { return text; }
172 
173 private:
174 
175   GString *target;
176   GString *text;
177 };
178 
179 //------------------------------------------------------------------------
180 
181 class ZxElement: public ZxNode {
182 public:
183 
184   ZxElement(GString *typeA);
185   virtual ~ZxElement();
186 
isElement()187   virtual bool isElement() { return true; }
188   virtual bool isElement(const char *typeA);
getType()189   GString *getType() { return type; }
190   ZxAttr *findAttr(const char *attrName);
getFirstAttr()191   ZxAttr *getFirstAttr() { return firstAttr; }
192   void addAttr(ZxAttr *attr);
193 
194 private:
195 
196   GString *type;
197   GHash *attrs;			// [ZxAttr]
198   ZxAttr *firstAttr, *lastAttr;
199 };
200 
201 //------------------------------------------------------------------------
202 
203 class ZxAttr {
204 public:
205 
206   ZxAttr(GString *nameA, GString *valueA);
207   ~ZxAttr();
208 
getName()209   GString *getName() { return name; }
getValue()210   GString *getValue() { return value; }
getNextAttr()211   ZxAttr *getNextAttr() { return next; }
212 
213 private:
214 
215   GString *name;
216   GString *value;
217   ZxElement *parent;
218   ZxAttr *next;
219 
220   friend class ZxElement;
221 };
222 
223 //------------------------------------------------------------------------
224 
225 class ZxCharData: public ZxNode {
226 public:
227 
228   ZxCharData(GString *dataA, bool parsedA);
229   virtual ~ZxCharData();
230 
isCharData()231   virtual bool isCharData() { return true; }
getData()232   GString *getData() { return data; }
isParsed()233   bool isParsed() { return parsed; }
234 
235 private:
236 
237   GString *data;		// in UTF-8 format
238   bool parsed;
239 };
240 
241 #endif
242