aboutsummaryrefslogtreecommitdiff
path: root/common
diff options
context:
space:
mode:
Diffstat (limited to 'common')
-rw-r--r--common/module.mk1
-rw-r--r--common/rect.h10
-rw-r--r--common/xmlparser.cpp339
-rw-r--r--common/xmlparser.h487
4 files changed, 837 insertions, 0 deletions
diff --git a/common/module.mk b/common/module.mk
index 599ffcf8a6..e04af5270b 100644
--- a/common/module.mk
+++ b/common/module.mk
@@ -17,6 +17,7 @@ MODULE_OBJS := \
system.o \
unarj.o \
unzip.o \
+ xmlparser.o \
zlib.o
# Include common rules
diff --git a/common/rect.h b/common/rect.h
index dcf1c8b421..962069bf48 100644
--- a/common/rect.h
+++ b/common/rect.h
@@ -124,6 +124,16 @@ struct Rect {
return contains(p.x, p.y);
}
+ /*! @brief check if the given rect is _fully_ contained inside this rectangle
+
+ @param r The rectangle to check
+
+ @retur true if the given rect is inside, false otherwise
+ */
+ bool contains(const Rect &r) const {
+ return (left < r.left) && (right > r.right) && (top < r.top) && (bottom > r.bottom);
+ }
+
/*! @brief check if given rectangle intersects with this rectangle
@param r the rectangle to check
diff --git a/common/xmlparser.cpp b/common/xmlparser.cpp
new file mode 100644
index 0000000000..44274f7c8d
--- /dev/null
+++ b/common/xmlparser.cpp
@@ -0,0 +1,339 @@
+/* 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$
+ *
+ */
+
+#include "common/util.h"
+#include "common/system.h"
+#include "common/events.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/xmlparser.h"
+
+namespace Common {
+
+using namespace Graphics;
+
+bool XMLParser::parserError(const char *errorString, ...) {
+ _state = kParserError;
+
+ int original_pos = _stream->pos();
+ int pos = original_pos;
+ int lineCount = 1;
+ int lineStart = 0;
+
+ if (_fileName == "Memory Stream") {
+ lineStart = MAX(0, original_pos - 35);
+ lineCount = 0;
+ } else {
+ do {
+ if (_char == '\n' || _char == '\r') {
+ lineCount++;
+
+ if (lineStart == 0)
+ lineStart = MAX(pos + 1, original_pos - 60);
+ }
+
+ _stream->seek(-1, SEEK_CUR);
+
+ } while (_stream->pos() > 0);
+ }
+
+ char lineStr[70];
+ _stream->seek(original_pos - 35, SEEK_SET);
+ _stream->readLine_NEW(lineStr, 70);
+
+ for (int i = 0; i < 70; ++i)
+ if (lineStr[i] == '\n')
+ lineStr[i] = ' ';
+
+ printf("\n File <%s>, line %d:\n", _fileName.c_str(), lineCount);
+
+ bool startFull = lineStr[0] == '<';
+ bool endFull = lineStr[strlen(lineStr) - 1] == '>';
+
+ printf("%s%s%s\n", startFull ? "" : "...", lineStr, endFull ? "" : "...");
+
+ int cursor = 35;
+
+ if (!startFull)
+ cursor += 3;
+
+ while (cursor--)
+ printf(" ");
+
+ printf("^\n");
+ printf("Parser error: ");
+
+ va_list args;
+ va_start(args, errorString);
+ vprintf(errorString, args);
+ va_end(args);
+
+ printf("\n\n");
+
+ return false;
+}
+
+bool XMLParser::parseActiveKey(bool closed) {
+ bool ignore = false;
+ assert(_activeKey.empty() == false);
+
+ ParserNode *key = _activeKey.top();
+ XMLKeyLayout *layout = (_activeKey.size() == 1) ? _XMLkeys : getParentNode(key)->layout;
+
+ if (layout->children.contains(key->name)) {
+ key->layout = layout->children[key->name];
+
+ Common::StringMap localMap = key->values;
+ int keyCount = localMap.size();
+
+ for (Common::List<XMLKeyLayout::XMLKeyProperty>::const_iterator i = key->layout->properties.begin(); i != key->layout->properties.end(); ++i) {
+ if (i->required && !localMap.contains(i->name))
+ return parserError("Missing required property '%s' inside key '%s'", i->name.c_str(), key->name.c_str());
+ else if (localMap.contains(i->name))
+ keyCount--;
+ }
+
+ if (keyCount > 0)
+ return parserError("Unhandled property inside key '%s': '%s'", key->name.c_str(), localMap.begin()->_key.c_str());
+
+ } else {
+ return parserError("Unexpected key in the active scope: '%s'.", key->name.c_str());
+ }
+
+ // check if any of the parents must be ignored.
+ // if a parent is ignored, all children are too.
+ for (int i = _activeKey.size() - 1; i >= 0; --i) {
+ if (_activeKey[i]->ignore)
+ ignore = true;
+ }
+
+ if (ignore == false && keyCallback(key) == false) {
+ // HACK: People may be stupid and overlook the fact that
+ // when keyCallback() fails, a parserError() must be set.
+ // We set it manually in that case.
+ if (_state != kParserError)
+ parserError("Unhandled exception when parsing '%s' key.", key->name.c_str());
+
+ return false;
+ }
+
+ if (closed)
+ return closeKey();
+
+ return true;
+}
+
+bool XMLParser::parseKeyValue(Common::String keyName) {
+ assert(_activeKey.empty() == false);
+
+ if (_activeKey.top()->values.contains(keyName))
+ return false;
+
+ _token.clear();
+ char stringStart;
+
+ if (_char == '"' || _char == '\'') {
+ stringStart = _char;
+ _char = _stream->readByte();
+
+ while (_char && _char != stringStart) {
+ _token += _char;
+ _char = _stream->readByte();
+ }
+
+ if (_char == 0)
+ return false;
+
+ _char = _stream->readByte();
+
+ } else if (!parseToken()) {
+ return false;
+ }
+
+ _activeKey.top()->values[keyName] = _token;
+ return true;
+}
+
+bool XMLParser::closeKey() {
+ bool ignore = false;
+ bool result = true;
+
+ for (int i = _activeKey.size() - 1; i >= 0; --i) {
+ if (_activeKey[i]->ignore)
+ ignore = true;
+ }
+
+ if (ignore == false)
+ result = closedKeyCallback(_activeKey.top());
+
+ freeNode(_activeKey.pop());
+
+ return result;
+}
+
+bool XMLParser::parse() {
+
+ if (_stream == 0)
+ return parserError("XML stream not ready for reading.");
+
+ if (_XMLkeys == 0)
+ buildLayout();
+
+ while (!_activeKey.empty())
+ freeNode(_activeKey.pop());
+
+ cleanup();
+
+ bool activeClosure = false;
+ bool selfClosure = false;
+
+ _state = kParserNeedKey;
+ _activeKey.clear();
+
+ _char = _stream->readByte();
+
+ while (_char && _state != kParserError) {
+ if (skipSpaces())
+ continue;
+
+ if (skipComments())
+ continue;
+
+ switch (_state) {
+ case kParserNeedKey:
+ if (_char != '<') {
+ parserError("Parser expecting key start.");
+ break;
+ }
+
+ if ((_char = _stream->readByte()) == 0) {
+ parserError("Unexpected end of file.");
+ break;
+ }
+
+ if (_char == '/') { // FIXME: What if it's a comment start
+ _char = _stream->readByte();
+ activeClosure = true;
+ }
+
+ _state = kParserNeedKeyName;
+ break;
+
+ case kParserNeedKeyName:
+ if (!parseToken()) {
+ parserError("Invalid key name.");
+ break;
+ }
+
+ if (activeClosure) {
+ if (_activeKey.empty() || _token != _activeKey.top()->name) {
+ parserError("Unexpected closure.");
+ break;
+ }
+ } else {
+ ParserNode *node = allocNode(); //new ParserNode;
+ node->name = _token;
+ node->ignore = false;
+ node->depth = _activeKey.size();
+ node->layout = 0;
+ _activeKey.push(node);
+ }
+
+ _state = kParserNeedPropertyName;
+ break;
+
+ case kParserNeedPropertyName:
+ if (activeClosure) {
+ if (!closeKey()) {
+ parserError("Missing data when closing key '%s'.", _activeKey.top()->name.c_str());
+ break;
+ }
+
+ activeClosure = false;
+
+ if (_char != '>')
+ parserError("Invalid syntax in key closure.");
+ else
+ _state = kParserNeedKey;
+
+ _char = _stream->readByte();
+ break;
+ }
+
+ selfClosure = false;
+
+ if (_char == '/') { // FIXME: comment start?
+ selfClosure = true;
+ _char = _stream->readByte();
+ }
+
+ if (_char == '>') {
+ if (parseActiveKey(selfClosure)) {
+ _char = _stream->readByte();
+ _state = kParserNeedKey;
+ }
+ break;
+ }
+
+ if (!parseToken())
+ parserError("Error when parsing key value.");
+ else
+ _state = kParserNeedPropertyOperator;
+
+ break;
+
+ case kParserNeedPropertyOperator:
+ if (_char != '=')
+ parserError("Syntax error after key name.");
+ else
+ _state = kParserNeedPropertyValue;
+
+ _char = _stream->readByte();
+ break;
+
+ case kParserNeedPropertyValue:
+ if (!parseKeyValue(_token))
+ parserError("Invalid key value.");
+ else
+ _state = kParserNeedPropertyName;
+
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ if (_state == kParserError)
+ return false;
+
+ if (_state != kParserNeedKey || !_activeKey.empty())
+ return parserError("Unexpected end of file.");
+
+ return true;
+}
+
+}
+
diff --git a/common/xmlparser.h b/common/xmlparser.h
new file mode 100644
index 0000000000..5f649f517f
--- /dev/null
+++ b/common/xmlparser.h
@@ -0,0 +1,487 @@
+/* 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 {
+
+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 {
+ 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;
+ int depth;
+ XMLKeyLayout *layout;
+ };
+
+ FixedSizeMemoryPool<sizeof(ParserNode), MAX_XML_DEPTH> _nodePool;
+
+ ParserNode *allocNode() {
+ void* mem = _nodePool.malloc();
+ return new (mem) ParserNode;
+ }
+
+ void freeNode(ParserNode *node) {
+ node->~ParserNode();
+ _nodePool.free(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) {
+ Common::File *f = new Common::File;
+
+ if (!f->open(filename)) {
+ delete f;
+ return false;
+ }
+
+ _fileName = filename;
+ _stream = f;
+ return true;
+ }
+
+ bool loadFile(const FSNode &node) {
+ Common::File *f = new Common::File;
+
+ if (!f->open(node)) {
+ delete f;
+ return false;
+ }
+
+ _fileName = node.getName();
+ _stream = f;
+ 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() {
+ if (_stream) {
+ 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() {
+ char endComment1 = 0, endComment2 = 0;
+
+ if (_char == '/') {
+ _char = _stream->readByte();
+
+ if (_char != '*') {
+ _stream->seek(-1, SEEK_CUR);
+ _char = '/';
+ return false;
+ }
+
+ _char = _stream->readByte();
+
+ while (_char) {
+ endComment1 = endComment2;
+ endComment2 = _char;
+ _char = _stream->readByte();
+
+ if (endComment1 == '*' && endComment2 == '/')
+ break;
+
+ if (_char == 0)
+ return parserError("Comment has no closure.");
+ }
+ _char = _stream->readByte();
+ 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 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 == '/';
+ }
+
+ /**
+ * 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);
+ }
+
+ /**
+ * 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
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-24 02:23:54 +0000