// Generated from EscriptParser.g4 by ANTLR 4.13.1 #pragma once #include "antlr4-runtime.h" namespace EscriptGrammar { class EscriptParser : public antlr4::Parser { public: enum { IF = 1, THEN = 2, ELSEIF = 3, ENDIF = 4, ELSE = 5, GOTO = 6, RETURN = 7, TOK_CONST = 8, VAR = 9, DO = 10, DOWHILE = 11, WHILE = 12, ENDWHILE = 13, EXIT = 14, FUNCTION = 15, ENDFUNCTION = 16, EXPORTED = 17, USE = 18, INCLUDE = 19, BREAK = 20, CONTINUE = 21, FOR = 22, ENDFOR = 23, TO = 24, FOREACH = 25, ENDFOREACH = 26, REPEAT = 27, UNTIL = 28, PROGRAM = 29, ENDPROGRAM = 30, CASE = 31, DEFAULT = 32, ENDCASE = 33, ENUM = 34, ENDENUM = 35, CLASS = 36, ENDCLASS = 37, DOWNTO = 38, STEP = 39, REFERENCE = 40, TOK_OUT = 41, INOUT = 42, BYVAL = 43, STRING = 44, TOK_LONG = 45, INTEGER = 46, UNSIGNED = 47, SIGNED = 48, REAL = 49, FLOAT = 50, DOUBLE = 51, AS = 52, ELLIPSIS = 53, AND_A = 54, AND_B = 55, OR_A = 56, OR_B = 57, BANG_A = 58, BANG_B = 59, BYREF = 60, UNUSED = 61, TOK_ERROR = 62, HASH = 63, DICTIONARY = 64, STRUCT = 65, ARRAY = 66, STACK = 67, TOK_IN = 68, UNINIT = 69, BOOL_TRUE = 70, BOOL_FALSE = 71, IS = 72, DECIMAL_LITERAL = 73, HEX_LITERAL = 74, OCT_LITERAL = 75, BINARY_LITERAL = 76, FLOAT_LITERAL = 77, HEX_FLOAT_LITERAL = 78, STRING_LITERAL = 79, REGEXP_LITERAL = 80, INTERPOLATED_STRING_START = 81, LPAREN = 82, RPAREN = 83, LBRACK = 84, RBRACK = 85, LBRACE = 86, RBRACE = 87, DOT = 88, ARROW = 89, MUL = 90, DIV = 91, MOD = 92, ADD = 93, SUB = 94, ADD_ASSIGN = 95, SUB_ASSIGN = 96, MUL_ASSIGN = 97, DIV_ASSIGN = 98, MOD_ASSIGN = 99, LE = 100, LT = 101, GE = 102, GT = 103, RSHIFT = 104, LSHIFT = 105, BITAND = 106, CARET = 107, BITOR = 108, NOTEQUAL_A = 109, NOTEQUAL_B = 110, EQUAL_DEPRECATED = 111, EQUAL = 112, ASSIGN = 113, ADDMEMBER = 114, DELMEMBER = 115, CHKMEMBER = 116, SEMI = 117, COMMA = 118, TILDE = 119, AT = 120, COLONCOLON = 121, COLON = 122, INC = 123, DEC = 124, ELVIS = 125, QUESTION = 126, WS = 127, COMMENT = 128, LINE_COMMENT = 129, IDENTIFIER = 130, DOUBLE_LBRACE_INSIDE = 131, LBRACE_INSIDE = 132, REGULAR_CHAR_INSIDE = 133, DOUBLE_QUOTE_INSIDE = 134, DOUBLE_RBRACE = 135, STRING_LITERAL_INSIDE = 136, CLOSE_RBRACE_INSIDE = 137, FORMAT_STRING = 138 }; enum { RuleCompilationUnit = 0, RuleModuleUnit = 1, RuleEvaluateUnit = 2, RuleModuleDeclarationStatement = 3, RuleModuleFunctionDeclaration = 4, RuleModuleFunctionParameterList = 5, RuleModuleFunctionParameter = 6, RuleTopLevelDeclaration = 7, RuleClassDeclaration = 8, RuleClassParameters = 9, RuleClassParameterList = 10, RuleClassBody = 11, RuleClassStatement = 12, RuleUninitFunctionDeclaration = 13, RuleFunctionDeclaration = 14, RuleStringIdentifier = 15, RuleUseDeclaration = 16, RuleIncludeDeclaration = 17, RuleProgramDeclaration = 18, RuleStatement = 19, RuleStatementLabel = 20, RuleIfStatement = 21, RuleGotoStatement = 22, RuleReturnStatement = 23, RuleConstStatement = 24, RuleVarStatement = 25, RuleDoStatement = 26, RuleWhileStatement = 27, RuleExitStatement = 28, RuleBreakStatement = 29, RuleContinueStatement = 30, RuleForStatement = 31, RuleForeachIterableExpression = 32, RuleForeachStatement = 33, RuleRepeatStatement = 34, RuleCaseStatement = 35, RuleEnumStatement = 36, RuleBlock = 37, RuleVariableDeclarationInitializer = 38, RuleEnumList = 39, RuleEnumListEntry = 40, RuleSwitchBlockStatementGroup = 41, RuleSwitchLabel = 42, RuleForGroup = 43, RuleBasicForStatement = 44, RuleCstyleForStatement = 45, RuleIdentifierList = 46, RuleVariableDeclarationList = 47, RuleConstantDeclaration = 48, RuleVariableDeclaration = 49, RuleBindingDeclaration = 50, RuleIndexBindingList = 51, RuleSequenceBindingList = 52, RuleSequenceBinding = 53, RuleIndexBinding = 54, RuleBinding = 55, RuleBindingDeclarationInitializer = 56, RuleProgramParameters = 57, RuleProgramParameterList = 58, RuleProgramParameter = 59, RuleFunctionParameters = 60, RuleFunctionParameterList = 61, RuleFunctionParameter = 62, RuleScopedFunctionCall = 63, RuleFunctionReference = 64, RuleExpression = 65, RulePrimary = 66, RuleScopedIdentifier = 67, RuleFunctionExpression = 68, RuleExplicitArrayInitializer = 69, RuleExplicitStructInitializer = 70, RuleExplicitDictInitializer = 71, RuleExplicitErrorInitializer = 72, RuleBareArrayInitializer = 73, RuleParExpression = 74, RuleExpressionList = 75, RuleExpressionListEntry = 76, RuleExpressionSuffix = 77, RuleIndexingSuffix = 78, RuleIndexList = 79, RuleNavigationSuffix = 80, RuleMethodCallSuffix = 81, RuleFunctionCallSuffix = 82, RuleFunctionCall = 83, RuleStructInitializerExpression = 84, RuleStructInitializerExpressionList = 85, RuleStructInitializer = 86, RuleDictInitializerExpression = 87, RuleDictInitializerExpressionList = 88, RuleDictInitializer = 89, RuleArrayInitializer = 90, RuleLiteral = 91, RuleInterpolatedString = 92, RuleInterpolatedStringPart = 93, RuleIntegerLiteral = 94, RuleFloatLiteral = 95, RuleBoolLiteral = 96 }; explicit EscriptParser(antlr4::TokenStream *input); EscriptParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); ~EscriptParser() override; std::string getGrammarFileName() const override; const antlr4::atn::ATN& getATN() const override; const std::vector& getRuleNames() const override; const antlr4::dfa::Vocabulary& getVocabulary() const override; antlr4::atn::SerializedATNView getSerializedATN() const override; bool inUninitFunction = false; class CompilationUnitContext; class ModuleUnitContext; class EvaluateUnitContext; class ModuleDeclarationStatementContext; class ModuleFunctionDeclarationContext; class ModuleFunctionParameterListContext; class ModuleFunctionParameterContext; class TopLevelDeclarationContext; class ClassDeclarationContext; class ClassParametersContext; class ClassParameterListContext; class ClassBodyContext; class ClassStatementContext; class UninitFunctionDeclarationContext; class FunctionDeclarationContext; class StringIdentifierContext; class UseDeclarationContext; class IncludeDeclarationContext; class ProgramDeclarationContext; class StatementContext; class StatementLabelContext; class IfStatementContext; class GotoStatementContext; class ReturnStatementContext; class ConstStatementContext; class VarStatementContext; class DoStatementContext; class WhileStatementContext; class ExitStatementContext; class BreakStatementContext; class ContinueStatementContext; class ForStatementContext; class ForeachIterableExpressionContext; class ForeachStatementContext; class RepeatStatementContext; class CaseStatementContext; class EnumStatementContext; class BlockContext; class VariableDeclarationInitializerContext; class EnumListContext; class EnumListEntryContext; class SwitchBlockStatementGroupContext; class SwitchLabelContext; class ForGroupContext; class BasicForStatementContext; class CstyleForStatementContext; class IdentifierListContext; class VariableDeclarationListContext; class ConstantDeclarationContext; class VariableDeclarationContext; class BindingDeclarationContext; class IndexBindingListContext; class SequenceBindingListContext; class SequenceBindingContext; class IndexBindingContext; class BindingContext; class BindingDeclarationInitializerContext; class ProgramParametersContext; class ProgramParameterListContext; class ProgramParameterContext; class FunctionParametersContext; class FunctionParameterListContext; class FunctionParameterContext; class ScopedFunctionCallContext; class FunctionReferenceContext; class ExpressionContext; class PrimaryContext; class ScopedIdentifierContext; class FunctionExpressionContext; class ExplicitArrayInitializerContext; class ExplicitStructInitializerContext; class ExplicitDictInitializerContext; class ExplicitErrorInitializerContext; class BareArrayInitializerContext; class ParExpressionContext; class ExpressionListContext; class ExpressionListEntryContext; class ExpressionSuffixContext; class IndexingSuffixContext; class IndexListContext; class NavigationSuffixContext; class MethodCallSuffixContext; class FunctionCallSuffixContext; class FunctionCallContext; class StructInitializerExpressionContext; class StructInitializerExpressionListContext; class StructInitializerContext; class DictInitializerExpressionContext; class DictInitializerExpressionListContext; class DictInitializerContext; class ArrayInitializerContext; class LiteralContext; class InterpolatedStringContext; class InterpolatedStringPartContext; class IntegerLiteralContext; class FloatLiteralContext; class BoolLiteralContext; class CompilationUnitContext : public antlr4::ParserRuleContext { public: CompilationUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *EOF(); std::vector topLevelDeclaration(); TopLevelDeclarationContext* topLevelDeclaration(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; CompilationUnitContext* compilationUnit(); class ModuleUnitContext : public antlr4::ParserRuleContext { public: ModuleUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *EOF(); std::vector moduleDeclarationStatement(); ModuleDeclarationStatementContext* moduleDeclarationStatement(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ModuleUnitContext* moduleUnit(); class EvaluateUnitContext : public antlr4::ParserRuleContext { public: EvaluateUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); antlr4::tree::TerminalNode *EOF(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; EvaluateUnitContext* evaluateUnit(); class ModuleDeclarationStatementContext : public antlr4::ParserRuleContext { public: ModuleDeclarationStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ModuleFunctionDeclarationContext *moduleFunctionDeclaration(); ConstStatementContext *constStatement(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ModuleDeclarationStatementContext* moduleDeclarationStatement(); class ModuleFunctionDeclarationContext : public antlr4::ParserRuleContext { public: ModuleFunctionDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); antlr4::tree::TerminalNode *SEMI(); ModuleFunctionParameterListContext *moduleFunctionParameterList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ModuleFunctionDeclarationContext* moduleFunctionDeclaration(); class ModuleFunctionParameterListContext : public antlr4::ParserRuleContext { public: ModuleFunctionParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector moduleFunctionParameter(); ModuleFunctionParameterContext* moduleFunctionParameter(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ModuleFunctionParameterListContext* moduleFunctionParameterList(); class ModuleFunctionParameterContext : public antlr4::ParserRuleContext { public: ModuleFunctionParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *ASSIGN(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ModuleFunctionParameterContext* moduleFunctionParameter(); class TopLevelDeclarationContext : public antlr4::ParserRuleContext { public: TopLevelDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; UseDeclarationContext *useDeclaration(); IncludeDeclarationContext *includeDeclaration(); ProgramDeclarationContext *programDeclaration(); FunctionDeclarationContext *functionDeclaration(); ClassDeclarationContext *classDeclaration(); StatementContext *statement(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; TopLevelDeclarationContext* topLevelDeclaration(); class ClassDeclarationContext : public antlr4::ParserRuleContext { public: ClassDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CLASS(); antlr4::tree::TerminalNode *IDENTIFIER(); ClassParametersContext *classParameters(); ClassBodyContext *classBody(); antlr4::tree::TerminalNode *ENDCLASS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ClassDeclarationContext* classDeclaration(); class ClassParametersContext : public antlr4::ParserRuleContext { public: ClassParametersContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); ClassParameterListContext *classParameterList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ClassParametersContext* classParameters(); class ClassParameterListContext : public antlr4::ParserRuleContext { public: ClassParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector IDENTIFIER(); antlr4::tree::TerminalNode* IDENTIFIER(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ClassParameterListContext* classParameterList(); class ClassBodyContext : public antlr4::ParserRuleContext { public: ClassBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector classStatement(); ClassStatementContext* classStatement(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ClassBodyContext* classBody(); class ClassStatementContext : public antlr4::ParserRuleContext { public: ClassStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; FunctionDeclarationContext *functionDeclaration(); VarStatementContext *varStatement(); UninitFunctionDeclarationContext *uninitFunctionDeclaration(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ClassStatementContext* classStatement(); class UninitFunctionDeclarationContext : public antlr4::ParserRuleContext { public: UninitFunctionDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *UNINIT(); antlr4::tree::TerminalNode *FUNCTION(); antlr4::tree::TerminalNode *IDENTIFIER(); FunctionParametersContext *functionParameters(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; UninitFunctionDeclarationContext* uninitFunctionDeclaration(); class FunctionDeclarationContext : public antlr4::ParserRuleContext { public: FunctionDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FUNCTION(); antlr4::tree::TerminalNode *IDENTIFIER(); FunctionParametersContext *functionParameters(); BlockContext *block(); antlr4::tree::TerminalNode *ENDFUNCTION(); antlr4::tree::TerminalNode *EXPORTED(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionDeclarationContext* functionDeclaration(); class StringIdentifierContext : public antlr4::ParserRuleContext { public: StringIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *STRING_LITERAL(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; StringIdentifierContext* stringIdentifier(); class UseDeclarationContext : public antlr4::ParserRuleContext { public: UseDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *USE(); StringIdentifierContext *stringIdentifier(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; UseDeclarationContext* useDeclaration(); class IncludeDeclarationContext : public antlr4::ParserRuleContext { public: IncludeDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *INCLUDE(); StringIdentifierContext *stringIdentifier(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IncludeDeclarationContext* includeDeclaration(); class ProgramDeclarationContext : public antlr4::ParserRuleContext { public: ProgramDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *PROGRAM(); antlr4::tree::TerminalNode *IDENTIFIER(); ProgramParametersContext *programParameters(); BlockContext *block(); antlr4::tree::TerminalNode *ENDPROGRAM(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ProgramDeclarationContext* programDeclaration(); class StatementContext : public antlr4::ParserRuleContext { public: EscriptParser::ExpressionContext *statementExpression = nullptr; StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; IfStatementContext *ifStatement(); GotoStatementContext *gotoStatement(); ReturnStatementContext *returnStatement(); ConstStatementContext *constStatement(); VarStatementContext *varStatement(); DoStatementContext *doStatement(); WhileStatementContext *whileStatement(); ExitStatementContext *exitStatement(); BreakStatementContext *breakStatement(); ContinueStatementContext *continueStatement(); ForStatementContext *forStatement(); ForeachStatementContext *foreachStatement(); RepeatStatementContext *repeatStatement(); CaseStatementContext *caseStatement(); EnumStatementContext *enumStatement(); antlr4::tree::TerminalNode *SEMI(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; StatementContext* statement(); class StatementLabelContext : public antlr4::ParserRuleContext { public: StatementLabelContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *COLON(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; StatementLabelContext* statementLabel(); class IfStatementContext : public antlr4::ParserRuleContext { public: IfStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IF(); std::vector parExpression(); ParExpressionContext* parExpression(size_t i); std::vector block(); BlockContext* block(size_t i); antlr4::tree::TerminalNode *ENDIF(); antlr4::tree::TerminalNode *THEN(); std::vector ELSEIF(); antlr4::tree::TerminalNode* ELSEIF(size_t i); antlr4::tree::TerminalNode *ELSE(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IfStatementContext* ifStatement(); class GotoStatementContext : public antlr4::ParserRuleContext { public: GotoStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *GOTO(); antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; GotoStatementContext* gotoStatement(); class ReturnStatementContext : public antlr4::ParserRuleContext { public: ReturnStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *RETURN(); antlr4::tree::TerminalNode *SEMI(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ReturnStatementContext* returnStatement(); class ConstStatementContext : public antlr4::ParserRuleContext { public: ConstStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *TOK_CONST(); ConstantDeclarationContext *constantDeclaration(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ConstStatementContext* constStatement(); class VarStatementContext : public antlr4::ParserRuleContext { public: VarStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *VAR(); VariableDeclarationListContext *variableDeclarationList(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; VarStatementContext* varStatement(); class DoStatementContext : public antlr4::ParserRuleContext { public: DoStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DO(); BlockContext *block(); antlr4::tree::TerminalNode *DOWHILE(); ParExpressionContext *parExpression(); antlr4::tree::TerminalNode *SEMI(); StatementLabelContext *statementLabel(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; DoStatementContext* doStatement(); class WhileStatementContext : public antlr4::ParserRuleContext { public: WhileStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *WHILE(); ParExpressionContext *parExpression(); BlockContext *block(); antlr4::tree::TerminalNode *ENDWHILE(); StatementLabelContext *statementLabel(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; WhileStatementContext* whileStatement(); class ExitStatementContext : public antlr4::ParserRuleContext { public: ExitStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *EXIT(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExitStatementContext* exitStatement(); class BreakStatementContext : public antlr4::ParserRuleContext { public: BreakStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *BREAK(); antlr4::tree::TerminalNode *SEMI(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BreakStatementContext* breakStatement(); class ContinueStatementContext : public antlr4::ParserRuleContext { public: ContinueStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CONTINUE(); antlr4::tree::TerminalNode *SEMI(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ContinueStatementContext* continueStatement(); class ForStatementContext : public antlr4::ParserRuleContext { public: ForStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FOR(); ForGroupContext *forGroup(); antlr4::tree::TerminalNode *ENDFOR(); StatementLabelContext *statementLabel(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ForStatementContext* forStatement(); class ForeachIterableExpressionContext : public antlr4::ParserRuleContext { public: ForeachIterableExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; FunctionCallContext *functionCall(); ScopedFunctionCallContext *scopedFunctionCall(); ScopedIdentifierContext *scopedIdentifier(); antlr4::tree::TerminalNode *IDENTIFIER(); ParExpressionContext *parExpression(); BareArrayInitializerContext *bareArrayInitializer(); ExplicitArrayInitializerContext *explicitArrayInitializer(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ForeachIterableExpressionContext* foreachIterableExpression(); class ForeachStatementContext : public antlr4::ParserRuleContext { public: ForeachStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FOREACH(); antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *TOK_IN(); ForeachIterableExpressionContext *foreachIterableExpression(); BlockContext *block(); antlr4::tree::TerminalNode *ENDFOREACH(); StatementLabelContext *statementLabel(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ForeachStatementContext* foreachStatement(); class RepeatStatementContext : public antlr4::ParserRuleContext { public: RepeatStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *REPEAT(); BlockContext *block(); antlr4::tree::TerminalNode *UNTIL(); ExpressionContext *expression(); antlr4::tree::TerminalNode *SEMI(); StatementLabelContext *statementLabel(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; RepeatStatementContext* repeatStatement(); class CaseStatementContext : public antlr4::ParserRuleContext { public: CaseStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CASE(); antlr4::tree::TerminalNode *LPAREN(); ExpressionContext *expression(); antlr4::tree::TerminalNode *RPAREN(); antlr4::tree::TerminalNode *ENDCASE(); StatementLabelContext *statementLabel(); std::vector switchBlockStatementGroup(); SwitchBlockStatementGroupContext* switchBlockStatementGroup(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; CaseStatementContext* caseStatement(); class EnumStatementContext : public antlr4::ParserRuleContext { public: EnumStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ENUM(); antlr4::tree::TerminalNode *IDENTIFIER(); EnumListContext *enumList(); antlr4::tree::TerminalNode *ENDENUM(); antlr4::tree::TerminalNode *CLASS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; EnumStatementContext* enumStatement(); class BlockContext : public antlr4::ParserRuleContext { public: BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector statement(); StatementContext* statement(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BlockContext* block(); class VariableDeclarationInitializerContext : public antlr4::ParserRuleContext { public: VariableDeclarationInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ASSIGN(); ExpressionContext *expression(); antlr4::tree::TerminalNode *EQUAL_DEPRECATED(); antlr4::tree::TerminalNode *ARRAY(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; VariableDeclarationInitializerContext* variableDeclarationInitializer(); class EnumListContext : public antlr4::ParserRuleContext { public: EnumListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector enumListEntry(); EnumListEntryContext* enumListEntry(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; EnumListContext* enumList(); class EnumListEntryContext : public antlr4::ParserRuleContext { public: EnumListEntryContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *ASSIGN(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; EnumListEntryContext* enumListEntry(); class SwitchBlockStatementGroupContext : public antlr4::ParserRuleContext { public: SwitchBlockStatementGroupContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; BlockContext *block(); std::vector switchLabel(); SwitchLabelContext* switchLabel(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; SwitchBlockStatementGroupContext* switchBlockStatementGroup(); class SwitchLabelContext : public antlr4::ParserRuleContext { public: SwitchLabelContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *COLON(); IntegerLiteralContext *integerLiteral(); BoolLiteralContext *boolLiteral(); ScopedIdentifierContext *scopedIdentifier(); antlr4::tree::TerminalNode *UNINIT(); antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *STRING_LITERAL(); antlr4::tree::TerminalNode *DEFAULT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; SwitchLabelContext* switchLabel(); class ForGroupContext : public antlr4::ParserRuleContext { public: ForGroupContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; CstyleForStatementContext *cstyleForStatement(); BasicForStatementContext *basicForStatement(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ForGroupContext* forGroup(); class BasicForStatementContext : public antlr4::ParserRuleContext { public: BasicForStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *ASSIGN(); std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *TO(); BlockContext *block(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BasicForStatementContext* basicForStatement(); class CstyleForStatementContext : public antlr4::ParserRuleContext { public: CstyleForStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LPAREN(); std::vector expression(); ExpressionContext* expression(size_t i); std::vector SEMI(); antlr4::tree::TerminalNode* SEMI(size_t i); antlr4::tree::TerminalNode *RPAREN(); BlockContext *block(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; CstyleForStatementContext* cstyleForStatement(); class IdentifierListContext : public antlr4::ParserRuleContext { public: IdentifierListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *COMMA(); IdentifierListContext *identifierList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IdentifierListContext* identifierList(); class VariableDeclarationListContext : public antlr4::ParserRuleContext { public: VariableDeclarationListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector variableDeclaration(); VariableDeclarationContext* variableDeclaration(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; VariableDeclarationListContext* variableDeclarationList(); class ConstantDeclarationContext : public antlr4::ParserRuleContext { public: ConstantDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); VariableDeclarationInitializerContext *variableDeclarationInitializer(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ConstantDeclarationContext* constantDeclaration(); class VariableDeclarationContext : public antlr4::ParserRuleContext { public: VariableDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); VariableDeclarationInitializerContext *variableDeclarationInitializer(); BindingDeclarationContext *bindingDeclaration(); BindingDeclarationInitializerContext *bindingDeclarationInitializer(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; VariableDeclarationContext* variableDeclaration(); class BindingDeclarationContext : public antlr4::ParserRuleContext { public: BindingDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LBRACK(); SequenceBindingListContext *sequenceBindingList(); antlr4::tree::TerminalNode *RBRACK(); antlr4::tree::TerminalNode *LBRACE(); IndexBindingListContext *indexBindingList(); antlr4::tree::TerminalNode *RBRACE(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BindingDeclarationContext* bindingDeclaration(); class IndexBindingListContext : public antlr4::ParserRuleContext { public: IndexBindingListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector indexBinding(); IndexBindingContext* indexBinding(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IndexBindingListContext* indexBindingList(); class SequenceBindingListContext : public antlr4::ParserRuleContext { public: SequenceBindingListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector sequenceBinding(); SequenceBindingContext* sequenceBinding(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; SequenceBindingListContext* sequenceBindingList(); class SequenceBindingContext : public antlr4::ParserRuleContext { public: SequenceBindingContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *ELLIPSIS(); BindingDeclarationContext *bindingDeclaration(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; SequenceBindingContext* sequenceBinding(); class IndexBindingContext : public antlr4::ParserRuleContext { public: IndexBindingContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *ELLIPSIS(); BindingContext *binding(); antlr4::tree::TerminalNode *LBRACK(); ExpressionContext *expression(); antlr4::tree::TerminalNode *RBRACK(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IndexBindingContext* indexBinding(); class BindingContext : public antlr4::ParserRuleContext { public: BindingContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *COLON(); antlr4::tree::TerminalNode *IDENTIFIER(); BindingDeclarationContext *bindingDeclaration(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BindingContext* binding(); class BindingDeclarationInitializerContext : public antlr4::ParserRuleContext { public: BindingDeclarationInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ASSIGN(); ExpressionContext *expression(); antlr4::tree::TerminalNode *EQUAL_DEPRECATED(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BindingDeclarationInitializerContext* bindingDeclarationInitializer(); class ProgramParametersContext : public antlr4::ParserRuleContext { public: ProgramParametersContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); ProgramParameterListContext *programParameterList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ProgramParametersContext* programParameters(); class ProgramParameterListContext : public antlr4::ParserRuleContext { public: ProgramParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector programParameter(); ProgramParameterContext* programParameter(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ProgramParameterListContext* programParameterList(); class ProgramParameterContext : public antlr4::ParserRuleContext { public: ProgramParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *UNUSED(); antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *ASSIGN(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ProgramParameterContext* programParameter(); class FunctionParametersContext : public antlr4::ParserRuleContext { public: FunctionParametersContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); FunctionParameterListContext *functionParameterList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionParametersContext* functionParameters(); class FunctionParameterListContext : public antlr4::ParserRuleContext { public: FunctionParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector functionParameter(); FunctionParameterContext* functionParameter(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionParameterListContext* functionParameterList(); class FunctionParameterContext : public antlr4::ParserRuleContext { public: FunctionParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *BYREF(); antlr4::tree::TerminalNode *UNUSED(); antlr4::tree::TerminalNode *DEFAULT(); antlr4::tree::TerminalNode *ELLIPSIS(); antlr4::tree::TerminalNode *ASSIGN(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionParameterContext* functionParameter(); class ScopedFunctionCallContext : public antlr4::ParserRuleContext { public: ScopedFunctionCallContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *COLONCOLON(); FunctionCallContext *functionCall(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ScopedFunctionCallContext* scopedFunctionCall(); class FunctionReferenceContext : public antlr4::ParserRuleContext { public: antlr4::Token *scope = nullptr; antlr4::Token *function = nullptr; FunctionReferenceContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *AT(); std::vector IDENTIFIER(); antlr4::tree::TerminalNode* IDENTIFIER(size_t i); antlr4::tree::TerminalNode *COLONCOLON(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionReferenceContext* functionReference(); class ExpressionContext : public antlr4::ParserRuleContext { public: antlr4::Token *prefix = nullptr; antlr4::Token *bop = nullptr; antlr4::Token *postfix = nullptr; ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; PrimaryContext *primary(); std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *ADD(); antlr4::tree::TerminalNode *SUB(); antlr4::tree::TerminalNode *INC(); antlr4::tree::TerminalNode *DEC(); antlr4::tree::TerminalNode *TILDE(); antlr4::tree::TerminalNode *BANG_A(); antlr4::tree::TerminalNode *BANG_B(); antlr4::tree::TerminalNode *MUL(); antlr4::tree::TerminalNode *DIV(); antlr4::tree::TerminalNode *MOD(); antlr4::tree::TerminalNode *LSHIFT(); antlr4::tree::TerminalNode *RSHIFT(); antlr4::tree::TerminalNode *BITAND(); antlr4::tree::TerminalNode *BITOR(); antlr4::tree::TerminalNode *CARET(); antlr4::tree::TerminalNode *ELVIS(); antlr4::tree::TerminalNode *TOK_IN(); antlr4::tree::TerminalNode *LE(); antlr4::tree::TerminalNode *GE(); antlr4::tree::TerminalNode *GT(); antlr4::tree::TerminalNode *LT(); antlr4::tree::TerminalNode *IS(); antlr4::tree::TerminalNode *EQUAL_DEPRECATED(); antlr4::tree::TerminalNode *EQUAL(); antlr4::tree::TerminalNode *NOTEQUAL_B(); antlr4::tree::TerminalNode *NOTEQUAL_A(); antlr4::tree::TerminalNode *AND_A(); antlr4::tree::TerminalNode *AND_B(); antlr4::tree::TerminalNode *OR_A(); antlr4::tree::TerminalNode *OR_B(); antlr4::tree::TerminalNode *QUESTION(); antlr4::tree::TerminalNode *COLON(); antlr4::tree::TerminalNode *ADDMEMBER(); antlr4::tree::TerminalNode *DELMEMBER(); antlr4::tree::TerminalNode *CHKMEMBER(); antlr4::tree::TerminalNode *ASSIGN(); antlr4::tree::TerminalNode *ADD_ASSIGN(); antlr4::tree::TerminalNode *SUB_ASSIGN(); antlr4::tree::TerminalNode *MUL_ASSIGN(); antlr4::tree::TerminalNode *DIV_ASSIGN(); antlr4::tree::TerminalNode *MOD_ASSIGN(); ExpressionSuffixContext *expressionSuffix(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExpressionContext* expression(); ExpressionContext* expression(int precedence); class PrimaryContext : public antlr4::ParserRuleContext { public: PrimaryContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; LiteralContext *literal(); ParExpressionContext *parExpression(); FunctionCallContext *functionCall(); ScopedFunctionCallContext *scopedFunctionCall(); ScopedIdentifierContext *scopedIdentifier(); antlr4::tree::TerminalNode *IDENTIFIER(); FunctionReferenceContext *functionReference(); FunctionExpressionContext *functionExpression(); ExplicitArrayInitializerContext *explicitArrayInitializer(); ExplicitStructInitializerContext *explicitStructInitializer(); ExplicitDictInitializerContext *explicitDictInitializer(); ExplicitErrorInitializerContext *explicitErrorInitializer(); BareArrayInitializerContext *bareArrayInitializer(); InterpolatedStringContext *interpolatedString(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; PrimaryContext* primary(); class ScopedIdentifierContext : public antlr4::ParserRuleContext { public: antlr4::Token *scope = nullptr; antlr4::Token *identifier = nullptr; ScopedIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *COLONCOLON(); std::vector IDENTIFIER(); antlr4::tree::TerminalNode* IDENTIFIER(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ScopedIdentifierContext* scopedIdentifier(); class FunctionExpressionContext : public antlr4::ParserRuleContext { public: FunctionExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *AT(); antlr4::tree::TerminalNode *LBRACE(); BlockContext *block(); antlr4::tree::TerminalNode *RBRACE(); FunctionParametersContext *functionParameters(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionExpressionContext* functionExpression(); class ExplicitArrayInitializerContext : public antlr4::ParserRuleContext { public: ExplicitArrayInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ARRAY(); ArrayInitializerContext *arrayInitializer(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExplicitArrayInitializerContext* explicitArrayInitializer(); class ExplicitStructInitializerContext : public antlr4::ParserRuleContext { public: ExplicitStructInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *STRUCT(); StructInitializerContext *structInitializer(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExplicitStructInitializerContext* explicitStructInitializer(); class ExplicitDictInitializerContext : public antlr4::ParserRuleContext { public: ExplicitDictInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DICTIONARY(); DictInitializerContext *dictInitializer(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExplicitDictInitializerContext* explicitDictInitializer(); class ExplicitErrorInitializerContext : public antlr4::ParserRuleContext { public: ExplicitErrorInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *TOK_ERROR(); StructInitializerContext *structInitializer(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExplicitErrorInitializerContext* explicitErrorInitializer(); class BareArrayInitializerContext : public antlr4::ParserRuleContext { public: BareArrayInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LBRACE(); antlr4::tree::TerminalNode *RBRACE(); ExpressionListContext *expressionList(); antlr4::tree::TerminalNode *COMMA(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BareArrayInitializerContext* bareArrayInitializer(); class ParExpressionContext : public antlr4::ParserRuleContext { public: ParExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LPAREN(); ExpressionContext *expression(); antlr4::tree::TerminalNode *RPAREN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ParExpressionContext* parExpression(); class ExpressionListContext : public antlr4::ParserRuleContext { public: ExpressionListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector expressionListEntry(); ExpressionListEntryContext* expressionListEntry(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExpressionListContext* expressionList(); class ExpressionListEntryContext : public antlr4::ParserRuleContext { public: ExpressionListEntryContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); antlr4::tree::TerminalNode *ELLIPSIS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExpressionListEntryContext* expressionListEntry(); class ExpressionSuffixContext : public antlr4::ParserRuleContext { public: ExpressionSuffixContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; IndexingSuffixContext *indexingSuffix(); MethodCallSuffixContext *methodCallSuffix(); NavigationSuffixContext *navigationSuffix(); FunctionCallSuffixContext *functionCallSuffix(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExpressionSuffixContext* expressionSuffix(); class IndexingSuffixContext : public antlr4::ParserRuleContext { public: IndexingSuffixContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LBRACK(); IndexListContext *indexList(); antlr4::tree::TerminalNode *RBRACK(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IndexingSuffixContext* indexingSuffix(); class IndexListContext : public antlr4::ParserRuleContext { public: IndexListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector expression(); ExpressionContext* expression(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IndexListContext* indexList(); class NavigationSuffixContext : public antlr4::ParserRuleContext { public: NavigationSuffixContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *STRING_LITERAL(); antlr4::tree::TerminalNode *FUNCTION(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; NavigationSuffixContext* navigationSuffix(); class MethodCallSuffixContext : public antlr4::ParserRuleContext { public: MethodCallSuffixContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); ExpressionListContext *expressionList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; MethodCallSuffixContext* methodCallSuffix(); class FunctionCallSuffixContext : public antlr4::ParserRuleContext { public: FunctionCallSuffixContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); ExpressionListContext *expressionList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionCallSuffixContext* functionCallSuffix(); class FunctionCallContext : public antlr4::ParserRuleContext { public: FunctionCallContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); ExpressionListContext *expressionList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FunctionCallContext* functionCall(); class StructInitializerExpressionContext : public antlr4::ParserRuleContext { public: StructInitializerExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *ASSIGN(); ExpressionContext *expression(); antlr4::tree::TerminalNode *STRING_LITERAL(); antlr4::tree::TerminalNode *ELLIPSIS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; StructInitializerExpressionContext* structInitializerExpression(); class StructInitializerExpressionListContext : public antlr4::ParserRuleContext { public: StructInitializerExpressionListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector structInitializerExpression(); StructInitializerExpressionContext* structInitializerExpression(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; StructInitializerExpressionListContext* structInitializerExpressionList(); class StructInitializerContext : public antlr4::ParserRuleContext { public: StructInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LBRACE(); antlr4::tree::TerminalNode *RBRACE(); StructInitializerExpressionListContext *structInitializerExpressionList(); antlr4::tree::TerminalNode *COMMA(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; StructInitializerContext* structInitializer(); class DictInitializerExpressionContext : public antlr4::ParserRuleContext { public: DictInitializerExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *ARROW(); antlr4::tree::TerminalNode *ELLIPSIS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; DictInitializerExpressionContext* dictInitializerExpression(); class DictInitializerExpressionListContext : public antlr4::ParserRuleContext { public: DictInitializerExpressionListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector dictInitializerExpression(); DictInitializerExpressionContext* dictInitializerExpression(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; DictInitializerExpressionListContext* dictInitializerExpressionList(); class DictInitializerContext : public antlr4::ParserRuleContext { public: DictInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LBRACE(); antlr4::tree::TerminalNode *RBRACE(); DictInitializerExpressionListContext *dictInitializerExpressionList(); antlr4::tree::TerminalNode *COMMA(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; DictInitializerContext* dictInitializer(); class ArrayInitializerContext : public antlr4::ParserRuleContext { public: ArrayInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LBRACE(); antlr4::tree::TerminalNode *RBRACE(); ExpressionListContext *expressionList(); antlr4::tree::TerminalNode *COMMA(); antlr4::tree::TerminalNode *LPAREN(); antlr4::tree::TerminalNode *RPAREN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ArrayInitializerContext* arrayInitializer(); class LiteralContext : public antlr4::ParserRuleContext { public: LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; IntegerLiteralContext *integerLiteral(); FloatLiteralContext *floatLiteral(); BoolLiteralContext *boolLiteral(); antlr4::tree::TerminalNode *STRING_LITERAL(); antlr4::tree::TerminalNode *UNINIT(); antlr4::tree::TerminalNode *REGEXP_LITERAL(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; LiteralContext* literal(); class InterpolatedStringContext : public antlr4::ParserRuleContext { public: InterpolatedStringContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *INTERPOLATED_STRING_START(); antlr4::tree::TerminalNode *DOUBLE_QUOTE_INSIDE(); std::vector interpolatedStringPart(); InterpolatedStringPartContext* interpolatedStringPart(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; InterpolatedStringContext* interpolatedString(); class InterpolatedStringPartContext : public antlr4::ParserRuleContext { public: InterpolatedStringPartContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LBRACE_INSIDE(); ExpressionContext *expression(); antlr4::tree::TerminalNode *COLON(); antlr4::tree::TerminalNode *FORMAT_STRING(); antlr4::tree::TerminalNode *DOUBLE_LBRACE_INSIDE(); antlr4::tree::TerminalNode *REGULAR_CHAR_INSIDE(); antlr4::tree::TerminalNode *DOUBLE_RBRACE(); antlr4::tree::TerminalNode *STRING_LITERAL_INSIDE(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; InterpolatedStringPartContext* interpolatedStringPart(); class IntegerLiteralContext : public antlr4::ParserRuleContext { public: IntegerLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DECIMAL_LITERAL(); antlr4::tree::TerminalNode *HEX_LITERAL(); antlr4::tree::TerminalNode *OCT_LITERAL(); antlr4::tree::TerminalNode *BINARY_LITERAL(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; IntegerLiteralContext* integerLiteral(); class FloatLiteralContext : public antlr4::ParserRuleContext { public: FloatLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FLOAT_LITERAL(); antlr4::tree::TerminalNode *HEX_FLOAT_LITERAL(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; FloatLiteralContext* floatLiteral(); class BoolLiteralContext : public antlr4::ParserRuleContext { public: BoolLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *BOOL_TRUE(); antlr4::tree::TerminalNode *BOOL_FALSE(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; BoolLiteralContext* boolLiteral(); bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; bool expressionSempred(ExpressionContext *_localctx, size_t predicateIndex); // By default the static state used to implement the parser is lazily initialized during the first // call to the constructor. You can call this function if you wish to initialize the static state // ahead of time. static void initialize(); private: }; } // namespace EscriptGrammar