mirror of
https://github.com/polserver/polserver
synced 2026-08-13 08:23:08 -04:00
6c7a2b0a30
* update grammar * implementation * formatting * executor implementation, tests * docs, core-changes * fix warning introduced in #760 * add format option FormatterEllipsisSpacing * update core-changes
10218 lines
332 KiB
C++
10218 lines
332 KiB
C++
|
|
|
|
|
|
// Generated from EscriptParser.g4 by ANTLR 4.13.1
|
|
|
|
|
|
#include "EscriptParserListener.h"
|
|
#include "EscriptParserVisitor.h"
|
|
|
|
#include "EscriptParser.h"
|
|
|
|
|
|
using namespace antlrcpp;
|
|
using namespace EscriptGrammar;
|
|
|
|
using namespace antlr4;
|
|
|
|
namespace {
|
|
|
|
struct EscriptParserStaticData final {
|
|
EscriptParserStaticData(std::vector<std::string> ruleNames,
|
|
std::vector<std::string> literalNames,
|
|
std::vector<std::string> symbolicNames)
|
|
: ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
|
|
symbolicNames(std::move(symbolicNames)),
|
|
vocabulary(this->literalNames, this->symbolicNames) {}
|
|
|
|
EscriptParserStaticData(const EscriptParserStaticData&) = delete;
|
|
EscriptParserStaticData(EscriptParserStaticData&&) = delete;
|
|
EscriptParserStaticData& operator=(const EscriptParserStaticData&) = delete;
|
|
EscriptParserStaticData& operator=(EscriptParserStaticData&&) = delete;
|
|
|
|
std::vector<antlr4::dfa::DFA> decisionToDFA;
|
|
antlr4::atn::PredictionContextCache sharedContextCache;
|
|
const std::vector<std::string> ruleNames;
|
|
const std::vector<std::string> literalNames;
|
|
const std::vector<std::string> symbolicNames;
|
|
const antlr4::dfa::Vocabulary vocabulary;
|
|
antlr4::atn::SerializedATNView serializedATN;
|
|
std::unique_ptr<antlr4::atn::ATN> atn;
|
|
};
|
|
|
|
::antlr4::internal::OnceFlag escriptparserParserOnceFlag;
|
|
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
|
static thread_local
|
|
#endif
|
|
EscriptParserStaticData *escriptparserParserStaticData = nullptr;
|
|
|
|
void escriptparserParserInitialize() {
|
|
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
|
if (escriptparserParserStaticData != nullptr) {
|
|
return;
|
|
}
|
|
#else
|
|
assert(escriptparserParserStaticData == nullptr);
|
|
#endif
|
|
auto staticData = std::make_unique<EscriptParserStaticData>(
|
|
std::vector<std::string>{
|
|
"compilationUnit", "moduleUnit", "evaluateUnit", "moduleDeclarationStatement",
|
|
"moduleFunctionDeclaration", "moduleFunctionParameterList", "moduleFunctionParameter",
|
|
"topLevelDeclaration", "classDeclaration", "classParameters", "classParameterList",
|
|
"classBody", "classStatement", "functionDeclaration", "stringIdentifier",
|
|
"useDeclaration", "includeDeclaration", "programDeclaration", "statement",
|
|
"statementLabel", "ifStatement", "gotoStatement", "returnStatement",
|
|
"constStatement", "varStatement", "doStatement", "whileStatement",
|
|
"exitStatement", "breakStatement", "continueStatement", "forStatement",
|
|
"foreachIterableExpression", "foreachStatement", "repeatStatement",
|
|
"caseStatement", "enumStatement", "block", "variableDeclarationInitializer",
|
|
"enumList", "enumListEntry", "switchBlockStatementGroup", "switchLabel",
|
|
"forGroup", "basicForStatement", "cstyleForStatement", "identifierList",
|
|
"variableDeclarationList", "constantDeclaration", "variableDeclaration",
|
|
"bindingDeclaration", "indexBindingList", "sequenceBindingList", "sequenceBinding",
|
|
"indexBinding", "binding", "bindingDeclarationInitializer", "programParameters",
|
|
"programParameterList", "programParameter", "functionParameters",
|
|
"functionParameterList", "functionParameter", "scopedFunctionCall",
|
|
"functionReference", "expression", "primary", "scopedIdentifier",
|
|
"functionExpression", "explicitArrayInitializer", "explicitStructInitializer",
|
|
"explicitDictInitializer", "explicitErrorInitializer", "bareArrayInitializer",
|
|
"parExpression", "expressionList", "expressionListEntry", "expressionSuffix",
|
|
"indexingSuffix", "indexList", "navigationSuffix", "methodCallSuffix",
|
|
"functionCallSuffix", "functionCall", "structInitializerExpression",
|
|
"structInitializerExpressionList", "structInitializer", "dictInitializerExpression",
|
|
"dictInitializerExpressionList", "dictInitializer", "arrayInitializer",
|
|
"literal", "interpolatedString", "interpolatedStringPart", "integerLiteral",
|
|
"floatLiteral", "boolLiteral"
|
|
},
|
|
std::vector<std::string>{
|
|
"", "'if'", "'then'", "'elseif'", "'endif'", "'else'", "'goto'", "'return'",
|
|
"'const'", "'var'", "'do'", "'dowhile'", "'while'", "'endwhile'",
|
|
"'exit'", "'function'", "'endfunction'", "'exported'", "'use'", "'include'",
|
|
"'break'", "'continue'", "'for'", "'endfor'", "'to'", "'foreach'",
|
|
"'endforeach'", "'repeat'", "'until'", "'program'", "'endprogram'",
|
|
"'case'", "'default'", "'endcase'", "'enum'", "'endenum'", "'class'",
|
|
"'endclass'", "'downto'", "'step'", "'reference'", "'out'", "'inout'",
|
|
"'ByVal'", "'string'", "'long'", "'integer'", "'unsigned'", "'signed'",
|
|
"'real'", "'float'", "'double'", "'as'", "'...'", "'&&'", "'and'",
|
|
"'||'", "'or'", "'!'", "'not'", "'byref'", "'unused'", "'error'",
|
|
"'hash'", "'dictionary'", "'struct'", "'array'", "'stack'", "'in'",
|
|
"'uninit'", "'true'", "'false'", "'is'", "", "", "", "", "", "", "",
|
|
"", "'('", "')'", "'['", "']'", "'{'", "'}'", "'.'", "'->'", "'*'",
|
|
"'/'", "'%'", "'+'", "'-'", "'+='", "'-='", "'*='", "'/='", "'%='",
|
|
"'<='", "'<'", "'>='", "'>'", "'>>'", "'<<'", "'&'", "'^'", "'|'",
|
|
"'<>'", "'!='", "'='", "'=='", "':='", "'.+'", "'.-'", "'.\\u003F'",
|
|
"';'", "','", "'~'", "'@'", "'::'", "':'", "'++'", "'--'", "'\\u003F:'",
|
|
"'\\u003F'", "", "", "", "", "'{{'"
|
|
},
|
|
std::vector<std::string>{
|
|
"", "IF", "THEN", "ELSEIF", "ENDIF", "ELSE", "GOTO", "RETURN", "TOK_CONST",
|
|
"VAR", "DO", "DOWHILE", "WHILE", "ENDWHILE", "EXIT", "FUNCTION", "ENDFUNCTION",
|
|
"EXPORTED", "USE", "INCLUDE", "BREAK", "CONTINUE", "FOR", "ENDFOR",
|
|
"TO", "FOREACH", "ENDFOREACH", "REPEAT", "UNTIL", "PROGRAM", "ENDPROGRAM",
|
|
"CASE", "DEFAULT", "ENDCASE", "ENUM", "ENDENUM", "CLASS", "ENDCLASS",
|
|
"DOWNTO", "STEP", "REFERENCE", "TOK_OUT", "INOUT", "BYVAL", "STRING",
|
|
"TOK_LONG", "INTEGER", "UNSIGNED", "SIGNED", "REAL", "FLOAT", "DOUBLE",
|
|
"AS", "ELLIPSIS", "AND_A", "AND_B", "OR_A", "OR_B", "BANG_A", "BANG_B",
|
|
"BYREF", "UNUSED", "TOK_ERROR", "HASH", "DICTIONARY", "STRUCT", "ARRAY",
|
|
"STACK", "TOK_IN", "UNINIT", "BOOL_TRUE", "BOOL_FALSE", "IS", "DECIMAL_LITERAL",
|
|
"HEX_LITERAL", "OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL",
|
|
"STRING_LITERAL", "INTERPOLATED_STRING_START", "LPAREN", "RPAREN",
|
|
"LBRACK", "RBRACK", "LBRACE", "RBRACE", "DOT", "ARROW", "MUL", "DIV",
|
|
"MOD", "ADD", "SUB", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN",
|
|
"MOD_ASSIGN", "LE", "LT", "GE", "GT", "RSHIFT", "LSHIFT", "BITAND",
|
|
"CARET", "BITOR", "NOTEQUAL_A", "NOTEQUAL_B", "EQUAL_DEPRECATED",
|
|
"EQUAL", "ASSIGN", "ADDMEMBER", "DELMEMBER", "CHKMEMBER", "SEMI",
|
|
"COMMA", "TILDE", "AT", "COLONCOLON", "COLON", "INC", "DEC", "ELVIS",
|
|
"QUESTION", "WS", "COMMENT", "LINE_COMMENT", "IDENTIFIER", "DOUBLE_LBRACE_INSIDE",
|
|
"LBRACE_INSIDE", "REGULAR_CHAR_INSIDE", "DOUBLE_QUOTE_INSIDE", "DOUBLE_RBRACE",
|
|
"STRING_LITERAL_INSIDE", "CLOSE_RBRACE_INSIDE", "FORMAT_STRING"
|
|
}
|
|
);
|
|
static const int32_t serializedATNSegment[] = {
|
|
4,1,137,987,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,
|
|
7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7,
|
|
14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,7,
|
|
21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,7,
|
|
28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,7,
|
|
35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,7,
|
|
42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,
|
|
49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,
|
|
56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,
|
|
63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,
|
|
70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,
|
|
77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,
|
|
84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
|
|
91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,1,0,5,0,194,8,0,10,0,12,0,
|
|
197,9,0,1,0,1,0,1,1,5,1,202,8,1,10,1,12,1,205,9,1,1,1,1,1,1,2,1,2,1,2,
|
|
1,3,1,3,3,3,214,8,3,1,4,1,4,1,4,3,4,219,8,4,1,4,1,4,1,4,1,5,1,5,1,5,5,
|
|
5,227,8,5,10,5,12,5,230,9,5,1,6,1,6,1,6,3,6,235,8,6,1,7,1,7,1,7,1,7,1,
|
|
7,1,7,3,7,243,8,7,1,8,1,8,1,8,1,8,1,8,1,8,1,9,1,9,3,9,253,8,9,1,9,1,9,
|
|
1,10,1,10,1,10,5,10,260,8,10,10,10,12,10,263,9,10,1,11,5,11,266,8,11,
|
|
10,11,12,11,269,9,11,1,12,1,12,3,12,273,8,12,1,13,3,13,276,8,13,1,13,
|
|
1,13,1,13,1,13,1,13,1,13,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16,1,16,
|
|
1,16,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,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,319,
|
|
8,18,1,19,1,19,1,19,1,20,1,20,1,20,3,20,327,8,20,1,20,1,20,1,20,1,20,
|
|
1,20,5,20,334,8,20,10,20,12,20,337,9,20,1,20,1,20,3,20,341,8,20,1,20,
|
|
1,20,1,21,1,21,1,21,1,21,1,22,1,22,3,22,351,8,22,1,22,1,22,1,23,1,23,
|
|
1,23,1,23,1,24,1,24,1,24,1,24,1,25,3,25,364,8,25,1,25,1,25,1,25,1,25,
|
|
1,25,1,25,1,26,3,26,373,8,26,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,
|
|
1,28,1,28,3,28,385,8,28,1,28,1,28,1,29,1,29,3,29,391,8,29,1,29,1,29,1,
|
|
30,3,30,396,8,30,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,
|
|
31,3,31,409,8,31,1,32,3,32,412,8,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
|
|
1,33,3,33,422,8,33,1,33,1,33,1,33,1,33,1,33,1,33,1,34,3,34,431,8,34,1,
|
|
34,1,34,1,34,1,34,1,34,4,34,438,8,34,11,34,12,34,439,1,34,1,34,1,35,1,
|
|
35,1,35,1,35,1,35,1,36,5,36,450,8,36,10,36,12,36,453,9,36,1,37,1,37,1,
|
|
37,1,37,1,37,1,37,1,37,3,37,462,8,37,1,38,1,38,1,38,5,38,467,8,38,10,
|
|
38,12,38,470,9,38,1,38,3,38,473,8,38,1,39,1,39,1,39,3,39,478,8,39,1,40,
|
|
4,40,481,8,40,11,40,12,40,482,1,40,1,40,1,41,1,41,1,41,1,41,1,41,3,41,
|
|
492,8,41,1,41,1,41,1,41,3,41,497,8,41,1,42,1,42,3,42,501,8,42,1,43,1,
|
|
43,1,43,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,
|
|
44,1,45,1,45,1,45,3,45,522,8,45,1,46,1,46,1,46,5,46,527,8,46,10,46,12,
|
|
46,530,9,46,1,47,1,47,1,47,1,48,1,48,3,48,537,8,48,1,48,1,48,1,48,3,48,
|
|
542,8,48,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,49,552,8,49,1,50,1,
|
|
50,1,50,5,50,557,8,50,10,50,12,50,560,9,50,1,51,1,51,1,51,5,51,565,8,
|
|
51,10,51,12,51,568,9,51,1,52,1,52,3,52,572,8,52,1,52,3,52,575,8,52,1,
|
|
53,1,53,3,53,579,8,53,1,53,1,53,3,53,583,8,53,1,53,1,53,1,53,1,53,1,53,
|
|
3,53,590,8,53,1,54,1,54,1,54,1,54,3,54,596,8,54,1,55,1,55,1,55,1,55,1,
|
|
55,1,55,3,55,604,8,55,1,56,1,56,3,56,608,8,56,1,56,1,56,1,57,1,57,3,57,
|
|
614,8,57,1,57,5,57,617,8,57,10,57,12,57,620,9,57,1,58,1,58,1,58,1,58,
|
|
1,58,3,58,627,8,58,3,58,629,8,58,1,59,1,59,3,59,633,8,59,1,59,1,59,1,
|
|
60,1,60,1,60,5,60,640,8,60,10,60,12,60,643,9,60,1,61,3,61,646,8,61,1,
|
|
61,3,61,649,8,61,1,61,1,61,3,61,653,8,61,1,61,1,61,3,61,657,8,61,1,62,
|
|
3,62,660,8,62,1,62,1,62,1,62,1,63,1,63,3,63,667,8,63,1,63,3,63,670,8,
|
|
63,1,63,1,63,1,64,1,64,1,64,1,64,1,64,1,64,3,64,680,8,64,1,64,1,64,1,
|
|
64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,
|
|
64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,
|
|
64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,
|
|
64,1,64,1,64,5,64,729,8,64,10,64,12,64,732,9,64,1,65,1,65,1,65,1,65,1,
|
|
65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,748,8,65,1,66,3,
|
|
66,751,8,66,1,66,1,66,1,66,1,67,1,67,3,67,758,8,67,1,67,1,67,1,67,1,67,
|
|
1,68,1,68,3,68,766,8,68,1,69,1,69,3,69,770,8,69,1,70,1,70,3,70,774,8,
|
|
70,1,71,1,71,3,71,778,8,71,1,72,1,72,3,72,782,8,72,1,72,1,72,1,72,3,72,
|
|
787,8,72,1,72,1,72,1,72,3,72,792,8,72,1,73,1,73,1,73,1,73,1,74,1,74,1,
|
|
74,5,74,801,8,74,10,74,12,74,804,9,74,1,75,1,75,3,75,808,8,75,1,76,1,
|
|
76,1,76,1,76,3,76,814,8,76,1,77,1,77,1,77,1,77,1,78,1,78,1,78,5,78,823,
|
|
8,78,10,78,12,78,826,9,78,1,79,1,79,1,79,1,80,1,80,1,80,1,80,3,80,835,
|
|
8,80,1,80,1,80,1,81,1,81,3,81,841,8,81,1,81,1,81,1,82,1,82,1,82,3,82,
|
|
848,8,82,1,82,1,82,1,83,1,83,1,83,3,83,855,8,83,1,83,1,83,1,83,3,83,860,
|
|
8,83,1,83,1,83,1,83,3,83,865,8,83,1,84,1,84,1,84,5,84,870,8,84,10,84,
|
|
12,84,873,9,84,1,85,1,85,3,85,877,8,85,1,85,1,85,1,85,3,85,882,8,85,1,
|
|
85,1,85,1,85,3,85,887,8,85,1,86,1,86,1,86,3,86,892,8,86,1,86,1,86,1,86,
|
|
3,86,897,8,86,1,87,1,87,1,87,5,87,902,8,87,10,87,12,87,905,9,87,1,88,
|
|
1,88,3,88,909,8,88,1,88,1,88,1,88,3,88,914,8,88,1,88,1,88,1,88,3,88,919,
|
|
8,88,1,89,1,89,3,89,923,8,89,1,89,1,89,1,89,3,89,928,8,89,1,89,1,89,1,
|
|
89,1,89,1,89,3,89,935,8,89,1,89,1,89,1,89,3,89,940,8,89,1,89,1,89,1,89,
|
|
3,89,945,8,89,1,90,1,90,1,90,1,90,1,90,3,90,952,8,90,1,91,1,91,5,91,956,
|
|
8,91,10,91,12,91,959,9,91,1,91,1,91,1,92,1,92,1,92,1,92,3,92,967,8,92,
|
|
1,92,1,92,1,92,3,92,972,8,92,1,92,1,92,1,92,1,92,1,92,3,92,979,8,92,1,
|
|
93,1,93,1,94,1,94,1,95,1,95,1,95,0,1,128,96,0,2,4,6,8,10,12,14,16,18,
|
|
20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,
|
|
66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,
|
|
110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,
|
|
146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,
|
|
182,184,186,188,190,0,16,2,0,79,79,129,129,2,0,92,93,122,123,2,0,58,59,
|
|
118,118,2,0,89,91,103,105,2,0,92,93,106,107,1,0,99,102,2,0,108,109,111,
|
|
111,1,0,54,55,1,0,56,57,1,0,113,115,2,0,94,98,112,112,1,0,122,123,3,0,
|
|
15,15,79,79,129,129,1,0,73,76,1,0,77,78,1,0,70,71,1064,0,195,1,0,0,0,
|
|
2,203,1,0,0,0,4,208,1,0,0,0,6,213,1,0,0,0,8,215,1,0,0,0,10,223,1,0,0,
|
|
0,12,231,1,0,0,0,14,242,1,0,0,0,16,244,1,0,0,0,18,250,1,0,0,0,20,256,
|
|
1,0,0,0,22,267,1,0,0,0,24,272,1,0,0,0,26,275,1,0,0,0,28,283,1,0,0,0,30,
|
|
285,1,0,0,0,32,289,1,0,0,0,34,293,1,0,0,0,36,318,1,0,0,0,38,320,1,0,0,
|
|
0,40,323,1,0,0,0,42,344,1,0,0,0,44,348,1,0,0,0,46,354,1,0,0,0,48,358,
|
|
1,0,0,0,50,363,1,0,0,0,52,372,1,0,0,0,54,379,1,0,0,0,56,382,1,0,0,0,58,
|
|
388,1,0,0,0,60,395,1,0,0,0,62,408,1,0,0,0,64,411,1,0,0,0,66,421,1,0,0,
|
|
0,68,430,1,0,0,0,70,443,1,0,0,0,72,451,1,0,0,0,74,461,1,0,0,0,76,463,
|
|
1,0,0,0,78,474,1,0,0,0,80,480,1,0,0,0,82,496,1,0,0,0,84,500,1,0,0,0,86,
|
|
502,1,0,0,0,88,509,1,0,0,0,90,518,1,0,0,0,92,523,1,0,0,0,94,531,1,0,0,
|
|
0,96,541,1,0,0,0,98,551,1,0,0,0,100,553,1,0,0,0,102,561,1,0,0,0,104,574,
|
|
1,0,0,0,106,589,1,0,0,0,108,595,1,0,0,0,110,603,1,0,0,0,112,605,1,0,0,
|
|
0,114,611,1,0,0,0,116,628,1,0,0,0,118,630,1,0,0,0,120,636,1,0,0,0,122,
|
|
645,1,0,0,0,124,659,1,0,0,0,126,664,1,0,0,0,128,679,1,0,0,0,130,747,1,
|
|
0,0,0,132,750,1,0,0,0,134,755,1,0,0,0,136,763,1,0,0,0,138,767,1,0,0,0,
|
|
140,771,1,0,0,0,142,775,1,0,0,0,144,791,1,0,0,0,146,793,1,0,0,0,148,797,
|
|
1,0,0,0,150,805,1,0,0,0,152,813,1,0,0,0,154,815,1,0,0,0,156,819,1,0,0,
|
|
0,158,827,1,0,0,0,160,830,1,0,0,0,162,838,1,0,0,0,164,844,1,0,0,0,166,
|
|
864,1,0,0,0,168,866,1,0,0,0,170,886,1,0,0,0,172,896,1,0,0,0,174,898,1,
|
|
0,0,0,176,918,1,0,0,0,178,944,1,0,0,0,180,951,1,0,0,0,182,953,1,0,0,0,
|
|
184,978,1,0,0,0,186,980,1,0,0,0,188,982,1,0,0,0,190,984,1,0,0,0,192,194,
|
|
3,14,7,0,193,192,1,0,0,0,194,197,1,0,0,0,195,193,1,0,0,0,195,196,1,0,
|
|
0,0,196,198,1,0,0,0,197,195,1,0,0,0,198,199,5,0,0,1,199,1,1,0,0,0,200,
|
|
202,3,6,3,0,201,200,1,0,0,0,202,205,1,0,0,0,203,201,1,0,0,0,203,204,1,
|
|
0,0,0,204,206,1,0,0,0,205,203,1,0,0,0,206,207,5,0,0,1,207,3,1,0,0,0,208,
|
|
209,3,128,64,0,209,210,5,0,0,1,210,5,1,0,0,0,211,214,3,8,4,0,212,214,
|
|
3,46,23,0,213,211,1,0,0,0,213,212,1,0,0,0,214,7,1,0,0,0,215,216,5,129,
|
|
0,0,216,218,5,81,0,0,217,219,3,10,5,0,218,217,1,0,0,0,218,219,1,0,0,0,
|
|
219,220,1,0,0,0,220,221,5,82,0,0,221,222,5,116,0,0,222,9,1,0,0,0,223,
|
|
228,3,12,6,0,224,225,5,117,0,0,225,227,3,12,6,0,226,224,1,0,0,0,227,230,
|
|
1,0,0,0,228,226,1,0,0,0,228,229,1,0,0,0,229,11,1,0,0,0,230,228,1,0,0,
|
|
0,231,234,5,129,0,0,232,233,5,112,0,0,233,235,3,128,64,0,234,232,1,0,
|
|
0,0,234,235,1,0,0,0,235,13,1,0,0,0,236,243,3,30,15,0,237,243,3,32,16,
|
|
0,238,243,3,34,17,0,239,243,3,26,13,0,240,243,3,16,8,0,241,243,3,36,18,
|
|
0,242,236,1,0,0,0,242,237,1,0,0,0,242,238,1,0,0,0,242,239,1,0,0,0,242,
|
|
240,1,0,0,0,242,241,1,0,0,0,243,15,1,0,0,0,244,245,5,36,0,0,245,246,5,
|
|
129,0,0,246,247,3,18,9,0,247,248,3,22,11,0,248,249,5,37,0,0,249,17,1,
|
|
0,0,0,250,252,5,81,0,0,251,253,3,20,10,0,252,251,1,0,0,0,252,253,1,0,
|
|
0,0,253,254,1,0,0,0,254,255,5,82,0,0,255,19,1,0,0,0,256,261,5,129,0,0,
|
|
257,258,5,117,0,0,258,260,5,129,0,0,259,257,1,0,0,0,260,263,1,0,0,0,261,
|
|
259,1,0,0,0,261,262,1,0,0,0,262,21,1,0,0,0,263,261,1,0,0,0,264,266,3,
|
|
24,12,0,265,264,1,0,0,0,266,269,1,0,0,0,267,265,1,0,0,0,267,268,1,0,0,
|
|
0,268,23,1,0,0,0,269,267,1,0,0,0,270,273,3,26,13,0,271,273,3,48,24,0,
|
|
272,270,1,0,0,0,272,271,1,0,0,0,273,25,1,0,0,0,274,276,5,17,0,0,275,274,
|
|
1,0,0,0,275,276,1,0,0,0,276,277,1,0,0,0,277,278,5,15,0,0,278,279,5,129,
|
|
0,0,279,280,3,118,59,0,280,281,3,72,36,0,281,282,5,16,0,0,282,27,1,0,
|
|
0,0,283,284,7,0,0,0,284,29,1,0,0,0,285,286,5,18,0,0,286,287,3,28,14,0,
|
|
287,288,5,116,0,0,288,31,1,0,0,0,289,290,5,19,0,0,290,291,3,28,14,0,291,
|
|
292,5,116,0,0,292,33,1,0,0,0,293,294,5,29,0,0,294,295,5,129,0,0,295,296,
|
|
3,112,56,0,296,297,3,72,36,0,297,298,5,30,0,0,298,35,1,0,0,0,299,319,
|
|
3,40,20,0,300,319,3,42,21,0,301,319,3,44,22,0,302,319,3,46,23,0,303,319,
|
|
3,48,24,0,304,319,3,50,25,0,305,319,3,52,26,0,306,319,3,54,27,0,307,319,
|
|
3,56,28,0,308,319,3,58,29,0,309,319,3,60,30,0,310,319,3,64,32,0,311,319,
|
|
3,66,33,0,312,319,3,68,34,0,313,319,3,70,35,0,314,319,5,116,0,0,315,316,
|
|
3,128,64,0,316,317,5,116,0,0,317,319,1,0,0,0,318,299,1,0,0,0,318,300,
|
|
1,0,0,0,318,301,1,0,0,0,318,302,1,0,0,0,318,303,1,0,0,0,318,304,1,0,0,
|
|
0,318,305,1,0,0,0,318,306,1,0,0,0,318,307,1,0,0,0,318,308,1,0,0,0,318,
|
|
309,1,0,0,0,318,310,1,0,0,0,318,311,1,0,0,0,318,312,1,0,0,0,318,313,1,
|
|
0,0,0,318,314,1,0,0,0,318,315,1,0,0,0,319,37,1,0,0,0,320,321,5,129,0,
|
|
0,321,322,5,121,0,0,322,39,1,0,0,0,323,324,5,1,0,0,324,326,3,146,73,0,
|
|
325,327,5,2,0,0,326,325,1,0,0,0,326,327,1,0,0,0,327,328,1,0,0,0,328,335,
|
|
3,72,36,0,329,330,5,3,0,0,330,331,3,146,73,0,331,332,3,72,36,0,332,334,
|
|
1,0,0,0,333,329,1,0,0,0,334,337,1,0,0,0,335,333,1,0,0,0,335,336,1,0,0,
|
|
0,336,340,1,0,0,0,337,335,1,0,0,0,338,339,5,5,0,0,339,341,3,72,36,0,340,
|
|
338,1,0,0,0,340,341,1,0,0,0,341,342,1,0,0,0,342,343,5,4,0,0,343,41,1,
|
|
0,0,0,344,345,5,6,0,0,345,346,5,129,0,0,346,347,5,116,0,0,347,43,1,0,
|
|
0,0,348,350,5,7,0,0,349,351,3,128,64,0,350,349,1,0,0,0,350,351,1,0,0,
|
|
0,351,352,1,0,0,0,352,353,5,116,0,0,353,45,1,0,0,0,354,355,5,8,0,0,355,
|
|
356,3,94,47,0,356,357,5,116,0,0,357,47,1,0,0,0,358,359,5,9,0,0,359,360,
|
|
3,92,46,0,360,361,5,116,0,0,361,49,1,0,0,0,362,364,3,38,19,0,363,362,
|
|
1,0,0,0,363,364,1,0,0,0,364,365,1,0,0,0,365,366,5,10,0,0,366,367,3,72,
|
|
36,0,367,368,5,11,0,0,368,369,3,146,73,0,369,370,5,116,0,0,370,51,1,0,
|
|
0,0,371,373,3,38,19,0,372,371,1,0,0,0,372,373,1,0,0,0,373,374,1,0,0,0,
|
|
374,375,5,12,0,0,375,376,3,146,73,0,376,377,3,72,36,0,377,378,5,13,0,
|
|
0,378,53,1,0,0,0,379,380,5,14,0,0,380,381,5,116,0,0,381,55,1,0,0,0,382,
|
|
384,5,20,0,0,383,385,5,129,0,0,384,383,1,0,0,0,384,385,1,0,0,0,385,386,
|
|
1,0,0,0,386,387,5,116,0,0,387,57,1,0,0,0,388,390,5,21,0,0,389,391,5,129,
|
|
0,0,390,389,1,0,0,0,390,391,1,0,0,0,391,392,1,0,0,0,392,393,5,116,0,0,
|
|
393,59,1,0,0,0,394,396,3,38,19,0,395,394,1,0,0,0,395,396,1,0,0,0,396,
|
|
397,1,0,0,0,397,398,5,22,0,0,398,399,3,84,42,0,399,400,5,23,0,0,400,61,
|
|
1,0,0,0,401,409,3,164,82,0,402,409,3,124,62,0,403,409,3,132,66,0,404,
|
|
409,5,129,0,0,405,409,3,146,73,0,406,409,3,144,72,0,407,409,3,136,68,
|
|
0,408,401,1,0,0,0,408,402,1,0,0,0,408,403,1,0,0,0,408,404,1,0,0,0,408,
|
|
405,1,0,0,0,408,406,1,0,0,0,408,407,1,0,0,0,409,63,1,0,0,0,410,412,3,
|
|
38,19,0,411,410,1,0,0,0,411,412,1,0,0,0,412,413,1,0,0,0,413,414,5,25,
|
|
0,0,414,415,5,129,0,0,415,416,5,68,0,0,416,417,3,62,31,0,417,418,3,72,
|
|
36,0,418,419,5,26,0,0,419,65,1,0,0,0,420,422,3,38,19,0,421,420,1,0,0,
|
|
0,421,422,1,0,0,0,422,423,1,0,0,0,423,424,5,27,0,0,424,425,3,72,36,0,
|
|
425,426,5,28,0,0,426,427,3,128,64,0,427,428,5,116,0,0,428,67,1,0,0,0,
|
|
429,431,3,38,19,0,430,429,1,0,0,0,430,431,1,0,0,0,431,432,1,0,0,0,432,
|
|
433,5,31,0,0,433,434,5,81,0,0,434,435,3,128,64,0,435,437,5,82,0,0,436,
|
|
438,3,80,40,0,437,436,1,0,0,0,438,439,1,0,0,0,439,437,1,0,0,0,439,440,
|
|
1,0,0,0,440,441,1,0,0,0,441,442,5,33,0,0,442,69,1,0,0,0,443,444,5,34,
|
|
0,0,444,445,5,129,0,0,445,446,3,76,38,0,446,447,5,35,0,0,447,71,1,0,0,
|
|
0,448,450,3,36,18,0,449,448,1,0,0,0,450,453,1,0,0,0,451,449,1,0,0,0,451,
|
|
452,1,0,0,0,452,73,1,0,0,0,453,451,1,0,0,0,454,455,5,112,0,0,455,462,
|
|
3,128,64,0,456,457,5,110,0,0,457,458,3,128,64,0,458,459,6,37,-1,0,459,
|
|
462,1,0,0,0,460,462,5,66,0,0,461,454,1,0,0,0,461,456,1,0,0,0,461,460,
|
|
1,0,0,0,462,75,1,0,0,0,463,468,3,78,39,0,464,465,5,117,0,0,465,467,3,
|
|
78,39,0,466,464,1,0,0,0,467,470,1,0,0,0,468,466,1,0,0,0,468,469,1,0,0,
|
|
0,469,472,1,0,0,0,470,468,1,0,0,0,471,473,5,117,0,0,472,471,1,0,0,0,472,
|
|
473,1,0,0,0,473,77,1,0,0,0,474,477,5,129,0,0,475,476,5,112,0,0,476,478,
|
|
3,128,64,0,477,475,1,0,0,0,477,478,1,0,0,0,478,79,1,0,0,0,479,481,3,82,
|
|
41,0,480,479,1,0,0,0,481,482,1,0,0,0,482,480,1,0,0,0,482,483,1,0,0,0,
|
|
483,484,1,0,0,0,484,485,3,72,36,0,485,81,1,0,0,0,486,492,3,186,93,0,487,
|
|
492,3,190,95,0,488,492,5,69,0,0,489,492,5,129,0,0,490,492,5,79,0,0,491,
|
|
486,1,0,0,0,491,487,1,0,0,0,491,488,1,0,0,0,491,489,1,0,0,0,491,490,1,
|
|
0,0,0,492,493,1,0,0,0,493,497,5,121,0,0,494,495,5,32,0,0,495,497,5,121,
|
|
0,0,496,491,1,0,0,0,496,494,1,0,0,0,497,83,1,0,0,0,498,501,3,88,44,0,
|
|
499,501,3,86,43,0,500,498,1,0,0,0,500,499,1,0,0,0,501,85,1,0,0,0,502,
|
|
503,5,129,0,0,503,504,5,112,0,0,504,505,3,128,64,0,505,506,5,24,0,0,506,
|
|
507,3,128,64,0,507,508,3,72,36,0,508,87,1,0,0,0,509,510,5,81,0,0,510,
|
|
511,3,128,64,0,511,512,5,116,0,0,512,513,3,128,64,0,513,514,5,116,0,0,
|
|
514,515,3,128,64,0,515,516,5,82,0,0,516,517,3,72,36,0,517,89,1,0,0,0,
|
|
518,521,5,129,0,0,519,520,5,117,0,0,520,522,3,90,45,0,521,519,1,0,0,0,
|
|
521,522,1,0,0,0,522,91,1,0,0,0,523,528,3,96,48,0,524,525,5,117,0,0,525,
|
|
527,3,96,48,0,526,524,1,0,0,0,527,530,1,0,0,0,528,526,1,0,0,0,528,529,
|
|
1,0,0,0,529,93,1,0,0,0,530,528,1,0,0,0,531,532,5,129,0,0,532,533,3,74,
|
|
37,0,533,95,1,0,0,0,534,536,5,129,0,0,535,537,3,74,37,0,536,535,1,0,0,
|
|
0,536,537,1,0,0,0,537,542,1,0,0,0,538,539,3,98,49,0,539,540,3,110,55,
|
|
0,540,542,1,0,0,0,541,534,1,0,0,0,541,538,1,0,0,0,542,97,1,0,0,0,543,
|
|
544,5,83,0,0,544,545,3,102,51,0,545,546,5,84,0,0,546,552,1,0,0,0,547,
|
|
548,5,85,0,0,548,549,3,100,50,0,549,550,5,86,0,0,550,552,1,0,0,0,551,
|
|
543,1,0,0,0,551,547,1,0,0,0,552,99,1,0,0,0,553,558,3,106,53,0,554,555,
|
|
5,117,0,0,555,557,3,106,53,0,556,554,1,0,0,0,557,560,1,0,0,0,558,556,
|
|
1,0,0,0,558,559,1,0,0,0,559,101,1,0,0,0,560,558,1,0,0,0,561,566,3,104,
|
|
52,0,562,563,5,117,0,0,563,565,3,104,52,0,564,562,1,0,0,0,565,568,1,0,
|
|
0,0,566,564,1,0,0,0,566,567,1,0,0,0,567,103,1,0,0,0,568,566,1,0,0,0,569,
|
|
571,5,129,0,0,570,572,5,53,0,0,571,570,1,0,0,0,571,572,1,0,0,0,572,575,
|
|
1,0,0,0,573,575,3,98,49,0,574,569,1,0,0,0,574,573,1,0,0,0,575,105,1,0,
|
|
0,0,576,578,5,129,0,0,577,579,5,53,0,0,578,577,1,0,0,0,578,579,1,0,0,
|
|
0,579,590,1,0,0,0,580,582,5,129,0,0,581,583,3,108,54,0,582,581,1,0,0,
|
|
0,582,583,1,0,0,0,583,590,1,0,0,0,584,585,5,83,0,0,585,586,3,128,64,0,
|
|
586,587,5,84,0,0,587,588,3,108,54,0,588,590,1,0,0,0,589,576,1,0,0,0,589,
|
|
580,1,0,0,0,589,584,1,0,0,0,590,107,1,0,0,0,591,592,5,121,0,0,592,596,
|
|
5,129,0,0,593,594,5,121,0,0,594,596,3,98,49,0,595,591,1,0,0,0,595,593,
|
|
1,0,0,0,596,109,1,0,0,0,597,598,5,112,0,0,598,604,3,128,64,0,599,600,
|
|
5,110,0,0,600,601,3,128,64,0,601,602,6,55,-1,0,602,604,1,0,0,0,603,597,
|
|
1,0,0,0,603,599,1,0,0,0,604,111,1,0,0,0,605,607,5,81,0,0,606,608,3,114,
|
|
57,0,607,606,1,0,0,0,607,608,1,0,0,0,608,609,1,0,0,0,609,610,5,82,0,0,
|
|
610,113,1,0,0,0,611,618,3,116,58,0,612,614,5,117,0,0,613,612,1,0,0,0,
|
|
613,614,1,0,0,0,614,615,1,0,0,0,615,617,3,116,58,0,616,613,1,0,0,0,617,
|
|
620,1,0,0,0,618,616,1,0,0,0,618,619,1,0,0,0,619,115,1,0,0,0,620,618,1,
|
|
0,0,0,621,622,5,61,0,0,622,629,5,129,0,0,623,626,5,129,0,0,624,625,5,
|
|
112,0,0,625,627,3,128,64,0,626,624,1,0,0,0,626,627,1,0,0,0,627,629,1,
|
|
0,0,0,628,621,1,0,0,0,628,623,1,0,0,0,629,117,1,0,0,0,630,632,5,81,0,
|
|
0,631,633,3,120,60,0,632,631,1,0,0,0,632,633,1,0,0,0,633,634,1,0,0,0,
|
|
634,635,5,82,0,0,635,119,1,0,0,0,636,641,3,122,61,0,637,638,5,117,0,0,
|
|
638,640,3,122,61,0,639,637,1,0,0,0,640,643,1,0,0,0,641,639,1,0,0,0,641,
|
|
642,1,0,0,0,642,121,1,0,0,0,643,641,1,0,0,0,644,646,5,60,0,0,645,644,
|
|
1,0,0,0,645,646,1,0,0,0,646,648,1,0,0,0,647,649,5,61,0,0,648,647,1,0,
|
|
0,0,648,649,1,0,0,0,649,650,1,0,0,0,650,652,5,129,0,0,651,653,5,53,0,
|
|
0,652,651,1,0,0,0,652,653,1,0,0,0,653,656,1,0,0,0,654,655,5,112,0,0,655,
|
|
657,3,128,64,0,656,654,1,0,0,0,656,657,1,0,0,0,657,123,1,0,0,0,658,660,
|
|
5,129,0,0,659,658,1,0,0,0,659,660,1,0,0,0,660,661,1,0,0,0,661,662,5,120,
|
|
0,0,662,663,3,164,82,0,663,125,1,0,0,0,664,669,5,119,0,0,665,667,5,129,
|
|
0,0,666,665,1,0,0,0,666,667,1,0,0,0,667,668,1,0,0,0,668,670,5,120,0,0,
|
|
669,666,1,0,0,0,669,670,1,0,0,0,670,671,1,0,0,0,671,672,5,129,0,0,672,
|
|
127,1,0,0,0,673,674,6,64,-1,0,674,680,3,130,65,0,675,676,7,1,0,0,676,
|
|
680,3,128,64,15,677,678,7,2,0,0,678,680,3,128,64,14,679,673,1,0,0,0,679,
|
|
675,1,0,0,0,679,677,1,0,0,0,680,730,1,0,0,0,681,682,10,13,0,0,682,683,
|
|
7,3,0,0,683,729,3,128,64,14,684,685,10,12,0,0,685,686,7,4,0,0,686,729,
|
|
3,128,64,13,687,688,10,11,0,0,688,689,5,124,0,0,689,729,3,128,64,12,690,
|
|
691,10,10,0,0,691,692,5,68,0,0,692,729,3,128,64,11,693,694,10,9,0,0,694,
|
|
695,7,5,0,0,695,729,3,128,64,10,696,697,10,8,0,0,697,698,5,72,0,0,698,
|
|
729,3,128,64,9,699,700,10,7,0,0,700,701,5,110,0,0,701,702,6,64,-1,0,702,
|
|
729,3,128,64,8,703,704,10,6,0,0,704,705,7,6,0,0,705,729,3,128,64,7,706,
|
|
707,10,5,0,0,707,708,7,7,0,0,708,729,3,128,64,6,709,710,10,4,0,0,710,
|
|
711,7,8,0,0,711,729,3,128,64,5,712,713,10,3,0,0,713,714,5,125,0,0,714,
|
|
715,3,128,64,0,715,716,5,121,0,0,716,717,3,128,64,4,717,729,1,0,0,0,718,
|
|
719,10,2,0,0,719,720,7,9,0,0,720,729,3,128,64,2,721,722,10,1,0,0,722,
|
|
723,7,10,0,0,723,729,3,128,64,1,724,725,10,17,0,0,725,729,3,152,76,0,
|
|
726,727,10,16,0,0,727,729,7,11,0,0,728,681,1,0,0,0,728,684,1,0,0,0,728,
|
|
687,1,0,0,0,728,690,1,0,0,0,728,693,1,0,0,0,728,696,1,0,0,0,728,699,1,
|
|
0,0,0,728,703,1,0,0,0,728,706,1,0,0,0,728,709,1,0,0,0,728,712,1,0,0,0,
|
|
728,718,1,0,0,0,728,721,1,0,0,0,728,724,1,0,0,0,728,726,1,0,0,0,729,732,
|
|
1,0,0,0,730,728,1,0,0,0,730,731,1,0,0,0,731,129,1,0,0,0,732,730,1,0,0,
|
|
0,733,748,3,180,90,0,734,748,3,146,73,0,735,748,3,164,82,0,736,748,3,
|
|
124,62,0,737,748,3,132,66,0,738,748,5,129,0,0,739,748,3,126,63,0,740,
|
|
748,3,134,67,0,741,748,3,136,68,0,742,748,3,138,69,0,743,748,3,140,70,
|
|
0,744,748,3,142,71,0,745,748,3,144,72,0,746,748,3,182,91,0,747,733,1,
|
|
0,0,0,747,734,1,0,0,0,747,735,1,0,0,0,747,736,1,0,0,0,747,737,1,0,0,0,
|
|
747,738,1,0,0,0,747,739,1,0,0,0,747,740,1,0,0,0,747,741,1,0,0,0,747,742,
|
|
1,0,0,0,747,743,1,0,0,0,747,744,1,0,0,0,747,745,1,0,0,0,747,746,1,0,0,
|
|
0,748,131,1,0,0,0,749,751,5,129,0,0,750,749,1,0,0,0,750,751,1,0,0,0,751,
|
|
752,1,0,0,0,752,753,5,120,0,0,753,754,5,129,0,0,754,133,1,0,0,0,755,757,
|
|
5,119,0,0,756,758,3,118,59,0,757,756,1,0,0,0,757,758,1,0,0,0,758,759,
|
|
1,0,0,0,759,760,5,85,0,0,760,761,3,72,36,0,761,762,5,86,0,0,762,135,1,
|
|
0,0,0,763,765,5,66,0,0,764,766,3,178,89,0,765,764,1,0,0,0,765,766,1,0,
|
|
0,0,766,137,1,0,0,0,767,769,5,65,0,0,768,770,3,170,85,0,769,768,1,0,0,
|
|
0,769,770,1,0,0,0,770,139,1,0,0,0,771,773,5,64,0,0,772,774,3,176,88,0,
|
|
773,772,1,0,0,0,773,774,1,0,0,0,774,141,1,0,0,0,775,777,5,62,0,0,776,
|
|
778,3,170,85,0,777,776,1,0,0,0,777,778,1,0,0,0,778,143,1,0,0,0,779,781,
|
|
5,85,0,0,780,782,3,148,74,0,781,780,1,0,0,0,781,782,1,0,0,0,782,783,1,
|
|
0,0,0,783,792,5,86,0,0,784,786,5,85,0,0,785,787,3,148,74,0,786,785,1,
|
|
0,0,0,786,787,1,0,0,0,787,788,1,0,0,0,788,789,5,117,0,0,789,790,5,86,
|
|
0,0,790,792,6,72,-1,0,791,779,1,0,0,0,791,784,1,0,0,0,792,145,1,0,0,0,
|
|
793,794,5,81,0,0,794,795,3,128,64,0,795,796,5,82,0,0,796,147,1,0,0,0,
|
|
797,802,3,150,75,0,798,799,5,117,0,0,799,801,3,150,75,0,800,798,1,0,0,
|
|
0,801,804,1,0,0,0,802,800,1,0,0,0,802,803,1,0,0,0,803,149,1,0,0,0,804,
|
|
802,1,0,0,0,805,807,3,128,64,0,806,808,5,53,0,0,807,806,1,0,0,0,807,808,
|
|
1,0,0,0,808,151,1,0,0,0,809,814,3,154,77,0,810,814,3,160,80,0,811,814,
|
|
3,158,79,0,812,814,3,162,81,0,813,809,1,0,0,0,813,810,1,0,0,0,813,811,
|
|
1,0,0,0,813,812,1,0,0,0,814,153,1,0,0,0,815,816,5,83,0,0,816,817,3,156,
|
|
78,0,817,818,5,84,0,0,818,155,1,0,0,0,819,824,3,128,64,0,820,821,5,117,
|
|
0,0,821,823,3,128,64,0,822,820,1,0,0,0,823,826,1,0,0,0,824,822,1,0,0,
|
|
0,824,825,1,0,0,0,825,157,1,0,0,0,826,824,1,0,0,0,827,828,5,87,0,0,828,
|
|
829,7,12,0,0,829,159,1,0,0,0,830,831,5,87,0,0,831,832,5,129,0,0,832,834,
|
|
5,81,0,0,833,835,3,148,74,0,834,833,1,0,0,0,834,835,1,0,0,0,835,836,1,
|
|
0,0,0,836,837,5,82,0,0,837,161,1,0,0,0,838,840,5,81,0,0,839,841,3,148,
|
|
74,0,840,839,1,0,0,0,840,841,1,0,0,0,841,842,1,0,0,0,842,843,5,82,0,0,
|
|
843,163,1,0,0,0,844,845,5,129,0,0,845,847,5,81,0,0,846,848,3,148,74,0,
|
|
847,846,1,0,0,0,847,848,1,0,0,0,848,849,1,0,0,0,849,850,5,82,0,0,850,
|
|
165,1,0,0,0,851,854,5,129,0,0,852,853,5,112,0,0,853,855,3,128,64,0,854,
|
|
852,1,0,0,0,854,855,1,0,0,0,855,865,1,0,0,0,856,859,5,79,0,0,857,858,
|
|
5,112,0,0,858,860,3,128,64,0,859,857,1,0,0,0,859,860,1,0,0,0,860,865,
|
|
1,0,0,0,861,862,3,128,64,0,862,863,5,53,0,0,863,865,1,0,0,0,864,851,1,
|
|
0,0,0,864,856,1,0,0,0,864,861,1,0,0,0,865,167,1,0,0,0,866,871,3,166,83,
|
|
0,867,868,5,117,0,0,868,870,3,166,83,0,869,867,1,0,0,0,870,873,1,0,0,
|
|
0,871,869,1,0,0,0,871,872,1,0,0,0,872,169,1,0,0,0,873,871,1,0,0,0,874,
|
|
876,5,85,0,0,875,877,3,168,84,0,876,875,1,0,0,0,876,877,1,0,0,0,877,878,
|
|
1,0,0,0,878,887,5,86,0,0,879,881,5,85,0,0,880,882,3,168,84,0,881,880,
|
|
1,0,0,0,881,882,1,0,0,0,882,883,1,0,0,0,883,884,5,117,0,0,884,885,5,86,
|
|
0,0,885,887,6,85,-1,0,886,874,1,0,0,0,886,879,1,0,0,0,887,171,1,0,0,0,
|
|
888,891,3,128,64,0,889,890,5,88,0,0,890,892,3,128,64,0,891,889,1,0,0,
|
|
0,891,892,1,0,0,0,892,897,1,0,0,0,893,894,3,128,64,0,894,895,5,53,0,0,
|
|
895,897,1,0,0,0,896,888,1,0,0,0,896,893,1,0,0,0,897,173,1,0,0,0,898,903,
|
|
3,172,86,0,899,900,5,117,0,0,900,902,3,172,86,0,901,899,1,0,0,0,902,905,
|
|
1,0,0,0,903,901,1,0,0,0,903,904,1,0,0,0,904,175,1,0,0,0,905,903,1,0,0,
|
|
0,906,908,5,85,0,0,907,909,3,174,87,0,908,907,1,0,0,0,908,909,1,0,0,0,
|
|
909,910,1,0,0,0,910,919,5,86,0,0,911,913,5,85,0,0,912,914,3,174,87,0,
|
|
913,912,1,0,0,0,913,914,1,0,0,0,914,915,1,0,0,0,915,916,5,117,0,0,916,
|
|
917,5,86,0,0,917,919,6,88,-1,0,918,906,1,0,0,0,918,911,1,0,0,0,919,177,
|
|
1,0,0,0,920,922,5,85,0,0,921,923,3,148,74,0,922,921,1,0,0,0,922,923,1,
|
|
0,0,0,923,924,1,0,0,0,924,945,5,86,0,0,925,927,5,85,0,0,926,928,3,148,
|
|
74,0,927,926,1,0,0,0,927,928,1,0,0,0,928,929,1,0,0,0,929,930,5,117,0,
|
|
0,930,931,5,86,0,0,931,945,6,89,-1,0,932,934,5,81,0,0,933,935,3,148,74,
|
|
0,934,933,1,0,0,0,934,935,1,0,0,0,935,936,1,0,0,0,936,945,5,82,0,0,937,
|
|
939,5,81,0,0,938,940,3,148,74,0,939,938,1,0,0,0,939,940,1,0,0,0,940,941,
|
|
1,0,0,0,941,942,5,117,0,0,942,943,5,82,0,0,943,945,6,89,-1,0,944,920,
|
|
1,0,0,0,944,925,1,0,0,0,944,932,1,0,0,0,944,937,1,0,0,0,945,179,1,0,0,
|
|
0,946,952,3,186,93,0,947,952,3,188,94,0,948,952,3,190,95,0,949,952,5,
|
|
79,0,0,950,952,5,69,0,0,951,946,1,0,0,0,951,947,1,0,0,0,951,948,1,0,0,
|
|
0,951,949,1,0,0,0,951,950,1,0,0,0,952,181,1,0,0,0,953,957,5,80,0,0,954,
|
|
956,3,184,92,0,955,954,1,0,0,0,956,959,1,0,0,0,957,955,1,0,0,0,957,958,
|
|
1,0,0,0,958,960,1,0,0,0,959,957,1,0,0,0,960,961,5,133,0,0,961,183,1,0,
|
|
0,0,962,963,5,131,0,0,963,966,3,128,64,0,964,965,5,121,0,0,965,967,5,
|
|
137,0,0,966,964,1,0,0,0,966,967,1,0,0,0,967,979,1,0,0,0,968,971,5,131,
|
|
0,0,969,970,5,121,0,0,970,972,5,137,0,0,971,969,1,0,0,0,971,972,1,0,0,
|
|
0,972,973,1,0,0,0,973,979,6,92,-1,0,974,979,5,130,0,0,975,979,5,132,0,
|
|
0,976,979,5,134,0,0,977,979,5,135,0,0,978,962,1,0,0,0,978,968,1,0,0,0,
|
|
978,974,1,0,0,0,978,975,1,0,0,0,978,976,1,0,0,0,978,977,1,0,0,0,979,185,
|
|
1,0,0,0,980,981,7,13,0,0,981,187,1,0,0,0,982,983,7,14,0,0,983,189,1,0,
|
|
0,0,984,985,7,15,0,0,985,191,1,0,0,0,107,195,203,213,218,228,234,242,
|
|
252,261,267,272,275,318,326,335,340,350,363,372,384,390,395,408,411,421,
|
|
430,439,451,461,468,472,477,482,491,496,500,521,528,536,541,551,558,566,
|
|
571,574,578,582,589,595,603,607,613,618,626,628,632,641,645,648,652,656,
|
|
659,666,669,679,728,730,747,750,757,765,769,773,777,781,786,791,802,807,
|
|
813,824,834,840,847,854,859,864,871,876,881,886,891,896,903,908,913,918,
|
|
922,927,934,939,944,951,957,966,971,978
|
|
};
|
|
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);
|
|
}
|
|
escriptparserParserStaticData = staticData.release();
|
|
}
|
|
|
|
}
|
|
|
|
EscriptParser::EscriptParser(TokenStream *input) : EscriptParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
|
|
|
|
EscriptParser::EscriptParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
|
|
EscriptParser::initialize();
|
|
_interpreter = new atn::ParserATNSimulator(this, *escriptparserParserStaticData->atn, escriptparserParserStaticData->decisionToDFA, escriptparserParserStaticData->sharedContextCache, options);
|
|
}
|
|
|
|
EscriptParser::~EscriptParser() {
|
|
delete _interpreter;
|
|
}
|
|
|
|
const atn::ATN& EscriptParser::getATN() const {
|
|
return *escriptparserParserStaticData->atn;
|
|
}
|
|
|
|
std::string EscriptParser::getGrammarFileName() const {
|
|
return "EscriptParser.g4";
|
|
}
|
|
|
|
const std::vector<std::string>& EscriptParser::getRuleNames() const {
|
|
return escriptparserParserStaticData->ruleNames;
|
|
}
|
|
|
|
const dfa::Vocabulary& EscriptParser::getVocabulary() const {
|
|
return escriptparserParserStaticData->vocabulary;
|
|
}
|
|
|
|
antlr4::atn::SerializedATNView EscriptParser::getSerializedATN() const {
|
|
return escriptparserParserStaticData->serializedATN;
|
|
}
|
|
|
|
|
|
//----------------- CompilationUnitContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::CompilationUnitContext::CompilationUnitContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CompilationUnitContext::EOF() {
|
|
return getToken(EscriptParser::EOF, 0);
|
|
}
|
|
|
|
std::vector<EscriptParser::TopLevelDeclarationContext *> EscriptParser::CompilationUnitContext::topLevelDeclaration() {
|
|
return getRuleContexts<EscriptParser::TopLevelDeclarationContext>();
|
|
}
|
|
|
|
EscriptParser::TopLevelDeclarationContext* EscriptParser::CompilationUnitContext::topLevelDeclaration(size_t i) {
|
|
return getRuleContext<EscriptParser::TopLevelDeclarationContext>(i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::CompilationUnitContext::getRuleIndex() const {
|
|
return EscriptParser::RuleCompilationUnit;
|
|
}
|
|
|
|
void EscriptParser::CompilationUnitContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterCompilationUnit(this);
|
|
}
|
|
|
|
void EscriptParser::CompilationUnitContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitCompilationUnit(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::CompilationUnitContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitCompilationUnit(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::CompilationUnitContext* EscriptParser::compilationUnit() {
|
|
CompilationUnitContext *_localctx = _tracker.createInstance<CompilationUnitContext>(_ctx, getState());
|
|
enterRule(_localctx, 0, EscriptParser::RuleCompilationUnit);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(195);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 5476377235642308546) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 995295518456544999) != 0) || _la == EscriptParser::IDENTIFIER) {
|
|
setState(192);
|
|
topLevelDeclaration();
|
|
setState(197);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(198);
|
|
match(EscriptParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ModuleUnitContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ModuleUnitContext::ModuleUnitContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleUnitContext::EOF() {
|
|
return getToken(EscriptParser::EOF, 0);
|
|
}
|
|
|
|
std::vector<EscriptParser::ModuleDeclarationStatementContext *> EscriptParser::ModuleUnitContext::moduleDeclarationStatement() {
|
|
return getRuleContexts<EscriptParser::ModuleDeclarationStatementContext>();
|
|
}
|
|
|
|
EscriptParser::ModuleDeclarationStatementContext* EscriptParser::ModuleUnitContext::moduleDeclarationStatement(size_t i) {
|
|
return getRuleContext<EscriptParser::ModuleDeclarationStatementContext>(i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ModuleUnitContext::getRuleIndex() const {
|
|
return EscriptParser::RuleModuleUnit;
|
|
}
|
|
|
|
void EscriptParser::ModuleUnitContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterModuleUnit(this);
|
|
}
|
|
|
|
void EscriptParser::ModuleUnitContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitModuleUnit(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ModuleUnitContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitModuleUnit(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ModuleUnitContext* EscriptParser::moduleUnit() {
|
|
ModuleUnitContext *_localctx = _tracker.createInstance<ModuleUnitContext>(_ctx, getState());
|
|
enterRule(_localctx, 2, EscriptParser::RuleModuleUnit);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(203);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::TOK_CONST || _la == EscriptParser::IDENTIFIER) {
|
|
setState(200);
|
|
moduleDeclarationStatement();
|
|
setState(205);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(206);
|
|
match(EscriptParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EvaluateUnitContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::EvaluateUnitContext::EvaluateUnitContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::EvaluateUnitContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::EvaluateUnitContext::EOF() {
|
|
return getToken(EscriptParser::EOF, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::EvaluateUnitContext::getRuleIndex() const {
|
|
return EscriptParser::RuleEvaluateUnit;
|
|
}
|
|
|
|
void EscriptParser::EvaluateUnitContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterEvaluateUnit(this);
|
|
}
|
|
|
|
void EscriptParser::EvaluateUnitContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitEvaluateUnit(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::EvaluateUnitContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitEvaluateUnit(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::EvaluateUnitContext* EscriptParser::evaluateUnit() {
|
|
EvaluateUnitContext *_localctx = _tracker.createInstance<EvaluateUnitContext>(_ctx, getState());
|
|
enterRule(_localctx, 4, EscriptParser::RuleEvaluateUnit);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(208);
|
|
expression(0);
|
|
setState(209);
|
|
match(EscriptParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ModuleDeclarationStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ModuleDeclarationStatementContext::ModuleDeclarationStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::ModuleFunctionDeclarationContext* EscriptParser::ModuleDeclarationStatementContext::moduleFunctionDeclaration() {
|
|
return getRuleContext<EscriptParser::ModuleFunctionDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::ConstStatementContext* EscriptParser::ModuleDeclarationStatementContext::constStatement() {
|
|
return getRuleContext<EscriptParser::ConstStatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ModuleDeclarationStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleModuleDeclarationStatement;
|
|
}
|
|
|
|
void EscriptParser::ModuleDeclarationStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterModuleDeclarationStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ModuleDeclarationStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitModuleDeclarationStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ModuleDeclarationStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitModuleDeclarationStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ModuleDeclarationStatementContext* EscriptParser::moduleDeclarationStatement() {
|
|
ModuleDeclarationStatementContext *_localctx = _tracker.createInstance<ModuleDeclarationStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 6, EscriptParser::RuleModuleDeclarationStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(213);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(211);
|
|
moduleFunctionDeclaration();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::TOK_CONST: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(212);
|
|
constStatement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ModuleFunctionDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ModuleFunctionDeclarationContext::ModuleFunctionDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleFunctionDeclarationContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleFunctionDeclarationContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleFunctionDeclarationContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleFunctionDeclarationContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
EscriptParser::ModuleFunctionParameterListContext* EscriptParser::ModuleFunctionDeclarationContext::moduleFunctionParameterList() {
|
|
return getRuleContext<EscriptParser::ModuleFunctionParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ModuleFunctionDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleModuleFunctionDeclaration;
|
|
}
|
|
|
|
void EscriptParser::ModuleFunctionDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterModuleFunctionDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::ModuleFunctionDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitModuleFunctionDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ModuleFunctionDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitModuleFunctionDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ModuleFunctionDeclarationContext* EscriptParser::moduleFunctionDeclaration() {
|
|
ModuleFunctionDeclarationContext *_localctx = _tracker.createInstance<ModuleFunctionDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 8, EscriptParser::RuleModuleFunctionDeclaration);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(215);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(216);
|
|
match(EscriptParser::LPAREN);
|
|
setState(218);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(217);
|
|
moduleFunctionParameterList();
|
|
}
|
|
setState(220);
|
|
match(EscriptParser::RPAREN);
|
|
setState(221);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ModuleFunctionParameterListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ModuleFunctionParameterListContext::ModuleFunctionParameterListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::ModuleFunctionParameterContext *> EscriptParser::ModuleFunctionParameterListContext::moduleFunctionParameter() {
|
|
return getRuleContexts<EscriptParser::ModuleFunctionParameterContext>();
|
|
}
|
|
|
|
EscriptParser::ModuleFunctionParameterContext* EscriptParser::ModuleFunctionParameterListContext::moduleFunctionParameter(size_t i) {
|
|
return getRuleContext<EscriptParser::ModuleFunctionParameterContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::ModuleFunctionParameterListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleFunctionParameterListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ModuleFunctionParameterListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleModuleFunctionParameterList;
|
|
}
|
|
|
|
void EscriptParser::ModuleFunctionParameterListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterModuleFunctionParameterList(this);
|
|
}
|
|
|
|
void EscriptParser::ModuleFunctionParameterListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitModuleFunctionParameterList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ModuleFunctionParameterListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitModuleFunctionParameterList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ModuleFunctionParameterListContext* EscriptParser::moduleFunctionParameterList() {
|
|
ModuleFunctionParameterListContext *_localctx = _tracker.createInstance<ModuleFunctionParameterListContext>(_ctx, getState());
|
|
enterRule(_localctx, 10, EscriptParser::RuleModuleFunctionParameterList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(223);
|
|
moduleFunctionParameter();
|
|
setState(228);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::COMMA) {
|
|
setState(224);
|
|
match(EscriptParser::COMMA);
|
|
setState(225);
|
|
moduleFunctionParameter();
|
|
setState(230);
|
|
_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;
|
|
}
|
|
|
|
//----------------- ModuleFunctionParameterContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ModuleFunctionParameterContext::ModuleFunctionParameterContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleFunctionParameterContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ModuleFunctionParameterContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::ModuleFunctionParameterContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ModuleFunctionParameterContext::getRuleIndex() const {
|
|
return EscriptParser::RuleModuleFunctionParameter;
|
|
}
|
|
|
|
void EscriptParser::ModuleFunctionParameterContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterModuleFunctionParameter(this);
|
|
}
|
|
|
|
void EscriptParser::ModuleFunctionParameterContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitModuleFunctionParameter(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ModuleFunctionParameterContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitModuleFunctionParameter(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ModuleFunctionParameterContext* EscriptParser::moduleFunctionParameter() {
|
|
ModuleFunctionParameterContext *_localctx = _tracker.createInstance<ModuleFunctionParameterContext>(_ctx, getState());
|
|
enterRule(_localctx, 12, EscriptParser::RuleModuleFunctionParameter);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(231);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(234);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ASSIGN) {
|
|
setState(232);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(233);
|
|
expression(0);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TopLevelDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::TopLevelDeclarationContext::TopLevelDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::UseDeclarationContext* EscriptParser::TopLevelDeclarationContext::useDeclaration() {
|
|
return getRuleContext<EscriptParser::UseDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::IncludeDeclarationContext* EscriptParser::TopLevelDeclarationContext::includeDeclaration() {
|
|
return getRuleContext<EscriptParser::IncludeDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::ProgramDeclarationContext* EscriptParser::TopLevelDeclarationContext::programDeclaration() {
|
|
return getRuleContext<EscriptParser::ProgramDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::FunctionDeclarationContext* EscriptParser::TopLevelDeclarationContext::functionDeclaration() {
|
|
return getRuleContext<EscriptParser::FunctionDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::ClassDeclarationContext* EscriptParser::TopLevelDeclarationContext::classDeclaration() {
|
|
return getRuleContext<EscriptParser::ClassDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::StatementContext* EscriptParser::TopLevelDeclarationContext::statement() {
|
|
return getRuleContext<EscriptParser::StatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::TopLevelDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleTopLevelDeclaration;
|
|
}
|
|
|
|
void EscriptParser::TopLevelDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterTopLevelDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::TopLevelDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitTopLevelDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::TopLevelDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitTopLevelDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::TopLevelDeclarationContext* EscriptParser::topLevelDeclaration() {
|
|
TopLevelDeclarationContext *_localctx = _tracker.createInstance<TopLevelDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 14, EscriptParser::RuleTopLevelDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(242);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::USE: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(236);
|
|
useDeclaration();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::INCLUDE: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(237);
|
|
includeDeclaration();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::PROGRAM: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(238);
|
|
programDeclaration();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::FUNCTION:
|
|
case EscriptParser::EXPORTED: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(239);
|
|
functionDeclaration();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::CLASS: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(240);
|
|
classDeclaration();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::IF:
|
|
case EscriptParser::GOTO:
|
|
case EscriptParser::RETURN:
|
|
case EscriptParser::TOK_CONST:
|
|
case EscriptParser::VAR:
|
|
case EscriptParser::DO:
|
|
case EscriptParser::WHILE:
|
|
case EscriptParser::EXIT:
|
|
case EscriptParser::BREAK:
|
|
case EscriptParser::CONTINUE:
|
|
case EscriptParser::FOR:
|
|
case EscriptParser::FOREACH:
|
|
case EscriptParser::REPEAT:
|
|
case EscriptParser::CASE:
|
|
case EscriptParser::ENUM:
|
|
case EscriptParser::BANG_A:
|
|
case EscriptParser::BANG_B:
|
|
case EscriptParser::TOK_ERROR:
|
|
case EscriptParser::DICTIONARY:
|
|
case EscriptParser::STRUCT:
|
|
case EscriptParser::ARRAY:
|
|
case EscriptParser::UNINIT:
|
|
case EscriptParser::BOOL_TRUE:
|
|
case EscriptParser::BOOL_FALSE:
|
|
case EscriptParser::DECIMAL_LITERAL:
|
|
case EscriptParser::HEX_LITERAL:
|
|
case EscriptParser::OCT_LITERAL:
|
|
case EscriptParser::BINARY_LITERAL:
|
|
case EscriptParser::FLOAT_LITERAL:
|
|
case EscriptParser::HEX_FLOAT_LITERAL:
|
|
case EscriptParser::STRING_LITERAL:
|
|
case EscriptParser::INTERPOLATED_STRING_START:
|
|
case EscriptParser::LPAREN:
|
|
case EscriptParser::LBRACE:
|
|
case EscriptParser::ADD:
|
|
case EscriptParser::SUB:
|
|
case EscriptParser::SEMI:
|
|
case EscriptParser::TILDE:
|
|
case EscriptParser::AT:
|
|
case EscriptParser::COLONCOLON:
|
|
case EscriptParser::INC:
|
|
case EscriptParser::DEC:
|
|
case EscriptParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(241);
|
|
statement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ClassDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ClassDeclarationContext::ClassDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ClassDeclarationContext::CLASS() {
|
|
return getToken(EscriptParser::CLASS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ClassDeclarationContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::ClassParametersContext* EscriptParser::ClassDeclarationContext::classParameters() {
|
|
return getRuleContext<EscriptParser::ClassParametersContext>(0);
|
|
}
|
|
|
|
EscriptParser::ClassBodyContext* EscriptParser::ClassDeclarationContext::classBody() {
|
|
return getRuleContext<EscriptParser::ClassBodyContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ClassDeclarationContext::ENDCLASS() {
|
|
return getToken(EscriptParser::ENDCLASS, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ClassDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleClassDeclaration;
|
|
}
|
|
|
|
void EscriptParser::ClassDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterClassDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::ClassDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitClassDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ClassDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitClassDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ClassDeclarationContext* EscriptParser::classDeclaration() {
|
|
ClassDeclarationContext *_localctx = _tracker.createInstance<ClassDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 16, EscriptParser::RuleClassDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(244);
|
|
match(EscriptParser::CLASS);
|
|
setState(245);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(246);
|
|
classParameters();
|
|
setState(247);
|
|
classBody();
|
|
setState(248);
|
|
match(EscriptParser::ENDCLASS);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ClassParametersContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ClassParametersContext::ClassParametersContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ClassParametersContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ClassParametersContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::ClassParameterListContext* EscriptParser::ClassParametersContext::classParameterList() {
|
|
return getRuleContext<EscriptParser::ClassParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ClassParametersContext::getRuleIndex() const {
|
|
return EscriptParser::RuleClassParameters;
|
|
}
|
|
|
|
void EscriptParser::ClassParametersContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterClassParameters(this);
|
|
}
|
|
|
|
void EscriptParser::ClassParametersContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitClassParameters(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ClassParametersContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitClassParameters(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ClassParametersContext* EscriptParser::classParameters() {
|
|
ClassParametersContext *_localctx = _tracker.createInstance<ClassParametersContext>(_ctx, getState());
|
|
enterRule(_localctx, 18, EscriptParser::RuleClassParameters);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(250);
|
|
match(EscriptParser::LPAREN);
|
|
setState(252);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(251);
|
|
classParameterList();
|
|
}
|
|
setState(254);
|
|
match(EscriptParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ClassParameterListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ClassParameterListContext::ClassParameterListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::ClassParameterListContext::IDENTIFIER() {
|
|
return getTokens(EscriptParser::IDENTIFIER);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ClassParameterListContext::IDENTIFIER(size_t i) {
|
|
return getToken(EscriptParser::IDENTIFIER, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::ClassParameterListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ClassParameterListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ClassParameterListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleClassParameterList;
|
|
}
|
|
|
|
void EscriptParser::ClassParameterListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterClassParameterList(this);
|
|
}
|
|
|
|
void EscriptParser::ClassParameterListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitClassParameterList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ClassParameterListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitClassParameterList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ClassParameterListContext* EscriptParser::classParameterList() {
|
|
ClassParameterListContext *_localctx = _tracker.createInstance<ClassParameterListContext>(_ctx, getState());
|
|
enterRule(_localctx, 20, EscriptParser::RuleClassParameterList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(256);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(261);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::COMMA) {
|
|
setState(257);
|
|
match(EscriptParser::COMMA);
|
|
setState(258);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(263);
|
|
_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;
|
|
}
|
|
|
|
//----------------- ClassBodyContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ClassBodyContext::ClassBodyContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::ClassStatementContext *> EscriptParser::ClassBodyContext::classStatement() {
|
|
return getRuleContexts<EscriptParser::ClassStatementContext>();
|
|
}
|
|
|
|
EscriptParser::ClassStatementContext* EscriptParser::ClassBodyContext::classStatement(size_t i) {
|
|
return getRuleContext<EscriptParser::ClassStatementContext>(i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ClassBodyContext::getRuleIndex() const {
|
|
return EscriptParser::RuleClassBody;
|
|
}
|
|
|
|
void EscriptParser::ClassBodyContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterClassBody(this);
|
|
}
|
|
|
|
void EscriptParser::ClassBodyContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitClassBody(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ClassBodyContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitClassBody(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ClassBodyContext* EscriptParser::classBody() {
|
|
ClassBodyContext *_localctx = _tracker.createInstance<ClassBodyContext>(_ctx, getState());
|
|
enterRule(_localctx, 22, EscriptParser::RuleClassBody);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(267);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 164352) != 0)) {
|
|
setState(264);
|
|
classStatement();
|
|
setState(269);
|
|
_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;
|
|
}
|
|
|
|
//----------------- ClassStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ClassStatementContext::ClassStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::FunctionDeclarationContext* EscriptParser::ClassStatementContext::functionDeclaration() {
|
|
return getRuleContext<EscriptParser::FunctionDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::VarStatementContext* EscriptParser::ClassStatementContext::varStatement() {
|
|
return getRuleContext<EscriptParser::VarStatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ClassStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleClassStatement;
|
|
}
|
|
|
|
void EscriptParser::ClassStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterClassStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ClassStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitClassStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ClassStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitClassStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ClassStatementContext* EscriptParser::classStatement() {
|
|
ClassStatementContext *_localctx = _tracker.createInstance<ClassStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 24, EscriptParser::RuleClassStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(272);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::FUNCTION:
|
|
case EscriptParser::EXPORTED: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(270);
|
|
functionDeclaration();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::VAR: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(271);
|
|
varStatement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionDeclarationContext::FunctionDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionDeclarationContext::FUNCTION() {
|
|
return getToken(EscriptParser::FUNCTION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionDeclarationContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::FunctionParametersContext* EscriptParser::FunctionDeclarationContext::functionParameters() {
|
|
return getRuleContext<EscriptParser::FunctionParametersContext>(0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::FunctionDeclarationContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionDeclarationContext::ENDFUNCTION() {
|
|
return getToken(EscriptParser::ENDFUNCTION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionDeclarationContext::EXPORTED() {
|
|
return getToken(EscriptParser::EXPORTED, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionDeclaration;
|
|
}
|
|
|
|
void EscriptParser::FunctionDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionDeclarationContext* EscriptParser::functionDeclaration() {
|
|
FunctionDeclarationContext *_localctx = _tracker.createInstance<FunctionDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 26, EscriptParser::RuleFunctionDeclaration);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(275);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::EXPORTED) {
|
|
setState(274);
|
|
match(EscriptParser::EXPORTED);
|
|
}
|
|
setState(277);
|
|
match(EscriptParser::FUNCTION);
|
|
setState(278);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(279);
|
|
functionParameters();
|
|
setState(280);
|
|
block();
|
|
setState(281);
|
|
match(EscriptParser::ENDFUNCTION);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StringIdentifierContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::StringIdentifierContext::StringIdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StringIdentifierContext::STRING_LITERAL() {
|
|
return getToken(EscriptParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StringIdentifierContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::StringIdentifierContext::getRuleIndex() const {
|
|
return EscriptParser::RuleStringIdentifier;
|
|
}
|
|
|
|
void EscriptParser::StringIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStringIdentifier(this);
|
|
}
|
|
|
|
void EscriptParser::StringIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStringIdentifier(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::StringIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitStringIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::StringIdentifierContext* EscriptParser::stringIdentifier() {
|
|
StringIdentifierContext *_localctx = _tracker.createInstance<StringIdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 28, EscriptParser::RuleStringIdentifier);
|
|
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 == EscriptParser::STRING_LITERAL
|
|
|
|
|| _la == EscriptParser::IDENTIFIER)) {
|
|
_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;
|
|
}
|
|
|
|
//----------------- UseDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::UseDeclarationContext::UseDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::UseDeclarationContext::USE() {
|
|
return getToken(EscriptParser::USE, 0);
|
|
}
|
|
|
|
EscriptParser::StringIdentifierContext* EscriptParser::UseDeclarationContext::stringIdentifier() {
|
|
return getRuleContext<EscriptParser::StringIdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::UseDeclarationContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::UseDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleUseDeclaration;
|
|
}
|
|
|
|
void EscriptParser::UseDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterUseDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::UseDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitUseDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::UseDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitUseDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::UseDeclarationContext* EscriptParser::useDeclaration() {
|
|
UseDeclarationContext *_localctx = _tracker.createInstance<UseDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 30, EscriptParser::RuleUseDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(285);
|
|
match(EscriptParser::USE);
|
|
setState(286);
|
|
stringIdentifier();
|
|
setState(287);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IncludeDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IncludeDeclarationContext::IncludeDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IncludeDeclarationContext::INCLUDE() {
|
|
return getToken(EscriptParser::INCLUDE, 0);
|
|
}
|
|
|
|
EscriptParser::StringIdentifierContext* EscriptParser::IncludeDeclarationContext::stringIdentifier() {
|
|
return getRuleContext<EscriptParser::StringIdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IncludeDeclarationContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IncludeDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIncludeDeclaration;
|
|
}
|
|
|
|
void EscriptParser::IncludeDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIncludeDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::IncludeDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIncludeDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IncludeDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIncludeDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IncludeDeclarationContext* EscriptParser::includeDeclaration() {
|
|
IncludeDeclarationContext *_localctx = _tracker.createInstance<IncludeDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 32, EscriptParser::RuleIncludeDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(289);
|
|
match(EscriptParser::INCLUDE);
|
|
setState(290);
|
|
stringIdentifier();
|
|
setState(291);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ProgramDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ProgramDeclarationContext::ProgramDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramDeclarationContext::PROGRAM() {
|
|
return getToken(EscriptParser::PROGRAM, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramDeclarationContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::ProgramParametersContext* EscriptParser::ProgramDeclarationContext::programParameters() {
|
|
return getRuleContext<EscriptParser::ProgramParametersContext>(0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::ProgramDeclarationContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramDeclarationContext::ENDPROGRAM() {
|
|
return getToken(EscriptParser::ENDPROGRAM, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ProgramDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleProgramDeclaration;
|
|
}
|
|
|
|
void EscriptParser::ProgramDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterProgramDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::ProgramDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitProgramDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ProgramDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitProgramDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ProgramDeclarationContext* EscriptParser::programDeclaration() {
|
|
ProgramDeclarationContext *_localctx = _tracker.createInstance<ProgramDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 34, EscriptParser::RuleProgramDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(293);
|
|
match(EscriptParser::PROGRAM);
|
|
setState(294);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(295);
|
|
programParameters();
|
|
setState(296);
|
|
block();
|
|
setState(297);
|
|
match(EscriptParser::ENDPROGRAM);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::IfStatementContext* EscriptParser::StatementContext::ifStatement() {
|
|
return getRuleContext<EscriptParser::IfStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::GotoStatementContext* EscriptParser::StatementContext::gotoStatement() {
|
|
return getRuleContext<EscriptParser::GotoStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::ReturnStatementContext* EscriptParser::StatementContext::returnStatement() {
|
|
return getRuleContext<EscriptParser::ReturnStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::ConstStatementContext* EscriptParser::StatementContext::constStatement() {
|
|
return getRuleContext<EscriptParser::ConstStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::VarStatementContext* EscriptParser::StatementContext::varStatement() {
|
|
return getRuleContext<EscriptParser::VarStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::DoStatementContext* EscriptParser::StatementContext::doStatement() {
|
|
return getRuleContext<EscriptParser::DoStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::WhileStatementContext* EscriptParser::StatementContext::whileStatement() {
|
|
return getRuleContext<EscriptParser::WhileStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::ExitStatementContext* EscriptParser::StatementContext::exitStatement() {
|
|
return getRuleContext<EscriptParser::ExitStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::BreakStatementContext* EscriptParser::StatementContext::breakStatement() {
|
|
return getRuleContext<EscriptParser::BreakStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::ContinueStatementContext* EscriptParser::StatementContext::continueStatement() {
|
|
return getRuleContext<EscriptParser::ContinueStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::ForStatementContext* EscriptParser::StatementContext::forStatement() {
|
|
return getRuleContext<EscriptParser::ForStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::ForeachStatementContext* EscriptParser::StatementContext::foreachStatement() {
|
|
return getRuleContext<EscriptParser::ForeachStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::RepeatStatementContext* EscriptParser::StatementContext::repeatStatement() {
|
|
return getRuleContext<EscriptParser::RepeatStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::CaseStatementContext* EscriptParser::StatementContext::caseStatement() {
|
|
return getRuleContext<EscriptParser::CaseStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::EnumStatementContext* EscriptParser::StatementContext::enumStatement() {
|
|
return getRuleContext<EscriptParser::EnumStatementContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::StatementContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::StatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleStatement;
|
|
}
|
|
|
|
void EscriptParser::StatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStatement(this);
|
|
}
|
|
|
|
void EscriptParser::StatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::StatementContext* EscriptParser::statement() {
|
|
StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 36, EscriptParser::RuleStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(318);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(299);
|
|
ifStatement();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(300);
|
|
gotoStatement();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(301);
|
|
returnStatement();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(302);
|
|
constStatement();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(303);
|
|
varStatement();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(304);
|
|
doStatement();
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(305);
|
|
whileStatement();
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
enterOuterAlt(_localctx, 8);
|
|
setState(306);
|
|
exitStatement();
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
enterOuterAlt(_localctx, 9);
|
|
setState(307);
|
|
breakStatement();
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
enterOuterAlt(_localctx, 10);
|
|
setState(308);
|
|
continueStatement();
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
enterOuterAlt(_localctx, 11);
|
|
setState(309);
|
|
forStatement();
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
enterOuterAlt(_localctx, 12);
|
|
setState(310);
|
|
foreachStatement();
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
enterOuterAlt(_localctx, 13);
|
|
setState(311);
|
|
repeatStatement();
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
enterOuterAlt(_localctx, 14);
|
|
setState(312);
|
|
caseStatement();
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
enterOuterAlt(_localctx, 15);
|
|
setState(313);
|
|
enumStatement();
|
|
break;
|
|
}
|
|
|
|
case 16: {
|
|
enterOuterAlt(_localctx, 16);
|
|
setState(314);
|
|
match(EscriptParser::SEMI);
|
|
break;
|
|
}
|
|
|
|
case 17: {
|
|
enterOuterAlt(_localctx, 17);
|
|
setState(315);
|
|
antlrcpp::downCast<StatementContext *>(_localctx)->statementExpression = expression(0);
|
|
setState(316);
|
|
match(EscriptParser::SEMI);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StatementLabelContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::StatementLabelContext::StatementLabelContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StatementLabelContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StatementLabelContext::COLON() {
|
|
return getToken(EscriptParser::COLON, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::StatementLabelContext::getRuleIndex() const {
|
|
return EscriptParser::RuleStatementLabel;
|
|
}
|
|
|
|
void EscriptParser::StatementLabelContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStatementLabel(this);
|
|
}
|
|
|
|
void EscriptParser::StatementLabelContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStatementLabel(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::StatementLabelContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitStatementLabel(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::StatementLabelContext* EscriptParser::statementLabel() {
|
|
StatementLabelContext *_localctx = _tracker.createInstance<StatementLabelContext>(_ctx, getState());
|
|
enterRule(_localctx, 38, EscriptParser::RuleStatementLabel);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(320);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(321);
|
|
match(EscriptParser::COLON);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IfStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IfStatementContext::IfStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IfStatementContext::IF() {
|
|
return getToken(EscriptParser::IF, 0);
|
|
}
|
|
|
|
std::vector<EscriptParser::ParExpressionContext *> EscriptParser::IfStatementContext::parExpression() {
|
|
return getRuleContexts<EscriptParser::ParExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::ParExpressionContext* EscriptParser::IfStatementContext::parExpression(size_t i) {
|
|
return getRuleContext<EscriptParser::ParExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<EscriptParser::BlockContext *> EscriptParser::IfStatementContext::block() {
|
|
return getRuleContexts<EscriptParser::BlockContext>();
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::IfStatementContext::block(size_t i) {
|
|
return getRuleContext<EscriptParser::BlockContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IfStatementContext::ENDIF() {
|
|
return getToken(EscriptParser::ENDIF, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IfStatementContext::THEN() {
|
|
return getToken(EscriptParser::THEN, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::IfStatementContext::ELSEIF() {
|
|
return getTokens(EscriptParser::ELSEIF);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IfStatementContext::ELSEIF(size_t i) {
|
|
return getToken(EscriptParser::ELSEIF, i);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IfStatementContext::ELSE() {
|
|
return getToken(EscriptParser::ELSE, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IfStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIfStatement;
|
|
}
|
|
|
|
void EscriptParser::IfStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIfStatement(this);
|
|
}
|
|
|
|
void EscriptParser::IfStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIfStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IfStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIfStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IfStatementContext* EscriptParser::ifStatement() {
|
|
IfStatementContext *_localctx = _tracker.createInstance<IfStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 40, EscriptParser::RuleIfStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(323);
|
|
match(EscriptParser::IF);
|
|
setState(324);
|
|
parExpression();
|
|
setState(326);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::THEN) {
|
|
setState(325);
|
|
match(EscriptParser::THEN);
|
|
}
|
|
setState(328);
|
|
block();
|
|
setState(335);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::ELSEIF) {
|
|
setState(329);
|
|
match(EscriptParser::ELSEIF);
|
|
setState(330);
|
|
parExpression();
|
|
setState(331);
|
|
block();
|
|
setState(337);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(340);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ELSE) {
|
|
setState(338);
|
|
match(EscriptParser::ELSE);
|
|
setState(339);
|
|
block();
|
|
}
|
|
setState(342);
|
|
match(EscriptParser::ENDIF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- GotoStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::GotoStatementContext::GotoStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::GotoStatementContext::GOTO() {
|
|
return getToken(EscriptParser::GOTO, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::GotoStatementContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::GotoStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::GotoStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleGotoStatement;
|
|
}
|
|
|
|
void EscriptParser::GotoStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterGotoStatement(this);
|
|
}
|
|
|
|
void EscriptParser::GotoStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitGotoStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::GotoStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitGotoStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::GotoStatementContext* EscriptParser::gotoStatement() {
|
|
GotoStatementContext *_localctx = _tracker.createInstance<GotoStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 42, EscriptParser::RuleGotoStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(344);
|
|
match(EscriptParser::GOTO);
|
|
setState(345);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(346);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ReturnStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ReturnStatementContext::ReturnStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ReturnStatementContext::RETURN() {
|
|
return getToken(EscriptParser::RETURN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ReturnStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::ReturnStatementContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ReturnStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleReturnStatement;
|
|
}
|
|
|
|
void EscriptParser::ReturnStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterReturnStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ReturnStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitReturnStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ReturnStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitReturnStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ReturnStatementContext* EscriptParser::returnStatement() {
|
|
ReturnStatementContext *_localctx = _tracker.createInstance<ReturnStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 44, EscriptParser::RuleReturnStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(348);
|
|
match(EscriptParser::RETURN);
|
|
setState(350);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(349);
|
|
expression(0);
|
|
}
|
|
setState(352);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ConstStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ConstStatementContext::ConstStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ConstStatementContext::TOK_CONST() {
|
|
return getToken(EscriptParser::TOK_CONST, 0);
|
|
}
|
|
|
|
EscriptParser::ConstantDeclarationContext* EscriptParser::ConstStatementContext::constantDeclaration() {
|
|
return getRuleContext<EscriptParser::ConstantDeclarationContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ConstStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ConstStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleConstStatement;
|
|
}
|
|
|
|
void EscriptParser::ConstStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterConstStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ConstStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitConstStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ConstStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitConstStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ConstStatementContext* EscriptParser::constStatement() {
|
|
ConstStatementContext *_localctx = _tracker.createInstance<ConstStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 46, EscriptParser::RuleConstStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(354);
|
|
match(EscriptParser::TOK_CONST);
|
|
setState(355);
|
|
constantDeclaration();
|
|
setState(356);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VarStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::VarStatementContext::VarStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::VarStatementContext::VAR() {
|
|
return getToken(EscriptParser::VAR, 0);
|
|
}
|
|
|
|
EscriptParser::VariableDeclarationListContext* EscriptParser::VarStatementContext::variableDeclarationList() {
|
|
return getRuleContext<EscriptParser::VariableDeclarationListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::VarStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::VarStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleVarStatement;
|
|
}
|
|
|
|
void EscriptParser::VarStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterVarStatement(this);
|
|
}
|
|
|
|
void EscriptParser::VarStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitVarStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::VarStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitVarStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::VarStatementContext* EscriptParser::varStatement() {
|
|
VarStatementContext *_localctx = _tracker.createInstance<VarStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 48, EscriptParser::RuleVarStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(358);
|
|
match(EscriptParser::VAR);
|
|
setState(359);
|
|
variableDeclarationList();
|
|
setState(360);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- DoStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::DoStatementContext::DoStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DoStatementContext::DO() {
|
|
return getToken(EscriptParser::DO, 0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::DoStatementContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DoStatementContext::DOWHILE() {
|
|
return getToken(EscriptParser::DOWHILE, 0);
|
|
}
|
|
|
|
EscriptParser::ParExpressionContext* EscriptParser::DoStatementContext::parExpression() {
|
|
return getRuleContext<EscriptParser::ParExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DoStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
EscriptParser::StatementLabelContext* EscriptParser::DoStatementContext::statementLabel() {
|
|
return getRuleContext<EscriptParser::StatementLabelContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::DoStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleDoStatement;
|
|
}
|
|
|
|
void EscriptParser::DoStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterDoStatement(this);
|
|
}
|
|
|
|
void EscriptParser::DoStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitDoStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::DoStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitDoStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::DoStatementContext* EscriptParser::doStatement() {
|
|
DoStatementContext *_localctx = _tracker.createInstance<DoStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 50, EscriptParser::RuleDoStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(363);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(362);
|
|
statementLabel();
|
|
}
|
|
setState(365);
|
|
match(EscriptParser::DO);
|
|
setState(366);
|
|
block();
|
|
setState(367);
|
|
match(EscriptParser::DOWHILE);
|
|
setState(368);
|
|
parExpression();
|
|
setState(369);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WhileStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::WhileStatementContext::WhileStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::WhileStatementContext::WHILE() {
|
|
return getToken(EscriptParser::WHILE, 0);
|
|
}
|
|
|
|
EscriptParser::ParExpressionContext* EscriptParser::WhileStatementContext::parExpression() {
|
|
return getRuleContext<EscriptParser::ParExpressionContext>(0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::WhileStatementContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::WhileStatementContext::ENDWHILE() {
|
|
return getToken(EscriptParser::ENDWHILE, 0);
|
|
}
|
|
|
|
EscriptParser::StatementLabelContext* EscriptParser::WhileStatementContext::statementLabel() {
|
|
return getRuleContext<EscriptParser::StatementLabelContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::WhileStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleWhileStatement;
|
|
}
|
|
|
|
void EscriptParser::WhileStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterWhileStatement(this);
|
|
}
|
|
|
|
void EscriptParser::WhileStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitWhileStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::WhileStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitWhileStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::WhileStatementContext* EscriptParser::whileStatement() {
|
|
WhileStatementContext *_localctx = _tracker.createInstance<WhileStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 52, EscriptParser::RuleWhileStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(372);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(371);
|
|
statementLabel();
|
|
}
|
|
setState(374);
|
|
match(EscriptParser::WHILE);
|
|
setState(375);
|
|
parExpression();
|
|
setState(376);
|
|
block();
|
|
setState(377);
|
|
match(EscriptParser::ENDWHILE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExitStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExitStatementContext::ExitStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExitStatementContext::EXIT() {
|
|
return getToken(EscriptParser::EXIT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExitStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExitStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExitStatement;
|
|
}
|
|
|
|
void EscriptParser::ExitStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExitStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ExitStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExitStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExitStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExitStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExitStatementContext* EscriptParser::exitStatement() {
|
|
ExitStatementContext *_localctx = _tracker.createInstance<ExitStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 54, EscriptParser::RuleExitStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(379);
|
|
match(EscriptParser::EXIT);
|
|
setState(380);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BreakStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BreakStatementContext::BreakStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BreakStatementContext::BREAK() {
|
|
return getToken(EscriptParser::BREAK, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BreakStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BreakStatementContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BreakStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBreakStatement;
|
|
}
|
|
|
|
void EscriptParser::BreakStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBreakStatement(this);
|
|
}
|
|
|
|
void EscriptParser::BreakStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBreakStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BreakStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBreakStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BreakStatementContext* EscriptParser::breakStatement() {
|
|
BreakStatementContext *_localctx = _tracker.createInstance<BreakStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 56, EscriptParser::RuleBreakStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(382);
|
|
match(EscriptParser::BREAK);
|
|
setState(384);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(383);
|
|
match(EscriptParser::IDENTIFIER);
|
|
}
|
|
setState(386);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ContinueStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ContinueStatementContext::ContinueStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ContinueStatementContext::CONTINUE() {
|
|
return getToken(EscriptParser::CONTINUE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ContinueStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ContinueStatementContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ContinueStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleContinueStatement;
|
|
}
|
|
|
|
void EscriptParser::ContinueStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterContinueStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ContinueStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitContinueStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ContinueStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitContinueStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ContinueStatementContext* EscriptParser::continueStatement() {
|
|
ContinueStatementContext *_localctx = _tracker.createInstance<ContinueStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 58, EscriptParser::RuleContinueStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(388);
|
|
match(EscriptParser::CONTINUE);
|
|
setState(390);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(389);
|
|
match(EscriptParser::IDENTIFIER);
|
|
}
|
|
setState(392);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ForStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ForStatementContext::ForStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ForStatementContext::FOR() {
|
|
return getToken(EscriptParser::FOR, 0);
|
|
}
|
|
|
|
EscriptParser::ForGroupContext* EscriptParser::ForStatementContext::forGroup() {
|
|
return getRuleContext<EscriptParser::ForGroupContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ForStatementContext::ENDFOR() {
|
|
return getToken(EscriptParser::ENDFOR, 0);
|
|
}
|
|
|
|
EscriptParser::StatementLabelContext* EscriptParser::ForStatementContext::statementLabel() {
|
|
return getRuleContext<EscriptParser::StatementLabelContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ForStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleForStatement;
|
|
}
|
|
|
|
void EscriptParser::ForStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterForStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ForStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitForStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ForStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitForStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ForStatementContext* EscriptParser::forStatement() {
|
|
ForStatementContext *_localctx = _tracker.createInstance<ForStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 60, EscriptParser::RuleForStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(395);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(394);
|
|
statementLabel();
|
|
}
|
|
setState(397);
|
|
match(EscriptParser::FOR);
|
|
setState(398);
|
|
forGroup();
|
|
setState(399);
|
|
match(EscriptParser::ENDFOR);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ForeachIterableExpressionContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ForeachIterableExpressionContext::ForeachIterableExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::FunctionCallContext* EscriptParser::ForeachIterableExpressionContext::functionCall() {
|
|
return getRuleContext<EscriptParser::FunctionCallContext>(0);
|
|
}
|
|
|
|
EscriptParser::ScopedFunctionCallContext* EscriptParser::ForeachIterableExpressionContext::scopedFunctionCall() {
|
|
return getRuleContext<EscriptParser::ScopedFunctionCallContext>(0);
|
|
}
|
|
|
|
EscriptParser::ScopedIdentifierContext* EscriptParser::ForeachIterableExpressionContext::scopedIdentifier() {
|
|
return getRuleContext<EscriptParser::ScopedIdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ForeachIterableExpressionContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::ParExpressionContext* EscriptParser::ForeachIterableExpressionContext::parExpression() {
|
|
return getRuleContext<EscriptParser::ParExpressionContext>(0);
|
|
}
|
|
|
|
EscriptParser::BareArrayInitializerContext* EscriptParser::ForeachIterableExpressionContext::bareArrayInitializer() {
|
|
return getRuleContext<EscriptParser::BareArrayInitializerContext>(0);
|
|
}
|
|
|
|
EscriptParser::ExplicitArrayInitializerContext* EscriptParser::ForeachIterableExpressionContext::explicitArrayInitializer() {
|
|
return getRuleContext<EscriptParser::ExplicitArrayInitializerContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ForeachIterableExpressionContext::getRuleIndex() const {
|
|
return EscriptParser::RuleForeachIterableExpression;
|
|
}
|
|
|
|
void EscriptParser::ForeachIterableExpressionContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterForeachIterableExpression(this);
|
|
}
|
|
|
|
void EscriptParser::ForeachIterableExpressionContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitForeachIterableExpression(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ForeachIterableExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitForeachIterableExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ForeachIterableExpressionContext* EscriptParser::foreachIterableExpression() {
|
|
ForeachIterableExpressionContext *_localctx = _tracker.createInstance<ForeachIterableExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 62, EscriptParser::RuleForeachIterableExpression);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(408);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(401);
|
|
functionCall();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(402);
|
|
scopedFunctionCall();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(403);
|
|
scopedIdentifier();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(404);
|
|
match(EscriptParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(405);
|
|
parExpression();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(406);
|
|
bareArrayInitializer();
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(407);
|
|
explicitArrayInitializer();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ForeachStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ForeachStatementContext::ForeachStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ForeachStatementContext::FOREACH() {
|
|
return getToken(EscriptParser::FOREACH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ForeachStatementContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ForeachStatementContext::TOK_IN() {
|
|
return getToken(EscriptParser::TOK_IN, 0);
|
|
}
|
|
|
|
EscriptParser::ForeachIterableExpressionContext* EscriptParser::ForeachStatementContext::foreachIterableExpression() {
|
|
return getRuleContext<EscriptParser::ForeachIterableExpressionContext>(0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::ForeachStatementContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ForeachStatementContext::ENDFOREACH() {
|
|
return getToken(EscriptParser::ENDFOREACH, 0);
|
|
}
|
|
|
|
EscriptParser::StatementLabelContext* EscriptParser::ForeachStatementContext::statementLabel() {
|
|
return getRuleContext<EscriptParser::StatementLabelContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ForeachStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleForeachStatement;
|
|
}
|
|
|
|
void EscriptParser::ForeachStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterForeachStatement(this);
|
|
}
|
|
|
|
void EscriptParser::ForeachStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitForeachStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ForeachStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitForeachStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ForeachStatementContext* EscriptParser::foreachStatement() {
|
|
ForeachStatementContext *_localctx = _tracker.createInstance<ForeachStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 64, EscriptParser::RuleForeachStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(411);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(410);
|
|
statementLabel();
|
|
}
|
|
setState(413);
|
|
match(EscriptParser::FOREACH);
|
|
setState(414);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(415);
|
|
match(EscriptParser::TOK_IN);
|
|
setState(416);
|
|
foreachIterableExpression();
|
|
setState(417);
|
|
block();
|
|
setState(418);
|
|
match(EscriptParser::ENDFOREACH);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- RepeatStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::RepeatStatementContext::RepeatStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::RepeatStatementContext::REPEAT() {
|
|
return getToken(EscriptParser::REPEAT, 0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::RepeatStatementContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::RepeatStatementContext::UNTIL() {
|
|
return getToken(EscriptParser::UNTIL, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::RepeatStatementContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::RepeatStatementContext::SEMI() {
|
|
return getToken(EscriptParser::SEMI, 0);
|
|
}
|
|
|
|
EscriptParser::StatementLabelContext* EscriptParser::RepeatStatementContext::statementLabel() {
|
|
return getRuleContext<EscriptParser::StatementLabelContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::RepeatStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleRepeatStatement;
|
|
}
|
|
|
|
void EscriptParser::RepeatStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterRepeatStatement(this);
|
|
}
|
|
|
|
void EscriptParser::RepeatStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitRepeatStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::RepeatStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitRepeatStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::RepeatStatementContext* EscriptParser::repeatStatement() {
|
|
RepeatStatementContext *_localctx = _tracker.createInstance<RepeatStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 66, EscriptParser::RuleRepeatStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(421);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(420);
|
|
statementLabel();
|
|
}
|
|
setState(423);
|
|
match(EscriptParser::REPEAT);
|
|
setState(424);
|
|
block();
|
|
setState(425);
|
|
match(EscriptParser::UNTIL);
|
|
setState(426);
|
|
expression(0);
|
|
setState(427);
|
|
match(EscriptParser::SEMI);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- CaseStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::CaseStatementContext::CaseStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CaseStatementContext::CASE() {
|
|
return getToken(EscriptParser::CASE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CaseStatementContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::CaseStatementContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CaseStatementContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CaseStatementContext::ENDCASE() {
|
|
return getToken(EscriptParser::ENDCASE, 0);
|
|
}
|
|
|
|
EscriptParser::StatementLabelContext* EscriptParser::CaseStatementContext::statementLabel() {
|
|
return getRuleContext<EscriptParser::StatementLabelContext>(0);
|
|
}
|
|
|
|
std::vector<EscriptParser::SwitchBlockStatementGroupContext *> EscriptParser::CaseStatementContext::switchBlockStatementGroup() {
|
|
return getRuleContexts<EscriptParser::SwitchBlockStatementGroupContext>();
|
|
}
|
|
|
|
EscriptParser::SwitchBlockStatementGroupContext* EscriptParser::CaseStatementContext::switchBlockStatementGroup(size_t i) {
|
|
return getRuleContext<EscriptParser::SwitchBlockStatementGroupContext>(i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::CaseStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleCaseStatement;
|
|
}
|
|
|
|
void EscriptParser::CaseStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterCaseStatement(this);
|
|
}
|
|
|
|
void EscriptParser::CaseStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitCaseStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::CaseStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitCaseStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::CaseStatementContext* EscriptParser::caseStatement() {
|
|
CaseStatementContext *_localctx = _tracker.createInstance<CaseStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 68, EscriptParser::RuleCaseStatement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(430);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(429);
|
|
statementLabel();
|
|
}
|
|
setState(432);
|
|
match(EscriptParser::CASE);
|
|
setState(433);
|
|
match(EscriptParser::LPAREN);
|
|
setState(434);
|
|
expression(0);
|
|
setState(435);
|
|
match(EscriptParser::RPAREN);
|
|
setState(437);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
do {
|
|
setState(436);
|
|
switchBlockStatementGroup();
|
|
setState(439);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
} while (_la == EscriptParser::DEFAULT || ((((_la - 69) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 69)) & 1152921504606848247) != 0));
|
|
setState(441);
|
|
match(EscriptParser::ENDCASE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EnumStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::EnumStatementContext::EnumStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::EnumStatementContext::ENUM() {
|
|
return getToken(EscriptParser::ENUM, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::EnumStatementContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::EnumListContext* EscriptParser::EnumStatementContext::enumList() {
|
|
return getRuleContext<EscriptParser::EnumListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::EnumStatementContext::ENDENUM() {
|
|
return getToken(EscriptParser::ENDENUM, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::EnumStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleEnumStatement;
|
|
}
|
|
|
|
void EscriptParser::EnumStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterEnumStatement(this);
|
|
}
|
|
|
|
void EscriptParser::EnumStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitEnumStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::EnumStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitEnumStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::EnumStatementContext* EscriptParser::enumStatement() {
|
|
EnumStatementContext *_localctx = _tracker.createInstance<EnumStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 70, EscriptParser::RuleEnumStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(443);
|
|
match(EscriptParser::ENUM);
|
|
setState(444);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(445);
|
|
enumList();
|
|
setState(446);
|
|
match(EscriptParser::ENDENUM);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BlockContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::StatementContext *> EscriptParser::BlockContext::statement() {
|
|
return getRuleContexts<EscriptParser::StatementContext>();
|
|
}
|
|
|
|
EscriptParser::StatementContext* EscriptParser::BlockContext::statement(size_t i) {
|
|
return getRuleContext<EscriptParser::StatementContext>(i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BlockContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBlock;
|
|
}
|
|
|
|
void EscriptParser::BlockContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBlock(this);
|
|
}
|
|
|
|
void EscriptParser::BlockContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBlock(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBlock(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::block() {
|
|
BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
|
|
enterRule(_localctx, 72, EscriptParser::RuleBlock);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(451);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(448);
|
|
statement();
|
|
}
|
|
setState(453);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VariableDeclarationInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::VariableDeclarationInitializerContext::VariableDeclarationInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::VariableDeclarationInitializerContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::VariableDeclarationInitializerContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::VariableDeclarationInitializerContext::EQUAL_DEPRECATED() {
|
|
return getToken(EscriptParser::EQUAL_DEPRECATED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::VariableDeclarationInitializerContext::ARRAY() {
|
|
return getToken(EscriptParser::ARRAY, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::VariableDeclarationInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleVariableDeclarationInitializer;
|
|
}
|
|
|
|
void EscriptParser::VariableDeclarationInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterVariableDeclarationInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::VariableDeclarationInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitVariableDeclarationInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::VariableDeclarationInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitVariableDeclarationInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::VariableDeclarationInitializerContext* EscriptParser::variableDeclarationInitializer() {
|
|
VariableDeclarationInitializerContext *_localctx = _tracker.createInstance<VariableDeclarationInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 74, EscriptParser::RuleVariableDeclarationInitializer);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(461);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::ASSIGN: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(454);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(455);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::EQUAL_DEPRECATED: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(456);
|
|
match(EscriptParser::EQUAL_DEPRECATED);
|
|
setState(457);
|
|
expression(0);
|
|
notifyErrorListeners("Unexpected token: '='. Did you mean := for assign?\n");
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::ARRAY: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(460);
|
|
match(EscriptParser::ARRAY);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EnumListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::EnumListContext::EnumListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::EnumListEntryContext *> EscriptParser::EnumListContext::enumListEntry() {
|
|
return getRuleContexts<EscriptParser::EnumListEntryContext>();
|
|
}
|
|
|
|
EscriptParser::EnumListEntryContext* EscriptParser::EnumListContext::enumListEntry(size_t i) {
|
|
return getRuleContext<EscriptParser::EnumListEntryContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::EnumListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::EnumListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::EnumListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleEnumList;
|
|
}
|
|
|
|
void EscriptParser::EnumListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterEnumList(this);
|
|
}
|
|
|
|
void EscriptParser::EnumListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitEnumList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::EnumListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitEnumList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::EnumListContext* EscriptParser::enumList() {
|
|
EnumListContext *_localctx = _tracker.createInstance<EnumListContext>(_ctx, getState());
|
|
enterRule(_localctx, 76, EscriptParser::RuleEnumList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(463);
|
|
enumListEntry();
|
|
setState(468);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(464);
|
|
match(EscriptParser::COMMA);
|
|
setState(465);
|
|
enumListEntry();
|
|
}
|
|
setState(470);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx);
|
|
}
|
|
setState(472);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::COMMA) {
|
|
setState(471);
|
|
match(EscriptParser::COMMA);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EnumListEntryContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::EnumListEntryContext::EnumListEntryContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::EnumListEntryContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::EnumListEntryContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::EnumListEntryContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::EnumListEntryContext::getRuleIndex() const {
|
|
return EscriptParser::RuleEnumListEntry;
|
|
}
|
|
|
|
void EscriptParser::EnumListEntryContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterEnumListEntry(this);
|
|
}
|
|
|
|
void EscriptParser::EnumListEntryContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitEnumListEntry(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::EnumListEntryContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitEnumListEntry(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::EnumListEntryContext* EscriptParser::enumListEntry() {
|
|
EnumListEntryContext *_localctx = _tracker.createInstance<EnumListEntryContext>(_ctx, getState());
|
|
enterRule(_localctx, 78, EscriptParser::RuleEnumListEntry);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(474);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(477);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ASSIGN) {
|
|
setState(475);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(476);
|
|
expression(0);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SwitchBlockStatementGroupContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::SwitchBlockStatementGroupContext::SwitchBlockStatementGroupContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::SwitchBlockStatementGroupContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
std::vector<EscriptParser::SwitchLabelContext *> EscriptParser::SwitchBlockStatementGroupContext::switchLabel() {
|
|
return getRuleContexts<EscriptParser::SwitchLabelContext>();
|
|
}
|
|
|
|
EscriptParser::SwitchLabelContext* EscriptParser::SwitchBlockStatementGroupContext::switchLabel(size_t i) {
|
|
return getRuleContext<EscriptParser::SwitchLabelContext>(i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::SwitchBlockStatementGroupContext::getRuleIndex() const {
|
|
return EscriptParser::RuleSwitchBlockStatementGroup;
|
|
}
|
|
|
|
void EscriptParser::SwitchBlockStatementGroupContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterSwitchBlockStatementGroup(this);
|
|
}
|
|
|
|
void EscriptParser::SwitchBlockStatementGroupContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitSwitchBlockStatementGroup(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::SwitchBlockStatementGroupContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitSwitchBlockStatementGroup(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::SwitchBlockStatementGroupContext* EscriptParser::switchBlockStatementGroup() {
|
|
SwitchBlockStatementGroupContext *_localctx = _tracker.createInstance<SwitchBlockStatementGroupContext>(_ctx, getState());
|
|
enterRule(_localctx, 80, EscriptParser::RuleSwitchBlockStatementGroup);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(480);
|
|
_errHandler->sync(this);
|
|
alt = 1;
|
|
do {
|
|
switch (alt) {
|
|
case 1: {
|
|
setState(479);
|
|
switchLabel();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(482);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx);
|
|
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
|
|
setState(484);
|
|
block();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SwitchLabelContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::SwitchLabelContext::SwitchLabelContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SwitchLabelContext::COLON() {
|
|
return getToken(EscriptParser::COLON, 0);
|
|
}
|
|
|
|
EscriptParser::IntegerLiteralContext* EscriptParser::SwitchLabelContext::integerLiteral() {
|
|
return getRuleContext<EscriptParser::IntegerLiteralContext>(0);
|
|
}
|
|
|
|
EscriptParser::BoolLiteralContext* EscriptParser::SwitchLabelContext::boolLiteral() {
|
|
return getRuleContext<EscriptParser::BoolLiteralContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SwitchLabelContext::UNINIT() {
|
|
return getToken(EscriptParser::UNINIT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SwitchLabelContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SwitchLabelContext::STRING_LITERAL() {
|
|
return getToken(EscriptParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SwitchLabelContext::DEFAULT() {
|
|
return getToken(EscriptParser::DEFAULT, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::SwitchLabelContext::getRuleIndex() const {
|
|
return EscriptParser::RuleSwitchLabel;
|
|
}
|
|
|
|
void EscriptParser::SwitchLabelContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterSwitchLabel(this);
|
|
}
|
|
|
|
void EscriptParser::SwitchLabelContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitSwitchLabel(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::SwitchLabelContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitSwitchLabel(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::SwitchLabelContext* EscriptParser::switchLabel() {
|
|
SwitchLabelContext *_localctx = _tracker.createInstance<SwitchLabelContext>(_ctx, getState());
|
|
enterRule(_localctx, 82, EscriptParser::RuleSwitchLabel);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(496);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::UNINIT:
|
|
case EscriptParser::BOOL_TRUE:
|
|
case EscriptParser::BOOL_FALSE:
|
|
case EscriptParser::DECIMAL_LITERAL:
|
|
case EscriptParser::HEX_LITERAL:
|
|
case EscriptParser::OCT_LITERAL:
|
|
case EscriptParser::BINARY_LITERAL:
|
|
case EscriptParser::STRING_LITERAL:
|
|
case EscriptParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(491);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::DECIMAL_LITERAL:
|
|
case EscriptParser::HEX_LITERAL:
|
|
case EscriptParser::OCT_LITERAL:
|
|
case EscriptParser::BINARY_LITERAL: {
|
|
setState(486);
|
|
integerLiteral();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::BOOL_TRUE:
|
|
case EscriptParser::BOOL_FALSE: {
|
|
setState(487);
|
|
boolLiteral();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::UNINIT: {
|
|
setState(488);
|
|
match(EscriptParser::UNINIT);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::IDENTIFIER: {
|
|
setState(489);
|
|
match(EscriptParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::STRING_LITERAL: {
|
|
setState(490);
|
|
match(EscriptParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(493);
|
|
match(EscriptParser::COLON);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::DEFAULT: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(494);
|
|
match(EscriptParser::DEFAULT);
|
|
setState(495);
|
|
match(EscriptParser::COLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ForGroupContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ForGroupContext::ForGroupContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::CstyleForStatementContext* EscriptParser::ForGroupContext::cstyleForStatement() {
|
|
return getRuleContext<EscriptParser::CstyleForStatementContext>(0);
|
|
}
|
|
|
|
EscriptParser::BasicForStatementContext* EscriptParser::ForGroupContext::basicForStatement() {
|
|
return getRuleContext<EscriptParser::BasicForStatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ForGroupContext::getRuleIndex() const {
|
|
return EscriptParser::RuleForGroup;
|
|
}
|
|
|
|
void EscriptParser::ForGroupContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterForGroup(this);
|
|
}
|
|
|
|
void EscriptParser::ForGroupContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitForGroup(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ForGroupContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitForGroup(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ForGroupContext* EscriptParser::forGroup() {
|
|
ForGroupContext *_localctx = _tracker.createInstance<ForGroupContext>(_ctx, getState());
|
|
enterRule(_localctx, 84, EscriptParser::RuleForGroup);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(500);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::LPAREN: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(498);
|
|
cstyleForStatement();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(499);
|
|
basicForStatement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BasicForStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BasicForStatementContext::BasicForStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BasicForStatementContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BasicForStatementContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
std::vector<EscriptParser::ExpressionContext *> EscriptParser::BasicForStatementContext::expression() {
|
|
return getRuleContexts<EscriptParser::ExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::BasicForStatementContext::expression(size_t i) {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BasicForStatementContext::TO() {
|
|
return getToken(EscriptParser::TO, 0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::BasicForStatementContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BasicForStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBasicForStatement;
|
|
}
|
|
|
|
void EscriptParser::BasicForStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBasicForStatement(this);
|
|
}
|
|
|
|
void EscriptParser::BasicForStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBasicForStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BasicForStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBasicForStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BasicForStatementContext* EscriptParser::basicForStatement() {
|
|
BasicForStatementContext *_localctx = _tracker.createInstance<BasicForStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 86, EscriptParser::RuleBasicForStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(502);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(503);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(504);
|
|
expression(0);
|
|
setState(505);
|
|
match(EscriptParser::TO);
|
|
setState(506);
|
|
expression(0);
|
|
setState(507);
|
|
block();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- CstyleForStatementContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::CstyleForStatementContext::CstyleForStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CstyleForStatementContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
std::vector<EscriptParser::ExpressionContext *> EscriptParser::CstyleForStatementContext::expression() {
|
|
return getRuleContexts<EscriptParser::ExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::CstyleForStatementContext::expression(size_t i) {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::CstyleForStatementContext::SEMI() {
|
|
return getTokens(EscriptParser::SEMI);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CstyleForStatementContext::SEMI(size_t i) {
|
|
return getToken(EscriptParser::SEMI, i);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::CstyleForStatementContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::CstyleForStatementContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::CstyleForStatementContext::getRuleIndex() const {
|
|
return EscriptParser::RuleCstyleForStatement;
|
|
}
|
|
|
|
void EscriptParser::CstyleForStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterCstyleForStatement(this);
|
|
}
|
|
|
|
void EscriptParser::CstyleForStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitCstyleForStatement(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::CstyleForStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitCstyleForStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::CstyleForStatementContext* EscriptParser::cstyleForStatement() {
|
|
CstyleForStatementContext *_localctx = _tracker.createInstance<CstyleForStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 88, EscriptParser::RuleCstyleForStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(509);
|
|
match(EscriptParser::LPAREN);
|
|
setState(510);
|
|
expression(0);
|
|
setState(511);
|
|
match(EscriptParser::SEMI);
|
|
setState(512);
|
|
expression(0);
|
|
setState(513);
|
|
match(EscriptParser::SEMI);
|
|
setState(514);
|
|
expression(0);
|
|
setState(515);
|
|
match(EscriptParser::RPAREN);
|
|
setState(516);
|
|
block();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IdentifierListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IdentifierListContext::IdentifierListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IdentifierListContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IdentifierListContext::COMMA() {
|
|
return getToken(EscriptParser::COMMA, 0);
|
|
}
|
|
|
|
EscriptParser::IdentifierListContext* EscriptParser::IdentifierListContext::identifierList() {
|
|
return getRuleContext<EscriptParser::IdentifierListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IdentifierListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIdentifierList;
|
|
}
|
|
|
|
void EscriptParser::IdentifierListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIdentifierList(this);
|
|
}
|
|
|
|
void EscriptParser::IdentifierListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIdentifierList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IdentifierListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIdentifierList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IdentifierListContext* EscriptParser::identifierList() {
|
|
IdentifierListContext *_localctx = _tracker.createInstance<IdentifierListContext>(_ctx, getState());
|
|
enterRule(_localctx, 90, EscriptParser::RuleIdentifierList);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(518);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(521);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx)) {
|
|
case 1: {
|
|
setState(519);
|
|
match(EscriptParser::COMMA);
|
|
setState(520);
|
|
identifierList();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VariableDeclarationListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::VariableDeclarationListContext::VariableDeclarationListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::VariableDeclarationContext *> EscriptParser::VariableDeclarationListContext::variableDeclaration() {
|
|
return getRuleContexts<EscriptParser::VariableDeclarationContext>();
|
|
}
|
|
|
|
EscriptParser::VariableDeclarationContext* EscriptParser::VariableDeclarationListContext::variableDeclaration(size_t i) {
|
|
return getRuleContext<EscriptParser::VariableDeclarationContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::VariableDeclarationListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::VariableDeclarationListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::VariableDeclarationListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleVariableDeclarationList;
|
|
}
|
|
|
|
void EscriptParser::VariableDeclarationListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterVariableDeclarationList(this);
|
|
}
|
|
|
|
void EscriptParser::VariableDeclarationListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitVariableDeclarationList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::VariableDeclarationListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitVariableDeclarationList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::VariableDeclarationListContext* EscriptParser::variableDeclarationList() {
|
|
VariableDeclarationListContext *_localctx = _tracker.createInstance<VariableDeclarationListContext>(_ctx, getState());
|
|
enterRule(_localctx, 92, EscriptParser::RuleVariableDeclarationList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(523);
|
|
variableDeclaration();
|
|
setState(528);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::COMMA) {
|
|
setState(524);
|
|
match(EscriptParser::COMMA);
|
|
setState(525);
|
|
variableDeclaration();
|
|
setState(530);
|
|
_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;
|
|
}
|
|
|
|
//----------------- ConstantDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ConstantDeclarationContext::ConstantDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ConstantDeclarationContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::VariableDeclarationInitializerContext* EscriptParser::ConstantDeclarationContext::variableDeclarationInitializer() {
|
|
return getRuleContext<EscriptParser::VariableDeclarationInitializerContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ConstantDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleConstantDeclaration;
|
|
}
|
|
|
|
void EscriptParser::ConstantDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterConstantDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::ConstantDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitConstantDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ConstantDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitConstantDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ConstantDeclarationContext* EscriptParser::constantDeclaration() {
|
|
ConstantDeclarationContext *_localctx = _tracker.createInstance<ConstantDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 94, EscriptParser::RuleConstantDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(531);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(532);
|
|
variableDeclarationInitializer();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VariableDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::VariableDeclarationContext::VariableDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::VariableDeclarationContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::VariableDeclarationInitializerContext* EscriptParser::VariableDeclarationContext::variableDeclarationInitializer() {
|
|
return getRuleContext<EscriptParser::VariableDeclarationInitializerContext>(0);
|
|
}
|
|
|
|
EscriptParser::BindingDeclarationContext* EscriptParser::VariableDeclarationContext::bindingDeclaration() {
|
|
return getRuleContext<EscriptParser::BindingDeclarationContext>(0);
|
|
}
|
|
|
|
EscriptParser::BindingDeclarationInitializerContext* EscriptParser::VariableDeclarationContext::bindingDeclarationInitializer() {
|
|
return getRuleContext<EscriptParser::BindingDeclarationInitializerContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::VariableDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleVariableDeclaration;
|
|
}
|
|
|
|
void EscriptParser::VariableDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterVariableDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::VariableDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitVariableDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::VariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitVariableDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::VariableDeclarationContext* EscriptParser::variableDeclaration() {
|
|
VariableDeclarationContext *_localctx = _tracker.createInstance<VariableDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 96, EscriptParser::RuleVariableDeclaration);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(541);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(534);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(536);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 66) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 66)) & 87960930222081) != 0)) {
|
|
setState(535);
|
|
variableDeclarationInitializer();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::LBRACK:
|
|
case EscriptParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(538);
|
|
bindingDeclaration();
|
|
setState(539);
|
|
bindingDeclarationInitializer();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BindingDeclarationContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BindingDeclarationContext::BindingDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingDeclarationContext::LBRACK() {
|
|
return getToken(EscriptParser::LBRACK, 0);
|
|
}
|
|
|
|
EscriptParser::SequenceBindingListContext* EscriptParser::BindingDeclarationContext::sequenceBindingList() {
|
|
return getRuleContext<EscriptParser::SequenceBindingListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingDeclarationContext::RBRACK() {
|
|
return getToken(EscriptParser::RBRACK, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingDeclarationContext::LBRACE() {
|
|
return getToken(EscriptParser::LBRACE, 0);
|
|
}
|
|
|
|
EscriptParser::IndexBindingListContext* EscriptParser::BindingDeclarationContext::indexBindingList() {
|
|
return getRuleContext<EscriptParser::IndexBindingListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingDeclarationContext::RBRACE() {
|
|
return getToken(EscriptParser::RBRACE, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BindingDeclarationContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBindingDeclaration;
|
|
}
|
|
|
|
void EscriptParser::BindingDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBindingDeclaration(this);
|
|
}
|
|
|
|
void EscriptParser::BindingDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBindingDeclaration(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BindingDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBindingDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BindingDeclarationContext* EscriptParser::bindingDeclaration() {
|
|
BindingDeclarationContext *_localctx = _tracker.createInstance<BindingDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 98, EscriptParser::RuleBindingDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(551);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::LBRACK: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(543);
|
|
match(EscriptParser::LBRACK);
|
|
setState(544);
|
|
sequenceBindingList();
|
|
setState(545);
|
|
match(EscriptParser::RBRACK);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(547);
|
|
match(EscriptParser::LBRACE);
|
|
setState(548);
|
|
indexBindingList();
|
|
setState(549);
|
|
match(EscriptParser::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;
|
|
}
|
|
|
|
//----------------- IndexBindingListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IndexBindingListContext::IndexBindingListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::IndexBindingContext *> EscriptParser::IndexBindingListContext::indexBinding() {
|
|
return getRuleContexts<EscriptParser::IndexBindingContext>();
|
|
}
|
|
|
|
EscriptParser::IndexBindingContext* EscriptParser::IndexBindingListContext::indexBinding(size_t i) {
|
|
return getRuleContext<EscriptParser::IndexBindingContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::IndexBindingListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexBindingListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IndexBindingListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIndexBindingList;
|
|
}
|
|
|
|
void EscriptParser::IndexBindingListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIndexBindingList(this);
|
|
}
|
|
|
|
void EscriptParser::IndexBindingListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIndexBindingList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IndexBindingListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIndexBindingList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IndexBindingListContext* EscriptParser::indexBindingList() {
|
|
IndexBindingListContext *_localctx = _tracker.createInstance<IndexBindingListContext>(_ctx, getState());
|
|
enterRule(_localctx, 100, EscriptParser::RuleIndexBindingList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(553);
|
|
indexBinding();
|
|
setState(558);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::COMMA) {
|
|
setState(554);
|
|
match(EscriptParser::COMMA);
|
|
setState(555);
|
|
indexBinding();
|
|
setState(560);
|
|
_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;
|
|
}
|
|
|
|
//----------------- SequenceBindingListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::SequenceBindingListContext::SequenceBindingListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::SequenceBindingContext *> EscriptParser::SequenceBindingListContext::sequenceBinding() {
|
|
return getRuleContexts<EscriptParser::SequenceBindingContext>();
|
|
}
|
|
|
|
EscriptParser::SequenceBindingContext* EscriptParser::SequenceBindingListContext::sequenceBinding(size_t i) {
|
|
return getRuleContext<EscriptParser::SequenceBindingContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::SequenceBindingListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SequenceBindingListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::SequenceBindingListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleSequenceBindingList;
|
|
}
|
|
|
|
void EscriptParser::SequenceBindingListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterSequenceBindingList(this);
|
|
}
|
|
|
|
void EscriptParser::SequenceBindingListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitSequenceBindingList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::SequenceBindingListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitSequenceBindingList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::SequenceBindingListContext* EscriptParser::sequenceBindingList() {
|
|
SequenceBindingListContext *_localctx = _tracker.createInstance<SequenceBindingListContext>(_ctx, getState());
|
|
enterRule(_localctx, 102, EscriptParser::RuleSequenceBindingList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(561);
|
|
sequenceBinding();
|
|
setState(566);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::COMMA) {
|
|
setState(562);
|
|
match(EscriptParser::COMMA);
|
|
setState(563);
|
|
sequenceBinding();
|
|
setState(568);
|
|
_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;
|
|
}
|
|
|
|
//----------------- SequenceBindingContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::SequenceBindingContext::SequenceBindingContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SequenceBindingContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::SequenceBindingContext::ELLIPSIS() {
|
|
return getToken(EscriptParser::ELLIPSIS, 0);
|
|
}
|
|
|
|
EscriptParser::BindingDeclarationContext* EscriptParser::SequenceBindingContext::bindingDeclaration() {
|
|
return getRuleContext<EscriptParser::BindingDeclarationContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::SequenceBindingContext::getRuleIndex() const {
|
|
return EscriptParser::RuleSequenceBinding;
|
|
}
|
|
|
|
void EscriptParser::SequenceBindingContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterSequenceBinding(this);
|
|
}
|
|
|
|
void EscriptParser::SequenceBindingContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitSequenceBinding(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::SequenceBindingContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitSequenceBinding(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::SequenceBindingContext* EscriptParser::sequenceBinding() {
|
|
SequenceBindingContext *_localctx = _tracker.createInstance<SequenceBindingContext>(_ctx, getState());
|
|
enterRule(_localctx, 104, EscriptParser::RuleSequenceBinding);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(574);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(569);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(571);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ELLIPSIS) {
|
|
setState(570);
|
|
match(EscriptParser::ELLIPSIS);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::LBRACK:
|
|
case EscriptParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(573);
|
|
bindingDeclaration();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IndexBindingContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IndexBindingContext::IndexBindingContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexBindingContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexBindingContext::ELLIPSIS() {
|
|
return getToken(EscriptParser::ELLIPSIS, 0);
|
|
}
|
|
|
|
EscriptParser::BindingContext* EscriptParser::IndexBindingContext::binding() {
|
|
return getRuleContext<EscriptParser::BindingContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexBindingContext::LBRACK() {
|
|
return getToken(EscriptParser::LBRACK, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::IndexBindingContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexBindingContext::RBRACK() {
|
|
return getToken(EscriptParser::RBRACK, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IndexBindingContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIndexBinding;
|
|
}
|
|
|
|
void EscriptParser::IndexBindingContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIndexBinding(this);
|
|
}
|
|
|
|
void EscriptParser::IndexBindingContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIndexBinding(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IndexBindingContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIndexBinding(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IndexBindingContext* EscriptParser::indexBinding() {
|
|
IndexBindingContext *_localctx = _tracker.createInstance<IndexBindingContext>(_ctx, getState());
|
|
enterRule(_localctx, 106, EscriptParser::RuleIndexBinding);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(589);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(576);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(578);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ELLIPSIS) {
|
|
setState(577);
|
|
match(EscriptParser::ELLIPSIS);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(580);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(582);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::COLON) {
|
|
setState(581);
|
|
binding();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(584);
|
|
match(EscriptParser::LBRACK);
|
|
setState(585);
|
|
expression(0);
|
|
setState(586);
|
|
match(EscriptParser::RBRACK);
|
|
setState(587);
|
|
binding();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BindingContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BindingContext::BindingContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingContext::COLON() {
|
|
return getToken(EscriptParser::COLON, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::BindingDeclarationContext* EscriptParser::BindingContext::bindingDeclaration() {
|
|
return getRuleContext<EscriptParser::BindingDeclarationContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BindingContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBinding;
|
|
}
|
|
|
|
void EscriptParser::BindingContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBinding(this);
|
|
}
|
|
|
|
void EscriptParser::BindingContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBinding(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BindingContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBinding(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BindingContext* EscriptParser::binding() {
|
|
BindingContext *_localctx = _tracker.createInstance<BindingContext>(_ctx, getState());
|
|
enterRule(_localctx, 108, EscriptParser::RuleBinding);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(595);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(591);
|
|
match(EscriptParser::COLON);
|
|
setState(592);
|
|
match(EscriptParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(593);
|
|
match(EscriptParser::COLON);
|
|
setState(594);
|
|
bindingDeclaration();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BindingDeclarationInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BindingDeclarationInitializerContext::BindingDeclarationInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingDeclarationInitializerContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::BindingDeclarationInitializerContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BindingDeclarationInitializerContext::EQUAL_DEPRECATED() {
|
|
return getToken(EscriptParser::EQUAL_DEPRECATED, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BindingDeclarationInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBindingDeclarationInitializer;
|
|
}
|
|
|
|
void EscriptParser::BindingDeclarationInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBindingDeclarationInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::BindingDeclarationInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBindingDeclarationInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BindingDeclarationInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBindingDeclarationInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BindingDeclarationInitializerContext* EscriptParser::bindingDeclarationInitializer() {
|
|
BindingDeclarationInitializerContext *_localctx = _tracker.createInstance<BindingDeclarationInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 110, EscriptParser::RuleBindingDeclarationInitializer);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(603);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::ASSIGN: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(597);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(598);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::EQUAL_DEPRECATED: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(599);
|
|
match(EscriptParser::EQUAL_DEPRECATED);
|
|
setState(600);
|
|
expression(0);
|
|
notifyErrorListeners("Unexpected token: '='. Did you mean := for assign?\n");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ProgramParametersContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ProgramParametersContext::ProgramParametersContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramParametersContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramParametersContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::ProgramParameterListContext* EscriptParser::ProgramParametersContext::programParameterList() {
|
|
return getRuleContext<EscriptParser::ProgramParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ProgramParametersContext::getRuleIndex() const {
|
|
return EscriptParser::RuleProgramParameters;
|
|
}
|
|
|
|
void EscriptParser::ProgramParametersContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterProgramParameters(this);
|
|
}
|
|
|
|
void EscriptParser::ProgramParametersContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitProgramParameters(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ProgramParametersContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitProgramParameters(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ProgramParametersContext* EscriptParser::programParameters() {
|
|
ProgramParametersContext *_localctx = _tracker.createInstance<ProgramParametersContext>(_ctx, getState());
|
|
enterRule(_localctx, 112, EscriptParser::RuleProgramParameters);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(605);
|
|
match(EscriptParser::LPAREN);
|
|
setState(607);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::UNUSED || _la == EscriptParser::IDENTIFIER) {
|
|
setState(606);
|
|
programParameterList();
|
|
}
|
|
setState(609);
|
|
match(EscriptParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ProgramParameterListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ProgramParameterListContext::ProgramParameterListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::ProgramParameterContext *> EscriptParser::ProgramParameterListContext::programParameter() {
|
|
return getRuleContexts<EscriptParser::ProgramParameterContext>();
|
|
}
|
|
|
|
EscriptParser::ProgramParameterContext* EscriptParser::ProgramParameterListContext::programParameter(size_t i) {
|
|
return getRuleContext<EscriptParser::ProgramParameterContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::ProgramParameterListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramParameterListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ProgramParameterListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleProgramParameterList;
|
|
}
|
|
|
|
void EscriptParser::ProgramParameterListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterProgramParameterList(this);
|
|
}
|
|
|
|
void EscriptParser::ProgramParameterListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitProgramParameterList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ProgramParameterListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitProgramParameterList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ProgramParameterListContext* EscriptParser::programParameterList() {
|
|
ProgramParameterListContext *_localctx = _tracker.createInstance<ProgramParameterListContext>(_ctx, getState());
|
|
enterRule(_localctx, 114, EscriptParser::RuleProgramParameterList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(611);
|
|
programParameter();
|
|
setState(618);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::UNUSED || _la == EscriptParser::COMMA
|
|
|
|
|| _la == EscriptParser::IDENTIFIER) {
|
|
setState(613);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::COMMA) {
|
|
setState(612);
|
|
match(EscriptParser::COMMA);
|
|
}
|
|
setState(615);
|
|
programParameter();
|
|
setState(620);
|
|
_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;
|
|
}
|
|
|
|
//----------------- ProgramParameterContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ProgramParameterContext::ProgramParameterContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramParameterContext::UNUSED() {
|
|
return getToken(EscriptParser::UNUSED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramParameterContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ProgramParameterContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::ProgramParameterContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ProgramParameterContext::getRuleIndex() const {
|
|
return EscriptParser::RuleProgramParameter;
|
|
}
|
|
|
|
void EscriptParser::ProgramParameterContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterProgramParameter(this);
|
|
}
|
|
|
|
void EscriptParser::ProgramParameterContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitProgramParameter(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ProgramParameterContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitProgramParameter(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ProgramParameterContext* EscriptParser::programParameter() {
|
|
ProgramParameterContext *_localctx = _tracker.createInstance<ProgramParameterContext>(_ctx, getState());
|
|
enterRule(_localctx, 116, EscriptParser::RuleProgramParameter);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(628);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::UNUSED: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(621);
|
|
match(EscriptParser::UNUSED);
|
|
setState(622);
|
|
match(EscriptParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(623);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(626);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ASSIGN) {
|
|
setState(624);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(625);
|
|
expression(0);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionParametersContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionParametersContext::FunctionParametersContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParametersContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParametersContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::FunctionParameterListContext* EscriptParser::FunctionParametersContext::functionParameterList() {
|
|
return getRuleContext<EscriptParser::FunctionParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionParametersContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionParameters;
|
|
}
|
|
|
|
void EscriptParser::FunctionParametersContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionParameters(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionParametersContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionParameters(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionParametersContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionParameters(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionParametersContext* EscriptParser::functionParameters() {
|
|
FunctionParametersContext *_localctx = _tracker.createInstance<FunctionParametersContext>(_ctx, getState());
|
|
enterRule(_localctx, 118, EscriptParser::RuleFunctionParameters);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(630);
|
|
match(EscriptParser::LPAREN);
|
|
setState(632);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::BYREF
|
|
|
|
|| _la == EscriptParser::UNUSED || _la == EscriptParser::IDENTIFIER) {
|
|
setState(631);
|
|
functionParameterList();
|
|
}
|
|
setState(634);
|
|
match(EscriptParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionParameterListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionParameterListContext::FunctionParameterListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::FunctionParameterContext *> EscriptParser::FunctionParameterListContext::functionParameter() {
|
|
return getRuleContexts<EscriptParser::FunctionParameterContext>();
|
|
}
|
|
|
|
EscriptParser::FunctionParameterContext* EscriptParser::FunctionParameterListContext::functionParameter(size_t i) {
|
|
return getRuleContext<EscriptParser::FunctionParameterContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::FunctionParameterListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParameterListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionParameterListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionParameterList;
|
|
}
|
|
|
|
void EscriptParser::FunctionParameterListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionParameterList(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionParameterListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionParameterList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionParameterListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionParameterList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionParameterListContext* EscriptParser::functionParameterList() {
|
|
FunctionParameterListContext *_localctx = _tracker.createInstance<FunctionParameterListContext>(_ctx, getState());
|
|
enterRule(_localctx, 120, EscriptParser::RuleFunctionParameterList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(636);
|
|
functionParameter();
|
|
setState(641);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::COMMA) {
|
|
setState(637);
|
|
match(EscriptParser::COMMA);
|
|
setState(638);
|
|
functionParameter();
|
|
setState(643);
|
|
_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;
|
|
}
|
|
|
|
//----------------- FunctionParameterContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionParameterContext::FunctionParameterContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParameterContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParameterContext::BYREF() {
|
|
return getToken(EscriptParser::BYREF, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParameterContext::UNUSED() {
|
|
return getToken(EscriptParser::UNUSED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParameterContext::ELLIPSIS() {
|
|
return getToken(EscriptParser::ELLIPSIS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionParameterContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::FunctionParameterContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionParameterContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionParameter;
|
|
}
|
|
|
|
void EscriptParser::FunctionParameterContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionParameter(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionParameterContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionParameter(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionParameterContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionParameter(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionParameterContext* EscriptParser::functionParameter() {
|
|
FunctionParameterContext *_localctx = _tracker.createInstance<FunctionParameterContext>(_ctx, getState());
|
|
enterRule(_localctx, 122, EscriptParser::RuleFunctionParameter);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(645);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::BYREF) {
|
|
setState(644);
|
|
match(EscriptParser::BYREF);
|
|
}
|
|
setState(648);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::UNUSED) {
|
|
setState(647);
|
|
match(EscriptParser::UNUSED);
|
|
}
|
|
setState(650);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(652);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ELLIPSIS) {
|
|
setState(651);
|
|
match(EscriptParser::ELLIPSIS);
|
|
}
|
|
setState(656);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ASSIGN) {
|
|
setState(654);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(655);
|
|
expression(0);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ScopedFunctionCallContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ScopedFunctionCallContext::ScopedFunctionCallContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ScopedFunctionCallContext::COLONCOLON() {
|
|
return getToken(EscriptParser::COLONCOLON, 0);
|
|
}
|
|
|
|
EscriptParser::FunctionCallContext* EscriptParser::ScopedFunctionCallContext::functionCall() {
|
|
return getRuleContext<EscriptParser::FunctionCallContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ScopedFunctionCallContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ScopedFunctionCallContext::getRuleIndex() const {
|
|
return EscriptParser::RuleScopedFunctionCall;
|
|
}
|
|
|
|
void EscriptParser::ScopedFunctionCallContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterScopedFunctionCall(this);
|
|
}
|
|
|
|
void EscriptParser::ScopedFunctionCallContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitScopedFunctionCall(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ScopedFunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitScopedFunctionCall(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ScopedFunctionCallContext* EscriptParser::scopedFunctionCall() {
|
|
ScopedFunctionCallContext *_localctx = _tracker.createInstance<ScopedFunctionCallContext>(_ctx, getState());
|
|
enterRule(_localctx, 124, EscriptParser::RuleScopedFunctionCall);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(659);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(658);
|
|
match(EscriptParser::IDENTIFIER);
|
|
}
|
|
setState(661);
|
|
match(EscriptParser::COLONCOLON);
|
|
setState(662);
|
|
functionCall();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionReferenceContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionReferenceContext::FunctionReferenceContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionReferenceContext::AT() {
|
|
return getToken(EscriptParser::AT, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::FunctionReferenceContext::IDENTIFIER() {
|
|
return getTokens(EscriptParser::IDENTIFIER);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionReferenceContext::IDENTIFIER(size_t i) {
|
|
return getToken(EscriptParser::IDENTIFIER, i);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionReferenceContext::COLONCOLON() {
|
|
return getToken(EscriptParser::COLONCOLON, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionReferenceContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionReference;
|
|
}
|
|
|
|
void EscriptParser::FunctionReferenceContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionReference(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionReferenceContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionReference(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionReferenceContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionReference(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionReferenceContext* EscriptParser::functionReference() {
|
|
FunctionReferenceContext *_localctx = _tracker.createInstance<FunctionReferenceContext>(_ctx, getState());
|
|
enterRule(_localctx, 126, EscriptParser::RuleFunctionReference);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(664);
|
|
match(EscriptParser::AT);
|
|
setState(669);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
|
|
case 1: {
|
|
setState(666);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(665);
|
|
antlrcpp::downCast<FunctionReferenceContext *>(_localctx)->scope = match(EscriptParser::IDENTIFIER);
|
|
}
|
|
setState(668);
|
|
match(EscriptParser::COLONCOLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(671);
|
|
antlrcpp::downCast<FunctionReferenceContext *>(_localctx)->function = match(EscriptParser::IDENTIFIER);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExpressionContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::PrimaryContext* EscriptParser::ExpressionContext::primary() {
|
|
return getRuleContext<EscriptParser::PrimaryContext>(0);
|
|
}
|
|
|
|
std::vector<EscriptParser::ExpressionContext *> EscriptParser::ExpressionContext::expression() {
|
|
return getRuleContexts<EscriptParser::ExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::ExpressionContext::expression(size_t i) {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::ADD() {
|
|
return getToken(EscriptParser::ADD, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::SUB() {
|
|
return getToken(EscriptParser::SUB, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::INC() {
|
|
return getToken(EscriptParser::INC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::DEC() {
|
|
return getToken(EscriptParser::DEC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::TILDE() {
|
|
return getToken(EscriptParser::TILDE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::BANG_A() {
|
|
return getToken(EscriptParser::BANG_A, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::BANG_B() {
|
|
return getToken(EscriptParser::BANG_B, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::MUL() {
|
|
return getToken(EscriptParser::MUL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::DIV() {
|
|
return getToken(EscriptParser::DIV, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::MOD() {
|
|
return getToken(EscriptParser::MOD, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::LSHIFT() {
|
|
return getToken(EscriptParser::LSHIFT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::RSHIFT() {
|
|
return getToken(EscriptParser::RSHIFT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::BITAND() {
|
|
return getToken(EscriptParser::BITAND, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::BITOR() {
|
|
return getToken(EscriptParser::BITOR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::CARET() {
|
|
return getToken(EscriptParser::CARET, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::ELVIS() {
|
|
return getToken(EscriptParser::ELVIS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::TOK_IN() {
|
|
return getToken(EscriptParser::TOK_IN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::LE() {
|
|
return getToken(EscriptParser::LE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::GE() {
|
|
return getToken(EscriptParser::GE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::GT() {
|
|
return getToken(EscriptParser::GT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::LT() {
|
|
return getToken(EscriptParser::LT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::IS() {
|
|
return getToken(EscriptParser::IS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::EQUAL_DEPRECATED() {
|
|
return getToken(EscriptParser::EQUAL_DEPRECATED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::EQUAL() {
|
|
return getToken(EscriptParser::EQUAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::NOTEQUAL_B() {
|
|
return getToken(EscriptParser::NOTEQUAL_B, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::NOTEQUAL_A() {
|
|
return getToken(EscriptParser::NOTEQUAL_A, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::AND_A() {
|
|
return getToken(EscriptParser::AND_A, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::AND_B() {
|
|
return getToken(EscriptParser::AND_B, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::OR_A() {
|
|
return getToken(EscriptParser::OR_A, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::OR_B() {
|
|
return getToken(EscriptParser::OR_B, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::QUESTION() {
|
|
return getToken(EscriptParser::QUESTION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::COLON() {
|
|
return getToken(EscriptParser::COLON, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::ADDMEMBER() {
|
|
return getToken(EscriptParser::ADDMEMBER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::DELMEMBER() {
|
|
return getToken(EscriptParser::DELMEMBER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::CHKMEMBER() {
|
|
return getToken(EscriptParser::CHKMEMBER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::ADD_ASSIGN() {
|
|
return getToken(EscriptParser::ADD_ASSIGN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::SUB_ASSIGN() {
|
|
return getToken(EscriptParser::SUB_ASSIGN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::MUL_ASSIGN() {
|
|
return getToken(EscriptParser::MUL_ASSIGN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::DIV_ASSIGN() {
|
|
return getToken(EscriptParser::DIV_ASSIGN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionContext::MOD_ASSIGN() {
|
|
return getToken(EscriptParser::MOD_ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionSuffixContext* EscriptParser::ExpressionContext::expressionSuffix() {
|
|
return getRuleContext<EscriptParser::ExpressionSuffixContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExpressionContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExpression;
|
|
}
|
|
|
|
void EscriptParser::ExpressionContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExpression(this);
|
|
}
|
|
|
|
void EscriptParser::ExpressionContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExpression(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::expression() {
|
|
return expression(0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::expression(int precedence) {
|
|
ParserRuleContext *parentContext = _ctx;
|
|
size_t parentState = getState();
|
|
EscriptParser::ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, parentState);
|
|
EscriptParser::ExpressionContext *previousContext = _localctx;
|
|
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
|
|
size_t startState = 128;
|
|
enterRecursionRule(_localctx, 128, EscriptParser::RuleExpression, 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(679);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::TOK_ERROR:
|
|
case EscriptParser::DICTIONARY:
|
|
case EscriptParser::STRUCT:
|
|
case EscriptParser::ARRAY:
|
|
case EscriptParser::UNINIT:
|
|
case EscriptParser::BOOL_TRUE:
|
|
case EscriptParser::BOOL_FALSE:
|
|
case EscriptParser::DECIMAL_LITERAL:
|
|
case EscriptParser::HEX_LITERAL:
|
|
case EscriptParser::OCT_LITERAL:
|
|
case EscriptParser::BINARY_LITERAL:
|
|
case EscriptParser::FLOAT_LITERAL:
|
|
case EscriptParser::HEX_FLOAT_LITERAL:
|
|
case EscriptParser::STRING_LITERAL:
|
|
case EscriptParser::INTERPOLATED_STRING_START:
|
|
case EscriptParser::LPAREN:
|
|
case EscriptParser::LBRACE:
|
|
case EscriptParser::AT:
|
|
case EscriptParser::COLONCOLON:
|
|
case EscriptParser::IDENTIFIER: {
|
|
setState(674);
|
|
primary();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::ADD:
|
|
case EscriptParser::SUB:
|
|
case EscriptParser::INC:
|
|
case EscriptParser::DEC: {
|
|
setState(675);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->prefix = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 92) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 92)) & 3221225475) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->prefix = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(676);
|
|
expression(15);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::BANG_A:
|
|
case EscriptParser::BANG_B:
|
|
case EscriptParser::TILDE: {
|
|
setState(677);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->prefix = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 1152921504606846979) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->prefix = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(678);
|
|
expression(14);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(730);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
setState(728);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(681);
|
|
|
|
if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)");
|
|
setState(682);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 89) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 89)) & 114695) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(683);
|
|
expression(14);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(684);
|
|
|
|
if (!(precpred(_ctx, 12))) throw FailedPredicateException(this, "precpred(_ctx, 12)");
|
|
setState(685);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 92) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 92)) & 49155) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(686);
|
|
expression(13);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(687);
|
|
|
|
if (!(precpred(_ctx, 11))) throw FailedPredicateException(this, "precpred(_ctx, 11)");
|
|
setState(688);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = match(EscriptParser::ELVIS);
|
|
setState(689);
|
|
expression(12);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(690);
|
|
|
|
if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)");
|
|
setState(691);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = match(EscriptParser::TOK_IN);
|
|
setState(692);
|
|
expression(11);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(693);
|
|
|
|
if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)");
|
|
setState(694);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 99) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 99)) & 15) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(695);
|
|
expression(10);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(696);
|
|
|
|
if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)");
|
|
setState(697);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = match(EscriptParser::IS);
|
|
setState(698);
|
|
expression(9);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(699);
|
|
|
|
if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
|
|
setState(700);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = match(EscriptParser::EQUAL_DEPRECATED);
|
|
notifyErrorListeners("Deprecated '=' found: did you mean '==' or ':='?\n");
|
|
setState(702);
|
|
expression(8);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(703);
|
|
|
|
if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
|
|
setState(704);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 108) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 108)) & 11) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(705);
|
|
expression(7);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(706);
|
|
|
|
if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
|
|
setState(707);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(_la == EscriptParser::AND_A
|
|
|
|
|| _la == EscriptParser::AND_B)) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(708);
|
|
expression(6);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(709);
|
|
|
|
if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(710);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(_la == EscriptParser::OR_A
|
|
|
|
|| _la == EscriptParser::OR_B)) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(711);
|
|
expression(5);
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(712);
|
|
|
|
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(713);
|
|
match(EscriptParser::QUESTION);
|
|
setState(714);
|
|
expression(0);
|
|
setState(715);
|
|
match(EscriptParser::COLON);
|
|
setState(716);
|
|
expression(4);
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(718);
|
|
|
|
if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(719);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 113) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 113)) & 7) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(720);
|
|
expression(2);
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(721);
|
|
|
|
if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(722);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 94) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 94)) & 262175) != 0))) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->bop = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(723);
|
|
expression(1);
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(724);
|
|
|
|
if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)");
|
|
setState(725);
|
|
expressionSuffix();
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
|
setState(726);
|
|
|
|
if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)");
|
|
setState(727);
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->postfix = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(_la == EscriptParser::INC
|
|
|
|
|| _la == EscriptParser::DEC)) {
|
|
antlrcpp::downCast<ExpressionContext *>(_localctx)->postfix = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
setState(732);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx);
|
|
}
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- PrimaryContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::PrimaryContext::PrimaryContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::LiteralContext* EscriptParser::PrimaryContext::literal() {
|
|
return getRuleContext<EscriptParser::LiteralContext>(0);
|
|
}
|
|
|
|
EscriptParser::ParExpressionContext* EscriptParser::PrimaryContext::parExpression() {
|
|
return getRuleContext<EscriptParser::ParExpressionContext>(0);
|
|
}
|
|
|
|
EscriptParser::FunctionCallContext* EscriptParser::PrimaryContext::functionCall() {
|
|
return getRuleContext<EscriptParser::FunctionCallContext>(0);
|
|
}
|
|
|
|
EscriptParser::ScopedFunctionCallContext* EscriptParser::PrimaryContext::scopedFunctionCall() {
|
|
return getRuleContext<EscriptParser::ScopedFunctionCallContext>(0);
|
|
}
|
|
|
|
EscriptParser::ScopedIdentifierContext* EscriptParser::PrimaryContext::scopedIdentifier() {
|
|
return getRuleContext<EscriptParser::ScopedIdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::PrimaryContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
EscriptParser::FunctionReferenceContext* EscriptParser::PrimaryContext::functionReference() {
|
|
return getRuleContext<EscriptParser::FunctionReferenceContext>(0);
|
|
}
|
|
|
|
EscriptParser::FunctionExpressionContext* EscriptParser::PrimaryContext::functionExpression() {
|
|
return getRuleContext<EscriptParser::FunctionExpressionContext>(0);
|
|
}
|
|
|
|
EscriptParser::ExplicitArrayInitializerContext* EscriptParser::PrimaryContext::explicitArrayInitializer() {
|
|
return getRuleContext<EscriptParser::ExplicitArrayInitializerContext>(0);
|
|
}
|
|
|
|
EscriptParser::ExplicitStructInitializerContext* EscriptParser::PrimaryContext::explicitStructInitializer() {
|
|
return getRuleContext<EscriptParser::ExplicitStructInitializerContext>(0);
|
|
}
|
|
|
|
EscriptParser::ExplicitDictInitializerContext* EscriptParser::PrimaryContext::explicitDictInitializer() {
|
|
return getRuleContext<EscriptParser::ExplicitDictInitializerContext>(0);
|
|
}
|
|
|
|
EscriptParser::ExplicitErrorInitializerContext* EscriptParser::PrimaryContext::explicitErrorInitializer() {
|
|
return getRuleContext<EscriptParser::ExplicitErrorInitializerContext>(0);
|
|
}
|
|
|
|
EscriptParser::BareArrayInitializerContext* EscriptParser::PrimaryContext::bareArrayInitializer() {
|
|
return getRuleContext<EscriptParser::BareArrayInitializerContext>(0);
|
|
}
|
|
|
|
EscriptParser::InterpolatedStringContext* EscriptParser::PrimaryContext::interpolatedString() {
|
|
return getRuleContext<EscriptParser::InterpolatedStringContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::PrimaryContext::getRuleIndex() const {
|
|
return EscriptParser::RulePrimary;
|
|
}
|
|
|
|
void EscriptParser::PrimaryContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterPrimary(this);
|
|
}
|
|
|
|
void EscriptParser::PrimaryContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitPrimary(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::PrimaryContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitPrimary(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::PrimaryContext* EscriptParser::primary() {
|
|
PrimaryContext *_localctx = _tracker.createInstance<PrimaryContext>(_ctx, getState());
|
|
enterRule(_localctx, 130, EscriptParser::RulePrimary);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(747);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(733);
|
|
literal();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(734);
|
|
parExpression();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(735);
|
|
functionCall();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(736);
|
|
scopedFunctionCall();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(737);
|
|
scopedIdentifier();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(738);
|
|
match(EscriptParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(739);
|
|
functionReference();
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
enterOuterAlt(_localctx, 8);
|
|
setState(740);
|
|
functionExpression();
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
enterOuterAlt(_localctx, 9);
|
|
setState(741);
|
|
explicitArrayInitializer();
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
enterOuterAlt(_localctx, 10);
|
|
setState(742);
|
|
explicitStructInitializer();
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
enterOuterAlt(_localctx, 11);
|
|
setState(743);
|
|
explicitDictInitializer();
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
enterOuterAlt(_localctx, 12);
|
|
setState(744);
|
|
explicitErrorInitializer();
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
enterOuterAlt(_localctx, 13);
|
|
setState(745);
|
|
bareArrayInitializer();
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
enterOuterAlt(_localctx, 14);
|
|
setState(746);
|
|
interpolatedString();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ScopedIdentifierContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ScopedIdentifierContext::ScopedIdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ScopedIdentifierContext::COLONCOLON() {
|
|
return getToken(EscriptParser::COLONCOLON, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::ScopedIdentifierContext::IDENTIFIER() {
|
|
return getTokens(EscriptParser::IDENTIFIER);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ScopedIdentifierContext::IDENTIFIER(size_t i) {
|
|
return getToken(EscriptParser::IDENTIFIER, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ScopedIdentifierContext::getRuleIndex() const {
|
|
return EscriptParser::RuleScopedIdentifier;
|
|
}
|
|
|
|
void EscriptParser::ScopedIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterScopedIdentifier(this);
|
|
}
|
|
|
|
void EscriptParser::ScopedIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitScopedIdentifier(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ScopedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitScopedIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ScopedIdentifierContext* EscriptParser::scopedIdentifier() {
|
|
ScopedIdentifierContext *_localctx = _tracker.createInstance<ScopedIdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 132, EscriptParser::RuleScopedIdentifier);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(750);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::IDENTIFIER) {
|
|
setState(749);
|
|
antlrcpp::downCast<ScopedIdentifierContext *>(_localctx)->scope = match(EscriptParser::IDENTIFIER);
|
|
}
|
|
setState(752);
|
|
match(EscriptParser::COLONCOLON);
|
|
setState(753);
|
|
antlrcpp::downCast<ScopedIdentifierContext *>(_localctx)->identifier = match(EscriptParser::IDENTIFIER);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionExpressionContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionExpressionContext::FunctionExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionExpressionContext::AT() {
|
|
return getToken(EscriptParser::AT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionExpressionContext::LBRACE() {
|
|
return getToken(EscriptParser::LBRACE, 0);
|
|
}
|
|
|
|
EscriptParser::BlockContext* EscriptParser::FunctionExpressionContext::block() {
|
|
return getRuleContext<EscriptParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionExpressionContext::RBRACE() {
|
|
return getToken(EscriptParser::RBRACE, 0);
|
|
}
|
|
|
|
EscriptParser::FunctionParametersContext* EscriptParser::FunctionExpressionContext::functionParameters() {
|
|
return getRuleContext<EscriptParser::FunctionParametersContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionExpressionContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionExpression;
|
|
}
|
|
|
|
void EscriptParser::FunctionExpressionContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionExpression(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionExpressionContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionExpression(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionExpressionContext* EscriptParser::functionExpression() {
|
|
FunctionExpressionContext *_localctx = _tracker.createInstance<FunctionExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 134, EscriptParser::RuleFunctionExpression);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(755);
|
|
match(EscriptParser::AT);
|
|
setState(757);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::LPAREN) {
|
|
setState(756);
|
|
functionParameters();
|
|
}
|
|
setState(759);
|
|
match(EscriptParser::LBRACE);
|
|
setState(760);
|
|
block();
|
|
setState(761);
|
|
match(EscriptParser::RBRACE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExplicitArrayInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExplicitArrayInitializerContext::ExplicitArrayInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExplicitArrayInitializerContext::ARRAY() {
|
|
return getToken(EscriptParser::ARRAY, 0);
|
|
}
|
|
|
|
EscriptParser::ArrayInitializerContext* EscriptParser::ExplicitArrayInitializerContext::arrayInitializer() {
|
|
return getRuleContext<EscriptParser::ArrayInitializerContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExplicitArrayInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExplicitArrayInitializer;
|
|
}
|
|
|
|
void EscriptParser::ExplicitArrayInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExplicitArrayInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::ExplicitArrayInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExplicitArrayInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExplicitArrayInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExplicitArrayInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExplicitArrayInitializerContext* EscriptParser::explicitArrayInitializer() {
|
|
ExplicitArrayInitializerContext *_localctx = _tracker.createInstance<ExplicitArrayInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 136, EscriptParser::RuleExplicitArrayInitializer);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(763);
|
|
match(EscriptParser::ARRAY);
|
|
setState(765);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 70, _ctx)) {
|
|
case 1: {
|
|
setState(764);
|
|
arrayInitializer();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExplicitStructInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExplicitStructInitializerContext::ExplicitStructInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExplicitStructInitializerContext::STRUCT() {
|
|
return getToken(EscriptParser::STRUCT, 0);
|
|
}
|
|
|
|
EscriptParser::StructInitializerContext* EscriptParser::ExplicitStructInitializerContext::structInitializer() {
|
|
return getRuleContext<EscriptParser::StructInitializerContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExplicitStructInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExplicitStructInitializer;
|
|
}
|
|
|
|
void EscriptParser::ExplicitStructInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExplicitStructInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::ExplicitStructInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExplicitStructInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExplicitStructInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExplicitStructInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExplicitStructInitializerContext* EscriptParser::explicitStructInitializer() {
|
|
ExplicitStructInitializerContext *_localctx = _tracker.createInstance<ExplicitStructInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 138, EscriptParser::RuleExplicitStructInitializer);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(767);
|
|
match(EscriptParser::STRUCT);
|
|
setState(769);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 71, _ctx)) {
|
|
case 1: {
|
|
setState(768);
|
|
structInitializer();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExplicitDictInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExplicitDictInitializerContext::ExplicitDictInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExplicitDictInitializerContext::DICTIONARY() {
|
|
return getToken(EscriptParser::DICTIONARY, 0);
|
|
}
|
|
|
|
EscriptParser::DictInitializerContext* EscriptParser::ExplicitDictInitializerContext::dictInitializer() {
|
|
return getRuleContext<EscriptParser::DictInitializerContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExplicitDictInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExplicitDictInitializer;
|
|
}
|
|
|
|
void EscriptParser::ExplicitDictInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExplicitDictInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::ExplicitDictInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExplicitDictInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExplicitDictInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExplicitDictInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExplicitDictInitializerContext* EscriptParser::explicitDictInitializer() {
|
|
ExplicitDictInitializerContext *_localctx = _tracker.createInstance<ExplicitDictInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 140, EscriptParser::RuleExplicitDictInitializer);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(771);
|
|
match(EscriptParser::DICTIONARY);
|
|
setState(773);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 72, _ctx)) {
|
|
case 1: {
|
|
setState(772);
|
|
dictInitializer();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExplicitErrorInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExplicitErrorInitializerContext::ExplicitErrorInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExplicitErrorInitializerContext::TOK_ERROR() {
|
|
return getToken(EscriptParser::TOK_ERROR, 0);
|
|
}
|
|
|
|
EscriptParser::StructInitializerContext* EscriptParser::ExplicitErrorInitializerContext::structInitializer() {
|
|
return getRuleContext<EscriptParser::StructInitializerContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExplicitErrorInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExplicitErrorInitializer;
|
|
}
|
|
|
|
void EscriptParser::ExplicitErrorInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExplicitErrorInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::ExplicitErrorInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExplicitErrorInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExplicitErrorInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExplicitErrorInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExplicitErrorInitializerContext* EscriptParser::explicitErrorInitializer() {
|
|
ExplicitErrorInitializerContext *_localctx = _tracker.createInstance<ExplicitErrorInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 142, EscriptParser::RuleExplicitErrorInitializer);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(775);
|
|
match(EscriptParser::TOK_ERROR);
|
|
setState(777);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 73, _ctx)) {
|
|
case 1: {
|
|
setState(776);
|
|
structInitializer();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BareArrayInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BareArrayInitializerContext::BareArrayInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BareArrayInitializerContext::LBRACE() {
|
|
return getToken(EscriptParser::LBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BareArrayInitializerContext::RBRACE() {
|
|
return getToken(EscriptParser::RBRACE, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionListContext* EscriptParser::BareArrayInitializerContext::expressionList() {
|
|
return getRuleContext<EscriptParser::ExpressionListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BareArrayInitializerContext::COMMA() {
|
|
return getToken(EscriptParser::COMMA, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BareArrayInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBareArrayInitializer;
|
|
}
|
|
|
|
void EscriptParser::BareArrayInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBareArrayInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::BareArrayInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBareArrayInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BareArrayInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBareArrayInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BareArrayInitializerContext* EscriptParser::bareArrayInitializer() {
|
|
BareArrayInitializerContext *_localctx = _tracker.createInstance<BareArrayInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 144, EscriptParser::RuleBareArrayInitializer);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(791);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(779);
|
|
match(EscriptParser::LBRACE);
|
|
setState(781);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(780);
|
|
expressionList();
|
|
}
|
|
setState(783);
|
|
match(EscriptParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(784);
|
|
match(EscriptParser::LBRACE);
|
|
setState(786);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(785);
|
|
expressionList();
|
|
}
|
|
setState(788);
|
|
match(EscriptParser::COMMA);
|
|
setState(789);
|
|
match(EscriptParser::RBRACE);
|
|
notifyErrorListeners("Expected expression following comma before right-brace in array initializer list");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ParExpressionContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ParExpressionContext::ParExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ParExpressionContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::ParExpressionContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ParExpressionContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ParExpressionContext::getRuleIndex() const {
|
|
return EscriptParser::RuleParExpression;
|
|
}
|
|
|
|
void EscriptParser::ParExpressionContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterParExpression(this);
|
|
}
|
|
|
|
void EscriptParser::ParExpressionContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitParExpression(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ParExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitParExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ParExpressionContext* EscriptParser::parExpression() {
|
|
ParExpressionContext *_localctx = _tracker.createInstance<ParExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 146, EscriptParser::RuleParExpression);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(793);
|
|
match(EscriptParser::LPAREN);
|
|
setState(794);
|
|
expression(0);
|
|
setState(795);
|
|
match(EscriptParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExpressionListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExpressionListContext::ExpressionListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::ExpressionListEntryContext *> EscriptParser::ExpressionListContext::expressionListEntry() {
|
|
return getRuleContexts<EscriptParser::ExpressionListEntryContext>();
|
|
}
|
|
|
|
EscriptParser::ExpressionListEntryContext* EscriptParser::ExpressionListContext::expressionListEntry(size_t i) {
|
|
return getRuleContext<EscriptParser::ExpressionListEntryContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::ExpressionListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExpressionListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExpressionList;
|
|
}
|
|
|
|
void EscriptParser::ExpressionListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExpressionList(this);
|
|
}
|
|
|
|
void EscriptParser::ExpressionListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExpressionList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExpressionListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExpressionList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExpressionListContext* EscriptParser::expressionList() {
|
|
ExpressionListContext *_localctx = _tracker.createInstance<ExpressionListContext>(_ctx, getState());
|
|
enterRule(_localctx, 148, EscriptParser::RuleExpressionList);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(797);
|
|
expressionListEntry();
|
|
setState(802);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 77, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(798);
|
|
match(EscriptParser::COMMA);
|
|
setState(799);
|
|
expressionListEntry();
|
|
}
|
|
setState(804);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 77, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExpressionListEntryContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExpressionListEntryContext::ExpressionListEntryContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::ExpressionListEntryContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ExpressionListEntryContext::ELLIPSIS() {
|
|
return getToken(EscriptParser::ELLIPSIS, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExpressionListEntryContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExpressionListEntry;
|
|
}
|
|
|
|
void EscriptParser::ExpressionListEntryContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExpressionListEntry(this);
|
|
}
|
|
|
|
void EscriptParser::ExpressionListEntryContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExpressionListEntry(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExpressionListEntryContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExpressionListEntry(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExpressionListEntryContext* EscriptParser::expressionListEntry() {
|
|
ExpressionListEntryContext *_localctx = _tracker.createInstance<ExpressionListEntryContext>(_ctx, getState());
|
|
enterRule(_localctx, 150, EscriptParser::RuleExpressionListEntry);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(805);
|
|
expression(0);
|
|
setState(807);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ELLIPSIS) {
|
|
setState(806);
|
|
match(EscriptParser::ELLIPSIS);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExpressionSuffixContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ExpressionSuffixContext::ExpressionSuffixContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::IndexingSuffixContext* EscriptParser::ExpressionSuffixContext::indexingSuffix() {
|
|
return getRuleContext<EscriptParser::IndexingSuffixContext>(0);
|
|
}
|
|
|
|
EscriptParser::MethodCallSuffixContext* EscriptParser::ExpressionSuffixContext::methodCallSuffix() {
|
|
return getRuleContext<EscriptParser::MethodCallSuffixContext>(0);
|
|
}
|
|
|
|
EscriptParser::NavigationSuffixContext* EscriptParser::ExpressionSuffixContext::navigationSuffix() {
|
|
return getRuleContext<EscriptParser::NavigationSuffixContext>(0);
|
|
}
|
|
|
|
EscriptParser::FunctionCallSuffixContext* EscriptParser::ExpressionSuffixContext::functionCallSuffix() {
|
|
return getRuleContext<EscriptParser::FunctionCallSuffixContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ExpressionSuffixContext::getRuleIndex() const {
|
|
return EscriptParser::RuleExpressionSuffix;
|
|
}
|
|
|
|
void EscriptParser::ExpressionSuffixContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterExpressionSuffix(this);
|
|
}
|
|
|
|
void EscriptParser::ExpressionSuffixContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitExpressionSuffix(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ExpressionSuffixContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitExpressionSuffix(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ExpressionSuffixContext* EscriptParser::expressionSuffix() {
|
|
ExpressionSuffixContext *_localctx = _tracker.createInstance<ExpressionSuffixContext>(_ctx, getState());
|
|
enterRule(_localctx, 152, EscriptParser::RuleExpressionSuffix);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(813);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(809);
|
|
indexingSuffix();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(810);
|
|
methodCallSuffix();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(811);
|
|
navigationSuffix();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(812);
|
|
functionCallSuffix();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IndexingSuffixContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IndexingSuffixContext::IndexingSuffixContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexingSuffixContext::LBRACK() {
|
|
return getToken(EscriptParser::LBRACK, 0);
|
|
}
|
|
|
|
EscriptParser::IndexListContext* EscriptParser::IndexingSuffixContext::indexList() {
|
|
return getRuleContext<EscriptParser::IndexListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexingSuffixContext::RBRACK() {
|
|
return getToken(EscriptParser::RBRACK, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IndexingSuffixContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIndexingSuffix;
|
|
}
|
|
|
|
void EscriptParser::IndexingSuffixContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIndexingSuffix(this);
|
|
}
|
|
|
|
void EscriptParser::IndexingSuffixContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIndexingSuffix(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IndexingSuffixContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIndexingSuffix(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IndexingSuffixContext* EscriptParser::indexingSuffix() {
|
|
IndexingSuffixContext *_localctx = _tracker.createInstance<IndexingSuffixContext>(_ctx, getState());
|
|
enterRule(_localctx, 154, EscriptParser::RuleIndexingSuffix);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(815);
|
|
match(EscriptParser::LBRACK);
|
|
setState(816);
|
|
indexList();
|
|
setState(817);
|
|
match(EscriptParser::RBRACK);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IndexListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IndexListContext::IndexListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::ExpressionContext *> EscriptParser::IndexListContext::expression() {
|
|
return getRuleContexts<EscriptParser::ExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::IndexListContext::expression(size_t i) {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::IndexListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IndexListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IndexListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIndexList;
|
|
}
|
|
|
|
void EscriptParser::IndexListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIndexList(this);
|
|
}
|
|
|
|
void EscriptParser::IndexListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIndexList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IndexListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIndexList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IndexListContext* EscriptParser::indexList() {
|
|
IndexListContext *_localctx = _tracker.createInstance<IndexListContext>(_ctx, getState());
|
|
enterRule(_localctx, 156, EscriptParser::RuleIndexList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(819);
|
|
expression(0);
|
|
setState(824);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == EscriptParser::COMMA) {
|
|
setState(820);
|
|
match(EscriptParser::COMMA);
|
|
setState(821);
|
|
expression(0);
|
|
setState(826);
|
|
_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;
|
|
}
|
|
|
|
//----------------- NavigationSuffixContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::NavigationSuffixContext::NavigationSuffixContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::NavigationSuffixContext::DOT() {
|
|
return getToken(EscriptParser::DOT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::NavigationSuffixContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::NavigationSuffixContext::STRING_LITERAL() {
|
|
return getToken(EscriptParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::NavigationSuffixContext::FUNCTION() {
|
|
return getToken(EscriptParser::FUNCTION, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::NavigationSuffixContext::getRuleIndex() const {
|
|
return EscriptParser::RuleNavigationSuffix;
|
|
}
|
|
|
|
void EscriptParser::NavigationSuffixContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterNavigationSuffix(this);
|
|
}
|
|
|
|
void EscriptParser::NavigationSuffixContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitNavigationSuffix(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::NavigationSuffixContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitNavigationSuffix(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::NavigationSuffixContext* EscriptParser::navigationSuffix() {
|
|
NavigationSuffixContext *_localctx = _tracker.createInstance<NavigationSuffixContext>(_ctx, getState());
|
|
enterRule(_localctx, 158, EscriptParser::RuleNavigationSuffix);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(827);
|
|
match(EscriptParser::DOT);
|
|
setState(828);
|
|
_la = _input->LA(1);
|
|
if (!(_la == EscriptParser::FUNCTION || _la == EscriptParser::STRING_LITERAL
|
|
|
|
|| _la == EscriptParser::IDENTIFIER)) {
|
|
_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;
|
|
}
|
|
|
|
//----------------- MethodCallSuffixContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::MethodCallSuffixContext::MethodCallSuffixContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::MethodCallSuffixContext::DOT() {
|
|
return getToken(EscriptParser::DOT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::MethodCallSuffixContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::MethodCallSuffixContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::MethodCallSuffixContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionListContext* EscriptParser::MethodCallSuffixContext::expressionList() {
|
|
return getRuleContext<EscriptParser::ExpressionListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::MethodCallSuffixContext::getRuleIndex() const {
|
|
return EscriptParser::RuleMethodCallSuffix;
|
|
}
|
|
|
|
void EscriptParser::MethodCallSuffixContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterMethodCallSuffix(this);
|
|
}
|
|
|
|
void EscriptParser::MethodCallSuffixContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitMethodCallSuffix(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::MethodCallSuffixContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitMethodCallSuffix(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::MethodCallSuffixContext* EscriptParser::methodCallSuffix() {
|
|
MethodCallSuffixContext *_localctx = _tracker.createInstance<MethodCallSuffixContext>(_ctx, getState());
|
|
enterRule(_localctx, 160, EscriptParser::RuleMethodCallSuffix);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(830);
|
|
match(EscriptParser::DOT);
|
|
setState(831);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(832);
|
|
match(EscriptParser::LPAREN);
|
|
setState(834);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(833);
|
|
expressionList();
|
|
}
|
|
setState(836);
|
|
match(EscriptParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionCallSuffixContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionCallSuffixContext::FunctionCallSuffixContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionCallSuffixContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionCallSuffixContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionListContext* EscriptParser::FunctionCallSuffixContext::expressionList() {
|
|
return getRuleContext<EscriptParser::ExpressionListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionCallSuffixContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionCallSuffix;
|
|
}
|
|
|
|
void EscriptParser::FunctionCallSuffixContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionCallSuffix(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionCallSuffixContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionCallSuffix(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionCallSuffixContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionCallSuffix(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionCallSuffixContext* EscriptParser::functionCallSuffix() {
|
|
FunctionCallSuffixContext *_localctx = _tracker.createInstance<FunctionCallSuffixContext>(_ctx, getState());
|
|
enterRule(_localctx, 162, EscriptParser::RuleFunctionCallSuffix);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(838);
|
|
match(EscriptParser::LPAREN);
|
|
setState(840);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(839);
|
|
expressionList();
|
|
}
|
|
setState(842);
|
|
match(EscriptParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionCallContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FunctionCallContext::FunctionCallContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionCallContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionCallContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FunctionCallContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionListContext* EscriptParser::FunctionCallContext::expressionList() {
|
|
return getRuleContext<EscriptParser::ExpressionListContext>(0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FunctionCallContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFunctionCall;
|
|
}
|
|
|
|
void EscriptParser::FunctionCallContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFunctionCall(this);
|
|
}
|
|
|
|
void EscriptParser::FunctionCallContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFunctionCall(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionCall(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FunctionCallContext* EscriptParser::functionCall() {
|
|
FunctionCallContext *_localctx = _tracker.createInstance<FunctionCallContext>(_ctx, getState());
|
|
enterRule(_localctx, 164, EscriptParser::RuleFunctionCall);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(844);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(845);
|
|
match(EscriptParser::LPAREN);
|
|
setState(847);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(846);
|
|
expressionList();
|
|
}
|
|
setState(849);
|
|
match(EscriptParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StructInitializerExpressionContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::StructInitializerExpressionContext::StructInitializerExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerExpressionContext::IDENTIFIER() {
|
|
return getToken(EscriptParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerExpressionContext::ASSIGN() {
|
|
return getToken(EscriptParser::ASSIGN, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::StructInitializerExpressionContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerExpressionContext::STRING_LITERAL() {
|
|
return getToken(EscriptParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerExpressionContext::ELLIPSIS() {
|
|
return getToken(EscriptParser::ELLIPSIS, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::StructInitializerExpressionContext::getRuleIndex() const {
|
|
return EscriptParser::RuleStructInitializerExpression;
|
|
}
|
|
|
|
void EscriptParser::StructInitializerExpressionContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStructInitializerExpression(this);
|
|
}
|
|
|
|
void EscriptParser::StructInitializerExpressionContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStructInitializerExpression(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::StructInitializerExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitStructInitializerExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::StructInitializerExpressionContext* EscriptParser::structInitializerExpression() {
|
|
StructInitializerExpressionContext *_localctx = _tracker.createInstance<StructInitializerExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 166, EscriptParser::RuleStructInitializerExpression);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(864);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(851);
|
|
match(EscriptParser::IDENTIFIER);
|
|
setState(854);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ASSIGN) {
|
|
setState(852);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(853);
|
|
expression(0);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(856);
|
|
match(EscriptParser::STRING_LITERAL);
|
|
setState(859);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ASSIGN) {
|
|
setState(857);
|
|
match(EscriptParser::ASSIGN);
|
|
setState(858);
|
|
expression(0);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(861);
|
|
expression(0);
|
|
setState(862);
|
|
match(EscriptParser::ELLIPSIS);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StructInitializerExpressionListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::StructInitializerExpressionListContext::StructInitializerExpressionListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::StructInitializerExpressionContext *> EscriptParser::StructInitializerExpressionListContext::structInitializerExpression() {
|
|
return getRuleContexts<EscriptParser::StructInitializerExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::StructInitializerExpressionContext* EscriptParser::StructInitializerExpressionListContext::structInitializerExpression(size_t i) {
|
|
return getRuleContext<EscriptParser::StructInitializerExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::StructInitializerExpressionListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerExpressionListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::StructInitializerExpressionListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleStructInitializerExpressionList;
|
|
}
|
|
|
|
void EscriptParser::StructInitializerExpressionListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStructInitializerExpressionList(this);
|
|
}
|
|
|
|
void EscriptParser::StructInitializerExpressionListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStructInitializerExpressionList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::StructInitializerExpressionListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitStructInitializerExpressionList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::StructInitializerExpressionListContext* EscriptParser::structInitializerExpressionList() {
|
|
StructInitializerExpressionListContext *_localctx = _tracker.createInstance<StructInitializerExpressionListContext>(_ctx, getState());
|
|
enterRule(_localctx, 168, EscriptParser::RuleStructInitializerExpressionList);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(866);
|
|
structInitializerExpression();
|
|
setState(871);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(867);
|
|
match(EscriptParser::COMMA);
|
|
setState(868);
|
|
structInitializerExpression();
|
|
}
|
|
setState(873);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StructInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::StructInitializerContext::StructInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerContext::LBRACE() {
|
|
return getToken(EscriptParser::LBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerContext::RBRACE() {
|
|
return getToken(EscriptParser::RBRACE, 0);
|
|
}
|
|
|
|
EscriptParser::StructInitializerExpressionListContext* EscriptParser::StructInitializerContext::structInitializerExpressionList() {
|
|
return getRuleContext<EscriptParser::StructInitializerExpressionListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::StructInitializerContext::COMMA() {
|
|
return getToken(EscriptParser::COMMA, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::StructInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleStructInitializer;
|
|
}
|
|
|
|
void EscriptParser::StructInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStructInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::StructInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStructInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::StructInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitStructInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::StructInitializerContext* EscriptParser::structInitializer() {
|
|
StructInitializerContext *_localctx = _tracker.createInstance<StructInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 170, EscriptParser::RuleStructInitializer);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(886);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(874);
|
|
match(EscriptParser::LBRACE);
|
|
setState(876);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(875);
|
|
structInitializerExpressionList();
|
|
}
|
|
setState(878);
|
|
match(EscriptParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(879);
|
|
match(EscriptParser::LBRACE);
|
|
setState(881);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(880);
|
|
structInitializerExpressionList();
|
|
}
|
|
setState(883);
|
|
match(EscriptParser::COMMA);
|
|
setState(884);
|
|
match(EscriptParser::RBRACE);
|
|
notifyErrorListeners("Expected expression following comma before right-brace in struct initializer list");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- DictInitializerExpressionContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::DictInitializerExpressionContext::DictInitializerExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::ExpressionContext *> EscriptParser::DictInitializerExpressionContext::expression() {
|
|
return getRuleContexts<EscriptParser::ExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::DictInitializerExpressionContext::expression(size_t i) {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DictInitializerExpressionContext::ARROW() {
|
|
return getToken(EscriptParser::ARROW, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DictInitializerExpressionContext::ELLIPSIS() {
|
|
return getToken(EscriptParser::ELLIPSIS, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::DictInitializerExpressionContext::getRuleIndex() const {
|
|
return EscriptParser::RuleDictInitializerExpression;
|
|
}
|
|
|
|
void EscriptParser::DictInitializerExpressionContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterDictInitializerExpression(this);
|
|
}
|
|
|
|
void EscriptParser::DictInitializerExpressionContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitDictInitializerExpression(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::DictInitializerExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitDictInitializerExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::DictInitializerExpressionContext* EscriptParser::dictInitializerExpression() {
|
|
DictInitializerExpressionContext *_localctx = _tracker.createInstance<DictInitializerExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 172, EscriptParser::RuleDictInitializerExpression);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(896);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(888);
|
|
expression(0);
|
|
setState(891);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::ARROW) {
|
|
setState(889);
|
|
match(EscriptParser::ARROW);
|
|
setState(890);
|
|
expression(0);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(893);
|
|
expression(0);
|
|
setState(894);
|
|
match(EscriptParser::ELLIPSIS);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- DictInitializerExpressionListContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::DictInitializerExpressionListContext::DictInitializerExpressionListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<EscriptParser::DictInitializerExpressionContext *> EscriptParser::DictInitializerExpressionListContext::dictInitializerExpression() {
|
|
return getRuleContexts<EscriptParser::DictInitializerExpressionContext>();
|
|
}
|
|
|
|
EscriptParser::DictInitializerExpressionContext* EscriptParser::DictInitializerExpressionListContext::dictInitializerExpression(size_t i) {
|
|
return getRuleContext<EscriptParser::DictInitializerExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> EscriptParser::DictInitializerExpressionListContext::COMMA() {
|
|
return getTokens(EscriptParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DictInitializerExpressionListContext::COMMA(size_t i) {
|
|
return getToken(EscriptParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::DictInitializerExpressionListContext::getRuleIndex() const {
|
|
return EscriptParser::RuleDictInitializerExpressionList;
|
|
}
|
|
|
|
void EscriptParser::DictInitializerExpressionListContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterDictInitializerExpressionList(this);
|
|
}
|
|
|
|
void EscriptParser::DictInitializerExpressionListContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitDictInitializerExpressionList(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::DictInitializerExpressionListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitDictInitializerExpressionList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::DictInitializerExpressionListContext* EscriptParser::dictInitializerExpressionList() {
|
|
DictInitializerExpressionListContext *_localctx = _tracker.createInstance<DictInitializerExpressionListContext>(_ctx, getState());
|
|
enterRule(_localctx, 174, EscriptParser::RuleDictInitializerExpressionList);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(898);
|
|
dictInitializerExpression();
|
|
setState(903);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 93, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(899);
|
|
match(EscriptParser::COMMA);
|
|
setState(900);
|
|
dictInitializerExpression();
|
|
}
|
|
setState(905);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 93, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- DictInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::DictInitializerContext::DictInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DictInitializerContext::LBRACE() {
|
|
return getToken(EscriptParser::LBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DictInitializerContext::RBRACE() {
|
|
return getToken(EscriptParser::RBRACE, 0);
|
|
}
|
|
|
|
EscriptParser::DictInitializerExpressionListContext* EscriptParser::DictInitializerContext::dictInitializerExpressionList() {
|
|
return getRuleContext<EscriptParser::DictInitializerExpressionListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::DictInitializerContext::COMMA() {
|
|
return getToken(EscriptParser::COMMA, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::DictInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleDictInitializer;
|
|
}
|
|
|
|
void EscriptParser::DictInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterDictInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::DictInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitDictInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::DictInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitDictInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::DictInitializerContext* EscriptParser::dictInitializer() {
|
|
DictInitializerContext *_localctx = _tracker.createInstance<DictInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 176, EscriptParser::RuleDictInitializer);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(918);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(906);
|
|
match(EscriptParser::LBRACE);
|
|
setState(908);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(907);
|
|
dictInitializerExpressionList();
|
|
}
|
|
setState(910);
|
|
match(EscriptParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(911);
|
|
match(EscriptParser::LBRACE);
|
|
setState(913);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(912);
|
|
dictInitializerExpressionList();
|
|
}
|
|
setState(915);
|
|
match(EscriptParser::COMMA);
|
|
setState(916);
|
|
match(EscriptParser::RBRACE);
|
|
notifyErrorListeners("Expected expression following comma before right-brace in dictionary initializer list");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ArrayInitializerContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::ArrayInitializerContext::ArrayInitializerContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ArrayInitializerContext::LBRACE() {
|
|
return getToken(EscriptParser::LBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ArrayInitializerContext::RBRACE() {
|
|
return getToken(EscriptParser::RBRACE, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionListContext* EscriptParser::ArrayInitializerContext::expressionList() {
|
|
return getRuleContext<EscriptParser::ExpressionListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ArrayInitializerContext::COMMA() {
|
|
return getToken(EscriptParser::COMMA, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ArrayInitializerContext::LPAREN() {
|
|
return getToken(EscriptParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::ArrayInitializerContext::RPAREN() {
|
|
return getToken(EscriptParser::RPAREN, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::ArrayInitializerContext::getRuleIndex() const {
|
|
return EscriptParser::RuleArrayInitializer;
|
|
}
|
|
|
|
void EscriptParser::ArrayInitializerContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterArrayInitializer(this);
|
|
}
|
|
|
|
void EscriptParser::ArrayInitializerContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitArrayInitializer(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::ArrayInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitArrayInitializer(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::ArrayInitializerContext* EscriptParser::arrayInitializer() {
|
|
ArrayInitializerContext *_localctx = _tracker.createInstance<ArrayInitializerContext>(_ctx, getState());
|
|
enterRule(_localctx, 178, EscriptParser::RuleArrayInitializer);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(944);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 101, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(920);
|
|
match(EscriptParser::LBRACE);
|
|
setState(922);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(921);
|
|
expressionList();
|
|
}
|
|
setState(924);
|
|
match(EscriptParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(925);
|
|
match(EscriptParser::LBRACE);
|
|
setState(927);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(926);
|
|
expressionList();
|
|
}
|
|
setState(929);
|
|
match(EscriptParser::COMMA);
|
|
setState(930);
|
|
match(EscriptParser::RBRACE);
|
|
notifyErrorListeners("Expected expression following comma before right-brace in array initializer list");
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(932);
|
|
match(EscriptParser::LPAREN);
|
|
setState(934);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(933);
|
|
expressionList();
|
|
}
|
|
setState(936);
|
|
match(EscriptParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(937);
|
|
match(EscriptParser::LPAREN);
|
|
setState(939);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 58) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 58)) & 8070450583938513363) != 0) || ((((_la - 122) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 122)) & 131) != 0)) {
|
|
setState(938);
|
|
expressionList();
|
|
}
|
|
setState(941);
|
|
match(EscriptParser::COMMA);
|
|
setState(942);
|
|
match(EscriptParser::RPAREN);
|
|
notifyErrorListeners("Expected expression following comma before right-paren in array initializer list");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- LiteralContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
EscriptParser::IntegerLiteralContext* EscriptParser::LiteralContext::integerLiteral() {
|
|
return getRuleContext<EscriptParser::IntegerLiteralContext>(0);
|
|
}
|
|
|
|
EscriptParser::FloatLiteralContext* EscriptParser::LiteralContext::floatLiteral() {
|
|
return getRuleContext<EscriptParser::FloatLiteralContext>(0);
|
|
}
|
|
|
|
EscriptParser::BoolLiteralContext* EscriptParser::LiteralContext::boolLiteral() {
|
|
return getRuleContext<EscriptParser::BoolLiteralContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::LiteralContext::STRING_LITERAL() {
|
|
return getToken(EscriptParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::LiteralContext::UNINIT() {
|
|
return getToken(EscriptParser::UNINIT, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::LiteralContext::getRuleIndex() const {
|
|
return EscriptParser::RuleLiteral;
|
|
}
|
|
|
|
void EscriptParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterLiteral(this);
|
|
}
|
|
|
|
void EscriptParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitLiteral(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::LiteralContext* EscriptParser::literal() {
|
|
LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 180, EscriptParser::RuleLiteral);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(951);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case EscriptParser::DECIMAL_LITERAL:
|
|
case EscriptParser::HEX_LITERAL:
|
|
case EscriptParser::OCT_LITERAL:
|
|
case EscriptParser::BINARY_LITERAL: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(946);
|
|
integerLiteral();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::FLOAT_LITERAL:
|
|
case EscriptParser::HEX_FLOAT_LITERAL: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(947);
|
|
floatLiteral();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::BOOL_TRUE:
|
|
case EscriptParser::BOOL_FALSE: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(948);
|
|
boolLiteral();
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::STRING_LITERAL: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(949);
|
|
match(EscriptParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case EscriptParser::UNINIT: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(950);
|
|
match(EscriptParser::UNINIT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- InterpolatedStringContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::InterpolatedStringContext::InterpolatedStringContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringContext::INTERPOLATED_STRING_START() {
|
|
return getToken(EscriptParser::INTERPOLATED_STRING_START, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringContext::DOUBLE_QUOTE_INSIDE() {
|
|
return getToken(EscriptParser::DOUBLE_QUOTE_INSIDE, 0);
|
|
}
|
|
|
|
std::vector<EscriptParser::InterpolatedStringPartContext *> EscriptParser::InterpolatedStringContext::interpolatedStringPart() {
|
|
return getRuleContexts<EscriptParser::InterpolatedStringPartContext>();
|
|
}
|
|
|
|
EscriptParser::InterpolatedStringPartContext* EscriptParser::InterpolatedStringContext::interpolatedStringPart(size_t i) {
|
|
return getRuleContext<EscriptParser::InterpolatedStringPartContext>(i);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::InterpolatedStringContext::getRuleIndex() const {
|
|
return EscriptParser::RuleInterpolatedString;
|
|
}
|
|
|
|
void EscriptParser::InterpolatedStringContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterInterpolatedString(this);
|
|
}
|
|
|
|
void EscriptParser::InterpolatedStringContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitInterpolatedString(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::InterpolatedStringContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitInterpolatedString(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::InterpolatedStringContext* EscriptParser::interpolatedString() {
|
|
InterpolatedStringContext *_localctx = _tracker.createInstance<InterpolatedStringContext>(_ctx, getState());
|
|
enterRule(_localctx, 182, EscriptParser::RuleInterpolatedString);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(953);
|
|
match(EscriptParser::INTERPOLATED_STRING_START);
|
|
setState(957);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (((((_la - 130) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 130)) & 55) != 0)) {
|
|
setState(954);
|
|
interpolatedStringPart();
|
|
setState(959);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(960);
|
|
match(EscriptParser::DOUBLE_QUOTE_INSIDE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- InterpolatedStringPartContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::InterpolatedStringPartContext::InterpolatedStringPartContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringPartContext::LBRACE_INSIDE() {
|
|
return getToken(EscriptParser::LBRACE_INSIDE, 0);
|
|
}
|
|
|
|
EscriptParser::ExpressionContext* EscriptParser::InterpolatedStringPartContext::expression() {
|
|
return getRuleContext<EscriptParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringPartContext::COLON() {
|
|
return getToken(EscriptParser::COLON, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringPartContext::FORMAT_STRING() {
|
|
return getToken(EscriptParser::FORMAT_STRING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringPartContext::DOUBLE_LBRACE_INSIDE() {
|
|
return getToken(EscriptParser::DOUBLE_LBRACE_INSIDE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringPartContext::REGULAR_CHAR_INSIDE() {
|
|
return getToken(EscriptParser::REGULAR_CHAR_INSIDE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringPartContext::DOUBLE_RBRACE() {
|
|
return getToken(EscriptParser::DOUBLE_RBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::InterpolatedStringPartContext::STRING_LITERAL_INSIDE() {
|
|
return getToken(EscriptParser::STRING_LITERAL_INSIDE, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::InterpolatedStringPartContext::getRuleIndex() const {
|
|
return EscriptParser::RuleInterpolatedStringPart;
|
|
}
|
|
|
|
void EscriptParser::InterpolatedStringPartContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterInterpolatedStringPart(this);
|
|
}
|
|
|
|
void EscriptParser::InterpolatedStringPartContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitInterpolatedStringPart(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::InterpolatedStringPartContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitInterpolatedStringPart(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::InterpolatedStringPartContext* EscriptParser::interpolatedStringPart() {
|
|
InterpolatedStringPartContext *_localctx = _tracker.createInstance<InterpolatedStringPartContext>(_ctx, getState());
|
|
enterRule(_localctx, 184, EscriptParser::RuleInterpolatedStringPart);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(978);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(962);
|
|
match(EscriptParser::LBRACE_INSIDE);
|
|
setState(963);
|
|
expression(0);
|
|
setState(966);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::COLON) {
|
|
setState(964);
|
|
match(EscriptParser::COLON);
|
|
setState(965);
|
|
match(EscriptParser::FORMAT_STRING);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(968);
|
|
match(EscriptParser::LBRACE_INSIDE);
|
|
setState(971);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == EscriptParser::COLON) {
|
|
setState(969);
|
|
match(EscriptParser::COLON);
|
|
setState(970);
|
|
match(EscriptParser::FORMAT_STRING);
|
|
}
|
|
notifyErrorListeners("Expected expression following interpolated string part start");
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(974);
|
|
match(EscriptParser::DOUBLE_LBRACE_INSIDE);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(975);
|
|
match(EscriptParser::REGULAR_CHAR_INSIDE);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(976);
|
|
match(EscriptParser::DOUBLE_RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(977);
|
|
match(EscriptParser::STRING_LITERAL_INSIDE);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IntegerLiteralContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::IntegerLiteralContext::IntegerLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IntegerLiteralContext::DECIMAL_LITERAL() {
|
|
return getToken(EscriptParser::DECIMAL_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IntegerLiteralContext::HEX_LITERAL() {
|
|
return getToken(EscriptParser::HEX_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IntegerLiteralContext::OCT_LITERAL() {
|
|
return getToken(EscriptParser::OCT_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::IntegerLiteralContext::BINARY_LITERAL() {
|
|
return getToken(EscriptParser::BINARY_LITERAL, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::IntegerLiteralContext::getRuleIndex() const {
|
|
return EscriptParser::RuleIntegerLiteral;
|
|
}
|
|
|
|
void EscriptParser::IntegerLiteralContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterIntegerLiteral(this);
|
|
}
|
|
|
|
void EscriptParser::IntegerLiteralContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitIntegerLiteral(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::IntegerLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitIntegerLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::IntegerLiteralContext* EscriptParser::integerLiteral() {
|
|
IntegerLiteralContext *_localctx = _tracker.createInstance<IntegerLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 186, EscriptParser::RuleIntegerLiteral);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(980);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 73) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 73)) & 15) != 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;
|
|
}
|
|
|
|
//----------------- FloatLiteralContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::FloatLiteralContext::FloatLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FloatLiteralContext::FLOAT_LITERAL() {
|
|
return getToken(EscriptParser::FLOAT_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::FloatLiteralContext::HEX_FLOAT_LITERAL() {
|
|
return getToken(EscriptParser::HEX_FLOAT_LITERAL, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::FloatLiteralContext::getRuleIndex() const {
|
|
return EscriptParser::RuleFloatLiteral;
|
|
}
|
|
|
|
void EscriptParser::FloatLiteralContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterFloatLiteral(this);
|
|
}
|
|
|
|
void EscriptParser::FloatLiteralContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitFloatLiteral(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::FloatLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitFloatLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::FloatLiteralContext* EscriptParser::floatLiteral() {
|
|
FloatLiteralContext *_localctx = _tracker.createInstance<FloatLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 188, EscriptParser::RuleFloatLiteral);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(982);
|
|
_la = _input->LA(1);
|
|
if (!(_la == EscriptParser::FLOAT_LITERAL
|
|
|
|
|| _la == EscriptParser::HEX_FLOAT_LITERAL)) {
|
|
_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;
|
|
}
|
|
|
|
//----------------- BoolLiteralContext ------------------------------------------------------------------
|
|
|
|
EscriptParser::BoolLiteralContext::BoolLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BoolLiteralContext::BOOL_TRUE() {
|
|
return getToken(EscriptParser::BOOL_TRUE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* EscriptParser::BoolLiteralContext::BOOL_FALSE() {
|
|
return getToken(EscriptParser::BOOL_FALSE, 0);
|
|
}
|
|
|
|
|
|
size_t EscriptParser::BoolLiteralContext::getRuleIndex() const {
|
|
return EscriptParser::RuleBoolLiteral;
|
|
}
|
|
|
|
void EscriptParser::BoolLiteralContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterBoolLiteral(this);
|
|
}
|
|
|
|
void EscriptParser::BoolLiteralContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<EscriptParserListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitBoolLiteral(this);
|
|
}
|
|
|
|
|
|
std::any EscriptParser::BoolLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<EscriptParserVisitor*>(visitor))
|
|
return parserVisitor->visitBoolLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
EscriptParser::BoolLiteralContext* EscriptParser::boolLiteral() {
|
|
BoolLiteralContext *_localctx = _tracker.createInstance<BoolLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 190, EscriptParser::RuleBoolLiteral);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(984);
|
|
_la = _input->LA(1);
|
|
if (!(_la == EscriptParser::BOOL_TRUE
|
|
|
|
|| _la == EscriptParser::BOOL_FALSE)) {
|
|
_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 EscriptParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
|
|
switch (ruleIndex) {
|
|
case 64: return expressionSempred(antlrcpp::downCast<ExpressionContext *>(context), predicateIndex);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool EscriptParser::expressionSempred(ExpressionContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 0: return precpred(_ctx, 13);
|
|
case 1: return precpred(_ctx, 12);
|
|
case 2: return precpred(_ctx, 11);
|
|
case 3: return precpred(_ctx, 10);
|
|
case 4: return precpred(_ctx, 9);
|
|
case 5: return precpred(_ctx, 8);
|
|
case 6: return precpred(_ctx, 7);
|
|
case 7: return precpred(_ctx, 6);
|
|
case 8: return precpred(_ctx, 5);
|
|
case 9: return precpred(_ctx, 4);
|
|
case 10: return precpred(_ctx, 3);
|
|
case 11: return precpred(_ctx, 2);
|
|
case 12: return precpred(_ctx, 1);
|
|
case 13: return precpred(_ctx, 17);
|
|
case 14: return precpred(_ctx, 16);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void EscriptParser::initialize() {
|
|
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
|
escriptparserParserInitialize();
|
|
#else
|
|
::antlr4::internal::call_once(escriptparserParserOnceFlag, escriptparserParserInitialize);
|
|
#endif
|
|
}
|