RDparser.h

#pragma once


#include <libutl/Graph.h>
#include <libutl/Queue.h>
#include <libutl/Regex.h>
#include <libutl/Token.h>


UTL_NS_BEGIN;


class GrammarNode;
class Production;
class ParseNode;
class RDparserState;
class Terminal;

// RDparser ////////////////////////////////////////////////////////////////////////////////////////


class RDparser : public Object, protected FlagsMI
{
    UTL_CLASS_DECL(RDparser, Object);

public:
    void clear();

    virtual void copy(const Object& rhs);

    void addProduction(uint_t id, const String& name, const String& rhs);

    void addTerminal(uint_t id, const String& name, const String& regex);

    bool compile();

    bool
    ok() const
    {
        return getFlag(flg_ok);
    }

    Graph* parse(Stream& stream, const String* prod = nullptr);

    Graph* parse(const String& str, const String* prod = nullptr);

private:
    enum flg_t
    {
        flg_ok
    };

private:
    void init();
    void
    deInit()
    {
    }
    static String getToken(const TDequeIt<String>& it);
    static bool isSymbol(char c);
    static bool isSymbol(const TDequeIt<String>& it);
    ParseNode*
    parse(RDparserState& state, TDequeIt<Token>& it, Graph* parseTree, const GrammarNode* gn);
    GrammarNode* parseExpressionI(TDequeIt<String>& it, GrammarNode* expr = nullptr);
    GrammarNode* parseBranchI(TDequeIt<String>& it);
    GrammarNode* parseAtomI(TDequeIt<String>& it);
    void scan(RDparserState& state, Stream& stream);
    void scanI(Queue<String>& queue, const String& str);
    void
    setOK(bool _ok)
    {
        setFlag(flg_ok, _ok);
    }
    ParseNode*
    tryParse(RDparserState& state, TDequeIt<Token>& it, Graph* parseTree, const GrammarNode* gn);

private:
    TRBtree<Production> _productions;
    TRBtree<Terminal> _terminals;
    TArray<Terminal> _terminalsArray;
    String _rootProd;
    Graph _gramTree;
};

// ParseNode ///////////////////////////////////////////////////////////////////////////////////////


class ParseNode : public Vertex
{
    UTL_CLASS_DECL(ParseNode, Vertex);

public:
    virtual void copy(const Object& rhs);

    bool
    isProduction() const
    {
        return (_prodId != uint_t_max);
    }

    uint_t
    productionId() const
    {
        return _prodId;
    }

    bool
    isToken() const
    {
        return (_token != nullptr);
    }

    const Token&
    token() const
    {
        ASSERTD(_token != nullptr);
        return *_token;
    }

    void
    setProductionId(uint_t prodId)
    {
        _prodId = prodId;
    }

    void
    setToken(const Token* token)
    {
        delete _token;
        _token = token;
        if (_token != nullptr) _token = _token->clone();
    }

private:
    void
    init()
    {
        _prodId = uint_t_max;
        _token = nullptr;
    }
    void
    deInit()
    {
        delete _token;
    }

private:
    uint_t _prodId;
    const Token* _token;
};


UTL_EXCEPTION_DECL(RDparserEx, Exception);

// ParseEx /////////////////////////////////////////////////////////////////////////////////////////


class ParseEx : public RDparserEx
{
    UTL_CLASS_DECL(ParseEx, RDparserEx);

public:
    ParseEx(const Token* token);
    virtual void copy(const Object& rhs);
    virtual void dump(Stream& os) const;

private:
    void
    init()
    {
        _token = nullptr;
    }
    void deInit();

private:
    const Token* _token;
};

// ScanEx //////////////////////////////////////////////////////////////////////////////////////////


class ScanEx : public RDparserEx
{
    UTL_CLASS_DECL(ScanEx, RDparserEx);
    UTL_CLASS_DEFID;

public:
    ScanEx(String* line, size_t lineNo, size_t colNo);
    virtual void copy(const Object& rhs);
    virtual void dump(Stream& os) const;

private:
    size_t _lineNo, _colNo;
};


UTL_NS_END;