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
|
/* 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/hashmap.h"
#include "common/hash-str.h"
#include "common/stack.h"
namespace Common {
class XMLStream {
protected:
SeekableReadStream *_stream;
int _pos;
public:
XMLStream() : _stream(0), _pos(0) {}
~XMLStream() {
delete _stream;
}
SeekableReadStream *stream() {
return _stream;
}
const char operator [](int idx) {
assert(_stream && idx >= 0);
if (_pos + 1 != idx)
_stream->seek(idx, SEEK_SET);
_pos = idx;
return _stream->readSByte();
}
void fillFromMem(const char *buffer, bool dispose = false) {
delete _stream;
_stream = new MemoryReadStream((const byte*)buffer, strlen(buffer), dispose);
}
void fillFromFile(const char *filename) {
}
};
/**
* 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 {
/** Maximum depth for nested keys that the parser supports */
static const int kParserMaxDepth = 4;
public:
/**
* Parser constructor.
*/
XMLParser() {}
virtual ~XMLParser() {}
/** Active state for the parser */
enum ParserState {
kParserNeedKey,
kParserNeedKeyName,
kParserNeedPropertyName,
kParserNeedPropertyOperator,
kParserNeedPropertyValue,
kParserError
};
/** Struct representing a parsed node */
struct ParserNode {
Common::String name;
Common::StringMap values;
bool ignore;
};
virtual bool parse();
void debug_testEval();
/**
* Returns the active node being parsed (the one on top of
* the node stack).
*/
ParserNode *activeNode() {
if (!_activeKey.empty())
return _activeKey.top();
return 0;
}
protected:
/**
* The keycallback function must be overloaded by inheriting classes
* to implement parser-specific functions.
*
* This function is called everytime a key has successfully been parsed.
* The keyName parameter contains the name of the key that has just been
* parsed; this same key is still on top of the Node Stack.
*
* Access the node stack to view this key's properties and its parents.
* Remember to leave the node stack _UNCHANGED_ in your own function. Removal
* of closed keys is done automatically.
*
* When parsing a key, 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.
*
* Return true if the key was properly handled (this includes the case when the
* key is being ignored). False otherwise.
* See the sample implementation in GUI::ThemeParser.
*/
virtual bool keyCallback(Common::String keyName) {
return false;
}
/**
* Parses the value of a given key. There's no reason to overload this.
*/
virtual 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.
* There's no reason to overload this.
*/
virtual bool parseActiveKey(bool closed);
/**
* Prints an error message when parsing fails and stops the parser.
*/
virtual void parserError(const char *errorString, ...) GCC_PRINTF(1, 2);
/**
* Skips spaces/whitelines etc. Returns true if any spaces were skipped.
* Overload this if you want to make your parser depend on newlines or
* whatever.
*/
virtual bool skipSpaces() {
if (!isspace(_text[_pos]))
return false;
while (_text[_pos] && isspace(_text[_pos]))
_pos++;
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 (_text[_pos] == '/' && _text[_pos + 1] == '*') {
_pos += 2;
while (_text[_pos++]) {
if (_text[_pos - 2] == '*' && _text[_pos - 1] == '/')
break;
if (_text[_pos] == 0)
parserError("Comment has no closure.");
}
return true;
}
if (_text[_pos] == '/' && _text[_pos + 1] == '/') {
_pos += 2;
while (_text[_pos] && _text[_pos] != '\n' && _text[_pos] != '\r')
_pos++;
return true;
}
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 bool isValidNameChar(char c) {
return isalnum(c) || c == '_';
}
/**
* Parses a the first textual token found.
* There's no reason to overload this.
*/
virtual bool parseToken() {
_token.clear();
while (isValidNameChar(_text[_pos]))
_token += _text[_pos++];
return isspace(_text[_pos]) != 0 || _text[_pos] == '>';
}
int _pos; /** Current position on the XML buffer. */
XMLStream _text; /** Buffer with the text being parsed */
char *_fileName;
ParserState _state; /** Internal state of the parser */
Common::String _error; /** Current error message */
Common::String _token; /** Current text token */
Common::FixedStack<ParserNode*, kParserMaxDepth> _activeKey; /** Node stack of the parsed keys */
};
}
#endif
|