From a4b4534a66bb6f24a66a27e28f7df0d390e1eea8 Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Wed, 18 Jun 2008 23:49:47 +0000 Subject: Split ThemeParser into XMLParser and ThemeParser as child class to have a common XML Parser. svn-id: r32734 --- common/module.mk | 1 + common/xmlparser.cpp | 216 +++++++++++++++++++++++++++++++++++++++++++++ common/xmlparser.h | 208 +++++++++++++++++++++++++++++++++++++++++++ dists/msvc9/scummvm.vcproj | 22 +++++ gui/ThemeParser.cpp | 207 ++++--------------------------------------- gui/ThemeParser.h | 98 ++------------------ 6 files changed, 471 insertions(+), 281 deletions(-) create mode 100644 common/xmlparser.cpp create mode 100644 common/xmlparser.h diff --git a/common/module.mk b/common/module.mk index c3f2a38c3f..ed15bf75ea 100644 --- a/common/module.mk +++ b/common/module.mk @@ -16,6 +16,7 @@ MODULE_OBJS := \ system.o \ unarj.o \ unzip.o \ + xmlparser.o \ zlib.o # Include common rules diff --git a/common/xmlparser.cpp b/common/xmlparser.cpp new file mode 100644 index 0000000000..7728d90d48 --- /dev/null +++ b/common/xmlparser.cpp @@ -0,0 +1,216 @@ +/* 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; + +void XMLParser::debug_testEval() { + static const char *debugConfigText = + "\n" + "\n" + "//\n" + "/* lol this is just a simple test*/\n"; + + _text = strdup(debugConfigText); + + Common::String test = "12, 125, 125"; + + printf("\n\nRegex result: %s.\n\n", test.regexMatch("^[d]*,[d]*,[d]*$", true) ? "Success." : "Fail"); + + parse(); +} + + +void XMLParser::parserError(const char *error_string) { + _state = kParserError; + printf("PARSER ERROR: %s\n", error_string); +} + +void XMLParser::parseActiveKey(bool closed) { + if (keyCallback(_activeKey.top()->name) == false) { + parserError("Unhandled value inside key."); + return; + } + + if (closed) { + delete _activeKey.pop(); + } +} + +bool XMLParser::parseKeyValue(Common::String keyName) { + assert(_activeKey.empty() == false); + + if (_activeKey.top()->values.contains(keyName)) + return false; + + _token.clear(); + char stringStart; + + if (_text[_pos] == '"' || _text[_pos] == '\'') { + stringStart = _text[_pos++]; + + while (_text[_pos] && _text[_pos] != stringStart) + _token += _text[_pos++]; + + if (_text[_pos++] == 0) + return false; + + } else if (!parseToken()) { + return false; + } + + _activeKey.top()->values[keyName] = _token; + return true; +} + +bool XMLParser::parse() { + + bool activeClosure = false; + bool selfClosure = false; + + _state = kParserNeedKey; + _pos = 0; + _activeKey.clear(); + + while (_text[_pos]) { + if (_state == kParserError) + break; + + if (skipSpaces()) + continue; + + if (skipComments()) + continue; + + switch (_state) { + case kParserNeedKey: + if (_text[_pos++] != '<') { + parserError("Expecting key start."); + break; + } + + if (_text[_pos] == 0) { + parserError("Unexpected end of file."); + break; + } + + if (_text[_pos] == '/' && _text[_pos + 1] != '*') { + _pos++; + 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."); + } else { + ParserNode *node = new ParserNode; + node->name = _token; + _activeKey.push(node); + } + + _state = kParserNeedPropertyName; + break; + + case kParserNeedPropertyName: + if (activeClosure) { + activeClosure = false; + delete _activeKey.pop(); + + if (_text[_pos++] != '>') + parserError("Invalid syntax in key closure."); + else + _state = kParserNeedKey; + + break; + } + + selfClosure = (_text[_pos] == '/'); + + if ((selfClosure && _text[_pos + 1] == '>') || _text[_pos] == '>') { + parseActiveKey(selfClosure); + _pos += selfClosure ? 2 : 1; + _state = kParserNeedKey; + break; + } + + if (!parseToken()) + parserError("Error when parsing key value."); + else + _state = kParserNeedPropertyOperator; + + break; + + case kParserNeedPropertyOperator: + if (_text[_pos++] != '=') + parserError("Unexpected character after key name."); + else + _state = kParserNeedPropertyValue; + + break; + + case kParserNeedPropertyValue: + if (!parseKeyValue(_token)) + parserError("Unable to parse key value."); + else + _state = kParserNeedPropertyName; + + break; + + default: + break; + } + } + + if (_state == kParserError) { + return false; + } + + if (_state != kParserNeedKey || !_activeKey.empty()) { + parserError("Unexpected end of file."); + return false; + } + + return true; +} + +} + diff --git a/common/xmlparser.h b/common/xmlparser.h new file mode 100644 index 0000000000..3edc2b31e1 --- /dev/null +++ b/common/xmlparser.h @@ -0,0 +1,208 @@ +/* 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/hashmap.h" +#include "common/hash-str.h" +#include "common/stack.h" + +namespace Common { + +/** + * 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; + }; + + 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. + * + * Return true if the key was properly handled. 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 void parseActiveKey(bool closed); + + /** + * Prints an error message when parsing fails and stops the parser. + * TODO: More descriptive error messages. + */ + virtual void parserError(const char *errorString); + + /** + * 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') + _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. */ + char *_text; /** Buffer with the text being parsed */ + + ParserState _state; /** Internal state of the parser */ + + Common::String _error; /** Current error message */ + Common::String _token; /** Current text token */ + + Common::FixedStack _activeKey; /** Node stack of the parsed keys */ +}; + +} + +#endif diff --git a/dists/msvc9/scummvm.vcproj b/dists/msvc9/scummvm.vcproj index bc88e6fc66..57ee62e358 100644 --- a/dists/msvc9/scummvm.vcproj +++ b/dists/msvc9/scummvm.vcproj @@ -453,6 +453,14 @@ RelativePath="..\..\common\util.h" > + + + + @@ -1223,10 +1231,24 @@ + + + + + + - - - - -*/ - namespace GUI { using namespace Graphics; +using namespace Common; -void ThemeParser::debug_testEval() { - static const char *debugConfigText = - "\n" - "\n" - "//\n" - "/* lol this is just a simple test*/\n"; - - _text = strdup(debugConfigText); - - Common::String test = "12, 125, 125"; - - printf("\n\nRegex result: %s.\n\n", test.regexMatch("^[d]*,[d]*,[d]*$", true) ? "Success." : "Fail"); - - parse(); +ThemeParser::ThemeParser() : XMLParser() { + _callbacks["drawstep"] = &ThemeParser::parserCallback_DRAWSTEP; + _callbacks["drawdata"] = &ThemeParser::parserCallback_DRAWDATA; } - -void ThemeParser::parserError(const char *error_string) { - _state = kParserError; - printf("PARSER ERROR: %s\n", error_string); +bool ThemeParser::keyCallback(Common::String keyName) { + // automatically handle with a function from the hash table. + if (!_callbacks.contains(_activeKey.top()->name)) + return false; + + return (this->*(_callbacks[_activeKey.top()->name]))(); } Graphics::DrawStep *ThemeParser::newDrawStep() { @@ -88,7 +72,7 @@ Graphics::DrawStep *ThemeParser::newDrawStep() { return step; } -void ThemeParser::parserCallback_DRAWSTEP() { +bool ThemeParser::parserCallback_DRAWSTEP() { ParserNode *stepNode = _activeKey.pop(); ParserNode *drawdataNode = _activeKey.pop(); @@ -104,7 +88,7 @@ void ThemeParser::parserCallback_DRAWSTEP() { parserError("Invalid drawing function in draw step."); _activeKey.push(drawdataNode); _activeKey.push(stepNode); - return; + return false; } drawstep->drawingCall = _drawFunctions[functionName]; @@ -121,173 +105,12 @@ void ThemeParser::parserCallback_DRAWSTEP() { _activeKey.push(drawdataNode); _activeKey.push(stepNode); -} - -void ThemeParser::parserCallback_DRAWDATA() { - printf("Drawdata callback!\n"); -} - -void ThemeParser::parseActiveKey(bool closed) { - printf("Parsed key %s.\n", _activeKey.top()->name.c_str()); - - if (!_callbacks.contains(_activeKey.top()->name)) { - parserError("Unhandled value inside key."); - return; - } - - // Don't you just love C++ syntax? Water clear. - (this->*(_callbacks[_activeKey.top()->name]))(); - -// for (Common::StringMap::const_iterator t = _activeKey.top()->values.begin(); t != _activeKey.top()->values.end(); ++t) -// printf(" Key %s = %s\n", t->_key.c_str(), t->_value.c_str()); - - if (closed) { - delete _activeKey.pop(); - } -} - -bool ThemeParser::parseKeyValue(Common::String keyName) { - assert(_activeKey.empty() == false); - - if (_activeKey.top()->values.contains(keyName)) - return false; - - _token.clear(); - char stringStart; - - if (_text[_pos] == '"' || _text[_pos] == '\'') { - stringStart = _text[_pos++]; - - while (_text[_pos] && _text[_pos] != stringStart) - _token += _text[_pos++]; - - if (_text[_pos++] == 0) - return false; - - } else if (!parseToken()) { - return false; - } - _activeKey.top()->values[keyName] = _token; return true; } -bool ThemeParser::parse() { - - bool activeClosure = false; - bool selfClosure = false; - - _state = kParserNeedKey; - _pos = 0; - _activeKey.clear(); - - while (_text[_pos]) { - if (_state == kParserError) - break; - - if (skipSpaces()) - continue; - - if (skipComments()) - continue; - - switch (_state) { - case kParserNeedKey: - if (_text[_pos++] != '<') { - parserError("Expecting key start."); - break; - } - - if (_text[_pos] == 0) { - parserError("Unexpected end of file."); - break; - } - - if (_text[_pos] == '/' && _text[_pos + 1] != '*') { - _pos++; - 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."); - } else { - ParserNode *node = new ParserNode; - node->name = _token; - _activeKey.push(node); - } - - _state = kParserNeedPropertyName; - break; - - case kParserNeedPropertyName: - if (activeClosure) { - activeClosure = false; - delete _activeKey.pop(); - - if (_text[_pos++] != '>') - parserError("Invalid syntax in key closure."); - else - _state = kParserNeedKey; - - break; - } - - selfClosure = (_text[_pos] == '/'); - - if ((selfClosure && _text[_pos + 1] == '>') || _text[_pos] == '>') { - parseActiveKey(selfClosure); - _pos += selfClosure ? 2 : 1; - _state = kParserNeedKey; - break; - } - - if (!parseToken()) - parserError("Error when parsing key value."); - else - _state = kParserNeedPropertyOperator; - - break; - - case kParserNeedPropertyOperator: - if (_text[_pos++] != '=') - parserError("Unexpected character after key name."); - else - _state = kParserNeedPropertyValue; - - break; - - case kParserNeedPropertyValue: - if (!parseKeyValue(_token)) - parserError("Unable to parse key value."); - else - _state = kParserNeedPropertyName; - - break; - - default: - break; - } - } - - if (_state == kParserError) { - return false; - } - - if (_state != kParserNeedKey || !_activeKey.empty()) { - parserError("Unexpected end of file."); - return false; - } - +bool ThemeParser::parserCallback_DRAWDATA() { + printf("Drawdata callback!\n"); return true; } diff --git a/gui/ThemeParser.h b/gui/ThemeParser.h index c5ee55dbbf..108a7263ba 100644 --- a/gui/ThemeParser.h +++ b/gui/ThemeParser.h @@ -33,6 +33,7 @@ #include "common/hashmap.h" #include "common/hash-str.h" #include "common/stack.h" +#include "common/xmlparser.h" #include "graphics/VectorRenderer.h" @@ -305,106 +306,25 @@ func = "fill" namespace GUI { using namespace Graphics; +using namespace Common; -class ThemeParser { - - static const int kParserMaxDepth = 4; - typedef void (ThemeParser::*ParserCallback)(); +class ThemeParser : public XMLParser { typedef void (VectorRenderer::*DrawingFunctionCallback)(const Common::Rect &, const DrawStep &); + typedef bool (ThemeParser::*ParserCallback)(); public: - ThemeParser() { - _callbacks["drawdata"] = &ThemeParser::parserCallback_DRAWDATA; - _callbacks["drawstep"] = &ThemeParser::parserCallback_DRAWSTEP; - } - - ~ThemeParser() {} - - enum ParserState { - kParserNeedKey, - kParserNeedKeyName, + ThemeParser(); - kParserNeedPropertyName, - kParserNeedPropertyOperator, - kParserNeedPropertyValue, - - kParserError - }; - - bool parse(); - void debug_testEval(); - protected: - void parserCallback_DRAWSTEP(); - void parserCallback_DRAWDATA(); + bool keyCallback(Common::String keyName); - bool parseKeyValue(Common::String keyName); - void parseActiveKey(bool closed); - void parserError(const char *errorString); + bool parserCallback_DRAWSTEP(); + bool parserCallback_DRAWDATA(); Graphics::DrawStep *newDrawStep(); - inline bool skipSpaces() { - if (!isspace(_text[_pos])) - return false; - - while (_text[_pos] && isspace(_text[_pos])) - _pos++; - - return true; - } - - inline 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') - _pos++; - return true; - } - - return false; - } - - inline bool isValidNameChar(char c) { - return isalnum(c) || c == '_'; - } - - inline bool parseToken() { - _token.clear(); - while (isValidNameChar(_text[_pos])) - _token += _text[_pos++]; - - return isspace(_text[_pos]) != 0 || _text[_pos] == '>'; - } - - int _pos; - char *_text; - - ParserState _state; - - Common::String _error; - Common::String _token; - - struct ParserNode { - Common::String name; - Common::StringMap values; - }; - - Common::FixedStack _activeKey; - - Common::HashMap _callbacks; Common::HashMap _drawFunctions; + Common::HashMap _callbacks; }; } -- cgit v1.2.3