xmlparser.h

/* 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef XML_PARSER_H
#define XML_PARSER_H

#include "common/scummsys.h"
#include "common/types.h"

#include "common/fs.h"
#include "common/list.h"
#include "common/hashmap.h"
#include "common/hash-str.h"
#include "common/stack.h"
#include "common/memorypool.h"


namespace Common {

class SeekableReadStream;

#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);

#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 CUSTOM_XML_PARSER(parserName) \
    protected: \
    typedef parserName kLocalParserName; \
    bool keyCallback(ParserNode *node) override {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);} };\
    void buildLayout() override { \
        Common::Stack<XMLKeyLayout *> layout; \
        CustomXMLKeyLayout *lay = 0; \
        XMLKeyLayout::XMLKeyProperty prop; \
        _XMLkeys = new CustomXMLKeyLayout; \
        layout.push(_XMLkeys);

#define PARSER_END() layout.clear(); }

class XMLParser {
public:
    XMLParser() : _XMLkeys(nullptr), _stream(nullptr), _allowText(false), _char(0) {}

    virtual ~XMLParser();

    enum ParserState {
        kParserNeedHeader,
        kParserNeedKey,
        kParserNeedKeyName,

        kParserNeedPropertyName,
        kParserNeedPropertyOperator,
        kParserNeedPropertyValue,

        kParserError
    };

    struct XMLKeyLayout;
    struct ParserNode;

    typedef HashMap<String, XMLParser::XMLKeyLayout*, IgnoreCase_Hash, IgnoreCase_EqualTo> ChildMap;

    struct XMLKeyLayout {
        struct XMLKeyProperty {
            String name;
            bool required;
        };

        List<XMLKeyProperty> properties;
        ChildMap children;

        virtual bool doCallback(XMLParser *parent, ParserNode *node) = 0;

        virtual ~XMLKeyLayout() {
            properties.clear();
        }
    };

    XMLKeyLayout *_XMLkeys;

    struct ParserNode {
        String name;
        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);
    }

    bool loadFile(const Path &filename);

    bool loadFile(const FSNode &node);

    bool loadBuffer(const byte *buffer, uint32 size, DisposeAfterUse::Flag disposable = DisposeAfterUse::NO);

    bool loadStream(SeekableReadStream *stream);

    void close();

    bool parse();

    ParserNode *getActiveNode() {
        if (!_activeKey.empty())
            return _activeKey.top();

        return nullptr;
    }

    ParserNode *getParentNode(ParserNode *child) {
        return child->depth > 0 ? _activeKey[child->depth - 1] : 0;
    }

    void setAllowText() {
        _allowText = true;
    }

protected:

    virtual void buildLayout() = 0;

    virtual bool keyCallback(ParserNode *node) = 0;

    virtual bool closedKeyCallback(ParserNode *node) {
        return true;
    }

    virtual bool textCallback(const String &val) {
        return true;
    }

    bool closeKey();

    bool parseKeyValue(String keyName);

    bool parseActiveKey(bool closed);

    bool parserError(const String &errStr);

    bool skipSpaces();

    bool skipComments();

    virtual inline bool isValidNameChar(char c) {
        return isAlnum(c) || c == '_';
    }

    bool parseToken();

    bool parseIntegerKey(const char *key, int count, ...);
    bool parseIntegerKey(const String &keyStr, int count, ...);
    bool vparseIntegerKey(const char *key, int count, va_list args);

    bool parseXMLHeader(ParserNode *node);

    virtual void cleanup() {}

    virtual bool handleUnknownKey(ParserNode *node) { return false; }

    List<XMLKeyLayout *> _layoutList;

private:
    char _char;
    bool _allowText; 
    SeekableReadStream *_stream;
    Path _fileName;

    ParserState _state; 
    String _error; 
    String _token; 
    Stack<ParserNode *> _activeKey; 
};

} // End of namespace Common

#endif