1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#ifndef XML_PARSER_H
#define XML_PARSER_H
#include "common/scummsys.h"
#include "graphics/surface.h"
#include "common/system.h"
#include "common/xmlparser.h"
#include "common/stream.h"
#include "common/file.h"
#include "common/fs.h"
#include "common/hashmap.h"
#include "common/hash-str.h"
#include "common/stack.h"
namespace Common {
/*
XMLParser.cpp/h -- Generic XML Parser
=====================================
External documentation available at:
http://www.smartlikearoboc.com/scummvm_doc/xmlparser_doc.html
*/
#define MAX_XML_DEPTH 8
#define XML_KEY(keyName) {\
lay = new CustomXMLKeyLayout;\
lay->callback = (&kLocalParserName::parserCallback_##keyName);\
layout.top()->children[#keyName] = lay;\
layout.push(lay); \
_layoutList.push_back(lay);\
for (Common::List<XMLKeyLayout::XMLKeyProperty>::const_iterator p = globalProps.begin(); p != globalProps.end(); ++p){\
layout.top()->properties.push_back(*p);}
#define XML_KEY_RECURSIVE(keyName) {\
layout.top()->children[#keyName] = layout.top();\
layout.push(layout.top());\
}
#define KEY_END() layout.pop(); }
#define XML_PROP(propName, req) {\
prop.name = #propName; \
prop.required = req; \
layout.top()->properties.push_back(prop); }
#define XML_GLOBAL_PROP(propName, req) {\
prop.name = #propName; \
prop.required = req;\
globalProps.push_back(prop); }
#define CUSTOM_XML_PARSER(parserName) \
protected: \
typedef parserName kLocalParserName; \
bool keyCallback(ParserNode *node) {return node->layout->doCallback(this, node); }\
struct CustomXMLKeyLayout : public XMLKeyLayout {\
typedef bool (parserName::*ParserCallback)(ParserNode *node);\
ParserCallback callback;\
bool doCallback(XMLParser *parent, ParserNode *node) {return ((kLocalParserName*)parent->*callback)(node);} };\
virtual void buildLayout() { \
Common::Stack<XMLKeyLayout*> layout; \
CustomXMLKeyLayout *lay = 0; \
XMLKeyLayout::XMLKeyProperty prop; \
Common::List<XMLKeyLayout::XMLKeyProperty> globalProps; \
_XMLkeys = new CustomXMLKeyLayout; \
layout.push(_XMLkeys);
#define PARSER_END() layout.clear(); }
/**
* The base XMLParser class implements generic functionality for parsing
* XML-like files.
*
* In order to use it, it must be inherited with a child class that implements
* the XMLParser::keyCallback() function.
*
* @see XMLParser::keyCallback()
*/
class XMLParser {
static const int kErrorMessageWidth = 512;
public:
/**
* Parser constructor.
*/
XMLParser() : _XMLkeys(0), _stream(0) {}
virtual ~XMLParser() {
while (!_activeKey.empty())
freeNode(_activeKey.pop());
delete _XMLkeys;
delete _stream;
for (Common::List<XMLKeyLayout*>::iterator i = _layoutList.begin();
i != _layoutList.end(); ++i)
delete *i;
_layoutList.clear();
}
/** Active state for the parser */
enum ParserState {
kParserNeedHeader,
kParserNeedKey,
kParserNeedKeyName,
kParserNeedPropertyName,
kParserNeedPropertyOperator,
kParserNeedPropertyValue,
kParserError
};
struct XMLKeyLayout;
struct ParserNode;
typedef Common::HashMap<Common::String, XMLParser::XMLKeyLayout*, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> ChildMap;
/** nested struct representing the layout of the XML file */
struct XMLKeyLayout {
struct XMLKeyProperty {
Common::String name;
bool required;
};
Common::List<XMLKeyProperty> properties;
ChildMap children;
virtual bool doCallback(XMLParser *parent, ParserNode *node) = 0;
virtual ~XMLKeyLayout() {
properties.clear();
}
} *_XMLkeys;
/** Struct representing a parsed node */
struct ParserNode {
Common::String name;
Common::StringMap values;
bool ignore;
bool header;
int depth;
XMLKeyLayout *layout;
};
ObjectPool<ParserNode, MAX_XML_DEPTH> _nodePool;
ParserNode *allocNode() {
return new (_nodePool) ParserNode;
}
void freeNode(ParserNode *node) {
_nodePool.deleteChunk(node);
}
/**
* Loads a file into the parser.
* Used for the loading of Theme Description files
* straight from the filesystem.
*
* @param filename Name of the file to load.
*/
bool loadFile(const Common::String &filename) {
_stream = SearchMan.openFile(filename);
if (!_stream)
return false;
_fileName = filename;
return true;
}
bool loadFile(const FSNode &node) {
_stream = node.openForReading();
if (!_stream)
return false;
_fileName = node.getName();
return true;
}
/**
* Loads a memory buffer into the parser.
* Used for loading the default theme fallback directly
* from memory if no themes can be found.
*
* @param buffer Pointer to the buffer.
* @param size Size of the buffer
* @param disposable Sets if the XMLParser owns the buffer,
* i.e. if it can be freed safely after it's
* no longer needed by the parser.
*/
bool loadBuffer(const byte *buffer, uint32 size, bool disposable = false) {
_stream = new MemoryReadStream(buffer, size, disposable);
_fileName = "Memory Stream";
return true;
}
bool loadStream(Common::SeekableReadStream *stream) {
_stream = stream;
_fileName = "File Stream";
return true;
}
void close() {
delete _stream;
_stream = 0;
}
/**
* The actual parsing function.
* Parses the loaded data stream, returns true if successful.
*/
bool parse();
/**
* Returns the active node being parsed (the one on top of
* the node stack).
*/
ParserNode *getActiveNode() {
if (!_activeKey.empty())
return _activeKey.top();
return 0;
}
/**
* Returns the parent of a given node in the stack.
*/
ParserNode *getParentNode(ParserNode *child) {
return child->depth > 0 ? _activeKey[child->depth - 1] : 0;
}
protected:
/**
* The buildLayout function builds the layout for the parser to use
* based on a series of helper macros. This function is automatically
* generated by the CUSTOM_XML_PARSER() macro on custom parsers.
*
* See the documentation regarding XML layouts.
*/
virtual void buildLayout() = 0;
/**
* The keycallback function is automatically overloaded on custom parsers
* when using the CUSTOM_XML_PARSER() macro.
*
* Its job is to call the corresponding Callback function for the given node.
* A function for each key type must be declared separately. See the custom
* parser creation instructions.
*
* When parsing a key in such function, one may chose to skip it, e.g. because it's not needed
* on the current configuration. In order to ignore a key, you must set
* the "ignore" field of its KeyNode struct to "true": The key and all its children
* will then be automatically ignored by the parser.
*
* The callback function must return true if the key was properly handled (this includes the case when the
* key is being ignored). False otherwise. The return of keyCallback() is the same as
* the callback function's.
* See the sample implementation in GUI::ThemeParser.
*/
virtual bool keyCallback(ParserNode *node) = 0;
/**
* The closed key callback function MAY be overloaded by inheriting classes to
* implement parser-specific functions.
*
* The closedKeyCallback is issued once a key has been finished parsing, to let
* the parser verify that all the required subkeys, etc, were included.
*
* Unlike the keyCallbacks(), there's just a closedKeyCallback() for all keys.
* Use "node->name" to distinguish between each key type.
*
* Returns true if the key was properly closed, false otherwise.
* By default, all keys are properly closed.
*/
virtual bool closedKeyCallback(ParserNode *node) {
return true;
}
/**
* Called when a node is closed. Manages its cleanup and calls the
* closing callback function if needed.
*/
bool closeKey();
/**
* Parses the value of a given key. There's no reason to overload this.
*/
bool parseKeyValue(Common::String keyName);
/**
* Called once a key has been parsed. It handles the closing/cleanup of the
* node stack and calls the keyCallback.
*/
bool parseActiveKey(bool closed);
/**
* Prints an error message when parsing fails and stops the parser.
* Parser error always returns "false" so we can pass the return value directly
* and break down the parsing.
*/
bool parserError(const char *errorString, ...) GCC_PRINTF(2, 3);
/**
* Skips spaces/whitelines etc. Returns true if any spaces were skipped.
*/
bool skipSpaces() {
if (!isspace(_char))
return false;
while (_char && isspace(_char))
_char = _stream->readByte();
return true;
}
/**
* Skips comment blocks and comment lines.
* Returns true if any comments were skipped.
* Overload this if you want to disable comments on your XML syntax
* or to change the commenting syntax.
*/
virtual bool skipComments() {
if (_char == '<') {
_char = _stream->readByte();
if (_char != '!') {
_stream->seek(-1, SEEK_CUR);
_char = '<';
return false;
}
if (_stream->readByte() != '-' || _stream->readByte() != '-')
return parserError("Malformed comment syntax.");
_char = _stream->readByte();
bool dash = false;
while (_char) {
if (_char == '-') {
if (dash && _stream->readByte() == '>') {
_char = _stream->readByte();
return true;
}
dash = !dash;
}
_char = _stream->readByte();
}
return parserError("Comment has no closure.");
}
return false;
}
/**
* Check if a given character can be part of a KEY or VALUE name.
* Overload this if you want to support keys with strange characters
* in their name.
*/
virtual inline bool isValidNameChar(char c) {
return isalnum(c) || c == '_';
}
/**
* Parses a the first textual token found.
* There's no reason to overload this.
*/
bool parseToken() {
_token.clear();
while (isValidNameChar(_char)) {
_token += _char;
_char = _stream->readByte();
}
return isspace(_char) != 0 || _char == '>' || _char == '=' || _char == '/' || _char == '?';
}
/**
* Parses the values inside an integer key.
* The count parameter specifies the number of values inside
* the key, which are expected to be separated with commas.
*
* Sample usage:
* parseIntegerKey("255, 255, 255", 3, &red, &green, &blue);
* [will parse each field into its own integer]
*
* parseIntegerKey("1234", 1, &number);
* [will parse the single number into the variable]
*
* @param key String containing the integers to be parsed.
* @param count Number of comma-separated ints in the string.
* @param ... Integer variables to store the parsed ints, passed
* by reference.
* @returns True if the parsing succeeded.
*/
bool parseIntegerKey(const char *key, int count, ...) {
char *parseEnd;
int *num_ptr;
va_list args;
va_start(args, count);
while (count--) {
while (isspace(*key))
key++;
num_ptr = va_arg(args, int*);
*num_ptr = strtol(key, &parseEnd, 10);
key = parseEnd;
while (isspace(*key))
key++;
if (count && *key++ != ',')
return false;
}
va_end(args);
return (*key == 0);
}
bool parseXMLHeader(ParserNode *node);
/**
* Overload if your parser needs to support parsing the same file
* several times, so you can clean up the internal state of the
* parser before each parse.
*/
virtual void cleanup() {}
Common::List<XMLKeyLayout*> _layoutList;
private:
char _char;
SeekableReadStream *_stream;
Common::String _fileName;
ParserState _state; /** Internal state of the parser */
Common::String _error; /** Current error message */
Common::String _token; /** Current text token */
Common::Stack<ParserNode*> _activeKey; /** Node stack of the parsed keys */
};
}
#endif
|