diff --git a/CMakeLists.txt b/CMakeLists.txt index 4046ab9..d68a321 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,23 +5,13 @@ project(sysy) set(CMAKE_CXX_STANDARD 17) set(CMAKE_EXPORT_COMPILE_COMMANDS 1) # generate food for clangd -# Include path for ExternalAntlr4Cpp -list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) -add_definitions(-DANTLR4CPP_STATIC) -# using /MD flag for antlr4_runtime (for Visual C++ compilers only) -set(ANTLR4_WITH_STATIC_CRT OFF) -set(ANTLR4_ZIP_REPOSITORY ${CMAKE_CURRENT_SOURCE_DIR}/tools/antlr4-4.12.0.zip) -include(ExternalAntlr4Cpp) -include_directories(${ANTLR4_INCLUDE_DIRS}) set(ANTLR_EXECUTABLE ${CMAKE_CURRENT_SOURCE_DIR}/tools/antlr-4.12.0-complete.jar) -find_package(ANTLR REQUIRED) -antlr_target(SysY ${CMAKE_CURRENT_SOURCE_DIR}/SysY.g4 VISITOR - PACKAGE antlrSysY - ) -include_directories(${ANTLR_SysY_OUTPUT_DIR}) +find_package(ANTLR4-RUNTIME REQUIRED) +include_directories(${ANTLR4_INCLUDE_DIR}) # Custom sources start here +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) file(GLOB_RECURSE SOURCES "src/*.cpp") -add_executable(sysy ${SOURCES} ${ANTLR_SysY_CXX_OUTPUTS}) +add_executable(sysy ${SOURCES}) target_link_libraries(sysy antlr4_static) \ No newline at end of file diff --git a/include/SysYBaseVisitor.h b/include/SysYBaseVisitor.h new file mode 100644 index 0000000..743ebc1 --- /dev/null +++ b/include/SysYBaseVisitor.h @@ -0,0 +1,207 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SysYVisitor.h" + + +namespace antlrSysY { + +/** + * This class provides an empty implementation of SysYVisitor, which can be + * extended to create a visitor which only needs to handle a subset of the available methods. + */ +class SysYBaseVisitor : public SysYVisitor { +public: + + virtual std::any visitProgram(SysYParser::ProgramContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitCompUnit(SysYParser::CompUnitContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitDecl(SysYParser::DeclContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitConstDecl(SysYParser::ConstDeclContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitBType(SysYParser::BTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitConstDef(SysYParser::ConstDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitConstInitVal(SysYParser::ConstInitValContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitVarDecl(SysYParser::VarDeclContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitVarDef(SysYParser::VarDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitInitVal(SysYParser::InitValContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncDef(SysYParser::FuncDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncType(SysYParser::FuncTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncFParam(SysYParser::FuncFParamContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitBlock(SysYParser::BlockContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitBlockItem(SysYParser::BlockItemContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitStmt(SysYParser::StmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitAssignStmt(SysYParser::AssignStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitExpStmt(SysYParser::ExpStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitConditionStmt(SysYParser::ConditionStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitWhileStmt(SysYParser::WhileStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitBreakStmt(SysYParser::BreakStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitContinueStmt(SysYParser::ContinueStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitReturnStmt(SysYParser::ReturnStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitExp(SysYParser::ExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitCond(SysYParser::CondContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitLVal(SysYParser::LValContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitPrimaryExp(SysYParser::PrimaryExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitNumber(SysYParser::NumberContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitIntConst(SysYParser::IntConstContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitCallee(SysYParser::CalleeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitUnaryOp(SysYParser::UnaryOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitParam(SysYParser::ParamContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitMulExp(SysYParser::MulExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitMulOp(SysYParser::MulOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitAddExp(SysYParser::AddExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitAddOp(SysYParser::AddOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitRelExp(SysYParser::RelExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitRelOp(SysYParser::RelOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitEqExp(SysYParser::EqExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitEqOp(SysYParser::EqOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitLAndExp(SysYParser::LAndExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitLOrExp(SysYParser::LOrExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitConstExp(SysYParser::ConstExpContext *ctx) override { + return visitChildren(ctx); + } + + +}; + +} // namespace antlrSysY diff --git a/include/SysYLexer.h b/include/SysYLexer.h new file mode 100644 index 0000000..c9131fe --- /dev/null +++ b/include/SysYLexer.h @@ -0,0 +1,58 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace antlrSysY { + + +class SysYLexer : public antlr4::Lexer { +public: + enum { + CONST_KW = 1, INT_KW = 2, VOID_KW = 3, IF_KW = 4, ELSE_KW = 5, WHILE_KW = 6, + BREAK_KW = 7, CONTINUE_KW = 8, RETURN_KW = 9, IDENT = 10, DECIMAL_CONST = 11, + OCTAL_CONST = 12, HEXADECIMAL_CONST = 13, STRING = 14, PLUS = 15, MINUS = 16, + NOT = 17, MUL = 18, DIV = 19, MOD = 20, ASSIGN = 21, EQ = 22, NEQ = 23, + LT = 24, GT = 25, LE = 26, GE = 27, AND = 28, OR = 29, L_PAREN = 30, + R_PAREN = 31, L_BRACE = 32, R_BRACE = 33, L_BRACKT = 34, R_BRACKT = 35, + COMMA = 36, SEMICOLON = 37, DOUBLE_QUOTE = 38, WS = 39, LINE_COMMENT = 40, + MULTILINE_COMMENT = 41 + }; + + explicit SysYLexer(antlr4::CharStream *input); + + ~SysYLexer() override; + + + std::string getGrammarFileName() const override; + + const std::vector& getRuleNames() const override; + + const std::vector& getChannelNames() const override; + + const std::vector& getModeNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + const antlr4::atn::ATN& getATN() const override; + + // By default the static state used to implement the lexer is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + +}; + +} // namespace antlrSysY diff --git a/include/SysYParser.h b/include/SysYParser.h new file mode 100644 index 0000000..1591c5f --- /dev/null +++ b/include/SysYParser.h @@ -0,0 +1,849 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace antlrSysY { + + +class SysYParser : public antlr4::Parser { +public: + enum { + CONST_KW = 1, INT_KW = 2, VOID_KW = 3, IF_KW = 4, ELSE_KW = 5, WHILE_KW = 6, + BREAK_KW = 7, CONTINUE_KW = 8, RETURN_KW = 9, IDENT = 10, DECIMAL_CONST = 11, + OCTAL_CONST = 12, HEXADECIMAL_CONST = 13, STRING = 14, PLUS = 15, MINUS = 16, + NOT = 17, MUL = 18, DIV = 19, MOD = 20, ASSIGN = 21, EQ = 22, NEQ = 23, + LT = 24, GT = 25, LE = 26, GE = 27, AND = 28, OR = 29, L_PAREN = 30, + R_PAREN = 31, L_BRACE = 32, R_BRACE = 33, L_BRACKT = 34, R_BRACKT = 35, + COMMA = 36, SEMICOLON = 37, DOUBLE_QUOTE = 38, WS = 39, LINE_COMMENT = 40, + MULTILINE_COMMENT = 41 + }; + + enum { + RuleProgram = 0, RuleCompUnit = 1, RuleDecl = 2, RuleConstDecl = 3, + RuleBType = 4, RuleConstDef = 5, RuleConstInitVal = 6, RuleVarDecl = 7, + RuleVarDef = 8, RuleInitVal = 9, RuleFuncDef = 10, RuleFuncType = 11, + RuleFuncFParams = 12, RuleFuncFParam = 13, RuleBlock = 14, RuleBlockItem = 15, + RuleStmt = 16, RuleAssignStmt = 17, RuleExpStmt = 18, RuleConditionStmt = 19, + RuleWhileStmt = 20, RuleBreakStmt = 21, RuleContinueStmt = 22, RuleReturnStmt = 23, + RuleExp = 24, RuleCond = 25, RuleLVal = 26, RulePrimaryExp = 27, RuleNumber = 28, + RuleIntConst = 29, RuleUnaryExp = 30, RuleCallee = 31, RuleUnaryOp = 32, + RuleFuncRParams = 33, RuleParam = 34, RuleMulExp = 35, RuleMulOp = 36, + RuleAddExp = 37, RuleAddOp = 38, RuleRelExp = 39, RuleRelOp = 40, RuleEqExp = 41, + RuleEqOp = 42, RuleLAndExp = 43, RuleLOrExp = 44, RuleConstExp = 45 + }; + + explicit SysYParser(antlr4::TokenStream *input); + + SysYParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); + + ~SysYParser() override; + + std::string getGrammarFileName() const override; + + const antlr4::atn::ATN& getATN() const override; + + const std::vector& getRuleNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + + class ProgramContext; + class CompUnitContext; + class DeclContext; + class ConstDeclContext; + class BTypeContext; + class ConstDefContext; + class ConstInitValContext; + class VarDeclContext; + class VarDefContext; + class InitValContext; + class FuncDefContext; + class FuncTypeContext; + class FuncFParamsContext; + class FuncFParamContext; + class BlockContext; + class BlockItemContext; + class StmtContext; + class AssignStmtContext; + class ExpStmtContext; + class ConditionStmtContext; + class WhileStmtContext; + class BreakStmtContext; + class ContinueStmtContext; + class ReturnStmtContext; + class ExpContext; + class CondContext; + class LValContext; + class PrimaryExpContext; + class NumberContext; + class IntConstContext; + class UnaryExpContext; + class CalleeContext; + class UnaryOpContext; + class FuncRParamsContext; + class ParamContext; + class MulExpContext; + class MulOpContext; + class AddExpContext; + class AddOpContext; + class RelExpContext; + class RelOpContext; + class EqExpContext; + class EqOpContext; + class LAndExpContext; + class LOrExpContext; + class ConstExpContext; + + class ProgramContext : public antlr4::ParserRuleContext { + public: + ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + CompUnitContext *compUnit(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ProgramContext* program(); + + class CompUnitContext : public antlr4::ParserRuleContext { + public: + CompUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector funcDef(); + FuncDefContext* funcDef(size_t i); + std::vector decl(); + DeclContext* decl(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CompUnitContext* compUnit(); + + class DeclContext : public antlr4::ParserRuleContext { + public: + DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstDeclContext *constDecl(); + VarDeclContext *varDecl(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + DeclContext* decl(); + + class ConstDeclContext : public antlr4::ParserRuleContext { + public: + ConstDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *CONST_KW(); + BTypeContext *bType(); + std::vector constDef(); + ConstDefContext* constDef(size_t i); + antlr4::tree::TerminalNode *SEMICOLON(); + std::vector COMMA(); + antlr4::tree::TerminalNode* COMMA(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstDeclContext* constDecl(); + + class BTypeContext : public antlr4::ParserRuleContext { + public: + BTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *INT_KW(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BTypeContext* bType(); + + class ConstDefContext : public antlr4::ParserRuleContext { + public: + ConstDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *IDENT(); + antlr4::tree::TerminalNode *ASSIGN(); + ConstInitValContext *constInitVal(); + std::vector L_BRACKT(); + antlr4::tree::TerminalNode* L_BRACKT(size_t i); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + std::vector R_BRACKT(); + antlr4::tree::TerminalNode* R_BRACKT(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstDefContext* constDef(); + + class ConstInitValContext : public antlr4::ParserRuleContext { + public: + ConstInitValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstExpContext *constExp(); + antlr4::tree::TerminalNode *L_BRACE(); + antlr4::tree::TerminalNode *R_BRACE(); + std::vector constInitVal(); + ConstInitValContext* constInitVal(size_t i); + std::vector COMMA(); + antlr4::tree::TerminalNode* COMMA(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstInitValContext* constInitVal(); + + class VarDeclContext : public antlr4::ParserRuleContext { + public: + VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + std::vector varDef(); + VarDefContext* varDef(size_t i); + antlr4::tree::TerminalNode *SEMICOLON(); + std::vector COMMA(); + antlr4::tree::TerminalNode* COMMA(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarDeclContext* varDecl(); + + class VarDefContext : public antlr4::ParserRuleContext { + public: + VarDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *IDENT(); + std::vector L_BRACKT(); + antlr4::tree::TerminalNode* L_BRACKT(size_t i); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + std::vector R_BRACKT(); + antlr4::tree::TerminalNode* R_BRACKT(size_t i); + antlr4::tree::TerminalNode *ASSIGN(); + InitValContext *initVal(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarDefContext* varDef(); + + class InitValContext : public antlr4::ParserRuleContext { + public: + InitValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpContext *exp(); + antlr4::tree::TerminalNode *L_BRACE(); + antlr4::tree::TerminalNode *R_BRACE(); + std::vector initVal(); + InitValContext* initVal(size_t i); + std::vector COMMA(); + antlr4::tree::TerminalNode* COMMA(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + InitValContext* initVal(); + + class FuncDefContext : public antlr4::ParserRuleContext { + public: + FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + FuncTypeContext *funcType(); + antlr4::tree::TerminalNode *IDENT(); + antlr4::tree::TerminalNode *L_PAREN(); + antlr4::tree::TerminalNode *R_PAREN(); + BlockContext *block(); + FuncFParamsContext *funcFParams(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncDefContext* funcDef(); + + class FuncTypeContext : public antlr4::ParserRuleContext { + public: + FuncTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *VOID_KW(); + antlr4::tree::TerminalNode *INT_KW(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncTypeContext* funcType(); + + class FuncFParamsContext : public antlr4::ParserRuleContext { + public: + FuncFParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector funcFParam(); + FuncFParamContext* funcFParam(size_t i); + std::vector COMMA(); + antlr4::tree::TerminalNode* COMMA(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncFParamsContext* funcFParams(); + + class FuncFParamContext : public antlr4::ParserRuleContext { + public: + FuncFParamContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + antlr4::tree::TerminalNode *IDENT(); + std::vector L_BRACKT(); + antlr4::tree::TerminalNode* L_BRACKT(size_t i); + std::vector R_BRACKT(); + antlr4::tree::TerminalNode* R_BRACKT(size_t i); + std::vector exp(); + ExpContext* exp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncFParamContext* funcFParam(); + + class BlockContext : public antlr4::ParserRuleContext { + public: + BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *L_BRACE(); + antlr4::tree::TerminalNode *R_BRACE(); + std::vector blockItem(); + BlockItemContext* blockItem(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BlockContext* block(); + + class BlockItemContext : public antlr4::ParserRuleContext { + public: + BlockItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstDeclContext *constDecl(); + VarDeclContext *varDecl(); + StmtContext *stmt(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BlockItemContext* blockItem(); + + class StmtContext : public antlr4::ParserRuleContext { + public: + StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AssignStmtContext *assignStmt(); + ExpStmtContext *expStmt(); + BlockContext *block(); + ConditionStmtContext *conditionStmt(); + WhileStmtContext *whileStmt(); + BreakStmtContext *breakStmt(); + ContinueStmtContext *continueStmt(); + ReturnStmtContext *returnStmt(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StmtContext* stmt(); + + class AssignStmtContext : public antlr4::ParserRuleContext { + public: + AssignStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LValContext *lVal(); + antlr4::tree::TerminalNode *ASSIGN(); + ExpContext *exp(); + antlr4::tree::TerminalNode *SEMICOLON(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AssignStmtContext* assignStmt(); + + class ExpStmtContext : public antlr4::ParserRuleContext { + public: + ExpStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *SEMICOLON(); + ExpContext *exp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ExpStmtContext* expStmt(); + + class ConditionStmtContext : public antlr4::ParserRuleContext { + public: + ConditionStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *IF_KW(); + antlr4::tree::TerminalNode *L_PAREN(); + CondContext *cond(); + antlr4::tree::TerminalNode *R_PAREN(); + std::vector stmt(); + StmtContext* stmt(size_t i); + antlr4::tree::TerminalNode *ELSE_KW(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConditionStmtContext* conditionStmt(); + + class WhileStmtContext : public antlr4::ParserRuleContext { + public: + WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *WHILE_KW(); + antlr4::tree::TerminalNode *L_PAREN(); + CondContext *cond(); + antlr4::tree::TerminalNode *R_PAREN(); + StmtContext *stmt(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + WhileStmtContext* whileStmt(); + + class BreakStmtContext : public antlr4::ParserRuleContext { + public: + BreakStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *BREAK_KW(); + antlr4::tree::TerminalNode *SEMICOLON(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BreakStmtContext* breakStmt(); + + class ContinueStmtContext : public antlr4::ParserRuleContext { + public: + ContinueStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *CONTINUE_KW(); + antlr4::tree::TerminalNode *SEMICOLON(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ContinueStmtContext* continueStmt(); + + class ReturnStmtContext : public antlr4::ParserRuleContext { + public: + ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *RETURN_KW(); + antlr4::tree::TerminalNode *SEMICOLON(); + ExpContext *exp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ReturnStmtContext* returnStmt(); + + class ExpContext : public antlr4::ParserRuleContext { + public: + ExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AddExpContext *addExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ExpContext* exp(); + + class CondContext : public antlr4::ParserRuleContext { + public: + CondContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LOrExpContext *lOrExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CondContext* cond(); + + class LValContext : public antlr4::ParserRuleContext { + public: + LValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *IDENT(); + std::vector L_BRACKT(); + antlr4::tree::TerminalNode* L_BRACKT(size_t i); + std::vector exp(); + ExpContext* exp(size_t i); + std::vector R_BRACKT(); + antlr4::tree::TerminalNode* R_BRACKT(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LValContext* lVal(); + + class PrimaryExpContext : public antlr4::ParserRuleContext { + public: + PrimaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *L_PAREN(); + ExpContext *exp(); + antlr4::tree::TerminalNode *R_PAREN(); + LValContext *lVal(); + NumberContext *number(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + PrimaryExpContext* primaryExp(); + + class NumberContext : public antlr4::ParserRuleContext { + public: + NumberContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IntConstContext *intConst(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NumberContext* number(); + + class IntConstContext : public antlr4::ParserRuleContext { + public: + IntConstContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *DECIMAL_CONST(); + antlr4::tree::TerminalNode *OCTAL_CONST(); + antlr4::tree::TerminalNode *HEXADECIMAL_CONST(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + IntConstContext* intConst(); + + class UnaryExpContext : public antlr4::ParserRuleContext { + public: + UnaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PrimaryExpContext *primaryExp(); + CalleeContext *callee(); + UnaryOpContext *unaryOp(); + UnaryExpContext *unaryExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnaryExpContext* unaryExp(); + + class CalleeContext : public antlr4::ParserRuleContext { + public: + CalleeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *IDENT(); + antlr4::tree::TerminalNode *L_PAREN(); + antlr4::tree::TerminalNode *R_PAREN(); + FuncRParamsContext *funcRParams(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CalleeContext* callee(); + + class UnaryOpContext : public antlr4::ParserRuleContext { + public: + UnaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *PLUS(); + antlr4::tree::TerminalNode *MINUS(); + antlr4::tree::TerminalNode *NOT(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnaryOpContext* unaryOp(); + + class FuncRParamsContext : public antlr4::ParserRuleContext { + public: + FuncRParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector param(); + ParamContext* param(size_t i); + std::vector COMMA(); + antlr4::tree::TerminalNode* COMMA(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncRParamsContext* funcRParams(); + + class ParamContext : public antlr4::ParserRuleContext { + public: + ParamContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpContext *exp(); + antlr4::tree::TerminalNode *STRING(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ParamContext* param(); + + class MulExpContext : public antlr4::ParserRuleContext { + public: + MulExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector unaryExp(); + UnaryExpContext* unaryExp(size_t i); + std::vector mulOp(); + MulOpContext* mulOp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MulExpContext* mulExp(); + + class MulOpContext : public antlr4::ParserRuleContext { + public: + MulOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *MUL(); + antlr4::tree::TerminalNode *DIV(); + antlr4::tree::TerminalNode *MOD(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MulOpContext* mulOp(); + + class AddExpContext : public antlr4::ParserRuleContext { + public: + AddExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector mulExp(); + MulExpContext* mulExp(size_t i); + std::vector addOp(); + AddOpContext* addOp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AddExpContext* addExp(); + + class AddOpContext : public antlr4::ParserRuleContext { + public: + AddOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *PLUS(); + antlr4::tree::TerminalNode *MINUS(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AddOpContext* addOp(); + + class RelExpContext : public antlr4::ParserRuleContext { + public: + RelExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector addExp(); + AddExpContext* addExp(size_t i); + std::vector relOp(); + RelOpContext* relOp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + RelExpContext* relExp(); + + class RelOpContext : public antlr4::ParserRuleContext { + public: + RelOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LT(); + antlr4::tree::TerminalNode *GT(); + antlr4::tree::TerminalNode *LE(); + antlr4::tree::TerminalNode *GE(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + RelOpContext* relOp(); + + class EqExpContext : public antlr4::ParserRuleContext { + public: + EqExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector relExp(); + RelExpContext* relExp(size_t i); + std::vector eqOp(); + EqOpContext* eqOp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EqExpContext* eqExp(); + + class EqOpContext : public antlr4::ParserRuleContext { + public: + EqOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *EQ(); + antlr4::tree::TerminalNode *NEQ(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EqOpContext* eqOp(); + + class LAndExpContext : public antlr4::ParserRuleContext { + public: + LAndExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector eqExp(); + EqExpContext* eqExp(size_t i); + std::vector AND(); + antlr4::tree::TerminalNode* AND(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LAndExpContext* lAndExp(); + + class LOrExpContext : public antlr4::ParserRuleContext { + public: + LOrExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector lAndExp(); + LAndExpContext* lAndExp(size_t i); + std::vector OR(); + antlr4::tree::TerminalNode* OR(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LOrExpContext* lOrExp(); + + class ConstExpContext : public antlr4::ParserRuleContext { + public: + ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AddExpContext *addExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstExpContext* constExp(); + + + // By default the static state used to implement the parser is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: +}; + +} // namespace antlrSysY diff --git a/include/SysYVisitor.h b/include/SysYVisitor.h new file mode 100644 index 0000000..7e5eb06 --- /dev/null +++ b/include/SysYVisitor.h @@ -0,0 +1,118 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SysYParser.h" + + +namespace antlrSysY { + +/** + * This class defines an abstract visitor for a parse tree + * produced by SysYParser. + */ +class SysYVisitor : public antlr4::tree::AbstractParseTreeVisitor { +public: + + /** + * Visit parse trees produced by SysYParser. + */ + virtual std::any visitProgram(SysYParser::ProgramContext *context) = 0; + + virtual std::any visitCompUnit(SysYParser::CompUnitContext *context) = 0; + + virtual std::any visitDecl(SysYParser::DeclContext *context) = 0; + + virtual std::any visitConstDecl(SysYParser::ConstDeclContext *context) = 0; + + virtual std::any visitBType(SysYParser::BTypeContext *context) = 0; + + virtual std::any visitConstDef(SysYParser::ConstDefContext *context) = 0; + + virtual std::any visitConstInitVal(SysYParser::ConstInitValContext *context) = 0; + + virtual std::any visitVarDecl(SysYParser::VarDeclContext *context) = 0; + + virtual std::any visitVarDef(SysYParser::VarDefContext *context) = 0; + + virtual std::any visitInitVal(SysYParser::InitValContext *context) = 0; + + virtual std::any visitFuncDef(SysYParser::FuncDefContext *context) = 0; + + virtual std::any visitFuncType(SysYParser::FuncTypeContext *context) = 0; + + virtual std::any visitFuncFParams(SysYParser::FuncFParamsContext *context) = 0; + + virtual std::any visitFuncFParam(SysYParser::FuncFParamContext *context) = 0; + + virtual std::any visitBlock(SysYParser::BlockContext *context) = 0; + + virtual std::any visitBlockItem(SysYParser::BlockItemContext *context) = 0; + + virtual std::any visitStmt(SysYParser::StmtContext *context) = 0; + + virtual std::any visitAssignStmt(SysYParser::AssignStmtContext *context) = 0; + + virtual std::any visitExpStmt(SysYParser::ExpStmtContext *context) = 0; + + virtual std::any visitConditionStmt(SysYParser::ConditionStmtContext *context) = 0; + + virtual std::any visitWhileStmt(SysYParser::WhileStmtContext *context) = 0; + + virtual std::any visitBreakStmt(SysYParser::BreakStmtContext *context) = 0; + + virtual std::any visitContinueStmt(SysYParser::ContinueStmtContext *context) = 0; + + virtual std::any visitReturnStmt(SysYParser::ReturnStmtContext *context) = 0; + + virtual std::any visitExp(SysYParser::ExpContext *context) = 0; + + virtual std::any visitCond(SysYParser::CondContext *context) = 0; + + virtual std::any visitLVal(SysYParser::LValContext *context) = 0; + + virtual std::any visitPrimaryExp(SysYParser::PrimaryExpContext *context) = 0; + + virtual std::any visitNumber(SysYParser::NumberContext *context) = 0; + + virtual std::any visitIntConst(SysYParser::IntConstContext *context) = 0; + + virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *context) = 0; + + virtual std::any visitCallee(SysYParser::CalleeContext *context) = 0; + + virtual std::any visitUnaryOp(SysYParser::UnaryOpContext *context) = 0; + + virtual std::any visitFuncRParams(SysYParser::FuncRParamsContext *context) = 0; + + virtual std::any visitParam(SysYParser::ParamContext *context) = 0; + + virtual std::any visitMulExp(SysYParser::MulExpContext *context) = 0; + + virtual std::any visitMulOp(SysYParser::MulOpContext *context) = 0; + + virtual std::any visitAddExp(SysYParser::AddExpContext *context) = 0; + + virtual std::any visitAddOp(SysYParser::AddOpContext *context) = 0; + + virtual std::any visitRelExp(SysYParser::RelExpContext *context) = 0; + + virtual std::any visitRelOp(SysYParser::RelOpContext *context) = 0; + + virtual std::any visitEqExp(SysYParser::EqExpContext *context) = 0; + + virtual std::any visitEqOp(SysYParser::EqOpContext *context) = 0; + + virtual std::any visitLAndExp(SysYParser::LAndExpContext *context) = 0; + + virtual std::any visitLOrExp(SysYParser::LOrExpContext *context) = 0; + + virtual std::any visitConstExp(SysYParser::ConstExpContext *context) = 0; + + +}; + +} // namespace antlrSysY diff --git a/scripts/antlr4-gen.sh b/scripts/antlr4-gen.sh new file mode 100755 index 0000000..cab1f64 --- /dev/null +++ b/scripts/antlr4-gen.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +mkdir -p build/antlr-gen +mkdir -p include +mkdir -p src +java -jar ./tools/antlr-4.12.0-complete.jar -no-listener -visitor -Dlanguage=Cpp -package antlrSysY -o build/antlr-gen SysY.g4 +cp build/antlr-gen/*.cpp src/ +cp build/antlr-gen/*.h include/ \ No newline at end of file diff --git a/scripts/install-runtime.sh b/scripts/install-runtime.sh new file mode 100644 index 0000000..4681a5f --- /dev/null +++ b/scripts/install-runtime.sh @@ -0,0 +1,15 @@ +#!/bin/bash + +mkdir -pv build/antlr4-cpp-runtime +unzip unzip tools/antlr4-cpp-runtime-4.12.0-source.zip -d build/antlr4-cpp-runtime +cd build/antlr4-cpp-runtime +mkdir build && mkdir run && cd build +cmake .. +make -j`nproc` +DESTDIR=../run make install +cd ../run +cd ../run/usr/local/include +sudo cp -r antlr4-runtime /usr/local/include +cd ../lib +sudo cp -r * /usr/local/lib +sudo ldconfig \ No newline at end of file diff --git a/src/SysYBaseVisitor.cpp b/src/SysYBaseVisitor.cpp new file mode 100644 index 0000000..cef7a78 --- /dev/null +++ b/src/SysYBaseVisitor.cpp @@ -0,0 +1,9 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + + +#include "SysYBaseVisitor.h" + + +using namespace antlrSysY; + diff --git a/src/SysYLexer.cpp b/src/SysYLexer.cpp new file mode 100644 index 0000000..bc8a0ae --- /dev/null +++ b/src/SysYLexer.cpp @@ -0,0 +1,235 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + + +#include "SysYLexer.h" + + +using namespace antlr4; + +using namespace antlrSysY; + + +using namespace antlr4; + +namespace { + +struct SysYLexerStaticData final { + SysYLexerStaticData(std::vector ruleNames, + std::vector channelNames, + std::vector modeNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)), + modeNames(std::move(modeNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + SysYLexerStaticData(const SysYLexerStaticData&) = delete; + SysYLexerStaticData(SysYLexerStaticData&&) = delete; + SysYLexerStaticData& operator=(const SysYLexerStaticData&) = delete; + SysYLexerStaticData& operator=(SysYLexerStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector channelNames; + const std::vector modeNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag sysylexerLexerOnceFlag; +SysYLexerStaticData *sysylexerLexerStaticData = nullptr; + +void sysylexerLexerInitialize() { + assert(sysylexerLexerStaticData == nullptr); + auto staticData = std::make_unique( + std::vector{ + "CONST_KW", "INT_KW", "VOID_KW", "IF_KW", "ELSE_KW", "WHILE_KW", "BREAK_KW", + "CONTINUE_KW", "RETURN_KW", "IDENT", "DECIMAL_CONST", "OCTAL_CONST", + "HEXADECIMAL_CONST", "STRING", "REGULAR_CHAR", "ESC", "PLUS", "MINUS", + "NOT", "MUL", "DIV", "MOD", "ASSIGN", "EQ", "NEQ", "LT", "GT", "LE", + "GE", "AND", "OR", "L_PAREN", "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACKT", + "R_BRACKT", "COMMA", "SEMICOLON", "DOUBLE_QUOTE", "WS", "LINE_COMMENT", + "MULTILINE_COMMENT" + }, + std::vector{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }, + std::vector{ + "DEFAULT_MODE" + }, + std::vector{ + "", "'const'", "'int'", "'void'", "'if'", "'else'", "'while'", "'break'", + "'continue'", "'return'", "", "", "", "", "", "'+'", "'-'", "'!'", + "'*'", "'/'", "'%'", "'='", "'=='", "'!='", "'<'", "'>'", "'<='", + "'>='", "'&&'", "'||'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "','", "';'", "'\"'" + }, + std::vector{ + "", "CONST_KW", "INT_KW", "VOID_KW", "IF_KW", "ELSE_KW", "WHILE_KW", + "BREAK_KW", "CONTINUE_KW", "RETURN_KW", "IDENT", "DECIMAL_CONST", + "OCTAL_CONST", "HEXADECIMAL_CONST", "STRING", "PLUS", "MINUS", "NOT", + "MUL", "DIV", "MOD", "ASSIGN", "EQ", "NEQ", "LT", "GT", "LE", "GE", + "AND", "OR", "L_PAREN", "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACKT", + "R_BRACKT", "COMMA", "SEMICOLON", "DOUBLE_QUOTE", "WS", "LINE_COMMENT", + "MULTILINE_COMMENT" + } + ); + static const int32_t serializedATNSegment[] = { + 4,0,41,281,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, + 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14, + 7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21, + 7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28, + 7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35, + 7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42, + 7,42,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,3, + 1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6,1, + 6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8, + 1,9,1,9,1,9,4,9,142,8,9,11,9,12,9,143,3,9,146,8,9,1,10,1,10,1,10,4,10, + 151,8,10,11,10,12,10,152,3,10,155,8,10,1,11,1,11,1,11,4,11,160,8,11,11, + 11,12,11,161,3,11,164,8,11,1,12,1,12,1,12,1,12,3,12,170,8,12,1,12,4,12, + 173,8,12,11,12,12,12,174,1,13,1,13,5,13,179,8,13,10,13,12,13,182,9,13, + 1,13,1,13,1,14,1,14,3,14,188,8,14,1,15,1,15,1,15,1,15,3,15,194,8,15,1, + 16,1,16,1,17,1,17,1,18,1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1, + 23,1,23,1,23,1,24,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,27,1,28,1, + 28,1,28,1,29,1,29,1,29,1,30,1,30,1,30,1,31,1,31,1,32,1,32,1,33,1,33,1, + 34,1,34,1,35,1,35,1,36,1,36,1,37,1,37,1,38,1,38,1,39,1,39,1,40,4,40,251, + 8,40,11,40,12,40,252,1,40,1,40,1,41,1,41,1,41,1,41,5,41,261,8,41,10,41, + 12,41,264,9,41,1,41,1,41,1,42,1,42,1,42,1,42,5,42,272,8,42,10,42,12,42, + 275,9,42,1,42,1,42,1,42,1,42,1,42,2,180,273,0,43,1,1,3,2,5,3,7,4,9,5, + 11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,0,31,0,33,15,35, + 16,37,17,39,18,41,19,43,20,45,21,47,22,49,23,51,24,53,25,55,26,57,27, + 59,28,61,29,63,30,65,31,67,32,69,33,71,34,73,35,75,36,77,37,79,38,81, + 39,83,40,85,41,1,0,8,3,0,65,90,95,95,97,122,4,0,48,57,65,90,95,95,97, + 122,1,0,49,57,1,0,48,57,1,0,48,55,3,0,48,57,65,70,97,102,3,0,9,10,13, + 13,32,32,2,0,10,10,13,13,292,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7, + 1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0, + 0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27,1,0,0,0,0, + 33,1,0,0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1, + 0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0, + 0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0, + 65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1, + 0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0, + 0,1,87,1,0,0,0,3,93,1,0,0,0,5,97,1,0,0,0,7,102,1,0,0,0,9,105,1,0,0,0, + 11,110,1,0,0,0,13,116,1,0,0,0,15,122,1,0,0,0,17,131,1,0,0,0,19,145,1, + 0,0,0,21,154,1,0,0,0,23,163,1,0,0,0,25,169,1,0,0,0,27,176,1,0,0,0,29, + 187,1,0,0,0,31,193,1,0,0,0,33,195,1,0,0,0,35,197,1,0,0,0,37,199,1,0,0, + 0,39,201,1,0,0,0,41,203,1,0,0,0,43,205,1,0,0,0,45,207,1,0,0,0,47,209, + 1,0,0,0,49,212,1,0,0,0,51,215,1,0,0,0,53,217,1,0,0,0,55,219,1,0,0,0,57, + 222,1,0,0,0,59,225,1,0,0,0,61,228,1,0,0,0,63,231,1,0,0,0,65,233,1,0,0, + 0,67,235,1,0,0,0,69,237,1,0,0,0,71,239,1,0,0,0,73,241,1,0,0,0,75,243, + 1,0,0,0,77,245,1,0,0,0,79,247,1,0,0,0,81,250,1,0,0,0,83,256,1,0,0,0,85, + 267,1,0,0,0,87,88,5,99,0,0,88,89,5,111,0,0,89,90,5,110,0,0,90,91,5,115, + 0,0,91,92,5,116,0,0,92,2,1,0,0,0,93,94,5,105,0,0,94,95,5,110,0,0,95,96, + 5,116,0,0,96,4,1,0,0,0,97,98,5,118,0,0,98,99,5,111,0,0,99,100,5,105,0, + 0,100,101,5,100,0,0,101,6,1,0,0,0,102,103,5,105,0,0,103,104,5,102,0,0, + 104,8,1,0,0,0,105,106,5,101,0,0,106,107,5,108,0,0,107,108,5,115,0,0,108, + 109,5,101,0,0,109,10,1,0,0,0,110,111,5,119,0,0,111,112,5,104,0,0,112, + 113,5,105,0,0,113,114,5,108,0,0,114,115,5,101,0,0,115,12,1,0,0,0,116, + 117,5,98,0,0,117,118,5,114,0,0,118,119,5,101,0,0,119,120,5,97,0,0,120, + 121,5,107,0,0,121,14,1,0,0,0,122,123,5,99,0,0,123,124,5,111,0,0,124,125, + 5,110,0,0,125,126,5,116,0,0,126,127,5,105,0,0,127,128,5,110,0,0,128,129, + 5,117,0,0,129,130,5,101,0,0,130,16,1,0,0,0,131,132,5,114,0,0,132,133, + 5,101,0,0,133,134,5,116,0,0,134,135,5,117,0,0,135,136,5,114,0,0,136,137, + 5,110,0,0,137,18,1,0,0,0,138,146,7,0,0,0,139,141,7,0,0,0,140,142,7,1, + 0,0,141,140,1,0,0,0,142,143,1,0,0,0,143,141,1,0,0,0,143,144,1,0,0,0,144, + 146,1,0,0,0,145,138,1,0,0,0,145,139,1,0,0,0,146,20,1,0,0,0,147,155,7, + 2,0,0,148,150,7,2,0,0,149,151,7,3,0,0,150,149,1,0,0,0,151,152,1,0,0,0, + 152,150,1,0,0,0,152,153,1,0,0,0,153,155,1,0,0,0,154,147,1,0,0,0,154,148, + 1,0,0,0,155,22,1,0,0,0,156,164,5,48,0,0,157,159,5,48,0,0,158,160,7,4, + 0,0,159,158,1,0,0,0,160,161,1,0,0,0,161,159,1,0,0,0,161,162,1,0,0,0,162, + 164,1,0,0,0,163,156,1,0,0,0,163,157,1,0,0,0,164,24,1,0,0,0,165,166,5, + 48,0,0,166,170,5,120,0,0,167,168,5,48,0,0,168,170,5,88,0,0,169,165,1, + 0,0,0,169,167,1,0,0,0,170,172,1,0,0,0,171,173,7,5,0,0,172,171,1,0,0,0, + 173,174,1,0,0,0,174,172,1,0,0,0,174,175,1,0,0,0,175,26,1,0,0,0,176,180, + 3,79,39,0,177,179,3,29,14,0,178,177,1,0,0,0,179,182,1,0,0,0,180,181,1, + 0,0,0,180,178,1,0,0,0,181,183,1,0,0,0,182,180,1,0,0,0,183,184,3,79,39, + 0,184,28,1,0,0,0,185,188,3,31,15,0,186,188,9,0,0,0,187,185,1,0,0,0,187, + 186,1,0,0,0,188,30,1,0,0,0,189,190,5,92,0,0,190,194,5,34,0,0,191,192, + 5,92,0,0,192,194,5,92,0,0,193,189,1,0,0,0,193,191,1,0,0,0,194,32,1,0, + 0,0,195,196,5,43,0,0,196,34,1,0,0,0,197,198,5,45,0,0,198,36,1,0,0,0,199, + 200,5,33,0,0,200,38,1,0,0,0,201,202,5,42,0,0,202,40,1,0,0,0,203,204,5, + 47,0,0,204,42,1,0,0,0,205,206,5,37,0,0,206,44,1,0,0,0,207,208,5,61,0, + 0,208,46,1,0,0,0,209,210,5,61,0,0,210,211,5,61,0,0,211,48,1,0,0,0,212, + 213,5,33,0,0,213,214,5,61,0,0,214,50,1,0,0,0,215,216,5,60,0,0,216,52, + 1,0,0,0,217,218,5,62,0,0,218,54,1,0,0,0,219,220,5,60,0,0,220,221,5,61, + 0,0,221,56,1,0,0,0,222,223,5,62,0,0,223,224,5,61,0,0,224,58,1,0,0,0,225, + 226,5,38,0,0,226,227,5,38,0,0,227,60,1,0,0,0,228,229,5,124,0,0,229,230, + 5,124,0,0,230,62,1,0,0,0,231,232,5,40,0,0,232,64,1,0,0,0,233,234,5,41, + 0,0,234,66,1,0,0,0,235,236,5,123,0,0,236,68,1,0,0,0,237,238,5,125,0,0, + 238,70,1,0,0,0,239,240,5,91,0,0,240,72,1,0,0,0,241,242,5,93,0,0,242,74, + 1,0,0,0,243,244,5,44,0,0,244,76,1,0,0,0,245,246,5,59,0,0,246,78,1,0,0, + 0,247,248,5,34,0,0,248,80,1,0,0,0,249,251,7,6,0,0,250,249,1,0,0,0,251, + 252,1,0,0,0,252,250,1,0,0,0,252,253,1,0,0,0,253,254,1,0,0,0,254,255,6, + 40,0,0,255,82,1,0,0,0,256,257,5,47,0,0,257,258,5,47,0,0,258,262,1,0,0, + 0,259,261,8,7,0,0,260,259,1,0,0,0,261,264,1,0,0,0,262,260,1,0,0,0,262, + 263,1,0,0,0,263,265,1,0,0,0,264,262,1,0,0,0,265,266,6,41,0,0,266,84,1, + 0,0,0,267,268,5,47,0,0,268,269,5,42,0,0,269,273,1,0,0,0,270,272,9,0,0, + 0,271,270,1,0,0,0,272,275,1,0,0,0,273,274,1,0,0,0,273,271,1,0,0,0,274, + 276,1,0,0,0,275,273,1,0,0,0,276,277,5,42,0,0,277,278,5,47,0,0,278,279, + 1,0,0,0,279,280,6,42,0,0,280,86,1,0,0,0,15,0,143,145,152,154,161,163, + 169,174,180,187,193,252,262,273,1,6,0,0 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + sysylexerLexerStaticData = staticData.release(); +} + +} + +SysYLexer::SysYLexer(CharStream *input) : Lexer(input) { + SysYLexer::initialize(); + _interpreter = new atn::LexerATNSimulator(this, *sysylexerLexerStaticData->atn, sysylexerLexerStaticData->decisionToDFA, sysylexerLexerStaticData->sharedContextCache); +} + +SysYLexer::~SysYLexer() { + delete _interpreter; +} + +std::string SysYLexer::getGrammarFileName() const { + return "SysY.g4"; +} + +const std::vector& SysYLexer::getRuleNames() const { + return sysylexerLexerStaticData->ruleNames; +} + +const std::vector& SysYLexer::getChannelNames() const { + return sysylexerLexerStaticData->channelNames; +} + +const std::vector& SysYLexer::getModeNames() const { + return sysylexerLexerStaticData->modeNames; +} + +const dfa::Vocabulary& SysYLexer::getVocabulary() const { + return sysylexerLexerStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView SysYLexer::getSerializedATN() const { + return sysylexerLexerStaticData->serializedATN; +} + +const atn::ATN& SysYLexer::getATN() const { + return *sysylexerLexerStaticData->atn; +} + + + + +void SysYLexer::initialize() { + ::antlr4::internal::call_once(sysylexerLexerOnceFlag, sysylexerLexerInitialize); +} diff --git a/src/SysYParser.cpp b/src/SysYParser.cpp new file mode 100644 index 0000000..9553fb1 --- /dev/null +++ b/src/SysYParser.cpp @@ -0,0 +1,3780 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + + +#include "SysYVisitor.h" + +#include "SysYParser.h" + + +using namespace antlrcpp; +using namespace antlrSysY; + +using namespace antlr4; + +namespace { + +struct SysYParserStaticData final { + SysYParserStaticData(std::vector ruleNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + SysYParserStaticData(const SysYParserStaticData&) = delete; + SysYParserStaticData(SysYParserStaticData&&) = delete; + SysYParserStaticData& operator=(const SysYParserStaticData&) = delete; + SysYParserStaticData& operator=(SysYParserStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag sysyParserOnceFlag; +SysYParserStaticData *sysyParserStaticData = nullptr; + +void sysyParserInitialize() { + assert(sysyParserStaticData == nullptr); + auto staticData = std::make_unique( + std::vector{ + "program", "compUnit", "decl", "constDecl", "bType", "constDef", "constInitVal", + "varDecl", "varDef", "initVal", "funcDef", "funcType", "funcFParams", + "funcFParam", "block", "blockItem", "stmt", "assignStmt", "expStmt", + "conditionStmt", "whileStmt", "breakStmt", "continueStmt", "returnStmt", + "exp", "cond", "lVal", "primaryExp", "number", "intConst", "unaryExp", + "callee", "unaryOp", "funcRParams", "param", "mulExp", "mulOp", "addExp", + "addOp", "relExp", "relOp", "eqExp", "eqOp", "lAndExp", "lOrExp", + "constExp" + }, + std::vector{ + "", "'const'", "'int'", "'void'", "'if'", "'else'", "'while'", "'break'", + "'continue'", "'return'", "", "", "", "", "", "'+'", "'-'", "'!'", + "'*'", "'/'", "'%'", "'='", "'=='", "'!='", "'<'", "'>'", "'<='", + "'>='", "'&&'", "'||'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "','", "';'", "'\"'" + }, + std::vector{ + "", "CONST_KW", "INT_KW", "VOID_KW", "IF_KW", "ELSE_KW", "WHILE_KW", + "BREAK_KW", "CONTINUE_KW", "RETURN_KW", "IDENT", "DECIMAL_CONST", + "OCTAL_CONST", "HEXADECIMAL_CONST", "STRING", "PLUS", "MINUS", "NOT", + "MUL", "DIV", "MOD", "ASSIGN", "EQ", "NEQ", "LT", "GT", "LE", "GE", + "AND", "OR", "L_PAREN", "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACKT", + "R_BRACKT", "COMMA", "SEMICOLON", "DOUBLE_QUOTE", "WS", "LINE_COMMENT", + "MULTILINE_COMMENT" + } + ); + static const int32_t serializedATNSegment[] = { + 4,1,41,398,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2, + 7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7, + 14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,7, + 21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,7, + 28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,7, + 35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,7, + 42,2,43,7,43,2,44,7,44,2,45,7,45,1,0,1,0,1,1,1,1,4,1,97,8,1,11,1,12,1, + 98,1,2,1,2,3,2,103,8,2,1,3,1,3,1,3,1,3,1,3,5,3,110,8,3,10,3,12,3,113, + 9,3,1,3,1,3,1,4,1,4,1,5,1,5,1,5,1,5,1,5,5,5,124,8,5,10,5,12,5,127,9,5, + 1,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,5,6,137,8,6,10,6,12,6,140,9,6,3,6,142, + 8,6,1,6,3,6,145,8,6,1,7,1,7,1,7,1,7,5,7,151,8,7,10,7,12,7,154,9,7,1,7, + 1,7,1,8,1,8,1,8,1,8,1,8,5,8,163,8,8,10,8,12,8,166,9,8,1,8,1,8,3,8,170, + 8,8,1,9,1,9,1,9,1,9,1,9,5,9,177,8,9,10,9,12,9,180,9,9,3,9,182,8,9,1,9, + 3,9,185,8,9,1,10,1,10,1,10,1,10,3,10,191,8,10,1,10,1,10,1,10,1,11,1,11, + 1,12,1,12,1,12,5,12,201,8,12,10,12,12,12,204,9,12,1,13,1,13,1,13,1,13, + 1,13,1,13,1,13,1,13,5,13,214,8,13,10,13,12,13,217,9,13,3,13,219,8,13, + 1,14,1,14,5,14,223,8,14,10,14,12,14,226,9,14,1,14,1,14,1,15,1,15,1,15, + 3,15,233,8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,243,8,16,1, + 17,1,17,1,17,1,17,1,17,1,18,3,18,251,8,18,1,18,1,18,1,19,1,19,1,19,1, + 19,1,19,1,19,1,19,3,19,262,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,21,1, + 21,1,21,1,22,1,22,1,22,1,23,1,23,3,23,278,8,23,1,23,1,23,1,24,1,24,1, + 25,1,25,1,26,1,26,1,26,1,26,1,26,5,26,291,8,26,10,26,12,26,294,9,26,1, + 27,1,27,1,27,1,27,1,27,1,27,3,27,302,8,27,1,28,1,28,1,29,1,29,1,30,1, + 30,1,30,1,30,1,30,3,30,313,8,30,1,31,1,31,1,31,3,31,318,8,31,1,31,1,31, + 1,32,1,32,1,33,1,33,1,33,5,33,327,8,33,10,33,12,33,330,9,33,1,34,1,34, + 3,34,334,8,34,1,35,1,35,1,35,1,35,5,35,340,8,35,10,35,12,35,343,9,35, + 1,36,1,36,1,37,1,37,1,37,1,37,5,37,351,8,37,10,37,12,37,354,9,37,1,38, + 1,38,1,39,1,39,1,39,1,39,5,39,362,8,39,10,39,12,39,365,9,39,1,40,1,40, + 1,41,1,41,1,41,1,41,5,41,373,8,41,10,41,12,41,376,9,41,1,42,1,42,1,43, + 1,43,1,43,5,43,383,8,43,10,43,12,43,386,9,43,1,44,1,44,1,44,5,44,391, + 8,44,10,44,12,44,394,9,44,1,45,1,45,1,45,0,0,46,0,2,4,6,8,10,12,14,16, + 18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62, + 64,66,68,70,72,74,76,78,80,82,84,86,88,90,0,7,1,0,2,3,1,0,11,13,1,0,15, + 17,1,0,18,20,1,0,15,16,1,0,24,27,1,0,22,23,396,0,92,1,0,0,0,2,96,1,0, + 0,0,4,102,1,0,0,0,6,104,1,0,0,0,8,116,1,0,0,0,10,118,1,0,0,0,12,144,1, + 0,0,0,14,146,1,0,0,0,16,157,1,0,0,0,18,184,1,0,0,0,20,186,1,0,0,0,22, + 195,1,0,0,0,24,197,1,0,0,0,26,205,1,0,0,0,28,220,1,0,0,0,30,232,1,0,0, + 0,32,242,1,0,0,0,34,244,1,0,0,0,36,250,1,0,0,0,38,254,1,0,0,0,40,263, + 1,0,0,0,42,269,1,0,0,0,44,272,1,0,0,0,46,275,1,0,0,0,48,281,1,0,0,0,50, + 283,1,0,0,0,52,285,1,0,0,0,54,301,1,0,0,0,56,303,1,0,0,0,58,305,1,0,0, + 0,60,312,1,0,0,0,62,314,1,0,0,0,64,321,1,0,0,0,66,323,1,0,0,0,68,333, + 1,0,0,0,70,335,1,0,0,0,72,344,1,0,0,0,74,346,1,0,0,0,76,355,1,0,0,0,78, + 357,1,0,0,0,80,366,1,0,0,0,82,368,1,0,0,0,84,377,1,0,0,0,86,379,1,0,0, + 0,88,387,1,0,0,0,90,395,1,0,0,0,92,93,3,2,1,0,93,1,1,0,0,0,94,97,3,20, + 10,0,95,97,3,4,2,0,96,94,1,0,0,0,96,95,1,0,0,0,97,98,1,0,0,0,98,96,1, + 0,0,0,98,99,1,0,0,0,99,3,1,0,0,0,100,103,3,6,3,0,101,103,3,14,7,0,102, + 100,1,0,0,0,102,101,1,0,0,0,103,5,1,0,0,0,104,105,5,1,0,0,105,106,3,8, + 4,0,106,111,3,10,5,0,107,108,5,36,0,0,108,110,3,10,5,0,109,107,1,0,0, + 0,110,113,1,0,0,0,111,109,1,0,0,0,111,112,1,0,0,0,112,114,1,0,0,0,113, + 111,1,0,0,0,114,115,5,37,0,0,115,7,1,0,0,0,116,117,5,2,0,0,117,9,1,0, + 0,0,118,125,5,10,0,0,119,120,5,34,0,0,120,121,3,90,45,0,121,122,5,35, + 0,0,122,124,1,0,0,0,123,119,1,0,0,0,124,127,1,0,0,0,125,123,1,0,0,0,125, + 126,1,0,0,0,126,128,1,0,0,0,127,125,1,0,0,0,128,129,5,21,0,0,129,130, + 3,12,6,0,130,11,1,0,0,0,131,145,3,90,45,0,132,141,5,32,0,0,133,138,3, + 12,6,0,134,135,5,36,0,0,135,137,3,12,6,0,136,134,1,0,0,0,137,140,1,0, + 0,0,138,136,1,0,0,0,138,139,1,0,0,0,139,142,1,0,0,0,140,138,1,0,0,0,141, + 133,1,0,0,0,141,142,1,0,0,0,142,143,1,0,0,0,143,145,5,33,0,0,144,131, + 1,0,0,0,144,132,1,0,0,0,145,13,1,0,0,0,146,147,3,8,4,0,147,152,3,16,8, + 0,148,149,5,36,0,0,149,151,3,16,8,0,150,148,1,0,0,0,151,154,1,0,0,0,152, + 150,1,0,0,0,152,153,1,0,0,0,153,155,1,0,0,0,154,152,1,0,0,0,155,156,5, + 37,0,0,156,15,1,0,0,0,157,164,5,10,0,0,158,159,5,34,0,0,159,160,3,90, + 45,0,160,161,5,35,0,0,161,163,1,0,0,0,162,158,1,0,0,0,163,166,1,0,0,0, + 164,162,1,0,0,0,164,165,1,0,0,0,165,169,1,0,0,0,166,164,1,0,0,0,167,168, + 5,21,0,0,168,170,3,18,9,0,169,167,1,0,0,0,169,170,1,0,0,0,170,17,1,0, + 0,0,171,185,3,48,24,0,172,181,5,32,0,0,173,178,3,18,9,0,174,175,5,36, + 0,0,175,177,3,18,9,0,176,174,1,0,0,0,177,180,1,0,0,0,178,176,1,0,0,0, + 178,179,1,0,0,0,179,182,1,0,0,0,180,178,1,0,0,0,181,173,1,0,0,0,181,182, + 1,0,0,0,182,183,1,0,0,0,183,185,5,33,0,0,184,171,1,0,0,0,184,172,1,0, + 0,0,185,19,1,0,0,0,186,187,3,22,11,0,187,188,5,10,0,0,188,190,5,30,0, + 0,189,191,3,24,12,0,190,189,1,0,0,0,190,191,1,0,0,0,191,192,1,0,0,0,192, + 193,5,31,0,0,193,194,3,28,14,0,194,21,1,0,0,0,195,196,7,0,0,0,196,23, + 1,0,0,0,197,202,3,26,13,0,198,199,5,36,0,0,199,201,3,26,13,0,200,198, + 1,0,0,0,201,204,1,0,0,0,202,200,1,0,0,0,202,203,1,0,0,0,203,25,1,0,0, + 0,204,202,1,0,0,0,205,206,3,8,4,0,206,218,5,10,0,0,207,208,5,34,0,0,208, + 215,5,35,0,0,209,210,5,34,0,0,210,211,3,48,24,0,211,212,5,35,0,0,212, + 214,1,0,0,0,213,209,1,0,0,0,214,217,1,0,0,0,215,213,1,0,0,0,215,216,1, + 0,0,0,216,219,1,0,0,0,217,215,1,0,0,0,218,207,1,0,0,0,218,219,1,0,0,0, + 219,27,1,0,0,0,220,224,5,32,0,0,221,223,3,30,15,0,222,221,1,0,0,0,223, + 226,1,0,0,0,224,222,1,0,0,0,224,225,1,0,0,0,225,227,1,0,0,0,226,224,1, + 0,0,0,227,228,5,33,0,0,228,29,1,0,0,0,229,233,3,6,3,0,230,233,3,14,7, + 0,231,233,3,32,16,0,232,229,1,0,0,0,232,230,1,0,0,0,232,231,1,0,0,0,233, + 31,1,0,0,0,234,243,3,34,17,0,235,243,3,36,18,0,236,243,3,28,14,0,237, + 243,3,38,19,0,238,243,3,40,20,0,239,243,3,42,21,0,240,243,3,44,22,0,241, + 243,3,46,23,0,242,234,1,0,0,0,242,235,1,0,0,0,242,236,1,0,0,0,242,237, + 1,0,0,0,242,238,1,0,0,0,242,239,1,0,0,0,242,240,1,0,0,0,242,241,1,0,0, + 0,243,33,1,0,0,0,244,245,3,52,26,0,245,246,5,21,0,0,246,247,3,48,24,0, + 247,248,5,37,0,0,248,35,1,0,0,0,249,251,3,48,24,0,250,249,1,0,0,0,250, + 251,1,0,0,0,251,252,1,0,0,0,252,253,5,37,0,0,253,37,1,0,0,0,254,255,5, + 4,0,0,255,256,5,30,0,0,256,257,3,50,25,0,257,258,5,31,0,0,258,261,3,32, + 16,0,259,260,5,5,0,0,260,262,3,32,16,0,261,259,1,0,0,0,261,262,1,0,0, + 0,262,39,1,0,0,0,263,264,5,6,0,0,264,265,5,30,0,0,265,266,3,50,25,0,266, + 267,5,31,0,0,267,268,3,32,16,0,268,41,1,0,0,0,269,270,5,7,0,0,270,271, + 5,37,0,0,271,43,1,0,0,0,272,273,5,8,0,0,273,274,5,37,0,0,274,45,1,0,0, + 0,275,277,5,9,0,0,276,278,3,48,24,0,277,276,1,0,0,0,277,278,1,0,0,0,278, + 279,1,0,0,0,279,280,5,37,0,0,280,47,1,0,0,0,281,282,3,74,37,0,282,49, + 1,0,0,0,283,284,3,88,44,0,284,51,1,0,0,0,285,292,5,10,0,0,286,287,5,34, + 0,0,287,288,3,48,24,0,288,289,5,35,0,0,289,291,1,0,0,0,290,286,1,0,0, + 0,291,294,1,0,0,0,292,290,1,0,0,0,292,293,1,0,0,0,293,53,1,0,0,0,294, + 292,1,0,0,0,295,296,5,30,0,0,296,297,3,48,24,0,297,298,5,31,0,0,298,302, + 1,0,0,0,299,302,3,52,26,0,300,302,3,56,28,0,301,295,1,0,0,0,301,299,1, + 0,0,0,301,300,1,0,0,0,302,55,1,0,0,0,303,304,3,58,29,0,304,57,1,0,0,0, + 305,306,7,1,0,0,306,59,1,0,0,0,307,313,3,54,27,0,308,313,3,62,31,0,309, + 310,3,64,32,0,310,311,3,60,30,0,311,313,1,0,0,0,312,307,1,0,0,0,312,308, + 1,0,0,0,312,309,1,0,0,0,313,61,1,0,0,0,314,315,5,10,0,0,315,317,5,30, + 0,0,316,318,3,66,33,0,317,316,1,0,0,0,317,318,1,0,0,0,318,319,1,0,0,0, + 319,320,5,31,0,0,320,63,1,0,0,0,321,322,7,2,0,0,322,65,1,0,0,0,323,328, + 3,68,34,0,324,325,5,36,0,0,325,327,3,68,34,0,326,324,1,0,0,0,327,330, + 1,0,0,0,328,326,1,0,0,0,328,329,1,0,0,0,329,67,1,0,0,0,330,328,1,0,0, + 0,331,334,3,48,24,0,332,334,5,14,0,0,333,331,1,0,0,0,333,332,1,0,0,0, + 334,69,1,0,0,0,335,341,3,60,30,0,336,337,3,72,36,0,337,338,3,60,30,0, + 338,340,1,0,0,0,339,336,1,0,0,0,340,343,1,0,0,0,341,339,1,0,0,0,341,342, + 1,0,0,0,342,71,1,0,0,0,343,341,1,0,0,0,344,345,7,3,0,0,345,73,1,0,0,0, + 346,352,3,70,35,0,347,348,3,76,38,0,348,349,3,70,35,0,349,351,1,0,0,0, + 350,347,1,0,0,0,351,354,1,0,0,0,352,350,1,0,0,0,352,353,1,0,0,0,353,75, + 1,0,0,0,354,352,1,0,0,0,355,356,7,4,0,0,356,77,1,0,0,0,357,363,3,74,37, + 0,358,359,3,80,40,0,359,360,3,74,37,0,360,362,1,0,0,0,361,358,1,0,0,0, + 362,365,1,0,0,0,363,361,1,0,0,0,363,364,1,0,0,0,364,79,1,0,0,0,365,363, + 1,0,0,0,366,367,7,5,0,0,367,81,1,0,0,0,368,374,3,78,39,0,369,370,3,84, + 42,0,370,371,3,78,39,0,371,373,1,0,0,0,372,369,1,0,0,0,373,376,1,0,0, + 0,374,372,1,0,0,0,374,375,1,0,0,0,375,83,1,0,0,0,376,374,1,0,0,0,377, + 378,7,6,0,0,378,85,1,0,0,0,379,384,3,82,41,0,380,381,5,28,0,0,381,383, + 3,82,41,0,382,380,1,0,0,0,383,386,1,0,0,0,384,382,1,0,0,0,384,385,1,0, + 0,0,385,87,1,0,0,0,386,384,1,0,0,0,387,392,3,86,43,0,388,389,5,29,0,0, + 389,391,3,86,43,0,390,388,1,0,0,0,391,394,1,0,0,0,392,390,1,0,0,0,392, + 393,1,0,0,0,393,89,1,0,0,0,394,392,1,0,0,0,395,396,3,74,37,0,396,91,1, + 0,0,0,36,96,98,102,111,125,138,141,144,152,164,169,178,181,184,190,202, + 215,218,224,232,242,250,261,277,292,301,312,317,328,333,341,352,363,374, + 384,392 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + sysyParserStaticData = staticData.release(); +} + +} + +SysYParser::SysYParser(TokenStream *input) : SysYParser(input, antlr4::atn::ParserATNSimulatorOptions()) {} + +SysYParser::SysYParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { + SysYParser::initialize(); + _interpreter = new atn::ParserATNSimulator(this, *sysyParserStaticData->atn, sysyParserStaticData->decisionToDFA, sysyParserStaticData->sharedContextCache, options); +} + +SysYParser::~SysYParser() { + delete _interpreter; +} + +const atn::ATN& SysYParser::getATN() const { + return *sysyParserStaticData->atn; +} + +std::string SysYParser::getGrammarFileName() const { + return "SysY.g4"; +} + +const std::vector& SysYParser::getRuleNames() const { + return sysyParserStaticData->ruleNames; +} + +const dfa::Vocabulary& SysYParser::getVocabulary() const { + return sysyParserStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView SysYParser::getSerializedATN() const { + return sysyParserStaticData->serializedATN; +} + + +//----------------- ProgramContext ------------------------------------------------------------------ + +SysYParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::CompUnitContext* SysYParser::ProgramContext::compUnit() { + return getRuleContext(0); +} + + +size_t SysYParser::ProgramContext::getRuleIndex() const { + return SysYParser::RuleProgram; +} + + +std::any SysYParser::ProgramContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitProgram(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ProgramContext* SysYParser::program() { + ProgramContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, SysYParser::RuleProgram); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(92); + compUnit(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CompUnitContext ------------------------------------------------------------------ + +SysYParser::CompUnitContext::CompUnitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::CompUnitContext::funcDef() { + return getRuleContexts(); +} + +SysYParser::FuncDefContext* SysYParser::CompUnitContext::funcDef(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::CompUnitContext::decl() { + return getRuleContexts(); +} + +SysYParser::DeclContext* SysYParser::CompUnitContext::decl(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::CompUnitContext::getRuleIndex() const { + return SysYParser::RuleCompUnit; +} + + +std::any SysYParser::CompUnitContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitCompUnit(this); + else + return visitor->visitChildren(this); +} + +SysYParser::CompUnitContext* SysYParser::compUnit() { + CompUnitContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 2, SysYParser::RuleCompUnit); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(96); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(96); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { + case 1: { + setState(94); + funcDef(); + break; + } + + case 2: { + setState(95); + decl(); + break; + } + + default: + break; + } + setState(98); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 14) != 0)); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclContext ------------------------------------------------------------------ + +SysYParser::DeclContext::DeclContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ConstDeclContext* SysYParser::DeclContext::constDecl() { + return getRuleContext(0); +} + +SysYParser::VarDeclContext* SysYParser::DeclContext::varDecl() { + return getRuleContext(0); +} + + +size_t SysYParser::DeclContext::getRuleIndex() const { + return SysYParser::RuleDecl; +} + + +std::any SysYParser::DeclContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitDecl(this); + else + return visitor->visitChildren(this); +} + +SysYParser::DeclContext* SysYParser::decl() { + DeclContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, SysYParser::RuleDecl); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(102); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::CONST_KW: { + enterOuterAlt(_localctx, 1); + setState(100); + constDecl(); + break; + } + + case SysYParser::INT_KW: { + enterOuterAlt(_localctx, 2); + setState(101); + varDecl(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstDeclContext ------------------------------------------------------------------ + +SysYParser::ConstDeclContext::ConstDeclContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ConstDeclContext::CONST_KW() { + return getToken(SysYParser::CONST_KW, 0); +} + +SysYParser::BTypeContext* SysYParser::ConstDeclContext::bType() { + return getRuleContext(0); +} + +std::vector SysYParser::ConstDeclContext::constDef() { + return getRuleContexts(); +} + +SysYParser::ConstDefContext* SysYParser::ConstDeclContext::constDef(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SysYParser::ConstDeclContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +std::vector SysYParser::ConstDeclContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::ConstDeclContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::ConstDeclContext::getRuleIndex() const { + return SysYParser::RuleConstDecl; +} + + +std::any SysYParser::ConstDeclContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstDecl(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstDeclContext* SysYParser::constDecl() { + ConstDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, SysYParser::RuleConstDecl); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(104); + match(SysYParser::CONST_KW); + setState(105); + bType(); + setState(106); + constDef(); + setState(111); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(107); + match(SysYParser::COMMA); + setState(108); + constDef(); + setState(113); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(114); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BTypeContext ------------------------------------------------------------------ + +SysYParser::BTypeContext::BTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::BTypeContext::INT_KW() { + return getToken(SysYParser::INT_KW, 0); +} + + +size_t SysYParser::BTypeContext::getRuleIndex() const { + return SysYParser::RuleBType; +} + + +std::any SysYParser::BTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBType(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BTypeContext* SysYParser::bType() { + BTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, SysYParser::RuleBType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(116); + match(SysYParser::INT_KW); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstDefContext ------------------------------------------------------------------ + +SysYParser::ConstDefContext::ConstDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ConstDefContext::IDENT() { + return getToken(SysYParser::IDENT, 0); +} + +tree::TerminalNode* SysYParser::ConstDefContext::ASSIGN() { + return getToken(SysYParser::ASSIGN, 0); +} + +SysYParser::ConstInitValContext* SysYParser::ConstDefContext::constInitVal() { + return getRuleContext(0); +} + +std::vector SysYParser::ConstDefContext::L_BRACKT() { + return getTokens(SysYParser::L_BRACKT); +} + +tree::TerminalNode* SysYParser::ConstDefContext::L_BRACKT(size_t i) { + return getToken(SysYParser::L_BRACKT, i); +} + +std::vector SysYParser::ConstDefContext::constExp() { + return getRuleContexts(); +} + +SysYParser::ConstExpContext* SysYParser::ConstDefContext::constExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::ConstDefContext::R_BRACKT() { + return getTokens(SysYParser::R_BRACKT); +} + +tree::TerminalNode* SysYParser::ConstDefContext::R_BRACKT(size_t i) { + return getToken(SysYParser::R_BRACKT, i); +} + + +size_t SysYParser::ConstDefContext::getRuleIndex() const { + return SysYParser::RuleConstDef; +} + + +std::any SysYParser::ConstDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstDef(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstDefContext* SysYParser::constDef() { + ConstDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, SysYParser::RuleConstDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(118); + match(SysYParser::IDENT); + setState(125); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::L_BRACKT) { + setState(119); + match(SysYParser::L_BRACKT); + setState(120); + constExp(); + setState(121); + match(SysYParser::R_BRACKT); + setState(127); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(128); + match(SysYParser::ASSIGN); + setState(129); + constInitVal(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstInitValContext ------------------------------------------------------------------ + +SysYParser::ConstInitValContext::ConstInitValContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ConstExpContext* SysYParser::ConstInitValContext::constExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::ConstInitValContext::L_BRACE() { + return getToken(SysYParser::L_BRACE, 0); +} + +tree::TerminalNode* SysYParser::ConstInitValContext::R_BRACE() { + return getToken(SysYParser::R_BRACE, 0); +} + +std::vector SysYParser::ConstInitValContext::constInitVal() { + return getRuleContexts(); +} + +SysYParser::ConstInitValContext* SysYParser::ConstInitValContext::constInitVal(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::ConstInitValContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::ConstInitValContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::ConstInitValContext::getRuleIndex() const { + return SysYParser::RuleConstInitVal; +} + + +std::any SysYParser::ConstInitValContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstInitVal(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstInitValContext* SysYParser::constInitVal() { + ConstInitValContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, SysYParser::RuleConstInitVal); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(144); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::IDENT: + case SysYParser::DECIMAL_CONST: + case SysYParser::OCTAL_CONST: + case SysYParser::HEXADECIMAL_CONST: + case SysYParser::PLUS: + case SysYParser::MINUS: + case SysYParser::NOT: + case SysYParser::L_PAREN: { + enterOuterAlt(_localctx, 1); + setState(131); + constExp(); + break; + } + + case SysYParser::L_BRACE: { + enterOuterAlt(_localctx, 2); + setState(132); + match(SysYParser::L_BRACE); + setState(141); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 5368953856) != 0)) { + setState(133); + constInitVal(); + setState(138); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(134); + match(SysYParser::COMMA); + setState(135); + constInitVal(); + setState(140); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(143); + match(SysYParser::R_BRACE); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VarDeclContext ------------------------------------------------------------------ + +SysYParser::VarDeclContext::VarDeclContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::BTypeContext* SysYParser::VarDeclContext::bType() { + return getRuleContext(0); +} + +std::vector SysYParser::VarDeclContext::varDef() { + return getRuleContexts(); +} + +SysYParser::VarDefContext* SysYParser::VarDeclContext::varDef(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SysYParser::VarDeclContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +std::vector SysYParser::VarDeclContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::VarDeclContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::VarDeclContext::getRuleIndex() const { + return SysYParser::RuleVarDecl; +} + + +std::any SysYParser::VarDeclContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVarDecl(this); + else + return visitor->visitChildren(this); +} + +SysYParser::VarDeclContext* SysYParser::varDecl() { + VarDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 14, SysYParser::RuleVarDecl); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(146); + bType(); + setState(147); + varDef(); + setState(152); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(148); + match(SysYParser::COMMA); + setState(149); + varDef(); + setState(154); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(155); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VarDefContext ------------------------------------------------------------------ + +SysYParser::VarDefContext::VarDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::VarDefContext::IDENT() { + return getToken(SysYParser::IDENT, 0); +} + +std::vector SysYParser::VarDefContext::L_BRACKT() { + return getTokens(SysYParser::L_BRACKT); +} + +tree::TerminalNode* SysYParser::VarDefContext::L_BRACKT(size_t i) { + return getToken(SysYParser::L_BRACKT, i); +} + +std::vector SysYParser::VarDefContext::constExp() { + return getRuleContexts(); +} + +SysYParser::ConstExpContext* SysYParser::VarDefContext::constExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::VarDefContext::R_BRACKT() { + return getTokens(SysYParser::R_BRACKT); +} + +tree::TerminalNode* SysYParser::VarDefContext::R_BRACKT(size_t i) { + return getToken(SysYParser::R_BRACKT, i); +} + +tree::TerminalNode* SysYParser::VarDefContext::ASSIGN() { + return getToken(SysYParser::ASSIGN, 0); +} + +SysYParser::InitValContext* SysYParser::VarDefContext::initVal() { + return getRuleContext(0); +} + + +size_t SysYParser::VarDefContext::getRuleIndex() const { + return SysYParser::RuleVarDef; +} + + +std::any SysYParser::VarDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVarDef(this); + else + return visitor->visitChildren(this); +} + +SysYParser::VarDefContext* SysYParser::varDef() { + VarDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 16, SysYParser::RuleVarDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(157); + match(SysYParser::IDENT); + setState(164); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::L_BRACKT) { + setState(158); + match(SysYParser::L_BRACKT); + setState(159); + constExp(); + setState(160); + match(SysYParser::R_BRACKT); + setState(166); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(169); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::ASSIGN) { + setState(167); + match(SysYParser::ASSIGN); + setState(168); + initVal(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitValContext ------------------------------------------------------------------ + +SysYParser::InitValContext::InitValContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ExpContext* SysYParser::InitValContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::InitValContext::L_BRACE() { + return getToken(SysYParser::L_BRACE, 0); +} + +tree::TerminalNode* SysYParser::InitValContext::R_BRACE() { + return getToken(SysYParser::R_BRACE, 0); +} + +std::vector SysYParser::InitValContext::initVal() { + return getRuleContexts(); +} + +SysYParser::InitValContext* SysYParser::InitValContext::initVal(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::InitValContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::InitValContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::InitValContext::getRuleIndex() const { + return SysYParser::RuleInitVal; +} + + +std::any SysYParser::InitValContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInitVal(this); + else + return visitor->visitChildren(this); +} + +SysYParser::InitValContext* SysYParser::initVal() { + InitValContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 18, SysYParser::RuleInitVal); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(184); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::IDENT: + case SysYParser::DECIMAL_CONST: + case SysYParser::OCTAL_CONST: + case SysYParser::HEXADECIMAL_CONST: + case SysYParser::PLUS: + case SysYParser::MINUS: + case SysYParser::NOT: + case SysYParser::L_PAREN: { + enterOuterAlt(_localctx, 1); + setState(171); + exp(); + break; + } + + case SysYParser::L_BRACE: { + enterOuterAlt(_localctx, 2); + setState(172); + match(SysYParser::L_BRACE); + setState(181); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 5368953856) != 0)) { + setState(173); + initVal(); + setState(178); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(174); + match(SysYParser::COMMA); + setState(175); + initVal(); + setState(180); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(183); + match(SysYParser::R_BRACE); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncDefContext ------------------------------------------------------------------ + +SysYParser::FuncDefContext::FuncDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::FuncTypeContext* SysYParser::FuncDefContext::funcType() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::FuncDefContext::IDENT() { + return getToken(SysYParser::IDENT, 0); +} + +tree::TerminalNode* SysYParser::FuncDefContext::L_PAREN() { + return getToken(SysYParser::L_PAREN, 0); +} + +tree::TerminalNode* SysYParser::FuncDefContext::R_PAREN() { + return getToken(SysYParser::R_PAREN, 0); +} + +SysYParser::BlockContext* SysYParser::FuncDefContext::block() { + return getRuleContext(0); +} + +SysYParser::FuncFParamsContext* SysYParser::FuncDefContext::funcFParams() { + return getRuleContext(0); +} + + +size_t SysYParser::FuncDefContext::getRuleIndex() const { + return SysYParser::RuleFuncDef; +} + + +std::any SysYParser::FuncDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncDef(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncDefContext* SysYParser::funcDef() { + FuncDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 20, SysYParser::RuleFuncDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(186); + funcType(); + setState(187); + match(SysYParser::IDENT); + setState(188); + match(SysYParser::L_PAREN); + setState(190); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::INT_KW) { + setState(189); + funcFParams(); + } + setState(192); + match(SysYParser::R_PAREN); + setState(193); + block(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncTypeContext ------------------------------------------------------------------ + +SysYParser::FuncTypeContext::FuncTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::FuncTypeContext::VOID_KW() { + return getToken(SysYParser::VOID_KW, 0); +} + +tree::TerminalNode* SysYParser::FuncTypeContext::INT_KW() { + return getToken(SysYParser::INT_KW, 0); +} + + +size_t SysYParser::FuncTypeContext::getRuleIndex() const { + return SysYParser::RuleFuncType; +} + + +std::any SysYParser::FuncTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncType(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncTypeContext* SysYParser::funcType() { + FuncTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 22, SysYParser::RuleFuncType); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(195); + _la = _input->LA(1); + if (!(_la == SysYParser::INT_KW + + || _la == SysYParser::VOID_KW)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncFParamsContext ------------------------------------------------------------------ + +SysYParser::FuncFParamsContext::FuncFParamsContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::FuncFParamsContext::funcFParam() { + return getRuleContexts(); +} + +SysYParser::FuncFParamContext* SysYParser::FuncFParamsContext::funcFParam(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::FuncFParamsContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::FuncFParamsContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::FuncFParamsContext::getRuleIndex() const { + return SysYParser::RuleFuncFParams; +} + + +std::any SysYParser::FuncFParamsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncFParams(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncFParamsContext* SysYParser::funcFParams() { + FuncFParamsContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 24, SysYParser::RuleFuncFParams); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(197); + funcFParam(); + setState(202); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(198); + match(SysYParser::COMMA); + setState(199); + funcFParam(); + setState(204); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncFParamContext ------------------------------------------------------------------ + +SysYParser::FuncFParamContext::FuncFParamContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::BTypeContext* SysYParser::FuncFParamContext::bType() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::FuncFParamContext::IDENT() { + return getToken(SysYParser::IDENT, 0); +} + +std::vector SysYParser::FuncFParamContext::L_BRACKT() { + return getTokens(SysYParser::L_BRACKT); +} + +tree::TerminalNode* SysYParser::FuncFParamContext::L_BRACKT(size_t i) { + return getToken(SysYParser::L_BRACKT, i); +} + +std::vector SysYParser::FuncFParamContext::R_BRACKT() { + return getTokens(SysYParser::R_BRACKT); +} + +tree::TerminalNode* SysYParser::FuncFParamContext::R_BRACKT(size_t i) { + return getToken(SysYParser::R_BRACKT, i); +} + +std::vector SysYParser::FuncFParamContext::exp() { + return getRuleContexts(); +} + +SysYParser::ExpContext* SysYParser::FuncFParamContext::exp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::FuncFParamContext::getRuleIndex() const { + return SysYParser::RuleFuncFParam; +} + + +std::any SysYParser::FuncFParamContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncFParam(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncFParamContext* SysYParser::funcFParam() { + FuncFParamContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 26, SysYParser::RuleFuncFParam); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(205); + bType(); + setState(206); + match(SysYParser::IDENT); + setState(218); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::L_BRACKT) { + setState(207); + match(SysYParser::L_BRACKT); + setState(208); + match(SysYParser::R_BRACKT); + setState(215); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::L_BRACKT) { + setState(209); + match(SysYParser::L_BRACKT); + setState(210); + exp(); + setState(211); + match(SysYParser::R_BRACKT); + setState(217); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BlockContext ------------------------------------------------------------------ + +SysYParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::BlockContext::L_BRACE() { + return getToken(SysYParser::L_BRACE, 0); +} + +tree::TerminalNode* SysYParser::BlockContext::R_BRACE() { + return getToken(SysYParser::R_BRACE, 0); +} + +std::vector SysYParser::BlockContext::blockItem() { + return getRuleContexts(); +} + +SysYParser::BlockItemContext* SysYParser::BlockContext::blockItem(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::BlockContext::getRuleIndex() const { + return SysYParser::RuleBlock; +} + + +std::any SysYParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBlock(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BlockContext* SysYParser::block() { + BlockContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 28, SysYParser::RuleBlock); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(220); + match(SysYParser::L_BRACE); + setState(224); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 142807908310) != 0)) { + setState(221); + blockItem(); + setState(226); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(227); + match(SysYParser::R_BRACE); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BlockItemContext ------------------------------------------------------------------ + +SysYParser::BlockItemContext::BlockItemContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ConstDeclContext* SysYParser::BlockItemContext::constDecl() { + return getRuleContext(0); +} + +SysYParser::VarDeclContext* SysYParser::BlockItemContext::varDecl() { + return getRuleContext(0); +} + +SysYParser::StmtContext* SysYParser::BlockItemContext::stmt() { + return getRuleContext(0); +} + + +size_t SysYParser::BlockItemContext::getRuleIndex() const { + return SysYParser::RuleBlockItem; +} + + +std::any SysYParser::BlockItemContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBlockItem(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BlockItemContext* SysYParser::blockItem() { + BlockItemContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 30, SysYParser::RuleBlockItem); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(232); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::CONST_KW: { + enterOuterAlt(_localctx, 1); + setState(229); + constDecl(); + break; + } + + case SysYParser::INT_KW: { + enterOuterAlt(_localctx, 2); + setState(230); + varDecl(); + break; + } + + case SysYParser::IF_KW: + case SysYParser::WHILE_KW: + case SysYParser::BREAK_KW: + case SysYParser::CONTINUE_KW: + case SysYParser::RETURN_KW: + case SysYParser::IDENT: + case SysYParser::DECIMAL_CONST: + case SysYParser::OCTAL_CONST: + case SysYParser::HEXADECIMAL_CONST: + case SysYParser::PLUS: + case SysYParser::MINUS: + case SysYParser::NOT: + case SysYParser::L_PAREN: + case SysYParser::L_BRACE: + case SysYParser::SEMICOLON: { + enterOuterAlt(_localctx, 3); + setState(231); + stmt(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StmtContext ------------------------------------------------------------------ + +SysYParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::AssignStmtContext* SysYParser::StmtContext::assignStmt() { + return getRuleContext(0); +} + +SysYParser::ExpStmtContext* SysYParser::StmtContext::expStmt() { + return getRuleContext(0); +} + +SysYParser::BlockContext* SysYParser::StmtContext::block() { + return getRuleContext(0); +} + +SysYParser::ConditionStmtContext* SysYParser::StmtContext::conditionStmt() { + return getRuleContext(0); +} + +SysYParser::WhileStmtContext* SysYParser::StmtContext::whileStmt() { + return getRuleContext(0); +} + +SysYParser::BreakStmtContext* SysYParser::StmtContext::breakStmt() { + return getRuleContext(0); +} + +SysYParser::ContinueStmtContext* SysYParser::StmtContext::continueStmt() { + return getRuleContext(0); +} + +SysYParser::ReturnStmtContext* SysYParser::StmtContext::returnStmt() { + return getRuleContext(0); +} + + +size_t SysYParser::StmtContext::getRuleIndex() const { + return SysYParser::RuleStmt; +} + + +std::any SysYParser::StmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::StmtContext* SysYParser::stmt() { + StmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 32, SysYParser::RuleStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(242); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 20, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(234); + assignStmt(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(235); + expStmt(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(236); + block(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(237); + conditionStmt(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(238); + whileStmt(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(239); + breakStmt(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(240); + continueStmt(); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(241); + returnStmt(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AssignStmtContext ------------------------------------------------------------------ + +SysYParser::AssignStmtContext::AssignStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::LValContext* SysYParser::AssignStmtContext::lVal() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::AssignStmtContext::ASSIGN() { + return getToken(SysYParser::ASSIGN, 0); +} + +SysYParser::ExpContext* SysYParser::AssignStmtContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::AssignStmtContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + + +size_t SysYParser::AssignStmtContext::getRuleIndex() const { + return SysYParser::RuleAssignStmt; +} + + +std::any SysYParser::AssignStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAssignStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::AssignStmtContext* SysYParser::assignStmt() { + AssignStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 34, SysYParser::RuleAssignStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(244); + lVal(); + setState(245); + match(SysYParser::ASSIGN); + setState(246); + exp(); + setState(247); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExpStmtContext ------------------------------------------------------------------ + +SysYParser::ExpStmtContext::ExpStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ExpStmtContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +SysYParser::ExpContext* SysYParser::ExpStmtContext::exp() { + return getRuleContext(0); +} + + +size_t SysYParser::ExpStmtContext::getRuleIndex() const { + return SysYParser::RuleExpStmt; +} + + +std::any SysYParser::ExpStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExpStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ExpStmtContext* SysYParser::expStmt() { + ExpStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, SysYParser::RuleExpStmt); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(250); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1073986560) != 0)) { + setState(249); + exp(); + } + setState(252); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConditionStmtContext ------------------------------------------------------------------ + +SysYParser::ConditionStmtContext::ConditionStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ConditionStmtContext::IF_KW() { + return getToken(SysYParser::IF_KW, 0); +} + +tree::TerminalNode* SysYParser::ConditionStmtContext::L_PAREN() { + return getToken(SysYParser::L_PAREN, 0); +} + +SysYParser::CondContext* SysYParser::ConditionStmtContext::cond() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::ConditionStmtContext::R_PAREN() { + return getToken(SysYParser::R_PAREN, 0); +} + +std::vector SysYParser::ConditionStmtContext::stmt() { + return getRuleContexts(); +} + +SysYParser::StmtContext* SysYParser::ConditionStmtContext::stmt(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SysYParser::ConditionStmtContext::ELSE_KW() { + return getToken(SysYParser::ELSE_KW, 0); +} + + +size_t SysYParser::ConditionStmtContext::getRuleIndex() const { + return SysYParser::RuleConditionStmt; +} + + +std::any SysYParser::ConditionStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConditionStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConditionStmtContext* SysYParser::conditionStmt() { + ConditionStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 38, SysYParser::RuleConditionStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(254); + match(SysYParser::IF_KW); + setState(255); + match(SysYParser::L_PAREN); + setState(256); + cond(); + setState(257); + match(SysYParser::R_PAREN); + setState(258); + stmt(); + setState(261); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 22, _ctx)) { + case 1: { + setState(259); + match(SysYParser::ELSE_KW); + setState(260); + stmt(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- WhileStmtContext ------------------------------------------------------------------ + +SysYParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::WhileStmtContext::WHILE_KW() { + return getToken(SysYParser::WHILE_KW, 0); +} + +tree::TerminalNode* SysYParser::WhileStmtContext::L_PAREN() { + return getToken(SysYParser::L_PAREN, 0); +} + +SysYParser::CondContext* SysYParser::WhileStmtContext::cond() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::WhileStmtContext::R_PAREN() { + return getToken(SysYParser::R_PAREN, 0); +} + +SysYParser::StmtContext* SysYParser::WhileStmtContext::stmt() { + return getRuleContext(0); +} + + +size_t SysYParser::WhileStmtContext::getRuleIndex() const { + return SysYParser::RuleWhileStmt; +} + + +std::any SysYParser::WhileStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitWhileStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::WhileStmtContext* SysYParser::whileStmt() { + WhileStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 40, SysYParser::RuleWhileStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(263); + match(SysYParser::WHILE_KW); + setState(264); + match(SysYParser::L_PAREN); + setState(265); + cond(); + setState(266); + match(SysYParser::R_PAREN); + setState(267); + stmt(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BreakStmtContext ------------------------------------------------------------------ + +SysYParser::BreakStmtContext::BreakStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::BreakStmtContext::BREAK_KW() { + return getToken(SysYParser::BREAK_KW, 0); +} + +tree::TerminalNode* SysYParser::BreakStmtContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + + +size_t SysYParser::BreakStmtContext::getRuleIndex() const { + return SysYParser::RuleBreakStmt; +} + + +std::any SysYParser::BreakStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBreakStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BreakStmtContext* SysYParser::breakStmt() { + BreakStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 42, SysYParser::RuleBreakStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(269); + match(SysYParser::BREAK_KW); + setState(270); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ContinueStmtContext ------------------------------------------------------------------ + +SysYParser::ContinueStmtContext::ContinueStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ContinueStmtContext::CONTINUE_KW() { + return getToken(SysYParser::CONTINUE_KW, 0); +} + +tree::TerminalNode* SysYParser::ContinueStmtContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + + +size_t SysYParser::ContinueStmtContext::getRuleIndex() const { + return SysYParser::RuleContinueStmt; +} + + +std::any SysYParser::ContinueStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitContinueStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ContinueStmtContext* SysYParser::continueStmt() { + ContinueStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 44, SysYParser::RuleContinueStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(272); + match(SysYParser::CONTINUE_KW); + setState(273); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ReturnStmtContext ------------------------------------------------------------------ + +SysYParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ReturnStmtContext::RETURN_KW() { + return getToken(SysYParser::RETURN_KW, 0); +} + +tree::TerminalNode* SysYParser::ReturnStmtContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +SysYParser::ExpContext* SysYParser::ReturnStmtContext::exp() { + return getRuleContext(0); +} + + +size_t SysYParser::ReturnStmtContext::getRuleIndex() const { + return SysYParser::RuleReturnStmt; +} + + +std::any SysYParser::ReturnStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitReturnStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ReturnStmtContext* SysYParser::returnStmt() { + ReturnStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 46, SysYParser::RuleReturnStmt); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(275); + match(SysYParser::RETURN_KW); + setState(277); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1073986560) != 0)) { + setState(276); + exp(); + } + setState(279); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExpContext ------------------------------------------------------------------ + +SysYParser::ExpContext::ExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::AddExpContext* SysYParser::ExpContext::addExp() { + return getRuleContext(0); +} + + +size_t SysYParser::ExpContext::getRuleIndex() const { + return SysYParser::RuleExp; +} + + +std::any SysYParser::ExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ExpContext* SysYParser::exp() { + ExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, SysYParser::RuleExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(281); + addExp(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CondContext ------------------------------------------------------------------ + +SysYParser::CondContext::CondContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::LOrExpContext* SysYParser::CondContext::lOrExp() { + return getRuleContext(0); +} + + +size_t SysYParser::CondContext::getRuleIndex() const { + return SysYParser::RuleCond; +} + + +std::any SysYParser::CondContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitCond(this); + else + return visitor->visitChildren(this); +} + +SysYParser::CondContext* SysYParser::cond() { + CondContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 50, SysYParser::RuleCond); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(283); + lOrExp(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LValContext ------------------------------------------------------------------ + +SysYParser::LValContext::LValContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::LValContext::IDENT() { + return getToken(SysYParser::IDENT, 0); +} + +std::vector SysYParser::LValContext::L_BRACKT() { + return getTokens(SysYParser::L_BRACKT); +} + +tree::TerminalNode* SysYParser::LValContext::L_BRACKT(size_t i) { + return getToken(SysYParser::L_BRACKT, i); +} + +std::vector SysYParser::LValContext::exp() { + return getRuleContexts(); +} + +SysYParser::ExpContext* SysYParser::LValContext::exp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::LValContext::R_BRACKT() { + return getTokens(SysYParser::R_BRACKT); +} + +tree::TerminalNode* SysYParser::LValContext::R_BRACKT(size_t i) { + return getToken(SysYParser::R_BRACKT, i); +} + + +size_t SysYParser::LValContext::getRuleIndex() const { + return SysYParser::RuleLVal; +} + + +std::any SysYParser::LValContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLVal(this); + else + return visitor->visitChildren(this); +} + +SysYParser::LValContext* SysYParser::lVal() { + LValContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 52, SysYParser::RuleLVal); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(285); + match(SysYParser::IDENT); + setState(292); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::L_BRACKT) { + setState(286); + match(SysYParser::L_BRACKT); + setState(287); + exp(); + setState(288); + match(SysYParser::R_BRACKT); + setState(294); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PrimaryExpContext ------------------------------------------------------------------ + +SysYParser::PrimaryExpContext::PrimaryExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::PrimaryExpContext::L_PAREN() { + return getToken(SysYParser::L_PAREN, 0); +} + +SysYParser::ExpContext* SysYParser::PrimaryExpContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::PrimaryExpContext::R_PAREN() { + return getToken(SysYParser::R_PAREN, 0); +} + +SysYParser::LValContext* SysYParser::PrimaryExpContext::lVal() { + return getRuleContext(0); +} + +SysYParser::NumberContext* SysYParser::PrimaryExpContext::number() { + return getRuleContext(0); +} + + +size_t SysYParser::PrimaryExpContext::getRuleIndex() const { + return SysYParser::RulePrimaryExp; +} + + +std::any SysYParser::PrimaryExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPrimaryExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::PrimaryExpContext* SysYParser::primaryExp() { + PrimaryExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 54, SysYParser::RulePrimaryExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(301); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::L_PAREN: { + enterOuterAlt(_localctx, 1); + setState(295); + match(SysYParser::L_PAREN); + setState(296); + exp(); + setState(297); + match(SysYParser::R_PAREN); + break; + } + + case SysYParser::IDENT: { + enterOuterAlt(_localctx, 2); + setState(299); + lVal(); + break; + } + + case SysYParser::DECIMAL_CONST: + case SysYParser::OCTAL_CONST: + case SysYParser::HEXADECIMAL_CONST: { + enterOuterAlt(_localctx, 3); + setState(300); + number(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NumberContext ------------------------------------------------------------------ + +SysYParser::NumberContext::NumberContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::IntConstContext* SysYParser::NumberContext::intConst() { + return getRuleContext(0); +} + + +size_t SysYParser::NumberContext::getRuleIndex() const { + return SysYParser::RuleNumber; +} + + +std::any SysYParser::NumberContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNumber(this); + else + return visitor->visitChildren(this); +} + +SysYParser::NumberContext* SysYParser::number() { + NumberContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 56, SysYParser::RuleNumber); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(303); + intConst(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IntConstContext ------------------------------------------------------------------ + +SysYParser::IntConstContext::IntConstContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::IntConstContext::DECIMAL_CONST() { + return getToken(SysYParser::DECIMAL_CONST, 0); +} + +tree::TerminalNode* SysYParser::IntConstContext::OCTAL_CONST() { + return getToken(SysYParser::OCTAL_CONST, 0); +} + +tree::TerminalNode* SysYParser::IntConstContext::HEXADECIMAL_CONST() { + return getToken(SysYParser::HEXADECIMAL_CONST, 0); +} + + +size_t SysYParser::IntConstContext::getRuleIndex() const { + return SysYParser::RuleIntConst; +} + + +std::any SysYParser::IntConstContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIntConst(this); + else + return visitor->visitChildren(this); +} + +SysYParser::IntConstContext* SysYParser::intConst() { + IntConstContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 58, SysYParser::RuleIntConst); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(305); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 14336) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnaryExpContext ------------------------------------------------------------------ + +SysYParser::UnaryExpContext::UnaryExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::PrimaryExpContext* SysYParser::UnaryExpContext::primaryExp() { + return getRuleContext(0); +} + +SysYParser::CalleeContext* SysYParser::UnaryExpContext::callee() { + return getRuleContext(0); +} + +SysYParser::UnaryOpContext* SysYParser::UnaryExpContext::unaryOp() { + return getRuleContext(0); +} + +SysYParser::UnaryExpContext* SysYParser::UnaryExpContext::unaryExp() { + return getRuleContext(0); +} + + +size_t SysYParser::UnaryExpContext::getRuleIndex() const { + return SysYParser::RuleUnaryExp; +} + + +std::any SysYParser::UnaryExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnaryExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::UnaryExpContext* SysYParser::unaryExp() { + UnaryExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 60, SysYParser::RuleUnaryExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(312); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 26, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(307); + primaryExp(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(308); + callee(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(309); + unaryOp(); + setState(310); + unaryExp(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CalleeContext ------------------------------------------------------------------ + +SysYParser::CalleeContext::CalleeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::CalleeContext::IDENT() { + return getToken(SysYParser::IDENT, 0); +} + +tree::TerminalNode* SysYParser::CalleeContext::L_PAREN() { + return getToken(SysYParser::L_PAREN, 0); +} + +tree::TerminalNode* SysYParser::CalleeContext::R_PAREN() { + return getToken(SysYParser::R_PAREN, 0); +} + +SysYParser::FuncRParamsContext* SysYParser::CalleeContext::funcRParams() { + return getRuleContext(0); +} + + +size_t SysYParser::CalleeContext::getRuleIndex() const { + return SysYParser::RuleCallee; +} + + +std::any SysYParser::CalleeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitCallee(this); + else + return visitor->visitChildren(this); +} + +SysYParser::CalleeContext* SysYParser::callee() { + CalleeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 62, SysYParser::RuleCallee); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(314); + match(SysYParser::IDENT); + setState(315); + match(SysYParser::L_PAREN); + setState(317); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1074002944) != 0)) { + setState(316); + funcRParams(); + } + setState(319); + match(SysYParser::R_PAREN); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnaryOpContext ------------------------------------------------------------------ + +SysYParser::UnaryOpContext::UnaryOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::UnaryOpContext::PLUS() { + return getToken(SysYParser::PLUS, 0); +} + +tree::TerminalNode* SysYParser::UnaryOpContext::MINUS() { + return getToken(SysYParser::MINUS, 0); +} + +tree::TerminalNode* SysYParser::UnaryOpContext::NOT() { + return getToken(SysYParser::NOT, 0); +} + + +size_t SysYParser::UnaryOpContext::getRuleIndex() const { + return SysYParser::RuleUnaryOp; +} + + +std::any SysYParser::UnaryOpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnaryOp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::UnaryOpContext* SysYParser::unaryOp() { + UnaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 64, SysYParser::RuleUnaryOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(321); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 229376) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncRParamsContext ------------------------------------------------------------------ + +SysYParser::FuncRParamsContext::FuncRParamsContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::FuncRParamsContext::param() { + return getRuleContexts(); +} + +SysYParser::ParamContext* SysYParser::FuncRParamsContext::param(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::FuncRParamsContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::FuncRParamsContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::FuncRParamsContext::getRuleIndex() const { + return SysYParser::RuleFuncRParams; +} + + +std::any SysYParser::FuncRParamsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncRParams(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncRParamsContext* SysYParser::funcRParams() { + FuncRParamsContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 66, SysYParser::RuleFuncRParams); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(323); + param(); + setState(328); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(324); + match(SysYParser::COMMA); + setState(325); + param(); + setState(330); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ParamContext ------------------------------------------------------------------ + +SysYParser::ParamContext::ParamContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ExpContext* SysYParser::ParamContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::ParamContext::STRING() { + return getToken(SysYParser::STRING, 0); +} + + +size_t SysYParser::ParamContext::getRuleIndex() const { + return SysYParser::RuleParam; +} + + +std::any SysYParser::ParamContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitParam(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ParamContext* SysYParser::param() { + ParamContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 68, SysYParser::RuleParam); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(333); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::IDENT: + case SysYParser::DECIMAL_CONST: + case SysYParser::OCTAL_CONST: + case SysYParser::HEXADECIMAL_CONST: + case SysYParser::PLUS: + case SysYParser::MINUS: + case SysYParser::NOT: + case SysYParser::L_PAREN: { + enterOuterAlt(_localctx, 1); + setState(331); + exp(); + break; + } + + case SysYParser::STRING: { + enterOuterAlt(_localctx, 2); + setState(332); + match(SysYParser::STRING); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MulExpContext ------------------------------------------------------------------ + +SysYParser::MulExpContext::MulExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::MulExpContext::unaryExp() { + return getRuleContexts(); +} + +SysYParser::UnaryExpContext* SysYParser::MulExpContext::unaryExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::MulExpContext::mulOp() { + return getRuleContexts(); +} + +SysYParser::MulOpContext* SysYParser::MulExpContext::mulOp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::MulExpContext::getRuleIndex() const { + return SysYParser::RuleMulExp; +} + + +std::any SysYParser::MulExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMulExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::MulExpContext* SysYParser::mulExp() { + MulExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 70, SysYParser::RuleMulExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(335); + unaryExp(); + setState(341); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1835008) != 0)) { + setState(336); + mulOp(); + setState(337); + unaryExp(); + setState(343); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MulOpContext ------------------------------------------------------------------ + +SysYParser::MulOpContext::MulOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::MulOpContext::MUL() { + return getToken(SysYParser::MUL, 0); +} + +tree::TerminalNode* SysYParser::MulOpContext::DIV() { + return getToken(SysYParser::DIV, 0); +} + +tree::TerminalNode* SysYParser::MulOpContext::MOD() { + return getToken(SysYParser::MOD, 0); +} + + +size_t SysYParser::MulOpContext::getRuleIndex() const { + return SysYParser::RuleMulOp; +} + + +std::any SysYParser::MulOpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMulOp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::MulOpContext* SysYParser::mulOp() { + MulOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 72, SysYParser::RuleMulOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(344); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1835008) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AddExpContext ------------------------------------------------------------------ + +SysYParser::AddExpContext::AddExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::AddExpContext::mulExp() { + return getRuleContexts(); +} + +SysYParser::MulExpContext* SysYParser::AddExpContext::mulExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::AddExpContext::addOp() { + return getRuleContexts(); +} + +SysYParser::AddOpContext* SysYParser::AddExpContext::addOp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::AddExpContext::getRuleIndex() const { + return SysYParser::RuleAddExp; +} + + +std::any SysYParser::AddExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAddExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::AddExpContext* SysYParser::addExp() { + AddExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 74, SysYParser::RuleAddExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(346); + mulExp(); + setState(352); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::PLUS + + || _la == SysYParser::MINUS) { + setState(347); + addOp(); + setState(348); + mulExp(); + setState(354); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AddOpContext ------------------------------------------------------------------ + +SysYParser::AddOpContext::AddOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::AddOpContext::PLUS() { + return getToken(SysYParser::PLUS, 0); +} + +tree::TerminalNode* SysYParser::AddOpContext::MINUS() { + return getToken(SysYParser::MINUS, 0); +} + + +size_t SysYParser::AddOpContext::getRuleIndex() const { + return SysYParser::RuleAddOp; +} + + +std::any SysYParser::AddOpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAddOp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::AddOpContext* SysYParser::addOp() { + AddOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 76, SysYParser::RuleAddOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(355); + _la = _input->LA(1); + if (!(_la == SysYParser::PLUS + + || _la == SysYParser::MINUS)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- RelExpContext ------------------------------------------------------------------ + +SysYParser::RelExpContext::RelExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::RelExpContext::addExp() { + return getRuleContexts(); +} + +SysYParser::AddExpContext* SysYParser::RelExpContext::addExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::RelExpContext::relOp() { + return getRuleContexts(); +} + +SysYParser::RelOpContext* SysYParser::RelExpContext::relOp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::RelExpContext::getRuleIndex() const { + return SysYParser::RuleRelExp; +} + + +std::any SysYParser::RelExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitRelExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::RelExpContext* SysYParser::relExp() { + RelExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 78, SysYParser::RuleRelExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(357); + addExp(); + setState(363); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 251658240) != 0)) { + setState(358); + relOp(); + setState(359); + addExp(); + setState(365); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- RelOpContext ------------------------------------------------------------------ + +SysYParser::RelOpContext::RelOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::RelOpContext::LT() { + return getToken(SysYParser::LT, 0); +} + +tree::TerminalNode* SysYParser::RelOpContext::GT() { + return getToken(SysYParser::GT, 0); +} + +tree::TerminalNode* SysYParser::RelOpContext::LE() { + return getToken(SysYParser::LE, 0); +} + +tree::TerminalNode* SysYParser::RelOpContext::GE() { + return getToken(SysYParser::GE, 0); +} + + +size_t SysYParser::RelOpContext::getRuleIndex() const { + return SysYParser::RuleRelOp; +} + + +std::any SysYParser::RelOpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitRelOp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::RelOpContext* SysYParser::relOp() { + RelOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 80, SysYParser::RuleRelOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(366); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 251658240) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EqExpContext ------------------------------------------------------------------ + +SysYParser::EqExpContext::EqExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::EqExpContext::relExp() { + return getRuleContexts(); +} + +SysYParser::RelExpContext* SysYParser::EqExpContext::relExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::EqExpContext::eqOp() { + return getRuleContexts(); +} + +SysYParser::EqOpContext* SysYParser::EqExpContext::eqOp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::EqExpContext::getRuleIndex() const { + return SysYParser::RuleEqExp; +} + + +std::any SysYParser::EqExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEqExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::EqExpContext* SysYParser::eqExp() { + EqExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 82, SysYParser::RuleEqExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(368); + relExp(); + setState(374); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::EQ + + || _la == SysYParser::NEQ) { + setState(369); + eqOp(); + setState(370); + relExp(); + setState(376); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EqOpContext ------------------------------------------------------------------ + +SysYParser::EqOpContext::EqOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::EqOpContext::EQ() { + return getToken(SysYParser::EQ, 0); +} + +tree::TerminalNode* SysYParser::EqOpContext::NEQ() { + return getToken(SysYParser::NEQ, 0); +} + + +size_t SysYParser::EqOpContext::getRuleIndex() const { + return SysYParser::RuleEqOp; +} + + +std::any SysYParser::EqOpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEqOp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::EqOpContext* SysYParser::eqOp() { + EqOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 84, SysYParser::RuleEqOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(377); + _la = _input->LA(1); + if (!(_la == SysYParser::EQ + + || _la == SysYParser::NEQ)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LAndExpContext ------------------------------------------------------------------ + +SysYParser::LAndExpContext::LAndExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::LAndExpContext::eqExp() { + return getRuleContexts(); +} + +SysYParser::EqExpContext* SysYParser::LAndExpContext::eqExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::LAndExpContext::AND() { + return getTokens(SysYParser::AND); +} + +tree::TerminalNode* SysYParser::LAndExpContext::AND(size_t i) { + return getToken(SysYParser::AND, i); +} + + +size_t SysYParser::LAndExpContext::getRuleIndex() const { + return SysYParser::RuleLAndExp; +} + + +std::any SysYParser::LAndExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLAndExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::LAndExpContext* SysYParser::lAndExp() { + LAndExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 86, SysYParser::RuleLAndExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(379); + eqExp(); + setState(384); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::AND) { + setState(380); + match(SysYParser::AND); + setState(381); + eqExp(); + setState(386); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LOrExpContext ------------------------------------------------------------------ + +SysYParser::LOrExpContext::LOrExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::LOrExpContext::lAndExp() { + return getRuleContexts(); +} + +SysYParser::LAndExpContext* SysYParser::LOrExpContext::lAndExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::LOrExpContext::OR() { + return getTokens(SysYParser::OR); +} + +tree::TerminalNode* SysYParser::LOrExpContext::OR(size_t i) { + return getToken(SysYParser::OR, i); +} + + +size_t SysYParser::LOrExpContext::getRuleIndex() const { + return SysYParser::RuleLOrExp; +} + + +std::any SysYParser::LOrExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLOrExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::LOrExpContext* SysYParser::lOrExp() { + LOrExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 88, SysYParser::RuleLOrExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(387); + lAndExp(); + setState(392); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::OR) { + setState(388); + match(SysYParser::OR); + setState(389); + lAndExp(); + setState(394); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstExpContext ------------------------------------------------------------------ + +SysYParser::ConstExpContext::ConstExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::AddExpContext* SysYParser::ConstExpContext::addExp() { + return getRuleContext(0); +} + + +size_t SysYParser::ConstExpContext::getRuleIndex() const { + return SysYParser::RuleConstExp; +} + + +std::any SysYParser::ConstExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstExpContext* SysYParser::constExp() { + ConstExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 90, SysYParser::RuleConstExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(395); + addExp(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +void SysYParser::initialize() { + ::antlr4::internal::call_once(sysyParserOnceFlag, sysyParserInitialize); +} diff --git a/src/SysYVisitor.cpp b/src/SysYVisitor.cpp new file mode 100644 index 0000000..423c7b2 --- /dev/null +++ b/src/SysYVisitor.cpp @@ -0,0 +1,9 @@ + +// Generated from SysY.g4 by ANTLR 4.12.0 + + +#include "SysYVisitor.h" + + +using namespace antlrSysY; + diff --git a/tools/antlr4-cpp-runtime-4.12.0-source.zip b/tools/antlr4-cpp-runtime-4.12.0-source.zip new file mode 100644 index 0000000..aabc847 Binary files /dev/null and b/tools/antlr4-cpp-runtime-4.12.0-source.zip differ