diff --git a/src/antlr4/SysYBaseVisitor.cpp b/src/antlr4/SysYBaseVisitor.cpp new file mode 100644 index 0000000..ff22821 --- /dev/null +++ b/src/antlr4/SysYBaseVisitor.cpp @@ -0,0 +1,7 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + + +#include "SysYBaseVisitor.h" + + diff --git a/src/antlr4/SysYBaseVisitor.h b/src/antlr4/SysYBaseVisitor.h new file mode 100644 index 0000000..2a171f4 --- /dev/null +++ b/src/antlr4/SysYBaseVisitor.h @@ -0,0 +1,144 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SysYVisitor.h" + + +/** + * 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 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 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 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 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); + } + + +}; + diff --git a/src/antlr4/SysYLexer.cpp b/src/antlr4/SysYLexer.cpp new file mode 100644 index 0000000..234615c --- /dev/null +++ b/src/antlr4/SysYLexer.cpp @@ -0,0 +1,269 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + + +#include "SysYLexer.h" + + +using namespace antlr4; + + + +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; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr sysylexerLexerStaticData = nullptr; + +void sysylexerLexerInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (sysylexerLexerStaticData != nullptr) { + return; + } +#else + assert(sysylexerLexerStaticData == nullptr); +#endif + 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", "T__32", + "DIGIT", "HEXDIGIT", "EXP", "PEXP", "FloatConst", "IntConst", "Ident", + "WS", "LINE_COMMENT", "BLOCK_COMMENT" + }, + std::vector{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }, + std::vector{ + "DEFAULT_MODE" + }, + std::vector{ + "", "'const'", "','", "';'", "'int'", "'float'", "'['", "']'", "'='", + "'{'", "'}'", "'('", "')'", "'void'", "'if'", "'else'", "'while'", + "'break'", "'continue'", "'return'", "'+'", "'-'", "'!'", "'*'", "'/'", + "'%'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'&&'", "'||'" + }, + std::vector{ + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "FloatConst", "IntConst", "Ident", "WS", "LINE_COMMENT", "BLOCK_COMMENT" + } + ); + static const int32_t serializedATNSegment[] = { + 4,0,39,350,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,2,1,2,1,3,1,3,1,3,1,3,1,4,1,4, + 1,4,1,4,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,12,1,12,1,12,1,12,1,12,1,13,1,13,1,13,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,17,1,17, + 1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,18,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,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,1,33,1,33,1,34,1,34,1,35,1,35,3,35,203, + 8,35,1,35,4,35,206,8,35,11,35,12,35,207,1,36,1,36,3,36,212,8,36,1,36, + 4,36,215,8,36,11,36,12,36,216,1,37,1,37,1,37,1,37,3,37,223,8,37,1,37, + 4,37,226,8,37,11,37,12,37,227,1,37,1,37,5,37,232,8,37,10,37,12,37,235, + 9,37,1,37,1,37,4,37,239,8,37,11,37,12,37,240,1,37,4,37,244,8,37,11,37, + 12,37,245,3,37,248,8,37,1,37,1,37,1,37,1,37,4,37,254,8,37,11,37,12,37, + 255,1,37,3,37,259,8,37,1,37,4,37,262,8,37,11,37,12,37,263,1,37,1,37,5, + 37,268,8,37,10,37,12,37,271,9,37,1,37,3,37,274,8,37,1,37,4,37,277,8,37, + 11,37,12,37,278,1,37,1,37,3,37,283,8,37,1,38,1,38,1,38,5,38,288,8,38, + 10,38,12,38,291,9,38,1,38,1,38,4,38,295,8,38,11,38,12,38,296,1,38,1,38, + 1,38,1,38,3,38,303,8,38,1,38,4,38,306,8,38,11,38,12,38,307,3,38,310,8, + 38,1,39,1,39,5,39,314,8,39,10,39,12,39,317,9,39,1,40,4,40,320,8,40,11, + 40,12,40,321,1,40,1,40,1,41,1,41,1,41,1,41,5,41,330,8,41,10,41,12,41, + 333,9,41,1,41,1,41,1,42,1,42,1,42,1,42,5,42,341,8,42,10,42,12,42,344, + 9,42,1,42,1,42,1,42,1,42,1,42,1,342,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,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,0,69,0,71,0,73,0,75,34,77,35,79,36,81,37,83,38,85, + 39,1,0,11,1,0,48,57,3,0,48,57,65,70,97,102,2,0,69,69,101,101,2,0,43,43, + 45,45,2,0,80,80,112,112,1,0,49,57,1,0,48,55,3,0,65,90,95,95,97,122,4, + 0,48,57,65,90,95,95,97,122,3,0,9,10,13,13,32,32,2,0,10,10,13,13,376,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,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,95,1,0,0,0,7,97,1,0,0,0,9, + 101,1,0,0,0,11,107,1,0,0,0,13,109,1,0,0,0,15,111,1,0,0,0,17,113,1,0,0, + 0,19,115,1,0,0,0,21,117,1,0,0,0,23,119,1,0,0,0,25,121,1,0,0,0,27,126, + 1,0,0,0,29,129,1,0,0,0,31,134,1,0,0,0,33,140,1,0,0,0,35,146,1,0,0,0,37, + 155,1,0,0,0,39,162,1,0,0,0,41,164,1,0,0,0,43,166,1,0,0,0,45,168,1,0,0, + 0,47,170,1,0,0,0,49,172,1,0,0,0,51,174,1,0,0,0,53,176,1,0,0,0,55,178, + 1,0,0,0,57,181,1,0,0,0,59,184,1,0,0,0,61,187,1,0,0,0,63,190,1,0,0,0,65, + 193,1,0,0,0,67,196,1,0,0,0,69,198,1,0,0,0,71,200,1,0,0,0,73,209,1,0,0, + 0,75,282,1,0,0,0,77,309,1,0,0,0,79,311,1,0,0,0,81,319,1,0,0,0,83,325, + 1,0,0,0,85,336,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,44,0,0,94,4,1,0, + 0,0,95,96,5,59,0,0,96,6,1,0,0,0,97,98,5,105,0,0,98,99,5,110,0,0,99,100, + 5,116,0,0,100,8,1,0,0,0,101,102,5,102,0,0,102,103,5,108,0,0,103,104,5, + 111,0,0,104,105,5,97,0,0,105,106,5,116,0,0,106,10,1,0,0,0,107,108,5,91, + 0,0,108,12,1,0,0,0,109,110,5,93,0,0,110,14,1,0,0,0,111,112,5,61,0,0,112, + 16,1,0,0,0,113,114,5,123,0,0,114,18,1,0,0,0,115,116,5,125,0,0,116,20, + 1,0,0,0,117,118,5,40,0,0,118,22,1,0,0,0,119,120,5,41,0,0,120,24,1,0,0, + 0,121,122,5,118,0,0,122,123,5,111,0,0,123,124,5,105,0,0,124,125,5,100, + 0,0,125,26,1,0,0,0,126,127,5,105,0,0,127,128,5,102,0,0,128,28,1,0,0,0, + 129,130,5,101,0,0,130,131,5,108,0,0,131,132,5,115,0,0,132,133,5,101,0, + 0,133,30,1,0,0,0,134,135,5,119,0,0,135,136,5,104,0,0,136,137,5,105,0, + 0,137,138,5,108,0,0,138,139,5,101,0,0,139,32,1,0,0,0,140,141,5,98,0,0, + 141,142,5,114,0,0,142,143,5,101,0,0,143,144,5,97,0,0,144,145,5,107,0, + 0,145,34,1,0,0,0,146,147,5,99,0,0,147,148,5,111,0,0,148,149,5,110,0,0, + 149,150,5,116,0,0,150,151,5,105,0,0,151,152,5,110,0,0,152,153,5,117,0, + 0,153,154,5,101,0,0,154,36,1,0,0,0,155,156,5,114,0,0,156,157,5,101,0, + 0,157,158,5,116,0,0,158,159,5,117,0,0,159,160,5,114,0,0,160,161,5,110, + 0,0,161,38,1,0,0,0,162,163,5,43,0,0,163,40,1,0,0,0,164,165,5,45,0,0,165, + 42,1,0,0,0,166,167,5,33,0,0,167,44,1,0,0,0,168,169,5,42,0,0,169,46,1, + 0,0,0,170,171,5,47,0,0,171,48,1,0,0,0,172,173,5,37,0,0,173,50,1,0,0,0, + 174,175,5,60,0,0,175,52,1,0,0,0,176,177,5,62,0,0,177,54,1,0,0,0,178,179, + 5,60,0,0,179,180,5,61,0,0,180,56,1,0,0,0,181,182,5,62,0,0,182,183,5,61, + 0,0,183,58,1,0,0,0,184,185,5,61,0,0,185,186,5,61,0,0,186,60,1,0,0,0,187, + 188,5,33,0,0,188,189,5,61,0,0,189,62,1,0,0,0,190,191,5,38,0,0,191,192, + 5,38,0,0,192,64,1,0,0,0,193,194,5,124,0,0,194,195,5,124,0,0,195,66,1, + 0,0,0,196,197,7,0,0,0,197,68,1,0,0,0,198,199,7,1,0,0,199,70,1,0,0,0,200, + 202,7,2,0,0,201,203,7,3,0,0,202,201,1,0,0,0,202,203,1,0,0,0,203,205,1, + 0,0,0,204,206,3,67,33,0,205,204,1,0,0,0,206,207,1,0,0,0,207,205,1,0,0, + 0,207,208,1,0,0,0,208,72,1,0,0,0,209,211,7,4,0,0,210,212,7,3,0,0,211, + 210,1,0,0,0,211,212,1,0,0,0,212,214,1,0,0,0,213,215,3,67,33,0,214,213, + 1,0,0,0,215,216,1,0,0,0,216,214,1,0,0,0,216,217,1,0,0,0,217,74,1,0,0, + 0,218,219,5,48,0,0,219,223,5,120,0,0,220,221,5,48,0,0,221,223,5,88,0, + 0,222,218,1,0,0,0,222,220,1,0,0,0,223,247,1,0,0,0,224,226,3,69,34,0,225, + 224,1,0,0,0,226,227,1,0,0,0,227,225,1,0,0,0,227,228,1,0,0,0,228,229,1, + 0,0,0,229,233,5,46,0,0,230,232,3,69,34,0,231,230,1,0,0,0,232,235,1,0, + 0,0,233,231,1,0,0,0,233,234,1,0,0,0,234,248,1,0,0,0,235,233,1,0,0,0,236, + 238,5,46,0,0,237,239,3,69,34,0,238,237,1,0,0,0,239,240,1,0,0,0,240,238, + 1,0,0,0,240,241,1,0,0,0,241,248,1,0,0,0,242,244,3,69,34,0,243,242,1,0, + 0,0,244,245,1,0,0,0,245,243,1,0,0,0,245,246,1,0,0,0,246,248,1,0,0,0,247, + 225,1,0,0,0,247,236,1,0,0,0,247,243,1,0,0,0,248,249,1,0,0,0,249,250,3, + 73,36,0,250,283,1,0,0,0,251,253,5,46,0,0,252,254,3,67,33,0,253,252,1, + 0,0,0,254,255,1,0,0,0,255,253,1,0,0,0,255,256,1,0,0,0,256,258,1,0,0,0, + 257,259,3,71,35,0,258,257,1,0,0,0,258,259,1,0,0,0,259,283,1,0,0,0,260, + 262,3,67,33,0,261,260,1,0,0,0,262,263,1,0,0,0,263,261,1,0,0,0,263,264, + 1,0,0,0,264,265,1,0,0,0,265,269,5,46,0,0,266,268,3,67,33,0,267,266,1, + 0,0,0,268,271,1,0,0,0,269,267,1,0,0,0,269,270,1,0,0,0,270,273,1,0,0,0, + 271,269,1,0,0,0,272,274,3,71,35,0,273,272,1,0,0,0,273,274,1,0,0,0,274, + 283,1,0,0,0,275,277,3,67,33,0,276,275,1,0,0,0,277,278,1,0,0,0,278,276, + 1,0,0,0,278,279,1,0,0,0,279,280,1,0,0,0,280,281,3,71,35,0,281,283,1,0, + 0,0,282,222,1,0,0,0,282,251,1,0,0,0,282,261,1,0,0,0,282,276,1,0,0,0,283, + 76,1,0,0,0,284,310,5,48,0,0,285,289,7,5,0,0,286,288,7,0,0,0,287,286,1, + 0,0,0,288,291,1,0,0,0,289,287,1,0,0,0,289,290,1,0,0,0,290,310,1,0,0,0, + 291,289,1,0,0,0,292,294,5,48,0,0,293,295,7,6,0,0,294,293,1,0,0,0,295, + 296,1,0,0,0,296,294,1,0,0,0,296,297,1,0,0,0,297,310,1,0,0,0,298,299,5, + 48,0,0,299,303,5,120,0,0,300,301,5,48,0,0,301,303,5,88,0,0,302,298,1, + 0,0,0,302,300,1,0,0,0,303,305,1,0,0,0,304,306,7,1,0,0,305,304,1,0,0,0, + 306,307,1,0,0,0,307,305,1,0,0,0,307,308,1,0,0,0,308,310,1,0,0,0,309,284, + 1,0,0,0,309,285,1,0,0,0,309,292,1,0,0,0,309,302,1,0,0,0,310,78,1,0,0, + 0,311,315,7,7,0,0,312,314,7,8,0,0,313,312,1,0,0,0,314,317,1,0,0,0,315, + 313,1,0,0,0,315,316,1,0,0,0,316,80,1,0,0,0,317,315,1,0,0,0,318,320,7, + 9,0,0,319,318,1,0,0,0,320,321,1,0,0,0,321,319,1,0,0,0,321,322,1,0,0,0, + 322,323,1,0,0,0,323,324,6,40,0,0,324,82,1,0,0,0,325,326,5,47,0,0,326, + 327,5,47,0,0,327,331,1,0,0,0,328,330,8,10,0,0,329,328,1,0,0,0,330,333, + 1,0,0,0,331,329,1,0,0,0,331,332,1,0,0,0,332,334,1,0,0,0,333,331,1,0,0, + 0,334,335,6,41,0,0,335,84,1,0,0,0,336,337,5,47,0,0,337,338,5,42,0,0,338, + 342,1,0,0,0,339,341,9,0,0,0,340,339,1,0,0,0,341,344,1,0,0,0,342,343,1, + 0,0,0,342,340,1,0,0,0,343,345,1,0,0,0,344,342,1,0,0,0,345,346,5,42,0, + 0,346,347,5,47,0,0,347,348,1,0,0,0,348,349,6,42,0,0,349,86,1,0,0,0,27, + 0,202,207,211,216,222,227,233,240,245,247,255,258,263,269,273,278,282, + 289,296,302,307,309,315,321,331,342,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 = std::move(staticData); +} + +} + +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() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + sysylexerLexerInitialize(); +#else + ::antlr4::internal::call_once(sysylexerLexerOnceFlag, sysylexerLexerInitialize); +#endif +} diff --git a/src/antlr4/SysYLexer.h b/src/antlr4/SysYLexer.h new file mode 100644 index 0000000..c3aba4b --- /dev/null +++ b/src/antlr4/SysYLexer.h @@ -0,0 +1,55 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class SysYLexer : public antlr4::Lexer { +public: + enum { + 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, + T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, + BLOCK_COMMENT = 39 + }; + + explicit SysYLexer(antlr4::CharStream *input); + + ~SysYLexer() override; + + + std::string getGrammarFileName() const override; + + const std::vector& getRuleNames() const override; + + const std::vector& getChannelNames() const override; + + const std::vector& getModeNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + const antlr4::atn::ATN& getATN() const override; + + // By default the static state used to implement the lexer is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + +}; + diff --git a/src/antlr4/SysYParser.cpp b/src/antlr4/SysYParser.cpp new file mode 100644 index 0000000..1d064d1 --- /dev/null +++ b/src/antlr4/SysYParser.cpp @@ -0,0 +1,2661 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + + +#include "SysYVisitor.h" + +#include "SysYParser.h" + + +using namespace antlrcpp; + +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; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr sysyParserStaticData = nullptr; + +void sysyParserInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (sysyParserStaticData != nullptr) { + return; + } +#else + assert(sysyParserStaticData == nullptr); +#endif + auto staticData = std::make_unique( + std::vector{ + "compUnit", "decl", "constDecl", "bType", "constDef", "constInitVal", + "varDecl", "varDef", "initVal", "funcDef", "funcType", "funcFParams", + "funcFParam", "block", "blockItem", "stmt", "exp", "cond", "lVal", + "primaryExp", "number", "unaryExp", "unaryOp", "funcRParams", "mulExp", + "addExp", "relExp", "eqExp", "lAndExp", "lOrExp", "constExp" + }, + std::vector{ + "", "'const'", "','", "';'", "'int'", "'float'", "'['", "']'", "'='", + "'{'", "'}'", "'('", "')'", "'void'", "'if'", "'else'", "'while'", + "'break'", "'continue'", "'return'", "'+'", "'-'", "'!'", "'*'", "'/'", + "'%'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'&&'", "'||'" + }, + std::vector{ + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "FloatConst", "IntConst", "Ident", "WS", "LINE_COMMENT", "BLOCK_COMMENT" + } + ); + static const int32_t serializedATNSegment[] = { + 4,1,39,344,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,1,0,1,0,4,0,65,8,0,11,0,12,0,66,1,1,1,1,3,1,71, + 8,1,1,2,1,2,1,2,1,2,1,2,5,2,78,8,2,10,2,12,2,81,9,2,1,2,1,2,1,3,1,3,1, + 4,1,4,1,4,1,4,1,4,5,4,92,8,4,10,4,12,4,95,9,4,1,4,1,4,1,4,1,5,1,5,1,5, + 1,5,1,5,5,5,105,8,5,10,5,12,5,108,9,5,3,5,110,8,5,1,5,3,5,113,8,5,1,6, + 1,6,1,6,1,6,5,6,119,8,6,10,6,12,6,122,9,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7, + 5,7,131,8,7,10,7,12,7,134,9,7,1,7,1,7,1,7,1,7,1,7,5,7,141,8,7,10,7,12, + 7,144,9,7,1,7,1,7,3,7,148,8,7,1,8,1,8,1,8,1,8,1,8,5,8,155,8,8,10,8,12, + 8,158,9,8,3,8,160,8,8,1,8,3,8,163,8,8,1,9,1,9,1,9,1,9,3,9,169,8,9,1,9, + 1,9,1,9,1,10,1,10,1,11,1,11,1,11,5,11,179,8,11,10,11,12,11,182,9,11,1, + 12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,5,12,192,8,12,10,12,12,12,195,9, + 12,3,12,197,8,12,1,13,1,13,5,13,201,8,13,10,13,12,13,204,9,13,1,13,1, + 13,1,14,1,14,3,14,210,8,14,1,15,1,15,1,15,1,15,1,15,1,15,3,15,218,8,15, + 1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,229,8,15,1,15,1,15, + 1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,243,8,15,1,15, + 3,15,246,8,15,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,5,18,257,8, + 18,10,18,12,18,260,9,18,1,19,1,19,1,19,1,19,1,19,1,19,3,19,268,8,19,1, + 20,1,20,1,21,1,21,1,21,1,21,3,21,276,8,21,1,21,1,21,1,21,1,21,3,21,282, + 8,21,1,22,1,22,1,23,1,23,1,23,5,23,289,8,23,10,23,12,23,292,9,23,1,24, + 1,24,1,24,5,24,297,8,24,10,24,12,24,300,9,24,1,25,1,25,1,25,5,25,305, + 8,25,10,25,12,25,308,9,25,1,26,1,26,1,26,5,26,313,8,26,10,26,12,26,316, + 9,26,1,27,1,27,1,27,5,27,321,8,27,10,27,12,27,324,9,27,1,28,1,28,1,28, + 5,28,329,8,28,10,28,12,28,332,9,28,1,29,1,29,1,29,5,29,337,8,29,10,29, + 12,29,340,9,29,1,30,1,30,1,30,0,0,31,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,0,8,1,0,4,5,2,0, + 4,5,13,13,1,0,34,35,1,0,20,22,1,0,23,25,1,0,20,21,1,0,26,29,1,0,30,31, + 356,0,64,1,0,0,0,2,70,1,0,0,0,4,72,1,0,0,0,6,84,1,0,0,0,8,86,1,0,0,0, + 10,112,1,0,0,0,12,114,1,0,0,0,14,147,1,0,0,0,16,162,1,0,0,0,18,164,1, + 0,0,0,20,173,1,0,0,0,22,175,1,0,0,0,24,183,1,0,0,0,26,198,1,0,0,0,28, + 209,1,0,0,0,30,245,1,0,0,0,32,247,1,0,0,0,34,249,1,0,0,0,36,251,1,0,0, + 0,38,267,1,0,0,0,40,269,1,0,0,0,42,281,1,0,0,0,44,283,1,0,0,0,46,285, + 1,0,0,0,48,293,1,0,0,0,50,301,1,0,0,0,52,309,1,0,0,0,54,317,1,0,0,0,56, + 325,1,0,0,0,58,333,1,0,0,0,60,341,1,0,0,0,62,65,3,2,1,0,63,65,3,18,9, + 0,64,62,1,0,0,0,64,63,1,0,0,0,65,66,1,0,0,0,66,64,1,0,0,0,66,67,1,0,0, + 0,67,1,1,0,0,0,68,71,3,4,2,0,69,71,3,12,6,0,70,68,1,0,0,0,70,69,1,0,0, + 0,71,3,1,0,0,0,72,73,5,1,0,0,73,74,3,6,3,0,74,79,3,8,4,0,75,76,5,2,0, + 0,76,78,3,8,4,0,77,75,1,0,0,0,78,81,1,0,0,0,79,77,1,0,0,0,79,80,1,0,0, + 0,80,82,1,0,0,0,81,79,1,0,0,0,82,83,5,3,0,0,83,5,1,0,0,0,84,85,7,0,0, + 0,85,7,1,0,0,0,86,93,5,36,0,0,87,88,5,6,0,0,88,89,3,60,30,0,89,90,5,7, + 0,0,90,92,1,0,0,0,91,87,1,0,0,0,92,95,1,0,0,0,93,91,1,0,0,0,93,94,1,0, + 0,0,94,96,1,0,0,0,95,93,1,0,0,0,96,97,5,8,0,0,97,98,3,10,5,0,98,9,1,0, + 0,0,99,113,3,60,30,0,100,109,5,9,0,0,101,106,3,10,5,0,102,103,5,2,0,0, + 103,105,3,10,5,0,104,102,1,0,0,0,105,108,1,0,0,0,106,104,1,0,0,0,106, + 107,1,0,0,0,107,110,1,0,0,0,108,106,1,0,0,0,109,101,1,0,0,0,109,110,1, + 0,0,0,110,111,1,0,0,0,111,113,5,10,0,0,112,99,1,0,0,0,112,100,1,0,0,0, + 113,11,1,0,0,0,114,115,3,6,3,0,115,120,3,14,7,0,116,117,5,2,0,0,117,119, + 3,14,7,0,118,116,1,0,0,0,119,122,1,0,0,0,120,118,1,0,0,0,120,121,1,0, + 0,0,121,123,1,0,0,0,122,120,1,0,0,0,123,124,5,3,0,0,124,13,1,0,0,0,125, + 132,5,36,0,0,126,127,5,6,0,0,127,128,3,60,30,0,128,129,5,7,0,0,129,131, + 1,0,0,0,130,126,1,0,0,0,131,134,1,0,0,0,132,130,1,0,0,0,132,133,1,0,0, + 0,133,148,1,0,0,0,134,132,1,0,0,0,135,142,5,36,0,0,136,137,5,6,0,0,137, + 138,3,60,30,0,138,139,5,7,0,0,139,141,1,0,0,0,140,136,1,0,0,0,141,144, + 1,0,0,0,142,140,1,0,0,0,142,143,1,0,0,0,143,145,1,0,0,0,144,142,1,0,0, + 0,145,146,5,8,0,0,146,148,3,16,8,0,147,125,1,0,0,0,147,135,1,0,0,0,148, + 15,1,0,0,0,149,163,3,32,16,0,150,159,5,9,0,0,151,156,3,16,8,0,152,153, + 5,2,0,0,153,155,3,16,8,0,154,152,1,0,0,0,155,158,1,0,0,0,156,154,1,0, + 0,0,156,157,1,0,0,0,157,160,1,0,0,0,158,156,1,0,0,0,159,151,1,0,0,0,159, + 160,1,0,0,0,160,161,1,0,0,0,161,163,5,10,0,0,162,149,1,0,0,0,162,150, + 1,0,0,0,163,17,1,0,0,0,164,165,3,20,10,0,165,166,5,36,0,0,166,168,5,11, + 0,0,167,169,3,22,11,0,168,167,1,0,0,0,168,169,1,0,0,0,169,170,1,0,0,0, + 170,171,5,12,0,0,171,172,3,26,13,0,172,19,1,0,0,0,173,174,7,1,0,0,174, + 21,1,0,0,0,175,180,3,24,12,0,176,177,5,2,0,0,177,179,3,24,12,0,178,176, + 1,0,0,0,179,182,1,0,0,0,180,178,1,0,0,0,180,181,1,0,0,0,181,23,1,0,0, + 0,182,180,1,0,0,0,183,184,3,6,3,0,184,196,5,36,0,0,185,186,5,6,0,0,186, + 193,5,7,0,0,187,188,5,6,0,0,188,189,3,32,16,0,189,190,5,7,0,0,190,192, + 1,0,0,0,191,187,1,0,0,0,192,195,1,0,0,0,193,191,1,0,0,0,193,194,1,0,0, + 0,194,197,1,0,0,0,195,193,1,0,0,0,196,185,1,0,0,0,196,197,1,0,0,0,197, + 25,1,0,0,0,198,202,5,9,0,0,199,201,3,28,14,0,200,199,1,0,0,0,201,204, + 1,0,0,0,202,200,1,0,0,0,202,203,1,0,0,0,203,205,1,0,0,0,204,202,1,0,0, + 0,205,206,5,10,0,0,206,27,1,0,0,0,207,210,3,2,1,0,208,210,3,30,15,0,209, + 207,1,0,0,0,209,208,1,0,0,0,210,29,1,0,0,0,211,212,3,36,18,0,212,213, + 5,8,0,0,213,214,3,32,16,0,214,215,5,3,0,0,215,246,1,0,0,0,216,218,3,32, + 16,0,217,216,1,0,0,0,217,218,1,0,0,0,218,219,1,0,0,0,219,246,5,3,0,0, + 220,246,3,26,13,0,221,222,5,14,0,0,222,223,5,11,0,0,223,224,3,34,17,0, + 224,225,5,12,0,0,225,228,3,30,15,0,226,227,5,15,0,0,227,229,3,30,15,0, + 228,226,1,0,0,0,228,229,1,0,0,0,229,246,1,0,0,0,230,231,5,16,0,0,231, + 232,5,11,0,0,232,233,3,34,17,0,233,234,5,12,0,0,234,235,3,30,15,0,235, + 246,1,0,0,0,236,237,5,17,0,0,237,246,5,3,0,0,238,239,5,18,0,0,239,246, + 5,3,0,0,240,242,5,19,0,0,241,243,3,32,16,0,242,241,1,0,0,0,242,243,1, + 0,0,0,243,244,1,0,0,0,244,246,5,3,0,0,245,211,1,0,0,0,245,217,1,0,0,0, + 245,220,1,0,0,0,245,221,1,0,0,0,245,230,1,0,0,0,245,236,1,0,0,0,245,238, + 1,0,0,0,245,240,1,0,0,0,246,31,1,0,0,0,247,248,3,50,25,0,248,33,1,0,0, + 0,249,250,3,58,29,0,250,35,1,0,0,0,251,258,5,36,0,0,252,253,5,6,0,0,253, + 254,3,32,16,0,254,255,5,7,0,0,255,257,1,0,0,0,256,252,1,0,0,0,257,260, + 1,0,0,0,258,256,1,0,0,0,258,259,1,0,0,0,259,37,1,0,0,0,260,258,1,0,0, + 0,261,262,5,11,0,0,262,263,3,32,16,0,263,264,5,12,0,0,264,268,1,0,0,0, + 265,268,3,36,18,0,266,268,3,40,20,0,267,261,1,0,0,0,267,265,1,0,0,0,267, + 266,1,0,0,0,268,39,1,0,0,0,269,270,7,2,0,0,270,41,1,0,0,0,271,282,3,38, + 19,0,272,273,5,36,0,0,273,275,5,11,0,0,274,276,3,46,23,0,275,274,1,0, + 0,0,275,276,1,0,0,0,276,277,1,0,0,0,277,282,5,12,0,0,278,279,3,44,22, + 0,279,280,3,42,21,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,43,1,0,0,0,283,284,7,3,0,0,284,45,1,0,0,0,285,290,3,32, + 16,0,286,287,5,2,0,0,287,289,3,32,16,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,47,1,0,0,0,292,290,1,0,0,0,293, + 298,3,42,21,0,294,295,7,4,0,0,295,297,3,42,21,0,296,294,1,0,0,0,297,300, + 1,0,0,0,298,296,1,0,0,0,298,299,1,0,0,0,299,49,1,0,0,0,300,298,1,0,0, + 0,301,306,3,48,24,0,302,303,7,5,0,0,303,305,3,48,24,0,304,302,1,0,0,0, + 305,308,1,0,0,0,306,304,1,0,0,0,306,307,1,0,0,0,307,51,1,0,0,0,308,306, + 1,0,0,0,309,314,3,50,25,0,310,311,7,6,0,0,311,313,3,50,25,0,312,310,1, + 0,0,0,313,316,1,0,0,0,314,312,1,0,0,0,314,315,1,0,0,0,315,53,1,0,0,0, + 316,314,1,0,0,0,317,322,3,52,26,0,318,319,7,7,0,0,319,321,3,52,26,0,320, + 318,1,0,0,0,321,324,1,0,0,0,322,320,1,0,0,0,322,323,1,0,0,0,323,55,1, + 0,0,0,324,322,1,0,0,0,325,330,3,54,27,0,326,327,5,32,0,0,327,329,3,54, + 27,0,328,326,1,0,0,0,329,332,1,0,0,0,330,328,1,0,0,0,330,331,1,0,0,0, + 331,57,1,0,0,0,332,330,1,0,0,0,333,338,3,56,28,0,334,335,5,33,0,0,335, + 337,3,56,28,0,336,334,1,0,0,0,337,340,1,0,0,0,338,336,1,0,0,0,338,339, + 1,0,0,0,339,59,1,0,0,0,340,338,1,0,0,0,341,342,3,50,25,0,342,61,1,0,0, + 0,36,64,66,70,79,93,106,109,112,120,132,142,147,156,159,162,168,180,193, + 196,202,209,217,228,242,245,258,267,275,281,290,298,306,314,322,330,338 + }; + 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 = std::move(staticData); +} + +} + +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; +} + + +//----------------- CompUnitContext ------------------------------------------------------------------ + +SysYParser::CompUnitContext::CompUnitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::CompUnitContext::decl() { + return getRuleContexts(); +} + +SysYParser::DeclContext* SysYParser::CompUnitContext::decl(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::CompUnitContext::funcDef() { + return getRuleContexts(); +} + +SysYParser::FuncDefContext* SysYParser::CompUnitContext::funcDef(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, 0, SysYParser::RuleCompUnit); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(64); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(64); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { + case 1: { + setState(62); + decl(); + break; + } + + case 2: { + setState(63); + funcDef(); + break; + } + + default: + break; + } + setState(66); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8242) != 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, 2, SysYParser::RuleDecl); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(70); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__0: { + enterOuterAlt(_localctx, 1); + setState(68); + constDecl(); + break; + } + + case SysYParser::T__3: + case SysYParser::T__4: { + enterOuterAlt(_localctx, 2); + setState(69); + 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, 4, SysYParser::RuleConstDecl); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(72); + match(SysYParser::T__0); + setState(73); + bType(); + setState(74); + constDef(); + setState(79); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(75); + match(SysYParser::T__1); + setState(76); + constDef(); + setState(81); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(82); + 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, 6, SysYParser::RuleBType); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(84); + _la = _input->LA(1); + if (!(_la == SysYParser::T__3 + + || _la == SysYParser::T__4)) { + _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; +} + +//----------------- 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, 8, SysYParser::RuleConstDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(86); + match(SysYParser::Ident); + setState(93); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(87); + match(SysYParser::T__5); + setState(88); + constExp(); + setState(89); + match(SysYParser::T__6); + setState(95); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(96); + match(SysYParser::T__7); + setState(97); + 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, 10, SysYParser::RuleConstInitVal); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(112); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__10: + case SysYParser::T__19: + case SysYParser::T__20: + case SysYParser::T__21: + case SysYParser::FloatConst: + case SysYParser::IntConst: + case SysYParser::Ident: { + enterOuterAlt(_localctx, 1); + setState(99); + constExp(); + break; + } + + case SysYParser::T__8: { + enterOuterAlt(_localctx, 2); + setState(100); + match(SysYParser::T__8); + setState(109); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120266426880) != 0)) { + setState(101); + constInitVal(); + setState(106); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(102); + match(SysYParser::T__1); + setState(103); + constInitVal(); + setState(108); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(111); + match(SysYParser::T__9); + 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, 12, SysYParser::RuleVarDecl); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(114); + bType(); + setState(115); + varDef(); + setState(120); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(116); + match(SysYParser::T__1); + setState(117); + varDef(); + setState(122); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(123); + 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, 14, SysYParser::RuleVarDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(147); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(125); + match(SysYParser::Ident); + setState(132); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(126); + match(SysYParser::T__5); + setState(127); + constExp(); + setState(128); + match(SysYParser::T__6); + setState(134); + _errHandler->sync(this); + _la = _input->LA(1); + } + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(135); + match(SysYParser::Ident); + setState(142); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(136); + match(SysYParser::T__5); + setState(137); + constExp(); + setState(138); + match(SysYParser::T__6); + setState(144); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(145); + match(SysYParser::T__7); + setState(146); + initVal(); + break; + } + + default: + break; + } + + } + 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, 16, SysYParser::RuleInitVal); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(162); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__10: + case SysYParser::T__19: + case SysYParser::T__20: + case SysYParser::T__21: + case SysYParser::FloatConst: + case SysYParser::IntConst: + case SysYParser::Ident: { + enterOuterAlt(_localctx, 1); + setState(149); + exp(); + break; + } + + case SysYParser::T__8: { + enterOuterAlt(_localctx, 2); + setState(150); + match(SysYParser::T__8); + setState(159); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120266426880) != 0)) { + setState(151); + initVal(); + setState(156); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(152); + match(SysYParser::T__1); + setState(153); + initVal(); + setState(158); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(161); + match(SysYParser::T__9); + 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, 18, SysYParser::RuleFuncDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(164); + funcType(); + setState(165); + match(SysYParser::Ident); + setState(166); + match(SysYParser::T__10); + setState(168); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::T__3 + + || _la == SysYParser::T__4) { + setState(167); + funcFParams(); + } + setState(170); + match(SysYParser::T__11); + setState(171); + 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, 20, SysYParser::RuleFuncType); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(173); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8240) != 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; +} + +//----------------- 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, 22, SysYParser::RuleFuncFParams); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(175); + funcFParam(); + setState(180); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(176); + match(SysYParser::T__1); + setState(177); + funcFParam(); + setState(182); + _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, 24, SysYParser::RuleFuncFParam); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(183); + bType(); + setState(184); + match(SysYParser::Ident); + setState(196); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::T__5) { + setState(185); + match(SysYParser::T__5); + setState(186); + match(SysYParser::T__6); + setState(193); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(187); + match(SysYParser::T__5); + setState(188); + exp(); + setState(189); + match(SysYParser::T__6); + setState(195); + _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, 26, SysYParser::RuleBlock); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(198); + match(SysYParser::T__8); + setState(202); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120267426362) != 0)) { + setState(199); + blockItem(); + setState(204); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(205); + match(SysYParser::T__9); + + } + 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, 28, SysYParser::RuleBlockItem); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(209); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__0: + case SysYParser::T__3: + case SysYParser::T__4: { + enterOuterAlt(_localctx, 1); + setState(207); + decl(); + break; + } + + case SysYParser::T__2: + case SysYParser::T__8: + case SysYParser::T__10: + case SysYParser::T__13: + 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::T__21: + case SysYParser::FloatConst: + case SysYParser::IntConst: + case SysYParser::Ident: { + enterOuterAlt(_localctx, 2); + setState(208); + 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::LValContext* SysYParser::StmtContext::lVal() { + return getRuleContext(0); +} + +SysYParser::ExpContext* SysYParser::StmtContext::exp() { + return getRuleContext(0); +} + +SysYParser::BlockContext* SysYParser::StmtContext::block() { + return getRuleContext(0); +} + +SysYParser::CondContext* SysYParser::StmtContext::cond() { + return getRuleContext(0); +} + +std::vector SysYParser::StmtContext::stmt() { + return getRuleContexts(); +} + +SysYParser::StmtContext* SysYParser::StmtContext::stmt(size_t i) { + return getRuleContext(i); +} + + +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, 30, SysYParser::RuleStmt); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(245); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 24, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(211); + lVal(); + setState(212); + match(SysYParser::T__7); + setState(213); + exp(); + setState(214); + match(SysYParser::T__2); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(217); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120266426368) != 0)) { + setState(216); + exp(); + } + setState(219); + match(SysYParser::T__2); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(220); + block(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(221); + match(SysYParser::T__13); + setState(222); + match(SysYParser::T__10); + setState(223); + cond(); + setState(224); + match(SysYParser::T__11); + setState(225); + stmt(); + setState(228); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 22, _ctx)) { + case 1: { + setState(226); + match(SysYParser::T__14); + setState(227); + stmt(); + break; + } + + default: + break; + } + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(230); + match(SysYParser::T__15); + setState(231); + match(SysYParser::T__10); + setState(232); + cond(); + setState(233); + match(SysYParser::T__11); + setState(234); + stmt(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(236); + match(SysYParser::T__16); + setState(237); + match(SysYParser::T__2); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(238); + match(SysYParser::T__17); + setState(239); + match(SysYParser::T__2); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(240); + match(SysYParser::T__18); + setState(242); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120266426368) != 0)) { + setState(241); + exp(); + } + setState(244); + 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, 32, SysYParser::RuleExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(247); + 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, 34, SysYParser::RuleCond); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(249); + 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::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, 36, SysYParser::RuleLVal); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(251); + match(SysYParser::Ident); + setState(258); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(252); + match(SysYParser::T__5); + setState(253); + exp(); + setState(254); + match(SysYParser::T__6); + setState(260); + _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) { +} + +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, 38, SysYParser::RulePrimaryExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(267); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__10: { + enterOuterAlt(_localctx, 1); + setState(261); + match(SysYParser::T__10); + setState(262); + exp(); + setState(263); + match(SysYParser::T__11); + break; + } + + case SysYParser::Ident: { + enterOuterAlt(_localctx, 2); + setState(265); + lVal(); + break; + } + + case SysYParser::FloatConst: + case SysYParser::IntConst: { + enterOuterAlt(_localctx, 3); + setState(266); + 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) { +} + +tree::TerminalNode* SysYParser::NumberContext::FloatConst() { + return getToken(SysYParser::FloatConst, 0); +} + +tree::TerminalNode* SysYParser::NumberContext::IntConst() { + return getToken(SysYParser::IntConst, 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, 40, SysYParser::RuleNumber); + 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 == SysYParser::FloatConst + + || _la == SysYParser::IntConst)) { + _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, 42, 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, 28, _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__10); + setState(275); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120266426368) != 0)) { + setState(274); + funcRParams(); + } + setState(277); + match(SysYParser::T__11); + 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, 44, 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) & 7340032) != 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::exp() { + return getRuleContexts(); +} + +SysYParser::ExpContext* SysYParser::FuncRParamsContext::exp(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, 46, 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); + exp(); + setState(290); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(286); + match(SysYParser::T__1); + setState(287); + exp(); + 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; +} + +//----------------- 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); +} + + +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, 48, SysYParser::RuleMulExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(293); + unaryExp(); + setState(298); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 58720256) != 0)) { + setState(294); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 58720256) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(295); + unaryExp(); + setState(300); + _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; +} + +//----------------- 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); +} + + +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, 50, SysYParser::RuleAddExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(301); + mulExp(); + setState(306); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__19 + + || _la == SysYParser::T__20) { + setState(302); + _la = _input->LA(1); + if (!(_la == SysYParser::T__19 + + || _la == SysYParser::T__20)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(303); + mulExp(); + setState(308); + _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; +} + +//----------------- 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); +} + + +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, 52, SysYParser::RuleRelExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(309); + addExp(); + setState(314); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1006632960) != 0)) { + setState(310); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 1006632960) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(311); + addExp(); + setState(316); + _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; +} + +//----------------- 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); +} + + +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, 54, SysYParser::RuleEqExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(317); + relExp(); + setState(322); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__29 + + || _la == SysYParser::T__30) { + setState(318); + _la = _input->LA(1); + if (!(_la == SysYParser::T__29 + + || _la == SysYParser::T__30)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(319); + relExp(); + setState(324); + _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; +} + +//----------------- 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); +} + + +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, 56, SysYParser::RuleLAndExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(325); + eqExp(); + setState(330); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__31) { + setState(326); + match(SysYParser::T__31); + setState(327); + eqExp(); + setState(332); + _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); +} + + +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, 58, SysYParser::RuleLOrExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(333); + lAndExp(); + setState(338); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__32) { + setState(334); + match(SysYParser::T__32); + setState(335); + lAndExp(); + setState(340); + _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, 60, SysYParser::RuleConstExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(341); + addExp(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +void SysYParser::initialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + sysyParserInitialize(); +#else + ::antlr4::internal::call_once(sysyParserOnceFlag, sysyParserInitialize); +#endif +} diff --git a/src/antlr4/SysYParser.h b/src/antlr4/SysYParser.h new file mode 100644 index 0000000..c4518ca --- /dev/null +++ b/src/antlr4/SysYParser.h @@ -0,0 +1,540 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class SysYParser : public antlr4::Parser { +public: + enum { + 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, + T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, + BLOCK_COMMENT = 39 + }; + + enum { + RuleCompUnit = 0, RuleDecl = 1, RuleConstDecl = 2, RuleBType = 3, RuleConstDef = 4, + RuleConstInitVal = 5, RuleVarDecl = 6, RuleVarDef = 7, RuleInitVal = 8, + RuleFuncDef = 9, RuleFuncType = 10, RuleFuncFParams = 11, RuleFuncFParam = 12, + RuleBlock = 13, RuleBlockItem = 14, RuleStmt = 15, RuleExp = 16, RuleCond = 17, + RuleLVal = 18, RulePrimaryExp = 19, RuleNumber = 20, RuleUnaryExp = 21, + RuleUnaryOp = 22, RuleFuncRParams = 23, RuleMulExp = 24, RuleAddExp = 25, + RuleRelExp = 26, RuleEqExp = 27, RuleLAndExp = 28, RuleLOrExp = 29, + RuleConstExp = 30 + }; + + explicit SysYParser(antlr4::TokenStream *input); + + SysYParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); + + ~SysYParser() override; + + std::string getGrammarFileName() const override; + + const antlr4::atn::ATN& getATN() const override; + + const std::vector& getRuleNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + + class CompUnitContext; + class DeclContext; + class ConstDeclContext; + class BTypeContext; + class ConstDefContext; + class ConstInitValContext; + class VarDeclContext; + class VarDefContext; + class InitValContext; + class FuncDefContext; + class FuncTypeContext; + class FuncFParamsContext; + class FuncFParamContext; + class BlockContext; + class BlockItemContext; + class StmtContext; + class ExpContext; + class CondContext; + class LValContext; + class PrimaryExpContext; + class NumberContext; + class UnaryExpContext; + class UnaryOpContext; + class FuncRParamsContext; + class MulExpContext; + class AddExpContext; + class RelExpContext; + class EqExpContext; + class LAndExpContext; + class LOrExpContext; + class ConstExpContext; + + class CompUnitContext : public antlr4::ParserRuleContext { + public: + CompUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector decl(); + DeclContext* decl(size_t i); + std::vector funcDef(); + FuncDefContext* funcDef(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CompUnitContext* compUnit(); + + class DeclContext : public antlr4::ParserRuleContext { + public: + DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstDeclContext *constDecl(); + VarDeclContext *varDecl(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + DeclContext* decl(); + + class ConstDeclContext : public antlr4::ParserRuleContext { + public: + ConstDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + std::vector constDef(); + ConstDefContext* constDef(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstDeclContext* constDecl(); + + class BTypeContext : public antlr4::ParserRuleContext { + public: + BTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BTypeContext* bType(); + + class ConstDefContext : public antlr4::ParserRuleContext { + public: + ConstDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Ident(); + ConstInitValContext *constInitVal(); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstDefContext* constDef(); + + class ConstInitValContext : public antlr4::ParserRuleContext { + public: + ConstInitValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstExpContext *constExp(); + std::vector constInitVal(); + ConstInitValContext* constInitVal(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstInitValContext* constInitVal(); + + class VarDeclContext : public antlr4::ParserRuleContext { + public: + VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + std::vector varDef(); + VarDefContext* varDef(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarDeclContext* varDecl(); + + class VarDefContext : public antlr4::ParserRuleContext { + public: + VarDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Ident(); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + InitValContext *initVal(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarDefContext* varDef(); + + class InitValContext : public antlr4::ParserRuleContext { + public: + InitValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpContext *exp(); + std::vector initVal(); + InitValContext* initVal(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + InitValContext* initVal(); + + class FuncDefContext : public antlr4::ParserRuleContext { + public: + FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + FuncTypeContext *funcType(); + antlr4::tree::TerminalNode *Ident(); + BlockContext *block(); + FuncFParamsContext *funcFParams(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncDefContext* funcDef(); + + class FuncTypeContext : public antlr4::ParserRuleContext { + public: + FuncTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncTypeContext* funcType(); + + class FuncFParamsContext : public antlr4::ParserRuleContext { + public: + FuncFParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector funcFParam(); + FuncFParamContext* funcFParam(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncFParamsContext* funcFParams(); + + class FuncFParamContext : public antlr4::ParserRuleContext { + public: + FuncFParamContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + antlr4::tree::TerminalNode *Ident(); + std::vector exp(); + ExpContext* exp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncFParamContext* funcFParam(); + + class BlockContext : public antlr4::ParserRuleContext { + public: + BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector blockItem(); + BlockItemContext* blockItem(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BlockContext* block(); + + class BlockItemContext : public antlr4::ParserRuleContext { + public: + BlockItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclContext *decl(); + StmtContext *stmt(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BlockItemContext* blockItem(); + + class StmtContext : public antlr4::ParserRuleContext { + public: + StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LValContext *lVal(); + ExpContext *exp(); + BlockContext *block(); + CondContext *cond(); + std::vector stmt(); + StmtContext* stmt(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StmtContext* stmt(); + + class ExpContext : public antlr4::ParserRuleContext { + public: + ExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AddExpContext *addExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ExpContext* exp(); + + class CondContext : public antlr4::ParserRuleContext { + public: + CondContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LOrExpContext *lOrExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CondContext* cond(); + + class LValContext : public antlr4::ParserRuleContext { + public: + LValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Ident(); + std::vector exp(); + ExpContext* exp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LValContext* lVal(); + + class PrimaryExpContext : public antlr4::ParserRuleContext { + public: + PrimaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpContext *exp(); + LValContext *lVal(); + NumberContext *number(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + PrimaryExpContext* primaryExp(); + + class NumberContext : public antlr4::ParserRuleContext { + public: + NumberContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *FloatConst(); + antlr4::tree::TerminalNode *IntConst(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NumberContext* number(); + + class UnaryExpContext : public antlr4::ParserRuleContext { + public: + UnaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PrimaryExpContext *primaryExp(); + antlr4::tree::TerminalNode *Ident(); + FuncRParamsContext *funcRParams(); + UnaryOpContext *unaryOp(); + UnaryExpContext *unaryExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnaryExpContext* unaryExp(); + + class UnaryOpContext : public antlr4::ParserRuleContext { + public: + UnaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnaryOpContext* unaryOp(); + + class FuncRParamsContext : public antlr4::ParserRuleContext { + public: + FuncRParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector exp(); + ExpContext* exp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncRParamsContext* funcRParams(); + + 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); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MulExpContext* mulExp(); + + 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); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AddExpContext* addExp(); + + 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); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + RelExpContext* relExp(); + + 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); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EqExpContext* eqExp(); + + 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); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LAndExpContext* lAndExp(); + + class LOrExpContext : public antlr4::ParserRuleContext { + public: + LOrExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector lAndExp(); + LAndExpContext* lAndExp(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LOrExpContext* lOrExp(); + + class ConstExpContext : public antlr4::ParserRuleContext { + public: + ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AddExpContext *addExp(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstExpContext* constExp(); + + + // By default the static state used to implement the parser is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: +}; + diff --git a/src/antlr4/SysYVisitor.cpp b/src/antlr4/SysYVisitor.cpp new file mode 100644 index 0000000..b91ddfe --- /dev/null +++ b/src/antlr4/SysYVisitor.cpp @@ -0,0 +1,7 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + + +#include "SysYVisitor.h" + + diff --git a/src/antlr4/SysYVisitor.h b/src/antlr4/SysYVisitor.h new file mode 100644 index 0000000..459c6bd --- /dev/null +++ b/src/antlr4/SysYVisitor.h @@ -0,0 +1,86 @@ + +// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SysYParser.h" + + + +/** + * 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 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 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 visitUnaryExp(SysYParser::UnaryExpContext *context) = 0; + + virtual std::any visitUnaryOp(SysYParser::UnaryOpContext *context) = 0; + + virtual std::any visitFuncRParams(SysYParser::FuncRParamsContext *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; + + +}; +