// Generated from MXParser.g4 by ANTLR 4.13.2 #include "MXParserVisitor.h" #include "MXParser.h" using namespace antlrcpp; using namespace antlr4; namespace { struct MXParserStaticData final { MXParserStaticData(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) {} MXParserStaticData(const MXParserStaticData&) = delete; MXParserStaticData(MXParserStaticData&&) = delete; MXParserStaticData& operator=(const MXParserStaticData&) = delete; MXParserStaticData& operator=(MXParserStaticData&&) = 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 mxparserParserOnceFlag; #if ANTLR4_USE_THREAD_LOCAL_CACHE static thread_local #endif std::unique_ptr mxparserParserStaticData = nullptr; void mxparserParserInitialize() { #if ANTLR4_USE_THREAD_LOCAL_CACHE if (mxparserParserStaticData != nullptr) { return; } #else assert(mxparserParserStaticData == nullptr); #endif auto staticData = std::make_unique( std::vector{ "mxprog", "function_def", "class_def", "class_var_def", "class_constructor", "suite", "statement", "define_statement", "expr", "basic_expr", "formatted_string", "constant", "type" }, std::vector{ "", "'void'", "'bool'", "'int'", "'string'", "'new'", "'class'", "'null'", "'true'", "'false'", "'this'", "'if'", "'else'", "'for'", "'while'", "'break'", "'continue'", "'return'", "'+'", "'-'", "'*'", "'/'", "'%'", "'>='", "'>'", "'<='", "'<'", "'!='", "'=='", "'&&'", "'||'", "'!'", "'>>'", "'<<'", "'&'", "'|'", "'^'", "'~'", "'='", "'++'", "'--'", "'.'", "'\\u003F'", "':'", "'('", "')'", "'['", "']'", "'{'", "'}'", "';'", "','" }, std::vector{ "", "VOID", "BOOL", "INT", "STRING", "NEW", "CLASS", "NULL", "TRUE", "FALSE", "THIS", "IF", "ELSE", "FOR", "WHILE", "BREAK", "CONTINUE", "RETURN", "PLUS", "MINUS", "MULTIPLY", "DIVIDE", "MOD", "GN", "GE", "LN", "LE", "NE", "EQ", "LAND", "LOR", "LNOT", "ARS", "ALS", "BAND", "BOR", "BXOR", "BNOT", "ASSIGN", "SELF_PLUS", "SELF_MINUS", "DOT", "QUESTION_MARK", "COLON", "LPAREN", "RPAREN", "LBRACKET", "RBRACKET", "LBRACE", "RBRACE", "SEMICOLON", "COMMA", "FORMAT_STRING_WHOLE", "FORMAT_STRING_HEAD", "FORMAT_STRING_TAIL", "FORMAT_STRING_BODY", "ID", "INT_LITERAL", "STRING_LITERAL", "WS", "LINE_COMMENT", "BLOCK_COMMENT" } ); static const int32_t serializedATNSegment[] = { 4,1,61,365,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,1,0,1,0,1,0,4,0,30, 8,0,11,0,12,0,31,1,0,1,0,1,1,1,1,1,1,5,1,39,8,1,10,1,12,1,42,9,1,1,1, 1,1,1,1,1,1,1,1,5,1,49,8,1,10,1,12,1,52,9,1,1,1,1,1,1,1,1,1,1,1,1,1,5, 1,60,8,1,10,1,12,1,63,9,1,1,1,1,1,5,1,67,8,1,10,1,12,1,70,9,1,3,1,72, 8,1,1,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,5,2,83,8,2,10,2,12,2,86,9,2,1, 2,1,2,1,2,1,3,1,3,1,3,5,3,94,8,3,10,3,12,3,97,9,3,1,3,1,3,1,3,5,3,102, 8,3,10,3,12,3,105,9,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,5,1,5,5,5,116,8,5, 10,5,12,5,119,9,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6, 1,6,3,6,135,8,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3, 6,150,8,6,1,6,3,6,153,8,6,1,6,1,6,1,6,3,6,158,8,6,1,6,1,6,1,6,1,6,1,6, 1,6,3,6,166,8,6,3,6,168,8,6,1,6,1,6,3,6,172,8,6,1,7,1,7,1,7,5,7,177,8, 7,10,7,12,7,180,9,7,1,7,1,7,1,7,3,7,185,8,7,1,7,1,7,1,7,1,7,3,7,191,8, 7,5,7,193,8,7,10,7,12,7,196,9,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,3,8,206, 8,8,1,8,5,8,209,8,8,10,8,12,8,212,9,8,1,8,3,8,215,8,8,1,8,1,8,1,8,1,8, 1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,232,8,8,1,8,1,8,1,8,1, 8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8, 1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1, 8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,5,8,281,8,8,10,8,12,8,284,9,8,3,8,286, 8,8,1,8,3,8,289,8,8,1,8,1,8,1,8,1,8,1,8,4,8,296,8,8,11,8,12,8,297,1,8, 1,8,5,8,302,8,8,10,8,12,8,305,9,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9, 1,9,1,9,5,9,318,8,9,10,9,12,9,321,9,9,3,9,323,8,9,1,9,1,9,1,9,3,9,328, 8,9,1,10,1,10,1,10,1,10,1,10,5,10,335,8,10,10,10,12,10,338,9,10,1,10, 1,10,3,10,342,8,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,5,11, 353,8,11,10,11,12,11,356,9,11,3,11,358,8,11,1,11,3,11,361,8,11,1,12,1, 12,1,12,1,336,1,16,13,0,2,4,6,8,10,12,14,16,18,20,22,24,0,7,1,0,39,40, 1,0,20,22,1,0,18,19,1,0,32,33,1,0,23,26,1,0,27,28,2,0,1,4,56,56,430,0, 29,1,0,0,0,2,35,1,0,0,0,4,76,1,0,0,0,6,90,1,0,0,0,8,108,1,0,0,0,10,113, 1,0,0,0,12,171,1,0,0,0,14,173,1,0,0,0,16,231,1,0,0,0,18,327,1,0,0,0,20, 341,1,0,0,0,22,360,1,0,0,0,24,362,1,0,0,0,26,30,3,4,2,0,27,30,3,14,7, 0,28,30,3,2,1,0,29,26,1,0,0,0,29,27,1,0,0,0,29,28,1,0,0,0,30,31,1,0,0, 0,31,29,1,0,0,0,31,32,1,0,0,0,32,33,1,0,0,0,33,34,5,0,0,1,34,1,1,0,0, 0,35,40,3,24,12,0,36,37,5,46,0,0,37,39,5,47,0,0,38,36,1,0,0,0,39,42,1, 0,0,0,40,38,1,0,0,0,40,41,1,0,0,0,41,43,1,0,0,0,42,40,1,0,0,0,43,44,5, 56,0,0,44,71,5,44,0,0,45,50,3,24,12,0,46,47,5,46,0,0,47,49,5,47,0,0,48, 46,1,0,0,0,49,52,1,0,0,0,50,48,1,0,0,0,50,51,1,0,0,0,51,53,1,0,0,0,52, 50,1,0,0,0,53,54,5,56,0,0,54,68,1,0,0,0,55,56,5,51,0,0,56,61,3,24,12, 0,57,58,5,46,0,0,58,60,5,47,0,0,59,57,1,0,0,0,60,63,1,0,0,0,61,59,1,0, 0,0,61,62,1,0,0,0,62,64,1,0,0,0,63,61,1,0,0,0,64,65,5,56,0,0,65,67,1, 0,0,0,66,55,1,0,0,0,67,70,1,0,0,0,68,66,1,0,0,0,68,69,1,0,0,0,69,72,1, 0,0,0,70,68,1,0,0,0,71,45,1,0,0,0,71,72,1,0,0,0,72,73,1,0,0,0,73,74,5, 45,0,0,74,75,3,10,5,0,75,3,1,0,0,0,76,77,5,6,0,0,77,78,5,56,0,0,78,84, 5,48,0,0,79,83,3,6,3,0,80,83,3,8,4,0,81,83,3,2,1,0,82,79,1,0,0,0,82,80, 1,0,0,0,82,81,1,0,0,0,83,86,1,0,0,0,84,82,1,0,0,0,84,85,1,0,0,0,85,87, 1,0,0,0,86,84,1,0,0,0,87,88,5,49,0,0,88,89,5,50,0,0,89,5,1,0,0,0,90,95, 3,24,12,0,91,92,5,46,0,0,92,94,5,47,0,0,93,91,1,0,0,0,94,97,1,0,0,0,95, 93,1,0,0,0,95,96,1,0,0,0,96,98,1,0,0,0,97,95,1,0,0,0,98,103,5,56,0,0, 99,100,5,51,0,0,100,102,5,56,0,0,101,99,1,0,0,0,102,105,1,0,0,0,103,101, 1,0,0,0,103,104,1,0,0,0,104,106,1,0,0,0,105,103,1,0,0,0,106,107,5,50, 0,0,107,7,1,0,0,0,108,109,5,56,0,0,109,110,5,44,0,0,110,111,5,45,0,0, 111,112,3,10,5,0,112,9,1,0,0,0,113,117,5,48,0,0,114,116,3,12,6,0,115, 114,1,0,0,0,116,119,1,0,0,0,117,115,1,0,0,0,117,118,1,0,0,0,118,120,1, 0,0,0,119,117,1,0,0,0,120,121,5,49,0,0,121,11,1,0,0,0,122,172,5,50,0, 0,123,172,3,14,7,0,124,125,3,16,8,0,125,126,5,50,0,0,126,172,1,0,0,0, 127,128,5,11,0,0,128,129,5,44,0,0,129,130,3,16,8,0,130,131,5,45,0,0,131, 134,3,12,6,0,132,133,5,12,0,0,133,135,3,12,6,0,134,132,1,0,0,0,134,135, 1,0,0,0,135,172,1,0,0,0,136,137,5,14,0,0,137,138,5,44,0,0,138,139,3,16, 8,0,139,140,5,45,0,0,140,141,3,12,6,0,141,172,1,0,0,0,142,143,5,13,0, 0,143,149,5,44,0,0,144,150,3,14,7,0,145,146,3,16,8,0,146,147,5,50,0,0, 147,150,1,0,0,0,148,150,5,50,0,0,149,144,1,0,0,0,149,145,1,0,0,0,149, 148,1,0,0,0,150,152,1,0,0,0,151,153,3,16,8,0,152,151,1,0,0,0,152,153, 1,0,0,0,153,154,1,0,0,0,154,157,5,50,0,0,155,158,3,14,7,0,156,158,3,16, 8,0,157,155,1,0,0,0,157,156,1,0,0,0,157,158,1,0,0,0,158,159,1,0,0,0,159, 160,5,45,0,0,160,172,3,12,6,0,161,168,5,15,0,0,162,168,5,16,0,0,163,165, 5,17,0,0,164,166,3,16,8,0,165,164,1,0,0,0,165,166,1,0,0,0,166,168,1,0, 0,0,167,161,1,0,0,0,167,162,1,0,0,0,167,163,1,0,0,0,168,169,1,0,0,0,169, 172,5,50,0,0,170,172,3,10,5,0,171,122,1,0,0,0,171,123,1,0,0,0,171,124, 1,0,0,0,171,127,1,0,0,0,171,136,1,0,0,0,171,142,1,0,0,0,171,167,1,0,0, 0,171,170,1,0,0,0,172,13,1,0,0,0,173,178,3,24,12,0,174,175,5,46,0,0,175, 177,5,47,0,0,176,174,1,0,0,0,177,180,1,0,0,0,178,176,1,0,0,0,178,179, 1,0,0,0,179,181,1,0,0,0,180,178,1,0,0,0,181,184,5,56,0,0,182,183,5,38, 0,0,183,185,3,16,8,0,184,182,1,0,0,0,184,185,1,0,0,0,185,194,1,0,0,0, 186,187,5,51,0,0,187,190,5,56,0,0,188,189,5,38,0,0,189,191,3,16,8,0,190, 188,1,0,0,0,190,191,1,0,0,0,191,193,1,0,0,0,192,186,1,0,0,0,193,196,1, 0,0,0,194,192,1,0,0,0,194,195,1,0,0,0,195,197,1,0,0,0,196,194,1,0,0,0, 197,198,5,50,0,0,198,15,1,0,0,0,199,200,6,8,-1,0,200,232,3,18,9,0,201, 202,5,5,0,0,202,210,3,24,12,0,203,205,5,46,0,0,204,206,3,16,8,0,205,204, 1,0,0,0,205,206,1,0,0,0,206,207,1,0,0,0,207,209,5,47,0,0,208,203,1,0, 0,0,209,212,1,0,0,0,210,208,1,0,0,0,210,211,1,0,0,0,211,214,1,0,0,0,212, 210,1,0,0,0,213,215,3,22,11,0,214,213,1,0,0,0,214,215,1,0,0,0,215,232, 1,0,0,0,216,217,5,5,0,0,217,218,3,24,12,0,218,219,5,44,0,0,219,220,5, 45,0,0,220,232,1,0,0,0,221,222,5,5,0,0,222,232,3,24,12,0,223,224,7,0, 0,0,224,232,3,16,8,16,225,226,5,19,0,0,226,232,3,16,8,15,227,228,5,31, 0,0,228,232,3,16,8,14,229,230,5,37,0,0,230,232,3,16,8,13,231,199,1,0, 0,0,231,201,1,0,0,0,231,216,1,0,0,0,231,221,1,0,0,0,231,223,1,0,0,0,231, 225,1,0,0,0,231,227,1,0,0,0,231,229,1,0,0,0,232,303,1,0,0,0,233,234,10, 12,0,0,234,235,7,1,0,0,235,302,3,16,8,13,236,237,10,11,0,0,237,238,7, 2,0,0,238,302,3,16,8,12,239,240,10,10,0,0,240,241,7,3,0,0,241,302,3,16, 8,11,242,243,10,9,0,0,243,244,7,4,0,0,244,302,3,16,8,10,245,246,10,8, 0,0,246,247,7,5,0,0,247,302,3,16,8,9,248,249,10,7,0,0,249,250,5,34,0, 0,250,302,3,16,8,8,251,252,10,6,0,0,252,253,5,36,0,0,253,302,3,16,8,7, 254,255,10,5,0,0,255,256,5,35,0,0,256,302,3,16,8,6,257,258,10,4,0,0,258, 259,5,29,0,0,259,302,3,16,8,5,260,261,10,3,0,0,261,262,5,30,0,0,262,302, 3,16,8,4,263,264,10,2,0,0,264,265,5,42,0,0,265,266,3,16,8,0,266,267,5, 43,0,0,267,268,3,16,8,2,268,302,1,0,0,0,269,270,10,1,0,0,270,271,5,38, 0,0,271,302,3,16,8,1,272,273,10,19,0,0,273,288,5,41,0,0,274,289,5,56, 0,0,275,276,5,56,0,0,276,285,5,44,0,0,277,282,3,16,8,0,278,279,5,51,0, 0,279,281,3,16,8,0,280,278,1,0,0,0,281,284,1,0,0,0,282,280,1,0,0,0,282, 283,1,0,0,0,283,286,1,0,0,0,284,282,1,0,0,0,285,277,1,0,0,0,285,286,1, 0,0,0,286,287,1,0,0,0,287,289,5,45,0,0,288,274,1,0,0,0,288,275,1,0,0, 0,289,302,1,0,0,0,290,295,10,18,0,0,291,292,5,46,0,0,292,293,3,16,8,0, 293,294,5,47,0,0,294,296,1,0,0,0,295,291,1,0,0,0,296,297,1,0,0,0,297, 295,1,0,0,0,297,298,1,0,0,0,298,302,1,0,0,0,299,300,10,17,0,0,300,302, 7,0,0,0,301,233,1,0,0,0,301,236,1,0,0,0,301,239,1,0,0,0,301,242,1,0,0, 0,301,245,1,0,0,0,301,248,1,0,0,0,301,251,1,0,0,0,301,254,1,0,0,0,301, 257,1,0,0,0,301,260,1,0,0,0,301,263,1,0,0,0,301,269,1,0,0,0,301,272,1, 0,0,0,301,290,1,0,0,0,301,299,1,0,0,0,302,305,1,0,0,0,303,301,1,0,0,0, 303,304,1,0,0,0,304,17,1,0,0,0,305,303,1,0,0,0,306,328,5,10,0,0,307,308, 5,44,0,0,308,309,3,16,8,0,309,310,5,45,0,0,310,328,1,0,0,0,311,328,5, 56,0,0,312,313,5,56,0,0,313,322,5,44,0,0,314,319,3,16,8,0,315,316,5,51, 0,0,316,318,3,16,8,0,317,315,1,0,0,0,318,321,1,0,0,0,319,317,1,0,0,0, 319,320,1,0,0,0,320,323,1,0,0,0,321,319,1,0,0,0,322,314,1,0,0,0,322,323, 1,0,0,0,323,324,1,0,0,0,324,328,5,45,0,0,325,328,3,20,10,0,326,328,3, 22,11,0,327,306,1,0,0,0,327,307,1,0,0,0,327,311,1,0,0,0,327,312,1,0,0, 0,327,325,1,0,0,0,327,326,1,0,0,0,328,19,1,0,0,0,329,342,5,52,0,0,330, 331,5,53,0,0,331,336,3,16,8,0,332,333,5,55,0,0,333,335,3,16,8,0,334,332, 1,0,0,0,335,338,1,0,0,0,336,337,1,0,0,0,336,334,1,0,0,0,337,339,1,0,0, 0,338,336,1,0,0,0,339,340,5,54,0,0,340,342,1,0,0,0,341,329,1,0,0,0,341, 330,1,0,0,0,342,21,1,0,0,0,343,361,5,8,0,0,344,361,5,9,0,0,345,361,5, 57,0,0,346,361,5,58,0,0,347,361,5,7,0,0,348,357,5,48,0,0,349,354,3,22, 11,0,350,351,5,51,0,0,351,353,3,22,11,0,352,350,1,0,0,0,353,356,1,0,0, 0,354,352,1,0,0,0,354,355,1,0,0,0,355,358,1,0,0,0,356,354,1,0,0,0,357, 349,1,0,0,0,357,358,1,0,0,0,358,359,1,0,0,0,359,361,5,49,0,0,360,343, 1,0,0,0,360,344,1,0,0,0,360,345,1,0,0,0,360,346,1,0,0,0,360,347,1,0,0, 0,360,348,1,0,0,0,361,23,1,0,0,0,362,363,7,6,0,0,363,25,1,0,0,0,41,29, 31,40,50,61,68,71,82,84,95,103,117,134,149,152,157,165,167,171,178,184, 190,194,205,210,214,231,282,285,288,297,301,303,319,322,327,336,341,354, 357,360 }; staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); antlr4::atn::ATNDeserializer deserializer; staticData->atn = deserializer.deserialize(staticData->serializedATN); const size_t count = staticData->atn->getNumberOfDecisions(); staticData->decisionToDFA.reserve(count); for (size_t i = 0; i < count; i++) { staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); } mxparserParserStaticData = std::move(staticData); } } MXParser::MXParser(TokenStream *input) : MXParser(input, antlr4::atn::ParserATNSimulatorOptions()) {} MXParser::MXParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { MXParser::initialize(); _interpreter = new atn::ParserATNSimulator(this, *mxparserParserStaticData->atn, mxparserParserStaticData->decisionToDFA, mxparserParserStaticData->sharedContextCache, options); } MXParser::~MXParser() { delete _interpreter; } const atn::ATN& MXParser::getATN() const { return *mxparserParserStaticData->atn; } std::string MXParser::getGrammarFileName() const { return "MXParser.g4"; } const std::vector& MXParser::getRuleNames() const { return mxparserParserStaticData->ruleNames; } const dfa::Vocabulary& MXParser::getVocabulary() const { return mxparserParserStaticData->vocabulary; } antlr4::atn::SerializedATNView MXParser::getSerializedATN() const { return mxparserParserStaticData->serializedATN; } //----------------- MxprogContext ------------------------------------------------------------------ MXParser::MxprogContext::MxprogContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::MxprogContext::EOF() { return getToken(MXParser::EOF, 0); } std::vector MXParser::MxprogContext::class_def() { return getRuleContexts(); } MXParser::Class_defContext* MXParser::MxprogContext::class_def(size_t i) { return getRuleContext(i); } std::vector MXParser::MxprogContext::define_statement() { return getRuleContexts(); } MXParser::Define_statementContext* MXParser::MxprogContext::define_statement(size_t i) { return getRuleContext(i); } std::vector MXParser::MxprogContext::function_def() { return getRuleContexts(); } MXParser::Function_defContext* MXParser::MxprogContext::function_def(size_t i) { return getRuleContext(i); } size_t MXParser::MxprogContext::getRuleIndex() const { return MXParser::RuleMxprog; } std::any MXParser::MxprogContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitMxprog(this); else return visitor->visitChildren(this); } MXParser::MxprogContext* MXParser::mxprog() { MxprogContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 0, MXParser::RuleMxprog); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(29); _errHandler->sync(this); _la = _input->LA(1); do { setState(29); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { case 1: { setState(26); class_def(); break; } case 2: { setState(27); define_statement(); break; } case 3: { setState(28); function_def(); break; } default: break; } setState(31); _errHandler->sync(this); _la = _input->LA(1); } while ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 72057594037928030) != 0)); setState(33); match(MXParser::EOF); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Function_defContext ------------------------------------------------------------------ MXParser::Function_defContext::Function_defContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } std::vector MXParser::Function_defContext::type() { return getRuleContexts(); } MXParser::TypeContext* MXParser::Function_defContext::type(size_t i) { return getRuleContext(i); } std::vector MXParser::Function_defContext::ID() { return getTokens(MXParser::ID); } tree::TerminalNode* MXParser::Function_defContext::ID(size_t i) { return getToken(MXParser::ID, i); } tree::TerminalNode* MXParser::Function_defContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } tree::TerminalNode* MXParser::Function_defContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } MXParser::SuiteContext* MXParser::Function_defContext::suite() { return getRuleContext(0); } std::vector MXParser::Function_defContext::LBRACKET() { return getTokens(MXParser::LBRACKET); } tree::TerminalNode* MXParser::Function_defContext::LBRACKET(size_t i) { return getToken(MXParser::LBRACKET, i); } std::vector MXParser::Function_defContext::RBRACKET() { return getTokens(MXParser::RBRACKET); } tree::TerminalNode* MXParser::Function_defContext::RBRACKET(size_t i) { return getToken(MXParser::RBRACKET, i); } std::vector MXParser::Function_defContext::COMMA() { return getTokens(MXParser::COMMA); } tree::TerminalNode* MXParser::Function_defContext::COMMA(size_t i) { return getToken(MXParser::COMMA, i); } size_t MXParser::Function_defContext::getRuleIndex() const { return MXParser::RuleFunction_def; } std::any MXParser::Function_defContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitFunction_def(this); else return visitor->visitChildren(this); } MXParser::Function_defContext* MXParser::function_def() { Function_defContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 2, MXParser::RuleFunction_def); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(35); type(); setState(40); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::LBRACKET) { setState(36); match(MXParser::LBRACKET); setState(37); match(MXParser::RBRACKET); setState(42); _errHandler->sync(this); _la = _input->LA(1); } setState(43); match(MXParser::ID); setState(44); match(MXParser::LPAREN); setState(71); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 72057594037927966) != 0)) { setState(45); type(); setState(50); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::LBRACKET) { setState(46); match(MXParser::LBRACKET); setState(47); match(MXParser::RBRACKET); setState(52); _errHandler->sync(this); _la = _input->LA(1); } setState(53); match(MXParser::ID); setState(68); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::COMMA) { setState(55); match(MXParser::COMMA); setState(56); type(); setState(61); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::LBRACKET) { setState(57); match(MXParser::LBRACKET); setState(58); match(MXParser::RBRACKET); setState(63); _errHandler->sync(this); _la = _input->LA(1); } setState(64); match(MXParser::ID); setState(70); _errHandler->sync(this); _la = _input->LA(1); } } setState(73); match(MXParser::RPAREN); setState(74); suite(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Class_defContext ------------------------------------------------------------------ MXParser::Class_defContext::Class_defContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::Class_defContext::CLASS() { return getToken(MXParser::CLASS, 0); } tree::TerminalNode* MXParser::Class_defContext::ID() { return getToken(MXParser::ID, 0); } tree::TerminalNode* MXParser::Class_defContext::LBRACE() { return getToken(MXParser::LBRACE, 0); } tree::TerminalNode* MXParser::Class_defContext::RBRACE() { return getToken(MXParser::RBRACE, 0); } tree::TerminalNode* MXParser::Class_defContext::SEMICOLON() { return getToken(MXParser::SEMICOLON, 0); } std::vector MXParser::Class_defContext::class_var_def() { return getRuleContexts(); } MXParser::Class_var_defContext* MXParser::Class_defContext::class_var_def(size_t i) { return getRuleContext(i); } std::vector MXParser::Class_defContext::class_constructor() { return getRuleContexts(); } MXParser::Class_constructorContext* MXParser::Class_defContext::class_constructor(size_t i) { return getRuleContext(i); } std::vector MXParser::Class_defContext::function_def() { return getRuleContexts(); } MXParser::Function_defContext* MXParser::Class_defContext::function_def(size_t i) { return getRuleContext(i); } size_t MXParser::Class_defContext::getRuleIndex() const { return MXParser::RuleClass_def; } std::any MXParser::Class_defContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitClass_def(this); else return visitor->visitChildren(this); } MXParser::Class_defContext* MXParser::class_def() { Class_defContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 4, MXParser::RuleClass_def); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(76); match(MXParser::CLASS); setState(77); match(MXParser::ID); setState(78); match(MXParser::LBRACE); setState(84); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 72057594037927966) != 0)) { setState(82); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 7, _ctx)) { case 1: { setState(79); class_var_def(); break; } case 2: { setState(80); class_constructor(); break; } case 3: { setState(81); function_def(); break; } default: break; } setState(86); _errHandler->sync(this); _la = _input->LA(1); } setState(87); match(MXParser::RBRACE); setState(88); match(MXParser::SEMICOLON); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Class_var_defContext ------------------------------------------------------------------ MXParser::Class_var_defContext::Class_var_defContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } MXParser::TypeContext* MXParser::Class_var_defContext::type() { return getRuleContext(0); } std::vector MXParser::Class_var_defContext::ID() { return getTokens(MXParser::ID); } tree::TerminalNode* MXParser::Class_var_defContext::ID(size_t i) { return getToken(MXParser::ID, i); } tree::TerminalNode* MXParser::Class_var_defContext::SEMICOLON() { return getToken(MXParser::SEMICOLON, 0); } std::vector MXParser::Class_var_defContext::LBRACKET() { return getTokens(MXParser::LBRACKET); } tree::TerminalNode* MXParser::Class_var_defContext::LBRACKET(size_t i) { return getToken(MXParser::LBRACKET, i); } std::vector MXParser::Class_var_defContext::RBRACKET() { return getTokens(MXParser::RBRACKET); } tree::TerminalNode* MXParser::Class_var_defContext::RBRACKET(size_t i) { return getToken(MXParser::RBRACKET, i); } std::vector MXParser::Class_var_defContext::COMMA() { return getTokens(MXParser::COMMA); } tree::TerminalNode* MXParser::Class_var_defContext::COMMA(size_t i) { return getToken(MXParser::COMMA, i); } size_t MXParser::Class_var_defContext::getRuleIndex() const { return MXParser::RuleClass_var_def; } std::any MXParser::Class_var_defContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitClass_var_def(this); else return visitor->visitChildren(this); } MXParser::Class_var_defContext* MXParser::class_var_def() { Class_var_defContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 6, MXParser::RuleClass_var_def); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(90); type(); setState(95); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::LBRACKET) { setState(91); match(MXParser::LBRACKET); setState(92); match(MXParser::RBRACKET); setState(97); _errHandler->sync(this); _la = _input->LA(1); } setState(98); match(MXParser::ID); setState(103); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::COMMA) { setState(99); match(MXParser::COMMA); setState(100); match(MXParser::ID); setState(105); _errHandler->sync(this); _la = _input->LA(1); } setState(106); match(MXParser::SEMICOLON); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Class_constructorContext ------------------------------------------------------------------ MXParser::Class_constructorContext::Class_constructorContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::Class_constructorContext::ID() { return getToken(MXParser::ID, 0); } tree::TerminalNode* MXParser::Class_constructorContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } tree::TerminalNode* MXParser::Class_constructorContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } MXParser::SuiteContext* MXParser::Class_constructorContext::suite() { return getRuleContext(0); } size_t MXParser::Class_constructorContext::getRuleIndex() const { return MXParser::RuleClass_constructor; } std::any MXParser::Class_constructorContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitClass_constructor(this); else return visitor->visitChildren(this); } MXParser::Class_constructorContext* MXParser::class_constructor() { Class_constructorContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 8, MXParser::RuleClass_constructor); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(108); match(MXParser::ID); setState(109); match(MXParser::LPAREN); setState(110); match(MXParser::RPAREN); setState(111); suite(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- SuiteContext ------------------------------------------------------------------ MXParser::SuiteContext::SuiteContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::SuiteContext::LBRACE() { return getToken(MXParser::LBRACE, 0); } tree::TerminalNode* MXParser::SuiteContext::RBRACE() { return getToken(MXParser::RBRACE, 0); } std::vector MXParser::SuiteContext::statement() { return getRuleContexts(); } MXParser::StatementContext* MXParser::SuiteContext::statement(size_t i) { return getRuleContext(i); } size_t MXParser::SuiteContext::getRuleIndex() const { return MXParser::RuleSuite; } std::any MXParser::SuiteContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSuite(this); else return visitor->visitChildren(this); } MXParser::SuiteContext* MXParser::suite() { SuiteContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 10, MXParser::RuleSuite); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(113); match(MXParser::LBRACE); setState(117); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 519340713071865790) != 0)) { setState(114); statement(); setState(119); _errHandler->sync(this); _la = _input->LA(1); } setState(120); match(MXParser::RBRACE); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- StatementContext ------------------------------------------------------------------ MXParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } size_t MXParser::StatementContext::getRuleIndex() const { return MXParser::RuleStatement; } void MXParser::StatementContext::copyFrom(StatementContext *ctx) { ParserRuleContext::copyFrom(ctx); } //----------------- For_statementContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::For_statementContext::FOR() { return getToken(MXParser::FOR, 0); } tree::TerminalNode* MXParser::For_statementContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } std::vector MXParser::For_statementContext::SEMICOLON() { return getTokens(MXParser::SEMICOLON); } tree::TerminalNode* MXParser::For_statementContext::SEMICOLON(size_t i) { return getToken(MXParser::SEMICOLON, i); } tree::TerminalNode* MXParser::For_statementContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } MXParser::StatementContext* MXParser::For_statementContext::statement() { return getRuleContext(0); } std::vector MXParser::For_statementContext::define_statement() { return getRuleContexts(); } MXParser::Define_statementContext* MXParser::For_statementContext::define_statement(size_t i) { return getRuleContext(i); } std::vector MXParser::For_statementContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::For_statementContext::expr(size_t i) { return getRuleContext(i); } MXParser::For_statementContext::For_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::For_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitFor_statement(this); else return visitor->visitChildren(this); } //----------------- Suite_statementContext ------------------------------------------------------------------ MXParser::SuiteContext* MXParser::Suite_statementContext::suite() { return getRuleContext(0); } MXParser::Suite_statementContext::Suite_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::Suite_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSuite_statement(this); else return visitor->visitChildren(this); } //----------------- Expr_statementContext ------------------------------------------------------------------ MXParser::ExprContext* MXParser::Expr_statementContext::expr() { return getRuleContext(0); } tree::TerminalNode* MXParser::Expr_statementContext::SEMICOLON() { return getToken(MXParser::SEMICOLON, 0); } MXParser::Expr_statementContext::Expr_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::Expr_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpr_statement(this); else return visitor->visitChildren(this); } //----------------- Jmp_statementContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::Jmp_statementContext::SEMICOLON() { return getToken(MXParser::SEMICOLON, 0); } tree::TerminalNode* MXParser::Jmp_statementContext::BREAK() { return getToken(MXParser::BREAK, 0); } tree::TerminalNode* MXParser::Jmp_statementContext::CONTINUE() { return getToken(MXParser::CONTINUE, 0); } tree::TerminalNode* MXParser::Jmp_statementContext::RETURN() { return getToken(MXParser::RETURN, 0); } MXParser::ExprContext* MXParser::Jmp_statementContext::expr() { return getRuleContext(0); } MXParser::Jmp_statementContext::Jmp_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::Jmp_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitJmp_statement(this); else return visitor->visitChildren(this); } //----------------- If_statementContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::If_statementContext::IF() { return getToken(MXParser::IF, 0); } tree::TerminalNode* MXParser::If_statementContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } MXParser::ExprContext* MXParser::If_statementContext::expr() { return getRuleContext(0); } tree::TerminalNode* MXParser::If_statementContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } std::vector MXParser::If_statementContext::statement() { return getRuleContexts(); } MXParser::StatementContext* MXParser::If_statementContext::statement(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::If_statementContext::ELSE() { return getToken(MXParser::ELSE, 0); } MXParser::If_statementContext::If_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::If_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitIf_statement(this); else return visitor->visitChildren(this); } //----------------- Definition_statementContext ------------------------------------------------------------------ MXParser::Define_statementContext* MXParser::Definition_statementContext::define_statement() { return getRuleContext(0); } MXParser::Definition_statementContext::Definition_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::Definition_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitDefinition_statement(this); else return visitor->visitChildren(this); } //----------------- While_statementContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::While_statementContext::WHILE() { return getToken(MXParser::WHILE, 0); } tree::TerminalNode* MXParser::While_statementContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } MXParser::ExprContext* MXParser::While_statementContext::expr() { return getRuleContext(0); } tree::TerminalNode* MXParser::While_statementContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } MXParser::StatementContext* MXParser::While_statementContext::statement() { return getRuleContext(0); } MXParser::While_statementContext::While_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::While_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitWhile_statement(this); else return visitor->visitChildren(this); } //----------------- Empty_statementContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::Empty_statementContext::SEMICOLON() { return getToken(MXParser::SEMICOLON, 0); } MXParser::Empty_statementContext::Empty_statementContext(StatementContext *ctx) { copyFrom(ctx); } std::any MXParser::Empty_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitEmpty_statement(this); else return visitor->visitChildren(this); } MXParser::StatementContext* MXParser::statement() { StatementContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 12, MXParser::RuleStatement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(171); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 18, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 1); setState(122); match(MXParser::SEMICOLON); break; } case 2: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 2); setState(123); define_statement(); break; } case 3: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 3); setState(124); expr(0); setState(125); match(MXParser::SEMICOLON); break; } case 4: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 4); setState(127); match(MXParser::IF); setState(128); match(MXParser::LPAREN); setState(129); expr(0); setState(130); match(MXParser::RPAREN); setState(131); statement(); setState(134); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 12, _ctx)) { case 1: { setState(132); match(MXParser::ELSE); setState(133); statement(); break; } default: break; } break; } case 5: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 5); setState(136); match(MXParser::WHILE); setState(137); match(MXParser::LPAREN); setState(138); expr(0); setState(139); match(MXParser::RPAREN); setState(140); statement(); break; } case 6: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 6); setState(142); match(MXParser::FOR); setState(143); match(MXParser::LPAREN); setState(149); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 13, _ctx)) { case 1: { setState(144); define_statement(); break; } case 2: { setState(145); expr(0); setState(146); match(MXParser::SEMICOLON); break; } case 3: { setState(148); match(MXParser::SEMICOLON); break; } default: break; } setState(152); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 518214813164767136) != 0)) { setState(151); expr(0); } setState(154); match(MXParser::SEMICOLON); setState(157); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 15, _ctx)) { case 1: { setState(155); define_statement(); break; } case 2: { setState(156); expr(0); break; } default: break; } setState(159); match(MXParser::RPAREN); setState(160); statement(); break; } case 7: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 7); setState(167); _errHandler->sync(this); switch (_input->LA(1)) { case MXParser::BREAK: { setState(161); match(MXParser::BREAK); break; } case MXParser::CONTINUE: { setState(162); match(MXParser::CONTINUE); break; } case MXParser::RETURN: { setState(163); match(MXParser::RETURN); setState(165); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 518214813164767136) != 0)) { setState(164); expr(0); } break; } default: throw NoViableAltException(this); } setState(169); match(MXParser::SEMICOLON); break; } case 8: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 8); setState(170); suite(); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Define_statementContext ------------------------------------------------------------------ MXParser::Define_statementContext::Define_statementContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } MXParser::TypeContext* MXParser::Define_statementContext::type() { return getRuleContext(0); } std::vector MXParser::Define_statementContext::ID() { return getTokens(MXParser::ID); } tree::TerminalNode* MXParser::Define_statementContext::ID(size_t i) { return getToken(MXParser::ID, i); } tree::TerminalNode* MXParser::Define_statementContext::SEMICOLON() { return getToken(MXParser::SEMICOLON, 0); } std::vector MXParser::Define_statementContext::LBRACKET() { return getTokens(MXParser::LBRACKET); } tree::TerminalNode* MXParser::Define_statementContext::LBRACKET(size_t i) { return getToken(MXParser::LBRACKET, i); } std::vector MXParser::Define_statementContext::RBRACKET() { return getTokens(MXParser::RBRACKET); } tree::TerminalNode* MXParser::Define_statementContext::RBRACKET(size_t i) { return getToken(MXParser::RBRACKET, i); } std::vector MXParser::Define_statementContext::ASSIGN() { return getTokens(MXParser::ASSIGN); } tree::TerminalNode* MXParser::Define_statementContext::ASSIGN(size_t i) { return getToken(MXParser::ASSIGN, i); } std::vector MXParser::Define_statementContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Define_statementContext::expr(size_t i) { return getRuleContext(i); } std::vector MXParser::Define_statementContext::COMMA() { return getTokens(MXParser::COMMA); } tree::TerminalNode* MXParser::Define_statementContext::COMMA(size_t i) { return getToken(MXParser::COMMA, i); } size_t MXParser::Define_statementContext::getRuleIndex() const { return MXParser::RuleDefine_statement; } std::any MXParser::Define_statementContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitDefine_statement(this); else return visitor->visitChildren(this); } MXParser::Define_statementContext* MXParser::define_statement() { Define_statementContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 14, MXParser::RuleDefine_statement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(173); type(); setState(178); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::LBRACKET) { setState(174); match(MXParser::LBRACKET); setState(175); match(MXParser::RBRACKET); setState(180); _errHandler->sync(this); _la = _input->LA(1); } setState(181); match(MXParser::ID); setState(184); _errHandler->sync(this); _la = _input->LA(1); if (_la == MXParser::ASSIGN) { setState(182); match(MXParser::ASSIGN); setState(183); expr(0); } setState(194); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::COMMA) { setState(186); match(MXParser::COMMA); setState(187); match(MXParser::ID); setState(190); _errHandler->sync(this); _la = _input->LA(1); if (_la == MXParser::ASSIGN) { setState(188); match(MXParser::ASSIGN); setState(189); expr(0); } setState(196); _errHandler->sync(this); _la = _input->LA(1); } setState(197); match(MXParser::SEMICOLON); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ExprContext ------------------------------------------------------------------ MXParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } size_t MXParser::ExprContext::getRuleIndex() const { return MXParser::RuleExpr; } void MXParser::ExprContext::copyFrom(ExprContext *ctx) { ParserRuleContext::copyFrom(ctx); } //----------------- Ggll_expressionContext ------------------------------------------------------------------ std::vector MXParser::Ggll_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Ggll_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Ggll_expressionContext::GN() { return getToken(MXParser::GN, 0); } tree::TerminalNode* MXParser::Ggll_expressionContext::GE() { return getToken(MXParser::GE, 0); } tree::TerminalNode* MXParser::Ggll_expressionContext::LN() { return getToken(MXParser::LN, 0); } tree::TerminalNode* MXParser::Ggll_expressionContext::LE() { return getToken(MXParser::LE, 0); } MXParser::Ggll_expressionContext::Ggll_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Ggll_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitGgll_expression(this); else return visitor->visitChildren(this); } //----------------- Bxor_expressionContext ------------------------------------------------------------------ std::vector MXParser::Bxor_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Bxor_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Bxor_expressionContext::BXOR() { return getToken(MXParser::BXOR, 0); } MXParser::Bxor_expressionContext::Bxor_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Bxor_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitBxor_expression(this); else return visitor->visitChildren(this); } //----------------- Suffix_expressionContext ------------------------------------------------------------------ MXParser::ExprContext* MXParser::Suffix_expressionContext::expr() { return getRuleContext(0); } tree::TerminalNode* MXParser::Suffix_expressionContext::SELF_PLUS() { return getToken(MXParser::SELF_PLUS, 0); } tree::TerminalNode* MXParser::Suffix_expressionContext::SELF_MINUS() { return getToken(MXParser::SELF_MINUS, 0); } MXParser::Suffix_expressionContext::Suffix_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Suffix_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSuffix_expression(this); else return visitor->visitChildren(this); } //----------------- Land_expressionContext ------------------------------------------------------------------ std::vector MXParser::Land_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Land_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Land_expressionContext::LAND() { return getToken(MXParser::LAND, 0); } MXParser::Land_expressionContext::Land_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Land_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitLand_expression(this); else return visitor->visitChildren(this); } //----------------- Pm_expressionContext ------------------------------------------------------------------ std::vector MXParser::Pm_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Pm_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Pm_expressionContext::PLUS() { return getToken(MXParser::PLUS, 0); } tree::TerminalNode* MXParser::Pm_expressionContext::MINUS() { return getToken(MXParser::MINUS, 0); } MXParser::Pm_expressionContext::Pm_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Pm_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPm_expression(this); else return visitor->visitChildren(this); } //----------------- Index_expressionContext ------------------------------------------------------------------ std::vector MXParser::Index_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Index_expressionContext::expr(size_t i) { return getRuleContext(i); } std::vector MXParser::Index_expressionContext::LBRACKET() { return getTokens(MXParser::LBRACKET); } tree::TerminalNode* MXParser::Index_expressionContext::LBRACKET(size_t i) { return getToken(MXParser::LBRACKET, i); } std::vector MXParser::Index_expressionContext::RBRACKET() { return getTokens(MXParser::RBRACKET); } tree::TerminalNode* MXParser::Index_expressionContext::RBRACKET(size_t i) { return getToken(MXParser::RBRACKET, i); } MXParser::Index_expressionContext::Index_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Index_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitIndex_expression(this); else return visitor->visitChildren(this); } //----------------- Opposite_expressionContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::Opposite_expressionContext::MINUS() { return getToken(MXParser::MINUS, 0); } MXParser::ExprContext* MXParser::Opposite_expressionContext::expr() { return getRuleContext(0); } MXParser::Opposite_expressionContext::Opposite_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Opposite_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitOpposite_expression(this); else return visitor->visitChildren(this); } //----------------- New_array_expressionContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::New_array_expressionContext::NEW() { return getToken(MXParser::NEW, 0); } MXParser::TypeContext* MXParser::New_array_expressionContext::type() { return getRuleContext(0); } std::vector MXParser::New_array_expressionContext::LBRACKET() { return getTokens(MXParser::LBRACKET); } tree::TerminalNode* MXParser::New_array_expressionContext::LBRACKET(size_t i) { return getToken(MXParser::LBRACKET, i); } std::vector MXParser::New_array_expressionContext::RBRACKET() { return getTokens(MXParser::RBRACKET); } tree::TerminalNode* MXParser::New_array_expressionContext::RBRACKET(size_t i) { return getToken(MXParser::RBRACKET, i); } MXParser::ConstantContext* MXParser::New_array_expressionContext::constant() { return getRuleContext(0); } std::vector MXParser::New_array_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::New_array_expressionContext::expr(size_t i) { return getRuleContext(i); } MXParser::New_array_expressionContext::New_array_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::New_array_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitNew_array_expression(this); else return visitor->visitChildren(this); } //----------------- Basic_expressionContext ------------------------------------------------------------------ MXParser::Basic_exprContext* MXParser::Basic_expressionContext::basic_expr() { return getRuleContext(0); } MXParser::Basic_expressionContext::Basic_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Basic_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitBasic_expression(this); else return visitor->visitChildren(this); } //----------------- Access_expressionContext ------------------------------------------------------------------ std::vector MXParser::Access_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Access_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Access_expressionContext::DOT() { return getToken(MXParser::DOT, 0); } tree::TerminalNode* MXParser::Access_expressionContext::ID() { return getToken(MXParser::ID, 0); } tree::TerminalNode* MXParser::Access_expressionContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } tree::TerminalNode* MXParser::Access_expressionContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } std::vector MXParser::Access_expressionContext::COMMA() { return getTokens(MXParser::COMMA); } tree::TerminalNode* MXParser::Access_expressionContext::COMMA(size_t i) { return getToken(MXParser::COMMA, i); } MXParser::Access_expressionContext::Access_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Access_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitAccess_expression(this); else return visitor->visitChildren(this); } //----------------- Band_expressionContext ------------------------------------------------------------------ std::vector MXParser::Band_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Band_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Band_expressionContext::BAND() { return getToken(MXParser::BAND, 0); } MXParser::Band_expressionContext::Band_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Band_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitBand_expression(this); else return visitor->visitChildren(this); } //----------------- New_construct_expressionContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::New_construct_expressionContext::NEW() { return getToken(MXParser::NEW, 0); } MXParser::TypeContext* MXParser::New_construct_expressionContext::type() { return getRuleContext(0); } tree::TerminalNode* MXParser::New_construct_expressionContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } tree::TerminalNode* MXParser::New_construct_expressionContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } MXParser::New_construct_expressionContext::New_construct_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::New_construct_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitNew_construct_expression(this); else return visitor->visitChildren(this); } //----------------- Ternary_expressionContext ------------------------------------------------------------------ std::vector MXParser::Ternary_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Ternary_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Ternary_expressionContext::QUESTION_MARK() { return getToken(MXParser::QUESTION_MARK, 0); } tree::TerminalNode* MXParser::Ternary_expressionContext::COLON() { return getToken(MXParser::COLON, 0); } MXParser::Ternary_expressionContext::Ternary_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Ternary_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitTernary_expression(this); else return visitor->visitChildren(this); } //----------------- Bnot_expressionContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::Bnot_expressionContext::BNOT() { return getToken(MXParser::BNOT, 0); } MXParser::ExprContext* MXParser::Bnot_expressionContext::expr() { return getRuleContext(0); } MXParser::Bnot_expressionContext::Bnot_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Bnot_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitBnot_expression(this); else return visitor->visitChildren(this); } //----------------- Lnot_expressionContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::Lnot_expressionContext::LNOT() { return getToken(MXParser::LNOT, 0); } MXParser::ExprContext* MXParser::Lnot_expressionContext::expr() { return getRuleContext(0); } MXParser::Lnot_expressionContext::Lnot_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Lnot_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitLnot_expression(this); else return visitor->visitChildren(this); } //----------------- Prefix_expressionContext ------------------------------------------------------------------ MXParser::ExprContext* MXParser::Prefix_expressionContext::expr() { return getRuleContext(0); } tree::TerminalNode* MXParser::Prefix_expressionContext::SELF_PLUS() { return getToken(MXParser::SELF_PLUS, 0); } tree::TerminalNode* MXParser::Prefix_expressionContext::SELF_MINUS() { return getToken(MXParser::SELF_MINUS, 0); } MXParser::Prefix_expressionContext::Prefix_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Prefix_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPrefix_expression(this); else return visitor->visitChildren(this); } //----------------- Rl_expressionContext ------------------------------------------------------------------ std::vector MXParser::Rl_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Rl_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Rl_expressionContext::ARS() { return getToken(MXParser::ARS, 0); } tree::TerminalNode* MXParser::Rl_expressionContext::ALS() { return getToken(MXParser::ALS, 0); } MXParser::Rl_expressionContext::Rl_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Rl_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRl_expression(this); else return visitor->visitChildren(this); } //----------------- Assign_expressionContext ------------------------------------------------------------------ std::vector MXParser::Assign_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Assign_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Assign_expressionContext::ASSIGN() { return getToken(MXParser::ASSIGN, 0); } MXParser::Assign_expressionContext::Assign_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Assign_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitAssign_expression(this); else return visitor->visitChildren(this); } //----------------- Mdm_expressionContext ------------------------------------------------------------------ std::vector MXParser::Mdm_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Mdm_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Mdm_expressionContext::MULTIPLY() { return getToken(MXParser::MULTIPLY, 0); } tree::TerminalNode* MXParser::Mdm_expressionContext::DIVIDE() { return getToken(MXParser::DIVIDE, 0); } tree::TerminalNode* MXParser::Mdm_expressionContext::MOD() { return getToken(MXParser::MOD, 0); } MXParser::Mdm_expressionContext::Mdm_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Mdm_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitMdm_expression(this); else return visitor->visitChildren(this); } //----------------- New_expressionContext ------------------------------------------------------------------ tree::TerminalNode* MXParser::New_expressionContext::NEW() { return getToken(MXParser::NEW, 0); } MXParser::TypeContext* MXParser::New_expressionContext::type() { return getRuleContext(0); } MXParser::New_expressionContext::New_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::New_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitNew_expression(this); else return visitor->visitChildren(this); } //----------------- Ne_expressionContext ------------------------------------------------------------------ std::vector MXParser::Ne_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Ne_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Ne_expressionContext::NE() { return getToken(MXParser::NE, 0); } tree::TerminalNode* MXParser::Ne_expressionContext::EQ() { return getToken(MXParser::EQ, 0); } MXParser::Ne_expressionContext::Ne_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Ne_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitNe_expression(this); else return visitor->visitChildren(this); } //----------------- Bor_expressionContext ------------------------------------------------------------------ std::vector MXParser::Bor_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Bor_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Bor_expressionContext::BOR() { return getToken(MXParser::BOR, 0); } MXParser::Bor_expressionContext::Bor_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Bor_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitBor_expression(this); else return visitor->visitChildren(this); } //----------------- Lor_expressionContext ------------------------------------------------------------------ std::vector MXParser::Lor_expressionContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Lor_expressionContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Lor_expressionContext::LOR() { return getToken(MXParser::LOR, 0); } MXParser::Lor_expressionContext::Lor_expressionContext(ExprContext *ctx) { copyFrom(ctx); } std::any MXParser::Lor_expressionContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitLor_expression(this); else return visitor->visitChildren(this); } MXParser::ExprContext* MXParser::expr() { return expr(0); } MXParser::ExprContext* MXParser::expr(int precedence) { ParserRuleContext *parentContext = _ctx; size_t parentState = getState(); MXParser::ExprContext *_localctx = _tracker.createInstance(_ctx, parentState); MXParser::ExprContext *previousContext = _localctx; (void)previousContext; // Silence compiler, in case the context is not used by generated code. size_t startState = 16; enterRecursionRule(_localctx, 16, MXParser::RuleExpr, precedence); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif unrollRecursionContexts(parentContext); }); try { size_t alt; enterOuterAlt(_localctx, 1); setState(231); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 26, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(200); basic_expr(); break; } case 2: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(201); match(MXParser::NEW); setState(202); type(); setState(210); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 24, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { setState(203); match(MXParser::LBRACKET); setState(205); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 518214813164767136) != 0)) { setState(204); expr(0); } setState(207); match(MXParser::RBRACKET); } setState(212); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 24, _ctx); } setState(214); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 25, _ctx)) { case 1: { setState(213); constant(); break; } default: break; } break; } case 3: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(216); match(MXParser::NEW); setState(217); type(); setState(218); match(MXParser::LPAREN); setState(219); match(MXParser::RPAREN); break; } case 4: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(221); match(MXParser::NEW); setState(222); type(); break; } case 5: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(223); _la = _input->LA(1); if (!(_la == MXParser::SELF_PLUS || _la == MXParser::SELF_MINUS)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(224); expr(16); break; } case 6: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(225); match(MXParser::MINUS); setState(226); expr(15); break; } case 7: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(227); match(MXParser::LNOT); setState(228); expr(14); break; } case 8: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(229); match(MXParser::BNOT); setState(230); expr(13); break; } default: break; } _ctx->stop = _input->LT(-1); setState(303); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { if (!_parseListeners.empty()) triggerExitRuleEvent(); previousContext = _localctx; setState(301); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 31, _ctx)) { case 1: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(233); if (!(precpred(_ctx, 12))) throw FailedPredicateException(this, "precpred(_ctx, 12)"); setState(234); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 7340032) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(235); expr(13); break; } case 2: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(236); if (!(precpred(_ctx, 11))) throw FailedPredicateException(this, "precpred(_ctx, 11)"); setState(237); _la = _input->LA(1); if (!(_la == MXParser::PLUS || _la == MXParser::MINUS)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(238); expr(12); break; } case 3: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(239); if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)"); setState(240); _la = _input->LA(1); if (!(_la == MXParser::ARS || _la == MXParser::ALS)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(241); expr(11); break; } case 4: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(242); if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)"); setState(243); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 125829120) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(244); expr(10); break; } case 5: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(245); if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)"); setState(246); _la = _input->LA(1); if (!(_la == MXParser::NE || _la == MXParser::EQ)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(247); expr(9); break; } case 6: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(248); if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)"); setState(249); match(MXParser::BAND); setState(250); expr(8); break; } case 7: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(251); if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)"); setState(252); match(MXParser::BXOR); setState(253); expr(7); break; } case 8: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(254); if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)"); setState(255); match(MXParser::BOR); setState(256); expr(6); break; } case 9: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(257); if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)"); setState(258); match(MXParser::LAND); setState(259); expr(5); break; } case 10: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(260); if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)"); setState(261); match(MXParser::LOR); setState(262); expr(4); break; } case 11: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(263); if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)"); setState(264); match(MXParser::QUESTION_MARK); setState(265); expr(0); setState(266); match(MXParser::COLON); setState(267); expr(2); break; } case 12: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(269); if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); setState(270); match(MXParser::ASSIGN); setState(271); expr(1); break; } case 13: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(272); if (!(precpred(_ctx, 19))) throw FailedPredicateException(this, "precpred(_ctx, 19)"); setState(273); match(MXParser::DOT); setState(288); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 29, _ctx)) { case 1: { setState(274); match(MXParser::ID); break; } case 2: { setState(275); match(MXParser::ID); setState(276); match(MXParser::LPAREN); setState(285); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 518214813164767136) != 0)) { setState(277); expr(0); setState(282); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::COMMA) { setState(278); match(MXParser::COMMA); setState(279); expr(0); setState(284); _errHandler->sync(this); _la = _input->LA(1); } } setState(287); match(MXParser::RPAREN); break; } default: break; } break; } case 14: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(290); if (!(precpred(_ctx, 18))) throw FailedPredicateException(this, "precpred(_ctx, 18)"); setState(295); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { setState(291); match(MXParser::LBRACKET); setState(292); expr(0); setState(293); match(MXParser::RBRACKET); break; } default: throw NoViableAltException(this); } setState(297); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 30, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); break; } case 15: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleExpr); setState(299); if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)"); setState(300); _la = _input->LA(1); if (!(_la == MXParser::SELF_PLUS || _la == MXParser::SELF_MINUS)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } break; } default: break; } } setState(305); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Basic_exprContext ------------------------------------------------------------------ MXParser::Basic_exprContext::Basic_exprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::Basic_exprContext::THIS() { return getToken(MXParser::THIS, 0); } tree::TerminalNode* MXParser::Basic_exprContext::LPAREN() { return getToken(MXParser::LPAREN, 0); } std::vector MXParser::Basic_exprContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Basic_exprContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Basic_exprContext::RPAREN() { return getToken(MXParser::RPAREN, 0); } tree::TerminalNode* MXParser::Basic_exprContext::ID() { return getToken(MXParser::ID, 0); } std::vector MXParser::Basic_exprContext::COMMA() { return getTokens(MXParser::COMMA); } tree::TerminalNode* MXParser::Basic_exprContext::COMMA(size_t i) { return getToken(MXParser::COMMA, i); } MXParser::Formatted_stringContext* MXParser::Basic_exprContext::formatted_string() { return getRuleContext(0); } MXParser::ConstantContext* MXParser::Basic_exprContext::constant() { return getRuleContext(0); } size_t MXParser::Basic_exprContext::getRuleIndex() const { return MXParser::RuleBasic_expr; } std::any MXParser::Basic_exprContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitBasic_expr(this); else return visitor->visitChildren(this); } MXParser::Basic_exprContext* MXParser::basic_expr() { Basic_exprContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 18, MXParser::RuleBasic_expr); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(327); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 35, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(306); match(MXParser::THIS); break; } case 2: { enterOuterAlt(_localctx, 2); setState(307); match(MXParser::LPAREN); setState(308); expr(0); setState(309); match(MXParser::RPAREN); break; } case 3: { enterOuterAlt(_localctx, 3); setState(311); match(MXParser::ID); break; } case 4: { enterOuterAlt(_localctx, 4); setState(312); match(MXParser::ID); setState(313); match(MXParser::LPAREN); setState(322); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 518214813164767136) != 0)) { setState(314); expr(0); setState(319); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::COMMA) { setState(315); match(MXParser::COMMA); setState(316); expr(0); setState(321); _errHandler->sync(this); _la = _input->LA(1); } } setState(324); match(MXParser::RPAREN); break; } case 5: { enterOuterAlt(_localctx, 5); setState(325); formatted_string(); break; } case 6: { enterOuterAlt(_localctx, 6); setState(326); constant(); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Formatted_stringContext ------------------------------------------------------------------ MXParser::Formatted_stringContext::Formatted_stringContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::Formatted_stringContext::FORMAT_STRING_WHOLE() { return getToken(MXParser::FORMAT_STRING_WHOLE, 0); } tree::TerminalNode* MXParser::Formatted_stringContext::FORMAT_STRING_HEAD() { return getToken(MXParser::FORMAT_STRING_HEAD, 0); } std::vector MXParser::Formatted_stringContext::expr() { return getRuleContexts(); } MXParser::ExprContext* MXParser::Formatted_stringContext::expr(size_t i) { return getRuleContext(i); } tree::TerminalNode* MXParser::Formatted_stringContext::FORMAT_STRING_TAIL() { return getToken(MXParser::FORMAT_STRING_TAIL, 0); } std::vector MXParser::Formatted_stringContext::FORMAT_STRING_BODY() { return getTokens(MXParser::FORMAT_STRING_BODY); } tree::TerminalNode* MXParser::Formatted_stringContext::FORMAT_STRING_BODY(size_t i) { return getToken(MXParser::FORMAT_STRING_BODY, i); } size_t MXParser::Formatted_stringContext::getRuleIndex() const { return MXParser::RuleFormatted_string; } std::any MXParser::Formatted_stringContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitFormatted_string(this); else return visitor->visitChildren(this); } MXParser::Formatted_stringContext* MXParser::formatted_string() { Formatted_stringContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 20, MXParser::RuleFormatted_string); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { size_t alt; setState(341); _errHandler->sync(this); switch (_input->LA(1)) { case MXParser::FORMAT_STRING_WHOLE: { enterOuterAlt(_localctx, 1); setState(329); match(MXParser::FORMAT_STRING_WHOLE); break; } case MXParser::FORMAT_STRING_HEAD: { enterOuterAlt(_localctx, 2); setState(330); match(MXParser::FORMAT_STRING_HEAD); setState(331); expr(0); setState(336); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 36, _ctx); while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1 + 1) { setState(332); match(MXParser::FORMAT_STRING_BODY); setState(333); expr(0); } setState(338); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 36, _ctx); } setState(339); match(MXParser::FORMAT_STRING_TAIL); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ConstantContext ------------------------------------------------------------------ MXParser::ConstantContext::ConstantContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::ConstantContext::TRUE() { return getToken(MXParser::TRUE, 0); } tree::TerminalNode* MXParser::ConstantContext::FALSE() { return getToken(MXParser::FALSE, 0); } tree::TerminalNode* MXParser::ConstantContext::INT_LITERAL() { return getToken(MXParser::INT_LITERAL, 0); } tree::TerminalNode* MXParser::ConstantContext::STRING_LITERAL() { return getToken(MXParser::STRING_LITERAL, 0); } tree::TerminalNode* MXParser::ConstantContext::NULL_() { return getToken(MXParser::NULL_, 0); } tree::TerminalNode* MXParser::ConstantContext::LBRACE() { return getToken(MXParser::LBRACE, 0); } tree::TerminalNode* MXParser::ConstantContext::RBRACE() { return getToken(MXParser::RBRACE, 0); } std::vector MXParser::ConstantContext::constant() { return getRuleContexts(); } MXParser::ConstantContext* MXParser::ConstantContext::constant(size_t i) { return getRuleContext(i); } std::vector MXParser::ConstantContext::COMMA() { return getTokens(MXParser::COMMA); } tree::TerminalNode* MXParser::ConstantContext::COMMA(size_t i) { return getToken(MXParser::COMMA, i); } size_t MXParser::ConstantContext::getRuleIndex() const { return MXParser::RuleConstant; } std::any MXParser::ConstantContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitConstant(this); else return visitor->visitChildren(this); } MXParser::ConstantContext* MXParser::constant() { ConstantContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 22, MXParser::RuleConstant); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(360); _errHandler->sync(this); switch (_input->LA(1)) { case MXParser::TRUE: { enterOuterAlt(_localctx, 1); setState(343); match(MXParser::TRUE); break; } case MXParser::FALSE: { enterOuterAlt(_localctx, 2); setState(344); match(MXParser::FALSE); break; } case MXParser::INT_LITERAL: { enterOuterAlt(_localctx, 3); setState(345); match(MXParser::INT_LITERAL); break; } case MXParser::STRING_LITERAL: { enterOuterAlt(_localctx, 4); setState(346); match(MXParser::STRING_LITERAL); break; } case MXParser::NULL_: { enterOuterAlt(_localctx, 5); setState(347); match(MXParser::NULL_); break; } case MXParser::LBRACE: { enterOuterAlt(_localctx, 6); setState(348); match(MXParser::LBRACE); setState(357); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 432627039204279168) != 0)) { setState(349); constant(); setState(354); _errHandler->sync(this); _la = _input->LA(1); while (_la == MXParser::COMMA) { setState(350); match(MXParser::COMMA); setState(351); constant(); setState(356); _errHandler->sync(this); _la = _input->LA(1); } } setState(359); match(MXParser::RBRACE); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- TypeContext ------------------------------------------------------------------ MXParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* MXParser::TypeContext::INT() { return getToken(MXParser::INT, 0); } tree::TerminalNode* MXParser::TypeContext::BOOL() { return getToken(MXParser::BOOL, 0); } tree::TerminalNode* MXParser::TypeContext::STRING() { return getToken(MXParser::STRING, 0); } tree::TerminalNode* MXParser::TypeContext::VOID() { return getToken(MXParser::VOID, 0); } tree::TerminalNode* MXParser::TypeContext::ID() { return getToken(MXParser::ID, 0); } size_t MXParser::TypeContext::getRuleIndex() const { return MXParser::RuleType; } std::any MXParser::TypeContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitType(this); else return visitor->visitChildren(this); } MXParser::TypeContext* MXParser::type() { TypeContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 24, MXParser::RuleType); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(362); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 72057594037927966) != 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; } bool MXParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { switch (ruleIndex) { case 8: return exprSempred(antlrcpp::downCast(context), predicateIndex); default: break; } return true; } bool MXParser::exprSempred(ExprContext *_localctx, size_t predicateIndex) { switch (predicateIndex) { case 0: return precpred(_ctx, 12); case 1: return precpred(_ctx, 11); case 2: return precpred(_ctx, 10); case 3: return precpred(_ctx, 9); case 4: return precpred(_ctx, 8); case 5: return precpred(_ctx, 7); case 6: return precpred(_ctx, 6); case 7: return precpred(_ctx, 5); case 8: return precpred(_ctx, 4); case 9: return precpred(_ctx, 3); case 10: return precpred(_ctx, 2); case 11: return precpred(_ctx, 1); case 12: return precpred(_ctx, 19); case 13: return precpred(_ctx, 18); case 14: return precpred(_ctx, 17); default: break; } return true; } void MXParser::initialize() { #if ANTLR4_USE_THREAD_LOCAL_CACHE mxparserParserInitialize(); #else ::antlr4::internal::call_once(mxparserParserOnceFlag, mxparserParserInitialize); #endif }