diff --git a/.gitignore b/.gitignore index d163863..81a5dc1 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ -build/ \ No newline at end of file +build/ +.antlr/ \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index d68a321..67226f2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,6 +11,7 @@ include_directories(${ANTLR4_INCLUDE_DIR}) # Custom sources start here include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/antlrgen) file(GLOB_RECURSE SOURCES "src/*.cpp") add_executable(sysy ${SOURCES}) diff --git a/SysY.g4 b/SysY.g4 deleted file mode 100644 index 8320d48..0000000 --- a/SysY.g4 +++ /dev/null @@ -1,381 +0,0 @@ -grammar SysY; - -program - : compUnit - ; - -compUnit - : (funcDef | decl)+ - ; - -decl - : constDecl - | varDecl - ; - -constDecl - : CONST_KW bType constDef (COMMA constDef)* ';' - ; - -bType - : INT_KW - ; - -constDef - : IDENT (L_BRACKT constExp R_BRACKT)* ASSIGN constInitVal - ; - -constInitVal - : constExp - | (L_BRACE (constInitVal (COMMA constInitVal)*)? R_BRACE) - ; - -varDecl - : bType varDef (COMMA varDef)* ';' - ; - -varDef - : IDENT (L_BRACKT constExp R_BRACKT)* (ASSIGN initVal)? - ; - -initVal - : exp - | (L_BRACE (initVal (COMMA initVal)*)? R_BRACE) - ; - -funcDef - : funcType IDENT L_PAREN funcFParams? R_PAREN block - ; - -funcType - : VOID_KW - | INT_KW - ; - -funcFParams - : funcFParam (COMMA funcFParam)* - ; - -funcFParam - : bType IDENT (L_BRACKT R_BRACKT (L_BRACKT exp R_BRACKT)*)? - ; - -block - : L_BRACE blockItem* R_BRACE - ; - -blockItem - : constDecl - | varDecl - | stmt - ; - -stmt - : assignStmt - | expStmt - | block - | conditionStmt - | whileStmt - | breakStmt - | continueStmt - | returnStmt - ; - -assignStmt - : lVal '=' exp ';' - ; - -expStmt - : exp? ';' - ; - -conditionStmt - : IF_KW L_PAREN cond R_PAREN stmt (ELSE_KW stmt)? - ; - -whileStmt - : WHILE_KW L_PAREN cond R_PAREN stmt - ; - -breakStmt - : BREAK_KW ';' - ; - -continueStmt - : CONTINUE_KW ';' - ; - -returnStmt - : RETURN_KW (exp)? ';' - ; - -exp - : addExp - ; - -cond - : lOrExp - ; - -lVal - : IDENT (L_BRACKT exp R_BRACKT)* - ; - -primaryExp - : (L_PAREN exp R_PAREN) - | lVal - | number - ; - -number - : intConst - ; - -intConst - : DECIMAL_CONST - | OCTAL_CONST - | HEXADECIMAL_CONST - ; - -unaryExp - : primaryExp - | callee - | (unaryOp unaryExp) - ; - -callee - : IDENT L_PAREN funcRParams? R_PAREN - ; - -unaryOp - : '+' - | '-' - | NOT - ; - -funcRParams - : param (COMMA param)* - ; - -param - : exp - | STRING - ; - -mulExp - : unaryExp (mulOp unaryExp)* - ; // eliminate left-recursive - -mulOp - : MUL - | DIV - | MOD - ; - -addExp - : mulExp (addOp mulExp)* - ; // eliminate left-recursive - -addOp - : '+' - | '-' - ; - -relExp - : addExp (relOp addExp)* - ; // eliminate left-recursive - -relOp - : LT - | GT - | LE - | GE - ; - -eqExp - : relExp (eqOp relExp)* - ; - -eqOp - : EQ - | NEQ - ; - -lAndExp - : eqExp (AND eqExp)* - ; - -lOrExp - : lAndExp (OR lAndExp)* - ; - -constExp - : addExp - ; - -CONST_KW - : 'const' - ; - -INT_KW - : 'int' - ; - -VOID_KW - : 'void' - ; - -IF_KW - : 'if' - ; - -ELSE_KW - : 'else' - ; - -WHILE_KW - : 'while' - ; - -BREAK_KW - : 'break' - ; - -CONTINUE_KW - : 'continue' - ; - -RETURN_KW - : 'return' - ; - -IDENT - : [_a-zA-Z] - | [_a-zA-Z] [_a-zA-Z0-9]+ - ; - -DECIMAL_CONST - : [1-9] - | [1-9] [0-9]+ - ; - -OCTAL_CONST - : '0' - | ('0' [0-7]+) - ; - -HEXADECIMAL_CONST - : ('0x' | '0X') [a-fA-F0-9]+ - ; - -STRING - : DOUBLE_QUOTE REGULAR_CHAR*? DOUBLE_QUOTE - ; - -fragment REGULAR_CHAR - : (ESC | .) - ; - -fragment ESC - : '\\"' | '\\\\' - ; - -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 - : [ \r\n\t]+ -> skip - ; - -LINE_COMMENT - : '//' ~ [\r\n]* -> skip - ; - -MULTILINE_COMMENT - : '/*' .*? '*/' -> skip - ; diff --git a/Sysy.g4 b/Sysy.g4 new file mode 100644 index 0000000..9b28b6d --- /dev/null +++ b/Sysy.g4 @@ -0,0 +1,114 @@ +grammar Sysy; + +program: compUnit; + +compUnit: (funcDef | decl)+; + +decl: constDecl | varDecl; + +constDecl: 'const' bType constDef (',' constDef)* ';'; + +bType: 'int'; + +constDef: IDENT ('[' constExp ']')* '=' constInitVal; + +constInitVal: + constExp + | ('{' (constInitVal (',' constInitVal)*)? '}'); + +varDecl: bType varDef (',' varDef)* ';'; + +varDef: IDENT ('[' constExp ']')* ('=' initVal)?; + +initVal: exp | ('{' (initVal (',' initVal)*)? '}'); + +funcDef: funcType IDENT '(' (funcFParams)? ')' block; + +funcType: 'void' | 'int'; + +funcFParams: funcFParam (',' funcFParam)*; + +funcFParam: bType IDENT ('[' ']' ('[' exp ']')*)?; + +block: '{' (blockItem)* '}'; + +blockItem: decl | stmt; + +stmt: + lVal '=' exp ';' # assignStmt + | (exp)? ';' # expStmt + | block # blockStmt + | 'if' '(' cond ')' stmt ('else' stmt)? # ifStmt + | 'while' '(' cond ')' stmt # whileStmt + | 'break' ';' # breakStmt + | 'continue' ';' # continueStmt + | 'return' (exp)? ';' # returnStmt; + +exp: addExp; + +cond: lOrExp; + +lVal: IDENT ('[' exp ']')*; + +primaryExp: ('(' exp ')') | lVal | number; + +number: intConst; + +intConst: DECIMAL_CONST | OCTAL_CONST | HEXADECIMAL_CONST; + +unaryExp: + primaryExp + | IDENT '(' (funcRParams)? ')' + | unaryOp unaryExp; + +unaryOp: '+' | '-' | '!'; // 注：'!'仅出现在条件表达式中 + +funcRParams: funcRParam (',' funcRParam)*; + +funcRParam: exp | StringLiteral; + +mulExp: + unaryExp + | mulExp ('*' | '/' | '%') unaryExp; // ANTLR4 has support for direct left recursion + +addExp: mulExp | addExp ('+' | '-') mulExp; + +relExp: addExp | relExp ('<' | '>' | '<=' | '>=') addExp; + +eqExp: relExp | eqExp ('==' | '!=') relExp; + +lAndExp: eqExp | lAndExp '&&' eqExp; + +lOrExp: lAndExp | lOrExp '||' lAndExp; + +constExp: addExp; // 注：使用的 Ident 必须是常量 + +// -------- Terminals --------- + +IDENT: [_a-zA-Z] | [_a-zA-Z] [_a-zA-Z0-9]+; + +DECIMAL_CONST: [1-9] | [1-9] [0-9]+; + +OCTAL_CONST: '0' | ('0' [0-7]+); + +HEXADECIMAL_CONST: ('0x' | '0X') [a-fA-F0-9]+; + +WS: [ \r\n\t]+ -> skip; + +SINGLELINE_COMMENT: '//' ~ [\r\n]* -> skip; + +MULTILINE_COMMENT: '/*' .*? '*/' -> skip; + +fragment EscapeSequence: + '\\' ['"?abfnrtv\\] + | '\\' [0-7] [0-7]? [0-7]? + | '\\x' [0-9a-fA-F]+; // https://github.com/antlr/grammars-v4/blob/master/c/C.g4 + +fragment SChar: + ~["\\\r\n] + | EscapeSequence + | '\\\n' // Added line + | '\\\r\n' ; // Added line + +StringLiteral: '"' (SChar+)? '"'; +// https://github.com/antlr/antlr4/blob/master/doc/lexer-rules.md \ No newline at end of file diff --git a/docs/SysY2022运行时库-V1.pdf b/docs/SysY2022运行时库-V1.pdf new file mode 100644 index 0000000..563764c Binary files /dev/null and b/docs/SysY2022运行时库-V1.pdf differ diff --git a/docs/SysY语言定义.pdf b/docs/SysY语言定义.pdf new file mode 100644 index 0000000..5e788c5 Binary files /dev/null and b/docs/SysY语言定义.pdf differ diff --git a/include/SysYBaseVisitor.h b/include/SysYBaseVisitor.h deleted file mode 100644 index 743ebc1..0000000 --- a/include/SysYBaseVisitor.h +++ /dev/null @@ -1,207 +0,0 @@ - -// 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/SysYVisitor.h b/include/SysYVisitor.h deleted file mode 100644 index 7e5eb06..0000000 --- a/include/SysYVisitor.h +++ /dev/null @@ -1,118 +0,0 @@ - -// 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/include/antlrgen/SysyBaseVisitor.h b/include/antlrgen/SysyBaseVisitor.h new file mode 100644 index 0000000..f8d2ece --- /dev/null +++ b/include/antlrgen/SysyBaseVisitor.h @@ -0,0 +1,187 @@ + +// 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 visitAssignStmt(SysyParser::AssignStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitExpStmt(SysyParser::ExpStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitBlockStmt(SysyParser::BlockStmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitIfStmt(SysyParser::IfStmtContext *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 visitUnaryOp(SysyParser::UnaryOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncRParams(SysyParser::FuncRParamsContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncRParam(SysyParser::FuncRParamContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitMulExp(SysyParser::MulExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitAddExp(SysyParser::AddExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitRelExp(SysyParser::RelExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitEqExp(SysyParser::EqExpContext *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/antlrgen/SysyLexer.h similarity index 56% rename from include/SysYLexer.h rename to include/antlrgen/SysyLexer.h index c9131fe..f68e3e9 100644 --- a/include/SysYLexer.h +++ b/include/antlrgen/SysyLexer.h @@ -1,5 +1,5 @@ -// Generated from SysY.g4 by ANTLR 4.12.0 +// Generated from Sysy.g4 by ANTLR 4.12.0 #pragma once @@ -10,22 +10,21 @@ namespace antlrSysY { -class SysYLexer : public antlr4::Lexer { +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 + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, + T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, + T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, + T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, + T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, + IDENT = 33, DECIMAL_CONST = 34, OCTAL_CONST = 35, HEXADECIMAL_CONST = 36, + WS = 37, SINGLELINE_COMMENT = 38, MULTILINE_COMMENT = 39, StringLiteral = 40 }; - explicit SysYLexer(antlr4::CharStream *input); + explicit SysyLexer(antlr4::CharStream *input); - ~SysYLexer() override; + ~SysyLexer() override; std::string getGrammarFileName() const override; diff --git a/include/SysYParser.h b/include/antlrgen/SysyParser.h similarity index 60% rename from include/SysYParser.h rename to include/antlrgen/SysyParser.h index 1591c5f..c45e7c4 100644 --- a/include/SysYParser.h +++ b/include/antlrgen/SysyParser.h @@ -1,5 +1,5 @@ -// Generated from SysY.g4 by ANTLR 4.12.0 +// Generated from Sysy.g4 by ANTLR 4.12.0 #pragma once @@ -10,17 +10,16 @@ namespace antlrSysY { -class SysYParser : public antlr4::Parser { +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 + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, + T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, + T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, + T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, + T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, + IDENT = 33, DECIMAL_CONST = 34, OCTAL_CONST = 35, HEXADECIMAL_CONST = 36, + WS = 37, SINGLELINE_COMMENT = 38, MULTILINE_COMMENT = 39, StringLiteral = 40 }; enum { @@ -28,20 +27,18 @@ public: 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 + RuleStmt = 16, RuleExp = 17, RuleCond = 18, RuleLVal = 19, RulePrimaryExp = 20, + RuleNumber = 21, RuleIntConst = 22, RuleUnaryExp = 23, RuleUnaryOp = 24, + RuleFuncRParams = 25, RuleFuncRParam = 26, RuleMulExp = 27, RuleAddExp = 28, + RuleRelExp = 29, RuleEqExp = 30, RuleLAndExp = 31, RuleLOrExp = 32, + RuleConstExp = 33 }; - explicit SysYParser(antlr4::TokenStream *input); + explicit SysyParser(antlr4::TokenStream *input); - SysYParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); + SysyParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); - ~SysYParser() override; + ~SysyParser() override; std::string getGrammarFileName() const override; @@ -71,13 +68,6 @@ public: 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; @@ -85,18 +75,13 @@ public: class NumberContext; class IntConstContext; class UnaryExpContext; - class CalleeContext; class UnaryOpContext; class FuncRParamsContext; - class ParamContext; + class FuncRParamContext; class MulExpContext; - class MulOpContext; class AddExpContext; - class AddOpContext; class RelExpContext; - class RelOpContext; class EqExpContext; - class EqOpContext; class LAndExpContext; class LOrExpContext; class ConstExpContext; @@ -148,13 +133,9 @@ public: 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; @@ -167,7 +148,6 @@ public: 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; @@ -181,14 +161,9 @@ 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; @@ -202,12 +177,8 @@ 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; @@ -223,9 +194,6 @@ public: 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; @@ -239,13 +207,8 @@ 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(); @@ -260,12 +223,8 @@ 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; @@ -280,8 +239,6 @@ public: 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(); @@ -296,8 +253,6 @@ public: 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; @@ -312,8 +267,6 @@ public: 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; @@ -328,10 +281,6 @@ public: 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); @@ -346,8 +295,6 @@ public: 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); @@ -362,8 +309,7 @@ public: public: BlockItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; - ConstDeclContext *constDecl(); - VarDeclContext *varDecl(); + DeclContext *decl(); StmtContext *stmt(); @@ -376,132 +322,92 @@ public: class StmtContext : public antlr4::ParserRuleContext { public: StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + + StmtContext() = default; + void copyFrom(StmtContext *context); + using antlr4::ParserRuleContext::copyFrom; + virtual size_t getRuleIndex() const override; - AssignStmtContext *assignStmt(); - ExpStmtContext *expStmt(); + + + }; + + class WhileStmtContext : public StmtContext { + public: + WhileStmtContext(StmtContext *ctx); + + CondContext *cond(); + StmtContext *stmt(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class IfStmtContext : public StmtContext { + public: + IfStmtContext(StmtContext *ctx); + + CondContext *cond(); + std::vector stmt(); + StmtContext* stmt(size_t i); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class BlockStmtContext : public StmtContext { + public: + BlockStmtContext(StmtContext *ctx); + BlockContext *block(); - ConditionStmtContext *conditionStmt(); - WhileStmtContext *whileStmt(); - BreakStmtContext *breakStmt(); - ContinueStmtContext *continueStmt(); - ReturnStmtContext *returnStmt(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class AssignStmtContext : public StmtContext { + public: + AssignStmtContext(StmtContext *ctx); + + LValContext *lVal(); + ExpContext *exp(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class BreakStmtContext : public StmtContext { + public: + BreakStmtContext(StmtContext *ctx); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class ExpStmtContext : public StmtContext { + public: + ExpStmtContext(StmtContext *ctx); + + ExpContext *exp(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class ReturnStmtContext : public StmtContext { + public: + ReturnStmtContext(StmtContext *ctx); + + ExpContext *exp(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class ContinueStmtContext : public StmtContext { + public: + ContinueStmtContext(StmtContext *ctx); 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); @@ -533,12 +439,8 @@ 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; @@ -551,9 +453,7 @@ public: 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(); @@ -597,7 +497,8 @@ public: UnaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; PrimaryExpContext *primaryExp(); - CalleeContext *callee(); + antlr4::tree::TerminalNode *IDENT(); + FuncRParamsContext *funcRParams(); UnaryOpContext *unaryOp(); UnaryExpContext *unaryExp(); @@ -608,29 +509,10 @@ public: 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; @@ -643,10 +525,8 @@ public: 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); + std::vector funcRParam(); + FuncRParamContext* funcRParam(size_t i); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; @@ -655,28 +535,26 @@ public: FuncRParamsContext* funcRParams(); - class ParamContext : public antlr4::ParserRuleContext { + class FuncRParamContext : public antlr4::ParserRuleContext { public: - ParamContext(antlr4::ParserRuleContext *parent, size_t invokingState); + FuncRParamContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpContext *exp(); - antlr4::tree::TerminalNode *STRING(); + antlr4::tree::TerminalNode *StringLiteral(); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; - ParamContext* param(); + FuncRParamContext* funcRParam(); 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); + UnaryExpContext *unaryExp(); + MulExpContext *mulExp(); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; @@ -684,30 +562,13 @@ public: }; 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(); - + MulExpContext* mulExp(int precedence); 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); + MulExpContext *mulExp(); + AddExpContext *addExp(); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; @@ -715,29 +576,13 @@ public: }; 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(); - + AddExpContext* addExp(int precedence); 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); + AddExpContext *addExp(); + RelExpContext *relExp(); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; @@ -745,31 +590,13 @@ public: }; 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(); - + RelExpContext* relExp(int precedence); 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); + RelExpContext *relExp(); + EqExpContext *eqExp(); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; @@ -777,29 +604,13 @@ public: }; 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(); - + EqExpContext* eqExp(int precedence); 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); + EqExpContext *eqExp(); + LAndExpContext *lAndExp(); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; @@ -807,15 +618,13 @@ public: }; LAndExpContext* lAndExp(); - + LAndExpContext* lAndExp(int precedence); 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); + LAndExpContext *lAndExp(); + LOrExpContext *lOrExp(); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; @@ -823,7 +632,7 @@ public: }; LOrExpContext* lOrExp(); - + LOrExpContext* lOrExp(int precedence); class ConstExpContext : public antlr4::ParserRuleContext { public: ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); @@ -838,6 +647,15 @@ public: ConstExpContext* constExp(); + bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; + + bool mulExpSempred(MulExpContext *_localctx, size_t predicateIndex); + bool addExpSempred(AddExpContext *_localctx, size_t predicateIndex); + bool relExpSempred(RelExpContext *_localctx, size_t predicateIndex); + bool eqExpSempred(EqExpContext *_localctx, size_t predicateIndex); + bool lAndExpSempred(LAndExpContext *_localctx, size_t predicateIndex); + bool lOrExpSempred(LOrExpContext *_localctx, size_t predicateIndex); + // 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. diff --git a/include/antlrgen/SysyVisitor.h b/include/antlrgen/SysyVisitor.h new file mode 100644 index 0000000..cf99d93 --- /dev/null +++ b/include/antlrgen/SysyVisitor.h @@ -0,0 +1,108 @@ + +// 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 visitAssignStmt(SysyParser::AssignStmtContext *context) = 0; + + virtual std::any visitExpStmt(SysyParser::ExpStmtContext *context) = 0; + + virtual std::any visitBlockStmt(SysyParser::BlockStmtContext *context) = 0; + + virtual std::any visitIfStmt(SysyParser::IfStmtContext *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 visitUnaryOp(SysyParser::UnaryOpContext *context) = 0; + + virtual std::any visitFuncRParams(SysyParser::FuncRParamsContext *context) = 0; + + virtual std::any visitFuncRParam(SysyParser::FuncRParamContext *context) = 0; + + virtual std::any visitMulExp(SysyParser::MulExpContext *context) = 0; + + virtual std::any visitAddExp(SysyParser::AddExpContext *context) = 0; + + virtual std::any visitRelExp(SysyParser::RelExpContext *context) = 0; + + virtual std::any visitEqExp(SysyParser::EqExpContext *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 index cab1f64..4214116 100755 --- a/scripts/antlr4-gen.sh +++ b/scripts/antlr4-gen.sh @@ -1,8 +1,11 @@ #!/bin/bash - +filename="Sysy.g4" 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 +rm -fv build/antlr-gen/* +java -jar ./tools/antlr-4.12.0-complete.jar -no-listener -visitor -Dlanguage=Cpp -package antlrSysY -o build/antlr-gen $filename +mkdir -p src/antlrgen +mkdir -p include/antlrgen +cp build/antlr-gen/*.cpp src/antlrgen/ +cp build/antlr-gen/*.h include/antlrgen/ \ No newline at end of file diff --git a/src/SysYBaseVisitor.cpp b/src/SysYBaseVisitor.cpp deleted file mode 100644 index cef7a78..0000000 --- a/src/SysYBaseVisitor.cpp +++ /dev/null @@ -1,9 +0,0 @@ - -// 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 deleted file mode 100644 index bc8a0ae..0000000 --- a/src/SysYLexer.cpp +++ /dev/null @@ -1,235 +0,0 @@ - -// 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 deleted file mode 100644 index 9553fb1..0000000 --- a/src/SysYParser.cpp +++ /dev/null @@ -1,3780 +0,0 @@ - -// 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 deleted file mode 100644 index 423c7b2..0000000 --- a/src/SysYVisitor.cpp +++ /dev/null @@ -1,9 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.12.0 - - -#include "SysYVisitor.h" - - -using namespace antlrSysY; - diff --git a/src/antlrgen/SysyBaseVisitor.cpp b/src/antlrgen/SysyBaseVisitor.cpp new file mode 100644 index 0000000..fe1e55c --- /dev/null +++ b/src/antlrgen/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/antlrgen/SysyLexer.cpp b/src/antlrgen/SysyLexer.cpp new file mode 100644 index 0000000..b53071e --- /dev/null +++ b/src/antlrgen/SysyLexer.cpp @@ -0,0 +1,239 @@ + +// 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{ + "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", + "T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", + "T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "T__24", + "T__25", "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", "IDENT", + "DECIMAL_CONST", "OCTAL_CONST", "HEXADECIMAL_CONST", "WS", "SINGLELINE_COMMENT", + "MULTILINE_COMMENT", "EscapeSequence", "SChar", "StringLiteral" + }, + std::vector{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }, + std::vector{ + "DEFAULT_MODE" + }, + std::vector{ + "", "'const'", "','", "';'", "'int'", "'['", "']'", "'='", "'{'", + "'}'", "'('", "')'", "'void'", "'if'", "'else'", "'while'", "'break'", + "'continue'", "'return'", "'+'", "'-'", "'!'", "'*'", "'/'", "'%'", + "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'&&'", "'||'" + }, + std::vector{ + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "IDENT", + "DECIMAL_CONST", "OCTAL_CONST", "HEXADECIMAL_CONST", "WS", "SINGLELINE_COMMENT", + "MULTILINE_COMMENT", "StringLiteral" + } + ); + static const int32_t serializedATNSegment[] = { + 4,0,40,297,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,1,0, + 1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,3,1,3,1,4,1,4,1,5,1,5,1, + 6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,12, + 1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,1,15, + 1,15,1,15,1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16, + 1,17,1,17,1,17,1,17,1,17,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,24,1,24,1,25,1,25,1,26,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,31,1,32, + 1,32,1,32,4,32,192,8,32,11,32,12,32,193,3,32,196,8,32,1,33,1,33,1,33, + 4,33,201,8,33,11,33,12,33,202,3,33,205,8,33,1,34,1,34,1,34,4,34,210,8, + 34,11,34,12,34,211,3,34,214,8,34,1,35,1,35,1,35,1,35,3,35,220,8,35,1, + 35,4,35,223,8,35,11,35,12,35,224,1,36,4,36,228,8,36,11,36,12,36,229,1, + 36,1,36,1,37,1,37,1,37,1,37,5,37,238,8,37,10,37,12,37,241,9,37,1,37,1, + 37,1,38,1,38,1,38,1,38,5,38,249,8,38,10,38,12,38,252,9,38,1,38,1,38,1, + 38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,3,39,264,8,39,1,39,3,39,267,8,39, + 1,39,1,39,1,39,1,39,4,39,273,8,39,11,39,12,39,274,3,39,277,8,39,1,40, + 1,40,1,40,1,40,1,40,1,40,1,40,3,40,286,8,40,1,41,1,41,4,41,290,8,41,11, + 41,12,41,291,3,41,294,8,41,1,41,1,41,1,250,0,42,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,15,31,16,33,17,35,18, + 37,19,39,20,41,21,43,22,45,23,47,24,49,25,51,26,53,27,55,28,57,29,59, + 30,61,31,63,32,65,33,67,34,69,35,71,36,73,37,75,38,77,39,79,0,81,0,83, + 40,1,0,10,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,10,0,34,34,39,39,63,63,92,92,97,98,102,102,110,110,114, + 114,116,116,118,118,4,0,10,10,13,13,34,34,92,92,315,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,29,1,0,0,0,0,31,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, + 83,1,0,0,0,1,85,1,0,0,0,3,91,1,0,0,0,5,93,1,0,0,0,7,95,1,0,0,0,9,99,1, + 0,0,0,11,101,1,0,0,0,13,103,1,0,0,0,15,105,1,0,0,0,17,107,1,0,0,0,19, + 109,1,0,0,0,21,111,1,0,0,0,23,113,1,0,0,0,25,118,1,0,0,0,27,121,1,0,0, + 0,29,126,1,0,0,0,31,132,1,0,0,0,33,138,1,0,0,0,35,147,1,0,0,0,37,154, + 1,0,0,0,39,156,1,0,0,0,41,158,1,0,0,0,43,160,1,0,0,0,45,162,1,0,0,0,47, + 164,1,0,0,0,49,166,1,0,0,0,51,168,1,0,0,0,53,170,1,0,0,0,55,173,1,0,0, + 0,57,176,1,0,0,0,59,179,1,0,0,0,61,182,1,0,0,0,63,185,1,0,0,0,65,195, + 1,0,0,0,67,204,1,0,0,0,69,213,1,0,0,0,71,219,1,0,0,0,73,227,1,0,0,0,75, + 233,1,0,0,0,77,244,1,0,0,0,79,276,1,0,0,0,81,285,1,0,0,0,83,287,1,0,0, + 0,85,86,5,99,0,0,86,87,5,111,0,0,87,88,5,110,0,0,88,89,5,115,0,0,89,90, + 5,116,0,0,90,2,1,0,0,0,91,92,5,44,0,0,92,4,1,0,0,0,93,94,5,59,0,0,94, + 6,1,0,0,0,95,96,5,105,0,0,96,97,5,110,0,0,97,98,5,116,0,0,98,8,1,0,0, + 0,99,100,5,91,0,0,100,10,1,0,0,0,101,102,5,93,0,0,102,12,1,0,0,0,103, + 104,5,61,0,0,104,14,1,0,0,0,105,106,5,123,0,0,106,16,1,0,0,0,107,108, + 5,125,0,0,108,18,1,0,0,0,109,110,5,40,0,0,110,20,1,0,0,0,111,112,5,41, + 0,0,112,22,1,0,0,0,113,114,5,118,0,0,114,115,5,111,0,0,115,116,5,105, + 0,0,116,117,5,100,0,0,117,24,1,0,0,0,118,119,5,105,0,0,119,120,5,102, + 0,0,120,26,1,0,0,0,121,122,5,101,0,0,122,123,5,108,0,0,123,124,5,115, + 0,0,124,125,5,101,0,0,125,28,1,0,0,0,126,127,5,119,0,0,127,128,5,104, + 0,0,128,129,5,105,0,0,129,130,5,108,0,0,130,131,5,101,0,0,131,30,1,0, + 0,0,132,133,5,98,0,0,133,134,5,114,0,0,134,135,5,101,0,0,135,136,5,97, + 0,0,136,137,5,107,0,0,137,32,1,0,0,0,138,139,5,99,0,0,139,140,5,111,0, + 0,140,141,5,110,0,0,141,142,5,116,0,0,142,143,5,105,0,0,143,144,5,110, + 0,0,144,145,5,117,0,0,145,146,5,101,0,0,146,34,1,0,0,0,147,148,5,114, + 0,0,148,149,5,101,0,0,149,150,5,116,0,0,150,151,5,117,0,0,151,152,5,114, + 0,0,152,153,5,110,0,0,153,36,1,0,0,0,154,155,5,43,0,0,155,38,1,0,0,0, + 156,157,5,45,0,0,157,40,1,0,0,0,158,159,5,33,0,0,159,42,1,0,0,0,160,161, + 5,42,0,0,161,44,1,0,0,0,162,163,5,47,0,0,163,46,1,0,0,0,164,165,5,37, + 0,0,165,48,1,0,0,0,166,167,5,60,0,0,167,50,1,0,0,0,168,169,5,62,0,0,169, + 52,1,0,0,0,170,171,5,60,0,0,171,172,5,61,0,0,172,54,1,0,0,0,173,174,5, + 62,0,0,174,175,5,61,0,0,175,56,1,0,0,0,176,177,5,61,0,0,177,178,5,61, + 0,0,178,58,1,0,0,0,179,180,5,33,0,0,180,181,5,61,0,0,181,60,1,0,0,0,182, + 183,5,38,0,0,183,184,5,38,0,0,184,62,1,0,0,0,185,186,5,124,0,0,186,187, + 5,124,0,0,187,64,1,0,0,0,188,196,7,0,0,0,189,191,7,0,0,0,190,192,7,1, + 0,0,191,190,1,0,0,0,192,193,1,0,0,0,193,191,1,0,0,0,193,194,1,0,0,0,194, + 196,1,0,0,0,195,188,1,0,0,0,195,189,1,0,0,0,196,66,1,0,0,0,197,205,7, + 2,0,0,198,200,7,2,0,0,199,201,7,3,0,0,200,199,1,0,0,0,201,202,1,0,0,0, + 202,200,1,0,0,0,202,203,1,0,0,0,203,205,1,0,0,0,204,197,1,0,0,0,204,198, + 1,0,0,0,205,68,1,0,0,0,206,214,5,48,0,0,207,209,5,48,0,0,208,210,7,4, + 0,0,209,208,1,0,0,0,210,211,1,0,0,0,211,209,1,0,0,0,211,212,1,0,0,0,212, + 214,1,0,0,0,213,206,1,0,0,0,213,207,1,0,0,0,214,70,1,0,0,0,215,216,5, + 48,0,0,216,220,5,120,0,0,217,218,5,48,0,0,218,220,5,88,0,0,219,215,1, + 0,0,0,219,217,1,0,0,0,220,222,1,0,0,0,221,223,7,5,0,0,222,221,1,0,0,0, + 223,224,1,0,0,0,224,222,1,0,0,0,224,225,1,0,0,0,225,72,1,0,0,0,226,228, + 7,6,0,0,227,226,1,0,0,0,228,229,1,0,0,0,229,227,1,0,0,0,229,230,1,0,0, + 0,230,231,1,0,0,0,231,232,6,36,0,0,232,74,1,0,0,0,233,234,5,47,0,0,234, + 235,5,47,0,0,235,239,1,0,0,0,236,238,8,7,0,0,237,236,1,0,0,0,238,241, + 1,0,0,0,239,237,1,0,0,0,239,240,1,0,0,0,240,242,1,0,0,0,241,239,1,0,0, + 0,242,243,6,37,0,0,243,76,1,0,0,0,244,245,5,47,0,0,245,246,5,42,0,0,246, + 250,1,0,0,0,247,249,9,0,0,0,248,247,1,0,0,0,249,252,1,0,0,0,250,251,1, + 0,0,0,250,248,1,0,0,0,251,253,1,0,0,0,252,250,1,0,0,0,253,254,5,42,0, + 0,254,255,5,47,0,0,255,256,1,0,0,0,256,257,6,38,0,0,257,78,1,0,0,0,258, + 259,5,92,0,0,259,277,7,8,0,0,260,261,5,92,0,0,261,263,7,4,0,0,262,264, + 7,4,0,0,263,262,1,0,0,0,263,264,1,0,0,0,264,266,1,0,0,0,265,267,7,4,0, + 0,266,265,1,0,0,0,266,267,1,0,0,0,267,277,1,0,0,0,268,269,5,92,0,0,269, + 270,5,120,0,0,270,272,1,0,0,0,271,273,7,5,0,0,272,271,1,0,0,0,273,274, + 1,0,0,0,274,272,1,0,0,0,274,275,1,0,0,0,275,277,1,0,0,0,276,258,1,0,0, + 0,276,260,1,0,0,0,276,268,1,0,0,0,277,80,1,0,0,0,278,286,8,9,0,0,279, + 286,3,79,39,0,280,281,5,92,0,0,281,286,5,10,0,0,282,283,5,92,0,0,283, + 284,5,13,0,0,284,286,5,10,0,0,285,278,1,0,0,0,285,279,1,0,0,0,285,280, + 1,0,0,0,285,282,1,0,0,0,286,82,1,0,0,0,287,293,5,34,0,0,288,290,3,81, + 40,0,289,288,1,0,0,0,290,291,1,0,0,0,291,289,1,0,0,0,291,292,1,0,0,0, + 292,294,1,0,0,0,293,289,1,0,0,0,293,294,1,0,0,0,294,295,1,0,0,0,295,296, + 5,34,0,0,296,84,1,0,0,0,19,0,193,195,202,204,211,213,219,224,229,239, + 250,263,266,274,276,285,291,293,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/antlrgen/SysyParser.cpp b/src/antlrgen/SysyParser.cpp new file mode 100644 index 0000000..2fb3a05 --- /dev/null +++ b/src/antlrgen/SysyParser.cpp @@ -0,0 +1,3107 @@ + +// 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", "exp", "cond", "lVal", + "primaryExp", "number", "intConst", "unaryExp", "unaryOp", "funcRParams", + "funcRParam", "mulExp", "addExp", "relExp", "eqExp", "lAndExp", "lOrExp", + "constExp" + }, + std::vector{ + "", "'const'", "','", "';'", "'int'", "'['", "']'", "'='", "'{'", + "'}'", "'('", "')'", "'void'", "'if'", "'else'", "'while'", "'break'", + "'continue'", "'return'", "'+'", "'-'", "'!'", "'*'", "'/'", "'%'", + "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'&&'", "'||'" + }, + std::vector{ + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "IDENT", + "DECIMAL_CONST", "OCTAL_CONST", "HEXADECIMAL_CONST", "WS", "SINGLELINE_COMMENT", + "MULTILINE_COMMENT", "StringLiteral" + } + ); + static const int32_t serializedATNSegment[] = { + 4,1,40,366,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,1,0,1,0,1,1,1,1, + 4,1,73,8,1,11,1,12,1,74,1,2,1,2,3,2,79,8,2,1,3,1,3,1,3,1,3,1,3,5,3,86, + 8,3,10,3,12,3,89,9,3,1,3,1,3,1,4,1,4,1,5,1,5,1,5,1,5,1,5,5,5,100,8,5, + 10,5,12,5,103,9,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,5,6,113,8,6,10,6,12, + 6,116,9,6,3,6,118,8,6,1,6,3,6,121,8,6,1,7,1,7,1,7,1,7,5,7,127,8,7,10, + 7,12,7,130,9,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,5,8,139,8,8,10,8,12,8,142, + 9,8,1,8,1,8,3,8,146,8,8,1,9,1,9,1,9,1,9,1,9,5,9,153,8,9,10,9,12,9,156, + 9,9,3,9,158,8,9,1,9,3,9,161,8,9,1,10,1,10,1,10,1,10,3,10,167,8,10,1,10, + 1,10,1,10,1,11,1,11,1,12,1,12,1,12,5,12,177,8,12,10,12,12,12,180,9,12, + 1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,5,13,190,8,13,10,13,12,13,193, + 9,13,3,13,195,8,13,1,14,1,14,5,14,199,8,14,10,14,12,14,202,9,14,1,14, + 1,14,1,15,1,15,3,15,208,8,15,1,16,1,16,1,16,1,16,1,16,1,16,3,16,216,8, + 16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,227,8,16,1,16,1, + 16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,241,8,16,1, + 16,3,16,244,8,16,1,17,1,17,1,18,1,18,1,19,1,19,1,19,1,19,1,19,5,19,255, + 8,19,10,19,12,19,258,9,19,1,20,1,20,1,20,1,20,1,20,1,20,3,20,266,8,20, + 1,21,1,21,1,22,1,22,1,23,1,23,1,23,1,23,3,23,276,8,23,1,23,1,23,1,23, + 1,23,3,23,282,8,23,1,24,1,24,1,25,1,25,1,25,5,25,289,8,25,10,25,12,25, + 292,9,25,1,26,1,26,3,26,296,8,26,1,27,1,27,1,27,1,27,1,27,1,27,5,27,304, + 8,27,10,27,12,27,307,9,27,1,28,1,28,1,28,1,28,1,28,1,28,5,28,315,8,28, + 10,28,12,28,318,9,28,1,29,1,29,1,29,1,29,1,29,1,29,5,29,326,8,29,10,29, + 12,29,329,9,29,1,30,1,30,1,30,1,30,1,30,1,30,5,30,337,8,30,10,30,12,30, + 340,9,30,1,31,1,31,1,31,1,31,1,31,1,31,5,31,348,8,31,10,31,12,31,351, + 9,31,1,32,1,32,1,32,1,32,1,32,1,32,5,32,359,8,32,10,32,12,32,362,9,32, + 1,33,1,33,1,33,0,6,54,56,58,60,62,64,34,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,0,7, + 2,0,4,4,12,12,1,0,34,36,1,0,19,21,1,0,22,24,1,0,19,20,1,0,25,28,1,0,29, + 30,375,0,68,1,0,0,0,2,72,1,0,0,0,4,78,1,0,0,0,6,80,1,0,0,0,8,92,1,0,0, + 0,10,94,1,0,0,0,12,120,1,0,0,0,14,122,1,0,0,0,16,133,1,0,0,0,18,160,1, + 0,0,0,20,162,1,0,0,0,22,171,1,0,0,0,24,173,1,0,0,0,26,181,1,0,0,0,28, + 196,1,0,0,0,30,207,1,0,0,0,32,243,1,0,0,0,34,245,1,0,0,0,36,247,1,0,0, + 0,38,249,1,0,0,0,40,265,1,0,0,0,42,267,1,0,0,0,44,269,1,0,0,0,46,281, + 1,0,0,0,48,283,1,0,0,0,50,285,1,0,0,0,52,295,1,0,0,0,54,297,1,0,0,0,56, + 308,1,0,0,0,58,319,1,0,0,0,60,330,1,0,0,0,62,341,1,0,0,0,64,352,1,0,0, + 0,66,363,1,0,0,0,68,69,3,2,1,0,69,1,1,0,0,0,70,73,3,20,10,0,71,73,3,4, + 2,0,72,70,1,0,0,0,72,71,1,0,0,0,73,74,1,0,0,0,74,72,1,0,0,0,74,75,1,0, + 0,0,75,3,1,0,0,0,76,79,3,6,3,0,77,79,3,14,7,0,78,76,1,0,0,0,78,77,1,0, + 0,0,79,5,1,0,0,0,80,81,5,1,0,0,81,82,3,8,4,0,82,87,3,10,5,0,83,84,5,2, + 0,0,84,86,3,10,5,0,85,83,1,0,0,0,86,89,1,0,0,0,87,85,1,0,0,0,87,88,1, + 0,0,0,88,90,1,0,0,0,89,87,1,0,0,0,90,91,5,3,0,0,91,7,1,0,0,0,92,93,5, + 4,0,0,93,9,1,0,0,0,94,101,5,33,0,0,95,96,5,5,0,0,96,97,3,66,33,0,97,98, + 5,6,0,0,98,100,1,0,0,0,99,95,1,0,0,0,100,103,1,0,0,0,101,99,1,0,0,0,101, + 102,1,0,0,0,102,104,1,0,0,0,103,101,1,0,0,0,104,105,5,7,0,0,105,106,3, + 12,6,0,106,11,1,0,0,0,107,121,3,66,33,0,108,117,5,8,0,0,109,114,3,12, + 6,0,110,111,5,2,0,0,111,113,3,12,6,0,112,110,1,0,0,0,113,116,1,0,0,0, + 114,112,1,0,0,0,114,115,1,0,0,0,115,118,1,0,0,0,116,114,1,0,0,0,117,109, + 1,0,0,0,117,118,1,0,0,0,118,119,1,0,0,0,119,121,5,9,0,0,120,107,1,0,0, + 0,120,108,1,0,0,0,121,13,1,0,0,0,122,123,3,8,4,0,123,128,3,16,8,0,124, + 125,5,2,0,0,125,127,3,16,8,0,126,124,1,0,0,0,127,130,1,0,0,0,128,126, + 1,0,0,0,128,129,1,0,0,0,129,131,1,0,0,0,130,128,1,0,0,0,131,132,5,3,0, + 0,132,15,1,0,0,0,133,140,5,33,0,0,134,135,5,5,0,0,135,136,3,66,33,0,136, + 137,5,6,0,0,137,139,1,0,0,0,138,134,1,0,0,0,139,142,1,0,0,0,140,138,1, + 0,0,0,140,141,1,0,0,0,141,145,1,0,0,0,142,140,1,0,0,0,143,144,5,7,0,0, + 144,146,3,18,9,0,145,143,1,0,0,0,145,146,1,0,0,0,146,17,1,0,0,0,147,161, + 3,34,17,0,148,157,5,8,0,0,149,154,3,18,9,0,150,151,5,2,0,0,151,153,3, + 18,9,0,152,150,1,0,0,0,153,156,1,0,0,0,154,152,1,0,0,0,154,155,1,0,0, + 0,155,158,1,0,0,0,156,154,1,0,0,0,157,149,1,0,0,0,157,158,1,0,0,0,158, + 159,1,0,0,0,159,161,5,9,0,0,160,147,1,0,0,0,160,148,1,0,0,0,161,19,1, + 0,0,0,162,163,3,22,11,0,163,164,5,33,0,0,164,166,5,10,0,0,165,167,3,24, + 12,0,166,165,1,0,0,0,166,167,1,0,0,0,167,168,1,0,0,0,168,169,5,11,0,0, + 169,170,3,28,14,0,170,21,1,0,0,0,171,172,7,0,0,0,172,23,1,0,0,0,173,178, + 3,26,13,0,174,175,5,2,0,0,175,177,3,26,13,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,25,1,0,0,0,180,178,1,0,0,0, + 181,182,3,8,4,0,182,194,5,33,0,0,183,184,5,5,0,0,184,191,5,6,0,0,185, + 186,5,5,0,0,186,187,3,34,17,0,187,188,5,6,0,0,188,190,1,0,0,0,189,185, + 1,0,0,0,190,193,1,0,0,0,191,189,1,0,0,0,191,192,1,0,0,0,192,195,1,0,0, + 0,193,191,1,0,0,0,194,183,1,0,0,0,194,195,1,0,0,0,195,27,1,0,0,0,196, + 200,5,8,0,0,197,199,3,30,15,0,198,197,1,0,0,0,199,202,1,0,0,0,200,198, + 1,0,0,0,200,201,1,0,0,0,201,203,1,0,0,0,202,200,1,0,0,0,203,204,5,9,0, + 0,204,29,1,0,0,0,205,208,3,4,2,0,206,208,3,32,16,0,207,205,1,0,0,0,207, + 206,1,0,0,0,208,31,1,0,0,0,209,210,3,38,19,0,210,211,5,7,0,0,211,212, + 3,34,17,0,212,213,5,3,0,0,213,244,1,0,0,0,214,216,3,34,17,0,215,214,1, + 0,0,0,215,216,1,0,0,0,216,217,1,0,0,0,217,244,5,3,0,0,218,244,3,28,14, + 0,219,220,5,13,0,0,220,221,5,10,0,0,221,222,3,36,18,0,222,223,5,11,0, + 0,223,226,3,32,16,0,224,225,5,14,0,0,225,227,3,32,16,0,226,224,1,0,0, + 0,226,227,1,0,0,0,227,244,1,0,0,0,228,229,5,15,0,0,229,230,5,10,0,0,230, + 231,3,36,18,0,231,232,5,11,0,0,232,233,3,32,16,0,233,244,1,0,0,0,234, + 235,5,16,0,0,235,244,5,3,0,0,236,237,5,17,0,0,237,244,5,3,0,0,238,240, + 5,18,0,0,239,241,3,34,17,0,240,239,1,0,0,0,240,241,1,0,0,0,241,242,1, + 0,0,0,242,244,5,3,0,0,243,209,1,0,0,0,243,215,1,0,0,0,243,218,1,0,0,0, + 243,219,1,0,0,0,243,228,1,0,0,0,243,234,1,0,0,0,243,236,1,0,0,0,243,238, + 1,0,0,0,244,33,1,0,0,0,245,246,3,56,28,0,246,35,1,0,0,0,247,248,3,64, + 32,0,248,37,1,0,0,0,249,256,5,33,0,0,250,251,5,5,0,0,251,252,3,34,17, + 0,252,253,5,6,0,0,253,255,1,0,0,0,254,250,1,0,0,0,255,258,1,0,0,0,256, + 254,1,0,0,0,256,257,1,0,0,0,257,39,1,0,0,0,258,256,1,0,0,0,259,260,5, + 10,0,0,260,261,3,34,17,0,261,262,5,11,0,0,262,266,1,0,0,0,263,266,3,38, + 19,0,264,266,3,42,21,0,265,259,1,0,0,0,265,263,1,0,0,0,265,264,1,0,0, + 0,266,41,1,0,0,0,267,268,3,44,22,0,268,43,1,0,0,0,269,270,7,1,0,0,270, + 45,1,0,0,0,271,282,3,40,20,0,272,273,5,33,0,0,273,275,5,10,0,0,274,276, + 3,50,25,0,275,274,1,0,0,0,275,276,1,0,0,0,276,277,1,0,0,0,277,282,5,11, + 0,0,278,279,3,48,24,0,279,280,3,46,23,0,280,282,1,0,0,0,281,271,1,0,0, + 0,281,272,1,0,0,0,281,278,1,0,0,0,282,47,1,0,0,0,283,284,7,2,0,0,284, + 49,1,0,0,0,285,290,3,52,26,0,286,287,5,2,0,0,287,289,3,52,26,0,288,286, + 1,0,0,0,289,292,1,0,0,0,290,288,1,0,0,0,290,291,1,0,0,0,291,51,1,0,0, + 0,292,290,1,0,0,0,293,296,3,34,17,0,294,296,5,40,0,0,295,293,1,0,0,0, + 295,294,1,0,0,0,296,53,1,0,0,0,297,298,6,27,-1,0,298,299,3,46,23,0,299, + 305,1,0,0,0,300,301,10,1,0,0,301,302,7,3,0,0,302,304,3,46,23,0,303,300, + 1,0,0,0,304,307,1,0,0,0,305,303,1,0,0,0,305,306,1,0,0,0,306,55,1,0,0, + 0,307,305,1,0,0,0,308,309,6,28,-1,0,309,310,3,54,27,0,310,316,1,0,0,0, + 311,312,10,1,0,0,312,313,7,4,0,0,313,315,3,54,27,0,314,311,1,0,0,0,315, + 318,1,0,0,0,316,314,1,0,0,0,316,317,1,0,0,0,317,57,1,0,0,0,318,316,1, + 0,0,0,319,320,6,29,-1,0,320,321,3,56,28,0,321,327,1,0,0,0,322,323,10, + 1,0,0,323,324,7,5,0,0,324,326,3,56,28,0,325,322,1,0,0,0,326,329,1,0,0, + 0,327,325,1,0,0,0,327,328,1,0,0,0,328,59,1,0,0,0,329,327,1,0,0,0,330, + 331,6,30,-1,0,331,332,3,58,29,0,332,338,1,0,0,0,333,334,10,1,0,0,334, + 335,7,6,0,0,335,337,3,58,29,0,336,333,1,0,0,0,337,340,1,0,0,0,338,336, + 1,0,0,0,338,339,1,0,0,0,339,61,1,0,0,0,340,338,1,0,0,0,341,342,6,31,-1, + 0,342,343,3,60,30,0,343,349,1,0,0,0,344,345,10,1,0,0,345,346,5,31,0,0, + 346,348,3,60,30,0,347,344,1,0,0,0,348,351,1,0,0,0,349,347,1,0,0,0,349, + 350,1,0,0,0,350,63,1,0,0,0,351,349,1,0,0,0,352,353,6,32,-1,0,353,354, + 3,62,31,0,354,360,1,0,0,0,355,356,10,1,0,0,356,357,5,32,0,0,357,359,3, + 62,31,0,358,355,1,0,0,0,359,362,1,0,0,0,360,358,1,0,0,0,360,361,1,0,0, + 0,361,65,1,0,0,0,362,360,1,0,0,0,363,364,3,56,28,0,364,67,1,0,0,0,36, + 72,74,78,87,101,114,117,120,128,140,145,154,157,160,166,178,191,194,200, + 207,215,226,240,243,256,265,275,281,290,295,305,316,327,338,349,360 + }; + 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(68); + 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(72); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(72); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { + case 1: { + setState(70); + funcDef(); + break; + } + + case 2: { + setState(71); + decl(); + break; + } + + default: + break; + } + setState(74); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 4114) != 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(78); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysyParser::T__0: { + enterOuterAlt(_localctx, 1); + setState(76); + constDecl(); + break; + } + + case SysyParser::T__3: { + enterOuterAlt(_localctx, 2); + setState(77); + 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) { +} + +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); +} + + +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(80); + match(SysyParser::T__0); + setState(81); + bType(); + setState(82); + constDef(); + setState(87); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__1) { + setState(83); + match(SysyParser::T__1); + setState(84); + constDef(); + setState(89); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(90); + match(SysyParser::T__2); + + } + 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) { +} + + +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(92); + match(SysyParser::T__3); + + } + 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); +} + +SysyParser::ConstInitValContext* SysyParser::ConstDefContext::constInitVal() { + return getRuleContext(0); +} + +std::vector SysyParser::ConstDefContext::constExp() { + return getRuleContexts(); +} + +SysyParser::ConstExpContext* SysyParser::ConstDefContext::constExp(size_t i) { + return getRuleContext(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(94); + match(SysyParser::IDENT); + setState(101); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__4) { + setState(95); + match(SysyParser::T__4); + setState(96); + constExp(); + setState(97); + match(SysyParser::T__5); + setState(103); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(104); + match(SysyParser::T__6); + setState(105); + 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); +} + +std::vector SysyParser::ConstInitValContext::constInitVal() { + return getRuleContexts(); +} + +SysyParser::ConstInitValContext* SysyParser::ConstInitValContext::constInitVal(size_t i) { + return getRuleContext(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(120); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysyParser::T__9: + case SysyParser::T__18: + case SysyParser::T__19: + case SysyParser::T__20: + case SysyParser::IDENT: + case SysyParser::DECIMAL_CONST: + case SysyParser::OCTAL_CONST: + case SysyParser::HEXADECIMAL_CONST: { + enterOuterAlt(_localctx, 1); + setState(107); + constExp(); + break; + } + + case SysyParser::T__7: { + enterOuterAlt(_localctx, 2); + setState(108); + match(SysyParser::T__7); + setState(117); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 128852690176) != 0)) { + setState(109); + constInitVal(); + setState(114); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__1) { + setState(110); + match(SysyParser::T__1); + setState(111); + constInitVal(); + setState(116); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(119); + match(SysyParser::T__8); + 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); +} + + +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(122); + bType(); + setState(123); + varDef(); + setState(128); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__1) { + setState(124); + match(SysyParser::T__1); + setState(125); + varDef(); + setState(130); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(131); + match(SysyParser::T__2); + + } + 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::constExp() { + return getRuleContexts(); +} + +SysyParser::ConstExpContext* SysyParser::VarDefContext::constExp(size_t i) { + return getRuleContext(i); +} + +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(133); + match(SysyParser::IDENT); + setState(140); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__4) { + setState(134); + match(SysyParser::T__4); + setState(135); + constExp(); + setState(136); + match(SysyParser::T__5); + setState(142); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(145); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysyParser::T__6) { + setState(143); + match(SysyParser::T__6); + setState(144); + 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); +} + +std::vector SysyParser::InitValContext::initVal() { + return getRuleContexts(); +} + +SysyParser::InitValContext* SysyParser::InitValContext::initVal(size_t i) { + return getRuleContext(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(160); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysyParser::T__9: + case SysyParser::T__18: + case SysyParser::T__19: + case SysyParser::T__20: + case SysyParser::IDENT: + case SysyParser::DECIMAL_CONST: + case SysyParser::OCTAL_CONST: + case SysyParser::HEXADECIMAL_CONST: { + enterOuterAlt(_localctx, 1); + setState(147); + exp(); + break; + } + + case SysyParser::T__7: { + enterOuterAlt(_localctx, 2); + setState(148); + match(SysyParser::T__7); + setState(157); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 128852690176) != 0)) { + setState(149); + initVal(); + setState(154); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__1) { + setState(150); + match(SysyParser::T__1); + setState(151); + initVal(); + setState(156); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(159); + match(SysyParser::T__8); + 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); +} + +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(162); + funcType(); + setState(163); + match(SysyParser::IDENT); + setState(164); + match(SysyParser::T__9); + setState(166); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysyParser::T__3) { + setState(165); + funcFParams(); + } + setState(168); + match(SysyParser::T__10); + setState(169); + 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) { +} + + +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(171); + _la = _input->LA(1); + if (!(_la == SysyParser::T__3 + + || _la == SysyParser::T__11)) { + _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); +} + + +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(173); + funcFParam(); + setState(178); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__1) { + setState(174); + match(SysyParser::T__1); + setState(175); + funcFParam(); + setState(180); + _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::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(181); + bType(); + setState(182); + match(SysyParser::IDENT); + setState(194); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysyParser::T__4) { + setState(183); + match(SysyParser::T__4); + setState(184); + match(SysyParser::T__5); + setState(191); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__4) { + setState(185); + match(SysyParser::T__4); + setState(186); + exp(); + setState(187); + match(SysyParser::T__5); + setState(193); + _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) { +} + +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(196); + match(SysyParser::T__7); + setState(200); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 128853189914) != 0)) { + setState(197); + blockItem(); + setState(202); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(203); + match(SysyParser::T__8); + + } + 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::DeclContext* SysyParser::BlockItemContext::decl() { + 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(207); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysyParser::T__0: + case SysyParser::T__3: { + enterOuterAlt(_localctx, 1); + setState(205); + decl(); + break; + } + + case SysyParser::T__2: + case SysyParser::T__7: + case SysyParser::T__9: + case SysyParser::T__12: + case SysyParser::T__14: + case SysyParser::T__15: + case SysyParser::T__16: + case SysyParser::T__17: + case SysyParser::T__18: + case SysyParser::T__19: + case SysyParser::T__20: + case SysyParser::IDENT: + case SysyParser::DECIMAL_CONST: + case SysyParser::OCTAL_CONST: + case SysyParser::HEXADECIMAL_CONST: { + enterOuterAlt(_localctx, 2); + setState(206); + 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) { +} + + +size_t SysyParser::StmtContext::getRuleIndex() const { + return SysyParser::RuleStmt; +} + +void SysyParser::StmtContext::copyFrom(StmtContext *ctx) { + ParserRuleContext::copyFrom(ctx); +} + +//----------------- WhileStmtContext ------------------------------------------------------------------ + +SysyParser::CondContext* SysyParser::WhileStmtContext::cond() { + return getRuleContext(0); +} + +SysyParser::StmtContext* SysyParser::WhileStmtContext::stmt() { + return getRuleContext(0); +} + +SysyParser::WhileStmtContext::WhileStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::WhileStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitWhileStmt(this); + else + return visitor->visitChildren(this); +} +//----------------- IfStmtContext ------------------------------------------------------------------ + +SysyParser::CondContext* SysyParser::IfStmtContext::cond() { + return getRuleContext(0); +} + +std::vector SysyParser::IfStmtContext::stmt() { + return getRuleContexts(); +} + +SysyParser::StmtContext* SysyParser::IfStmtContext::stmt(size_t i) { + return getRuleContext(i); +} + +SysyParser::IfStmtContext::IfStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::IfStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIfStmt(this); + else + return visitor->visitChildren(this); +} +//----------------- BlockStmtContext ------------------------------------------------------------------ + +SysyParser::BlockContext* SysyParser::BlockStmtContext::block() { + return getRuleContext(0); +} + +SysyParser::BlockStmtContext::BlockStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::BlockStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBlockStmt(this); + else + return visitor->visitChildren(this); +} +//----------------- AssignStmtContext ------------------------------------------------------------------ + +SysyParser::LValContext* SysyParser::AssignStmtContext::lVal() { + return getRuleContext(0); +} + +SysyParser::ExpContext* SysyParser::AssignStmtContext::exp() { + return getRuleContext(0); +} + +SysyParser::AssignStmtContext::AssignStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::AssignStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAssignStmt(this); + else + return visitor->visitChildren(this); +} +//----------------- BreakStmtContext ------------------------------------------------------------------ + +SysyParser::BreakStmtContext::BreakStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::BreakStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBreakStmt(this); + else + return visitor->visitChildren(this); +} +//----------------- ExpStmtContext ------------------------------------------------------------------ + +SysyParser::ExpContext* SysyParser::ExpStmtContext::exp() { + return getRuleContext(0); +} + +SysyParser::ExpStmtContext::ExpStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::ExpStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExpStmt(this); + else + return visitor->visitChildren(this); +} +//----------------- ReturnStmtContext ------------------------------------------------------------------ + +SysyParser::ExpContext* SysyParser::ReturnStmtContext::exp() { + return getRuleContext(0); +} + +SysyParser::ReturnStmtContext::ReturnStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::ReturnStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitReturnStmt(this); + else + return visitor->visitChildren(this); +} +//----------------- ContinueStmtContext ------------------------------------------------------------------ + +SysyParser::ContinueStmtContext::ContinueStmtContext(StmtContext *ctx) { copyFrom(ctx); } + + +std::any SysyParser::ContinueStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitContinueStmt(this); + else + return visitor->visitChildren(this); +} +SysyParser::StmtContext* SysyParser::stmt() { + StmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 32, SysyParser::RuleStmt); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(243); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 23, _ctx)) { + case 1: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 1); + setState(209); + lVal(); + setState(210); + match(SysyParser::T__6); + setState(211); + exp(); + setState(212); + match(SysyParser::T__2); + break; + } + + case 2: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 2); + setState(215); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 128852689920) != 0)) { + setState(214); + exp(); + } + setState(217); + match(SysyParser::T__2); + break; + } + + case 3: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 3); + setState(218); + block(); + break; + } + + case 4: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 4); + setState(219); + match(SysyParser::T__12); + setState(220); + match(SysyParser::T__9); + setState(221); + cond(); + setState(222); + match(SysyParser::T__10); + setState(223); + stmt(); + setState(226); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 21, _ctx)) { + case 1: { + setState(224); + match(SysyParser::T__13); + setState(225); + stmt(); + break; + } + + default: + break; + } + break; + } + + case 5: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 5); + setState(228); + match(SysyParser::T__14); + setState(229); + match(SysyParser::T__9); + setState(230); + cond(); + setState(231); + match(SysyParser::T__10); + setState(232); + stmt(); + break; + } + + case 6: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 6); + setState(234); + match(SysyParser::T__15); + setState(235); + match(SysyParser::T__2); + break; + } + + case 7: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 7); + setState(236); + match(SysyParser::T__16); + setState(237); + match(SysyParser::T__2); + break; + } + + case 8: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 8); + setState(238); + match(SysyParser::T__17); + setState(240); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 128852689920) != 0)) { + setState(239); + exp(); + } + setState(242); + match(SysyParser::T__2); + break; + } + + default: + break; + } + + } + 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, 34, SysyParser::RuleExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(245); + addExp(0); + + } + 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, 36, SysyParser::RuleCond); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(247); + lOrExp(0); + + } + 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::exp() { + return getRuleContexts(); +} + +SysyParser::ExpContext* SysyParser::LValContext::exp(size_t i) { + return getRuleContext(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, 38, SysyParser::RuleLVal); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(249); + match(SysyParser::IDENT); + setState(256); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 24, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(250); + match(SysyParser::T__4); + setState(251); + exp(); + setState(252); + match(SysyParser::T__5); + } + setState(258); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 24, _ctx); + } + + } + 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) { +} + +SysyParser::ExpContext* SysyParser::PrimaryExpContext::exp() { + return getRuleContext(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, 40, SysyParser::RulePrimaryExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(265); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysyParser::T__9: { + enterOuterAlt(_localctx, 1); + setState(259); + match(SysyParser::T__9); + setState(260); + exp(); + setState(261); + match(SysyParser::T__10); + break; + } + + case SysyParser::IDENT: { + enterOuterAlt(_localctx, 2); + setState(263); + lVal(); + break; + } + + case SysyParser::DECIMAL_CONST: + case SysyParser::OCTAL_CONST: + case SysyParser::HEXADECIMAL_CONST: { + enterOuterAlt(_localctx, 3); + setState(264); + 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, 42, SysyParser::RuleNumber); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(267); + 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, 44, SysyParser::RuleIntConst); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(269); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120259084288) != 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); +} + +tree::TerminalNode* SysyParser::UnaryExpContext::IDENT() { + return getToken(SysyParser::IDENT, 0); +} + +SysyParser::FuncRParamsContext* SysyParser::UnaryExpContext::funcRParams() { + 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, 46, SysyParser::RuleUnaryExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(281); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 27, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(271); + primaryExp(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(272); + match(SysyParser::IDENT); + setState(273); + match(SysyParser::T__9); + setState(275); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1228364317696) != 0)) { + setState(274); + funcRParams(); + } + setState(277); + match(SysyParser::T__10); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(278); + unaryOp(); + setState(279); + unaryExp(); + break; + } + + default: + break; + } + + } + 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) { +} + + +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, 48, SysyParser::RuleUnaryOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(283); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 3670016) != 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::funcRParam() { + return getRuleContexts(); +} + +SysyParser::FuncRParamContext* SysyParser::FuncRParamsContext::funcRParam(size_t i) { + return getRuleContext(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, 50, SysyParser::RuleFuncRParams); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(285); + funcRParam(); + setState(290); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysyParser::T__1) { + setState(286); + match(SysyParser::T__1); + setState(287); + funcRParam(); + setState(292); + _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; +} + +//----------------- FuncRParamContext ------------------------------------------------------------------ + +SysyParser::FuncRParamContext::FuncRParamContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysyParser::ExpContext* SysyParser::FuncRParamContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysyParser::FuncRParamContext::StringLiteral() { + return getToken(SysyParser::StringLiteral, 0); +} + + +size_t SysyParser::FuncRParamContext::getRuleIndex() const { + return SysyParser::RuleFuncRParam; +} + + +std::any SysyParser::FuncRParamContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncRParam(this); + else + return visitor->visitChildren(this); +} + +SysyParser::FuncRParamContext* SysyParser::funcRParam() { + FuncRParamContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 52, SysyParser::RuleFuncRParam); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(295); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysyParser::T__9: + case SysyParser::T__18: + case SysyParser::T__19: + case SysyParser::T__20: + case SysyParser::IDENT: + case SysyParser::DECIMAL_CONST: + case SysyParser::OCTAL_CONST: + case SysyParser::HEXADECIMAL_CONST: { + enterOuterAlt(_localctx, 1); + setState(293); + exp(); + break; + } + + case SysyParser::StringLiteral: { + enterOuterAlt(_localctx, 2); + setState(294); + match(SysyParser::StringLiteral); + 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) { +} + +SysyParser::UnaryExpContext* SysyParser::MulExpContext::unaryExp() { + return getRuleContext(0); +} + +SysyParser::MulExpContext* SysyParser::MulExpContext::mulExp() { + return getRuleContext(0); +} + + +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() { + return mulExp(0); +} + +SysyParser::MulExpContext* SysyParser::mulExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysyParser::MulExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysyParser::MulExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 54; + enterRecursionRule(_localctx, 54, SysyParser::RuleMulExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(298); + unaryExp(); + _ctx->stop = _input->LT(-1); + setState(305); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 30, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleMulExp); + setState(300); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(301); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 29360128) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(302); + unaryExp(); + } + setState(307); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 30, _ctx); + } + } + 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) { +} + +SysyParser::MulExpContext* SysyParser::AddExpContext::mulExp() { + return getRuleContext(0); +} + +SysyParser::AddExpContext* SysyParser::AddExpContext::addExp() { + return getRuleContext(0); +} + + +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() { + return addExp(0); +} + +SysyParser::AddExpContext* SysyParser::addExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysyParser::AddExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysyParser::AddExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 56; + enterRecursionRule(_localctx, 56, SysyParser::RuleAddExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(309); + mulExp(0); + _ctx->stop = _input->LT(-1); + setState(316); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 31, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleAddExp); + setState(311); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(312); + _la = _input->LA(1); + if (!(_la == SysyParser::T__18 + + || _la == SysyParser::T__19)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(313); + mulExp(0); + } + setState(318); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 31, _ctx); + } + } + 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) { +} + +SysyParser::AddExpContext* SysyParser::RelExpContext::addExp() { + return getRuleContext(0); +} + +SysyParser::RelExpContext* SysyParser::RelExpContext::relExp() { + return getRuleContext(0); +} + + +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() { + return relExp(0); +} + +SysyParser::RelExpContext* SysyParser::relExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysyParser::RelExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysyParser::RelExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 58; + enterRecursionRule(_localctx, 58, SysyParser::RuleRelExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(320); + addExp(0); + _ctx->stop = _input->LT(-1); + setState(327); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleRelExp); + setState(322); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(323); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 503316480) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(324); + addExp(0); + } + setState(329); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); + } + } + 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) { +} + +SysyParser::RelExpContext* SysyParser::EqExpContext::relExp() { + return getRuleContext(0); +} + +SysyParser::EqExpContext* SysyParser::EqExpContext::eqExp() { + return getRuleContext(0); +} + + +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() { + return eqExp(0); +} + +SysyParser::EqExpContext* SysyParser::eqExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysyParser::EqExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysyParser::EqExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 60; + enterRecursionRule(_localctx, 60, SysyParser::RuleEqExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(331); + relExp(0); + _ctx->stop = _input->LT(-1); + setState(338); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 33, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleEqExp); + setState(333); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(334); + _la = _input->LA(1); + if (!(_la == SysyParser::T__28 + + || _la == SysyParser::T__29)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(335); + relExp(0); + } + setState(340); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 33, _ctx); + } + } + 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) { +} + +SysyParser::EqExpContext* SysyParser::LAndExpContext::eqExp() { + return getRuleContext(0); +} + +SysyParser::LAndExpContext* SysyParser::LAndExpContext::lAndExp() { + return getRuleContext(0); +} + + +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() { + return lAndExp(0); +} + +SysyParser::LAndExpContext* SysyParser::lAndExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysyParser::LAndExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysyParser::LAndExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 62; + enterRecursionRule(_localctx, 62, SysyParser::RuleLAndExp, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(342); + eqExp(0); + _ctx->stop = _input->LT(-1); + setState(349); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleLAndExp); + setState(344); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(345); + match(SysyParser::T__30); + setState(346); + eqExp(0); + } + setState(351); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + } + } + 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) { +} + +SysyParser::LAndExpContext* SysyParser::LOrExpContext::lAndExp() { + return getRuleContext(0); +} + +SysyParser::LOrExpContext* SysyParser::LOrExpContext::lOrExp() { + return getRuleContext(0); +} + + +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() { + return lOrExp(0); +} + +SysyParser::LOrExpContext* SysyParser::lOrExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysyParser::LOrExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysyParser::LOrExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 64; + enterRecursionRule(_localctx, 64, SysyParser::RuleLOrExp, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(353); + lAndExp(0); + _ctx->stop = _input->LT(-1); + setState(360); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 35, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleLOrExp); + setState(355); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(356); + match(SysyParser::T__31); + setState(357); + lAndExp(0); + } + setState(362); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 35, _ctx); + } + } + 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, 66, SysyParser::RuleConstExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(363); + addExp(0); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +bool SysyParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 27: return mulExpSempred(antlrcpp::downCast(context), predicateIndex); + case 28: return addExpSempred(antlrcpp::downCast(context), predicateIndex); + case 29: return relExpSempred(antlrcpp::downCast(context), predicateIndex); + case 30: return eqExpSempred(antlrcpp::downCast(context), predicateIndex); + case 31: return lAndExpSempred(antlrcpp::downCast(context), predicateIndex); + case 32: return lOrExpSempred(antlrcpp::downCast(context), predicateIndex); + + default: + break; + } + return true; +} + +bool SysyParser::mulExpSempred(MulExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysyParser::addExpSempred(AddExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 1: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysyParser::relExpSempred(RelExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 2: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysyParser::eqExpSempred(EqExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 3: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysyParser::lAndExpSempred(LAndExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 4: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysyParser::lOrExpSempred(LOrExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 5: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +void SysyParser::initialize() { + ::antlr4::internal::call_once(sysyParserOnceFlag, sysyParserInitialize); +} diff --git a/src/antlrgen/SysyVisitor.cpp b/src/antlrgen/SysyVisitor.cpp new file mode 100644 index 0000000..de2868f --- /dev/null +++ b/src/antlrgen/SysyVisitor.cpp @@ -0,0 +1,9 @@ + +// Generated from Sysy.g4 by ANTLR 4.12.0 + + +#include "SysyVisitor.h" + + +using namespace antlrSysY; + diff --git a/src/main.cpp b/src/main.cpp index b07f31d..e385e45 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,15 +1,15 @@ #include #include "antlr4-runtime.h" -#include "SysYLexer.h" -#include "SysYParser.h" +#include "SysyLexer.h" +#include "SysyParser.h" using namespace antlrSysY; using namespace antlr4; int main(int , const char **) { ANTLRInputStream input(u8"🍴 = 🍐 + \"😎\";(((x * π))) * µ + ∰; a + (x * (y ? 0 : 1) + z);"); - SysYLexer lexer(&input); + SysyLexer lexer(&input); CommonTokenStream tokens(&lexer); tokens.fill(); @@ -17,7 +17,7 @@ int main(int , const char **) { std::cout << token->toString() << std::endl; } - SysYParser parser(&tokens); + SysyParser parser(&tokens); tree::ParseTree* tree = parser.program(); std::cout << tree->toStringTree(&parser) << std::endl << std::endl;