1 #include <string>\r
2 #include <vector>\r
3 \r
4 \r
5 namespace MiniDom\r
6 {\r
7 typedef std::string DOMString;\r
8 typedef unsigned int XMLCh;\r
9 \r
10 \r
11 class Namespace\r
12 {\r
13 public:\r
14 Namespace()\r
15 {}\r
16 \r
17 Namespace(const DOMString &prefixArg, const DOMString &namespaceURIArg)\r
18 {\r
19 prefix = prefixArg;\r
20 namespaceURI = namespaceURIArg;\r
21 }\r
22 \r
23 Namespace(const Namespace &other)\r
24 {\r
25 prefix = other.prefix;\r
26 namespaceURI = other.namespaceURI;\r
27 }\r
28 \r
29 virtual ~Namespace()\r
30 {}\r
31 \r
32 virtual DOMString getPrefix()\r
33 { return prefix; }\r
34 \r
35 virtual DOMString getNamespaceURI()\r
36 { return namespaceURI; }\r
37 \r
38 protected:\r
39 \r
40 DOMString prefix;\r
41 DOMString namespaceURI;\r
42 \r
43 };\r
44 \r
45 class Attribute\r
46 {\r
47 public:\r
48 Attribute()\r
49 {}\r
50 \r
51 Attribute(const DOMString &nameArg, const DOMString &valueArg)\r
52 {\r
53 name = nameArg;\r
54 value = valueArg;\r
55 }\r
56 \r
57 Attribute(const Attribute &other)\r
58 {\r
59 name = other.name;\r
60 value = other.value;\r
61 }\r
62 \r
63 virtual ~Attribute()\r
64 {}\r
65 \r
66 virtual DOMString getName()\r
67 { return name; }\r
68 \r
69 virtual DOMString getValue()\r
70 { return value; }\r
71 \r
72 protected:\r
73 \r
74 DOMString name;\r
75 DOMString value;\r
76 \r
77 };\r
78 \r
79 \r
80 class Element\r
81 {\r
82 friend class Parser;\r
83 \r
84 public:\r
85 Element()\r
86 {\r
87 parent = NULL;\r
88 }\r
89 \r
90 Element(const DOMString &nameArg)\r
91 {\r
92 parent = NULL;\r
93 name = nameArg;\r
94 }\r
95 \r
96 Element(const DOMString &nameArg, const DOMString &valueArg)\r
97 {\r
98 parent = NULL;\r
99 name = nameArg;\r
100 value = valueArg;\r
101 }\r
102 \r
103 Element(const Element &other)\r
104 {\r
105 parent = other.parent;\r
106 children = other.children;\r
107 attributes = other.attributes;\r
108 namespaces = other.namespaces;\r
109 name = other.name;\r
110 value = other.value;\r
111 }\r
112 \r
113 virtual ~Element()\r
114 {\r
115 for (int i=0 ; i<children.size() ; i++)\r
116 delete children[i];\r
117 }\r
118 \r
119 virtual DOMString getName()\r
120 { return name; }\r
121 \r
122 virtual DOMString getValue()\r
123 { return value; }\r
124 \r
125 Element *getParent()\r
126 { return parent; }\r
127 \r
128 std::vector<Element *> getChildren()\r
129 { return children; }\r
130 \r
131 std::vector<Element *> findElements(const DOMString &name);\r
132 \r
133 DOMString getAttribute(const DOMString &name);\r
134 \r
135 void addChild(Element *child);\r
136 \r
137 void addAttribute(const DOMString &name, const DOMString &value);\r
138 \r
139 void addNamespace(const DOMString &prefix, const DOMString &namespaceURI);\r
140 \r
141 \r
142 /**\r
143 * Prettyprint an XML tree to an output stream. Elements are indented\r
144 * according to element hierarchy.\r
145 * @param f a stream to receive the output\r
146 * @param elem the element to output\r
147 */\r
148 void writeIndented(FILE *f);\r
149 \r
150 /**\r
151 * Prettyprint an XML tree to standard output. This is the equivalent of\r
152 * writeIndented(stdout).\r
153 * @param elem the element to output\r
154 */\r
155 void print();\r
156 \r
157 protected:\r
158 \r
159 \r
160 void findElementsRecursive(std::vector<Element *>&res, const DOMString &name);\r
161 \r
162 void writeIndentedRecursive(FILE *f, int indent);\r
163 \r
164 Element *parent;\r
165 \r
166 std::vector<Element *>children;\r
167 \r
168 std::vector<Attribute> attributes;\r
169 std::vector<Namespace> namespaces;\r
170 \r
171 DOMString name;\r
172 DOMString value;\r
173 \r
174 };\r
175 \r
176 \r
177 \r
178 \r
179 \r
180 class Parser\r
181 {\r
182 public:\r
183 Parser()\r
184 { init(); }\r
185 \r
186 virtual ~Parser()\r
187 {}\r
188 \r
189 /**\r
190 * Parse XML in a char buffer.\r
191 * @param buf a character buffer to parse\r
192 * @param pos position to start parsing\r
193 * @param len number of chars, from pos, to parse.\r
194 * @return a pointer to the root of the XML document;\r
195 */\r
196 Element *parse(const char *buf,int pos,int len);\r
197 \r
198 /**\r
199 * Parse XML in a char buffer.\r
200 * @param buf a character buffer to parse\r
201 * @param pos position to start parsing\r
202 * @param len number of chars, from pos, to parse.\r
203 * @return a pointer to the root of the XML document;\r
204 */\r
205 Element *parse(const DOMString &buf);\r
206 \r
207 /**\r
208 * Parse a named XML file. The file is loaded like a data file;\r
209 * the original format is not preserved.\r
210 * @param fileName the name of the file to read\r
211 * @return a pointer to the root of the XML document;\r
212 */\r
213 Element *parseFile(const char *fileName);\r
214 \r
215 \r
216 \r
217 \r
218 private:\r
219 \r
220 void init()\r
221 {\r
222 keepGoing = true;\r
223 currentNode = NULL;\r
224 parselen = 0;\r
225 parsebuf = NULL;\r
226 currentPosition = 0;\r
227 }\r
228 \r
229 void getLineAndColumn(long pos, long *lineNr, long *colNr);\r
230 \r
231 void error(char *fmt, ...);\r
232 \r
233 int peek(long pos);\r
234 \r
235 int match(long pos, const char *text);\r
236 \r
237 int skipwhite(long p);\r
238 \r
239 int getWord(int p0, DOMString &buf);\r
240 \r
241 int getQuoted(int p0, DOMString &buf, int do_i_parse);\r
242 \r
243 int parseVersion(int p0);\r
244 \r
245 int parseDoctype(int p0);\r
246 \r
247 int parseElement(int p0, Element *par,int depth);\r
248 \r
249 Element *parse(XMLCh *buf,int pos,int len);\r
250 \r
251 bool keepGoing;\r
252 Element *currentNode;\r
253 long parselen;\r
254 XMLCh *parsebuf;\r
255 DOMString cdatabuf;\r
256 long currentPosition;\r
257 int colNr;\r
258 \r
259 \r
260 };\r
261 \r
262 \r
263 \r
264 }//namespace MiniDom\r
265 \r
266 \r
267 //########################################################################\r
268 //# E N D O F F I L E\r
269 //########################################################################\r
270 \r