s4g_parser.h

См. документацию.

/*
Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017
license MIT see in LICENSE or
https://s4g.su/
*/

#ifndef s4g_parser_h
#define s4g_parser_h

#include "s4g_types.h"
#include "s4g_parse.h"
#include "s4g_main.h"

enum PARSER_NODE
{
    PARSER_NODE__NULL,
    PARSER_NODE__LEX, 
    PARSER_NODE__PROGRAM, 

    PARSER_NODE_CLASS, 
    //PARSER_NODE_CLASS_VAR,

    PARSER_NODE_FUNCTION, 
    PARSER_NODE_FUNCTION_HDR, 
    PARSER_NODE_FUNCTION_KW, 
    PARSER_NODE_FUNCTION_EXTERN_KW, 
    PARSER_NODE_FUNCTION_DECL_ARG, 
    PARSER_NODE_FUNCTION_DECL_MARG, 
    PARSER_NODE_FUNCTION_DECL_EXTERN_ARG, 
    PARSER_NODE_IF, 
    PARSER_NODE_IF_HDR, 
    PARSER_NODE_WHILE, 
    PARSER_NODE_WHILE_HDR, 
    PARSER_NODE_FOR, 
    PARSER_NODE_FOR_HDR, 
    //PARSER_NODE_LISTID, //!< 
    //PARSER_NODE_CLASS_KW,
    PARSER_NODE_CLASS_HDR, 
    PARSER_NODE_CLASS_EXTENDS_KW, 
    PARSER_NODE_CLASS_DECL_EXTENDS_ARG, 

    //PARSER_NODE_ID,

    PARSER_NODE_RVAL, 
    PARSER_NODE_LVAL, 

    PARSER_NODE_DECLVAR, 
    PARSER_NODE_DECLVAREND, 
    PARSER_NODE_BLOCK, 

    PARSER_NODE_TABLE, 

    PARSER_NODE_EXPR, 
    PARSER_NODE_STMT, 
    PARSER_NODE_STMT_CHAIN, 
    PARSER_NODE_RETURN, 
    PARSER_NODE_CYCONTROL, 

    PARSER_NODE_DO_KW, 
    PARSER_NODE_DO, 

};

class s4g_Parser
{
public:
    int parse(s4g_Lexer *pLexer);

    bool matchRVal();
    bool matchLVal();

    bool matchClass();
    bool matchClassVar();
    bool matchListID();
    bool matchID();
    bool matchExpr();
    bool matchArray();
    bool matchTable();
    bool matchStatement();
    bool matchReturn();
    bool matchFunctionKW();
    bool matchFunction();
    bool matchFunctionDeclArg();
    bool matchFunctionDecl();
    bool matchFunctionExternKW();
    bool matchFunctionExternArg();
    bool matchCycleControl();
    bool matchBlock();
    bool matchIfKW();
    bool matchWhileKW();
    bool matchForKW();
    bool matchDoKW();
    bool matchClassKW();
    bool matchClassExtendsKW();
    bool matchClassExtendsArg();

    bool isConst(S4G_LEXEME_TYPE type, ID idWord);
    bool isOp2(S4G_LEXEME_TYPE type);
    bool isOpLeft(S4G_LEXEME_TYPE type, ID idWord);
    bool isOpRight(S4G_LEXEME_TYPE type, ID idWord);
    bool isSkipReduce(S4G_LEXEME_TYPE type, ID idWord);
    bool isAssign(S4G_LEXEME_TYPE type, ID idWord);
    void stepBack();
    void skipNext();
    void repeat();
    void error(s4g_Lexeme *pLexeme, const char * szMsg);
    void reportError();
    void resolveExpressions();
    static bool resolveExpressionsCB(s4g_BaseNode **ppNode);

    void traverseTree(bool(*pfnCallback)(s4g_BaseNode **ppNode), s4g_BaseNode **ppStartNode=NULL);

    static s4g_OpNode *getOpNode(s4g_Lexeme *pLexeme);

    void debugDump();

    void delSubtree(s4g_BaseNode *pRootNode=NULL);

    s4g_BaseNode *getRoot();
    
    void clear();

    struct TempNode
    {
        TempNode():
            m_pLex(NULL),
            m_node(PARSER_NODE__NULL),
            m_pASTnode(NULL)
        {}
        TempNode(s4g_Lexeme *pLex):
            m_pLex(pLex), 
            m_node(PARSER_NODE__LEX),
            m_pASTnode(NULL)
        {}
        TempNode(PARSER_NODE node, s4g_BaseNode *pASTnode):
            m_pLex(NULL),
            m_node(node),
            m_pASTnode(pASTnode)
        {}
        s4g_Lexeme * m_pLex;
        PARSER_NODE m_node;
        s4g_BaseNode *m_pASTnode;
        
        bool operator==(const TempNode &other) const
        {
            if(m_node != other.m_node)
            {
                return(false);
            }
            if(m_node == PARSER_NODE__LEX)
            {
                return(m_pLex->m_type == other.m_pLex->m_type
                    &&m_pLex->m_idWord == other.m_pLex->m_idWord);
            }
            return(true);
        }
        bool operator<(const TempNode &other) const
        {
            if(m_node != other.m_node)
            {
                return(m_node < other.m_node);
            }
            if(m_node == PARSER_NODE__LEX)
            {
                if(m_pLex->m_type != other.m_pLex->m_type)
                {
                    return(m_pLex->m_type < other.m_pLex->m_type);
                }
                return(m_pLex->m_idWord < other.m_pLex->m_idWord);
            }
            return(false);
        }
    };


    void putNode(TempNode node, int iReplace = 1);
    void error(TempNode *pNode, const char * szMsg);

    s4g_Lexeme *findLeftmostLexeme(TempNode *pNode);
    s4g_Lexeme *findLeftmostLexeme(s4g_BaseNode *pNode);

    s4g_Stack<s4g_BaseNode*> m_stDelList;

protected:
    s4g_Lexer *m_pLexer;

    s4g_Stack<TempNode> m_stNodes;

    int m_iBackSteps;
    int m_iRepeatSteps;
    int m_iSkipSteps;
    bool m_isError;
    TempNode m_nextNode;

    int m_iErrorCount;

    static bool delSubtreeCB(s4g_BaseNode **ppNode);
    static s4g_Lexeme *m_pLeftmostLexemeFounded;
    static bool findLeftmostLexemeCB(s4g_BaseNode **ppNode);
};

#endif