mirror of
https://github.com/polserver/polserver
synced 2026-08-13 08:23:08 -04:00
1627 lines
64 KiB
C++
1627 lines
64 KiB
C++
|
|
|
|
|
|
// Generated from lib/EscriptGrammar/EscriptParser.g4 by ANTLR 4.8
|
|
|
|
#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,
|
|
DOWNTO = 36, STEP = 37, REFERENCE = 38, TOK_OUT = 39, INOUT = 40, BYVAL = 41,
|
|
STRING = 42, TOK_LONG = 43, INTEGER = 44, UNSIGNED = 45, SIGNED = 46,
|
|
REAL = 47, FLOAT = 48, DOUBLE = 49, AS = 50, IS = 51, AND_A = 52, AND_B = 53,
|
|
OR_A = 54, OR_B = 55, BANG_A = 56, BANG_B = 57, BYREF = 58, UNUSED = 59,
|
|
TOK_ERROR = 60, HASH = 61, DICTIONARY = 62, STRUCT = 63, ARRAY = 64,
|
|
STACK = 65, TOK_IN = 66, DECIMAL_LITERAL = 67, HEX_LITERAL = 68, OCT_LITERAL = 69,
|
|
BINARY_LITERAL = 70, FLOAT_LITERAL = 71, HEX_FLOAT_LITERAL = 72, STRING_LITERAL = 73,
|
|
INTERPOLATED_STRING_START = 74, LPAREN = 75, RPAREN = 76, LBRACK = 77,
|
|
RBRACK = 78, LBRACE = 79, RBRACE = 80, DOT = 81, ARROW = 82, MUL = 83,
|
|
DIV = 84, MOD = 85, ADD = 86, SUB = 87, ADD_ASSIGN = 88, SUB_ASSIGN = 89,
|
|
MUL_ASSIGN = 90, DIV_ASSIGN = 91, MOD_ASSIGN = 92, LE = 93, LT = 94,
|
|
GE = 95, GT = 96, RSHIFT = 97, LSHIFT = 98, BITAND = 99, CARET = 100,
|
|
BITOR = 101, NOTEQUAL_A = 102, NOTEQUAL_B = 103, EQUAL_DEPRECATED = 104,
|
|
EQUAL = 105, ASSIGN = 106, ADDMEMBER = 107, DELMEMBER = 108, CHKMEMBER = 109,
|
|
SEMI = 110, COMMA = 111, TILDE = 112, AT = 113, COLONCOLON = 114, COLON = 115,
|
|
INC = 116, DEC = 117, ELVIS = 118, QUESTION = 119, WS = 120, COMMENT = 121,
|
|
LINE_COMMENT = 122, IDENTIFIER = 123, DOUBLE_LBRACE_INSIDE = 124, LBRACE_INSIDE = 125,
|
|
REGULAR_CHAR_INSIDE = 126, DOUBLE_QUOTE_INSIDE = 127, DOUBLE_RBRACE = 128,
|
|
STRING_LITERAL_INSIDE = 129, CLOSE_RBRACE_INSIDE = 130, FORMAT_STRING = 131
|
|
};
|
|
|
|
enum {
|
|
RuleCompilationUnit = 0, RuleModuleUnit = 1, RuleModuleDeclarationStatement = 2,
|
|
RuleModuleFunctionDeclaration = 3, RuleModuleFunctionParameterList = 4,
|
|
RuleModuleFunctionParameter = 5, RuleTopLevelDeclaration = 6, RuleFunctionDeclaration = 7,
|
|
RuleStringIdentifier = 8, RuleUseDeclaration = 9, RuleIncludeDeclaration = 10,
|
|
RuleProgramDeclaration = 11, RuleStatement = 12, RuleStatementLabel = 13,
|
|
RuleIfStatement = 14, RuleGotoStatement = 15, RuleReturnStatement = 16,
|
|
RuleConstStatement = 17, RuleVarStatement = 18, RuleDoStatement = 19,
|
|
RuleWhileStatement = 20, RuleExitStatement = 21, RuleBreakStatement = 22,
|
|
RuleContinueStatement = 23, RuleForStatement = 24, RuleForeachIterableExpression = 25,
|
|
RuleForeachStatement = 26, RuleRepeatStatement = 27, RuleCaseStatement = 28,
|
|
RuleEnumStatement = 29, RuleBlock = 30, RuleVariableDeclarationInitializer = 31,
|
|
RuleEnumList = 32, RuleEnumListEntry = 33, RuleSwitchBlockStatementGroup = 34,
|
|
RuleSwitchLabel = 35, RuleForGroup = 36, RuleBasicForStatement = 37,
|
|
RuleCstyleForStatement = 38, RuleIdentifierList = 39, RuleVariableDeclarationList = 40,
|
|
RuleConstantDeclaration = 41, RuleVariableDeclaration = 42, RuleProgramParameters = 43,
|
|
RuleProgramParameterList = 44, RuleProgramParameter = 45, RuleFunctionParameters = 46,
|
|
RuleFunctionParameterList = 47, RuleFunctionParameter = 48, RuleScopedFunctionCall = 49,
|
|
RuleFunctionReference = 50, RuleExpression = 51, RulePrimary = 52, RuleExplicitArrayInitializer = 53,
|
|
RuleExplicitStructInitializer = 54, RuleExplicitDictInitializer = 55,
|
|
RuleExplicitErrorInitializer = 56, RuleBareArrayInitializer = 57, RuleParExpression = 58,
|
|
RuleExpressionList = 59, RuleExpressionSuffix = 60, RuleIndexingSuffix = 61,
|
|
RuleNavigationSuffix = 62, RuleMethodCallSuffix = 63, RuleFunctionCall = 64,
|
|
RuleStructInitializerExpression = 65, RuleStructInitializerExpressionList = 66,
|
|
RuleStructInitializer = 67, RuleDictInitializerExpression = 68, RuleDictInitializerExpressionList = 69,
|
|
RuleDictInitializer = 70, RuleArrayInitializer = 71, RuleLiteral = 72,
|
|
RuleInterpolatedString = 73, RuleInterpolatedStringPart = 74, RuleIntegerLiteral = 75,
|
|
RuleFloatLiteral = 76
|
|
};
|
|
|
|
EscriptParser(antlr4::TokenStream *input);
|
|
~EscriptParser();
|
|
|
|
virtual std::string getGrammarFileName() const override;
|
|
virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
|
|
virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
|
|
virtual const std::vector<std::string>& getRuleNames() const override;
|
|
virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
|
|
|
|
|
|
|
|
|
|
class CompilationUnitContext;
|
|
class ModuleUnitContext;
|
|
class ModuleDeclarationStatementContext;
|
|
class ModuleFunctionDeclarationContext;
|
|
class ModuleFunctionParameterListContext;
|
|
class ModuleFunctionParameterContext;
|
|
class TopLevelDeclarationContext;
|
|
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 ProgramParametersContext;
|
|
class ProgramParameterListContext;
|
|
class ProgramParameterContext;
|
|
class FunctionParametersContext;
|
|
class FunctionParameterListContext;
|
|
class FunctionParameterContext;
|
|
class ScopedFunctionCallContext;
|
|
class FunctionReferenceContext;
|
|
class ExpressionContext;
|
|
class PrimaryContext;
|
|
class ExplicitArrayInitializerContext;
|
|
class ExplicitStructInitializerContext;
|
|
class ExplicitDictInitializerContext;
|
|
class ExplicitErrorInitializerContext;
|
|
class BareArrayInitializerContext;
|
|
class ParExpressionContext;
|
|
class ExpressionListContext;
|
|
class ExpressionSuffixContext;
|
|
class IndexingSuffixContext;
|
|
class NavigationSuffixContext;
|
|
class MethodCallSuffixContext;
|
|
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 CompilationUnitContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
CompilationUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *EOF();
|
|
std::vector<TopLevelDeclarationContext *> topLevelDeclaration();
|
|
TopLevelDeclarationContext* topLevelDeclaration(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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<ModuleDeclarationStatementContext *> moduleDeclarationStatement();
|
|
ModuleDeclarationStatementContext* moduleDeclarationStatement(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ModuleUnitContext* moduleUnit();
|
|
|
|
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 antlrcpp::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 antlrcpp::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<ModuleFunctionParameterContext *> moduleFunctionParameter();
|
|
ModuleFunctionParameterContext* moduleFunctionParameter(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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();
|
|
StatementContext *statement();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TopLevelDeclarationContext* topLevelDeclaration();
|
|
|
|
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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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<ParExpressionContext *> parExpression();
|
|
ParExpressionContext* parExpression(size_t i);
|
|
std::vector<BlockContext *> block();
|
|
BlockContext* block(size_t i);
|
|
antlr4::tree::TerminalNode *ENDIF();
|
|
antlr4::tree::TerminalNode *THEN();
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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();
|
|
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 antlrcpp::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 antlrcpp::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 antlrcpp::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<SwitchBlockStatementGroupContext *> switchBlockStatementGroup();
|
|
SwitchBlockStatementGroupContext* switchBlockStatementGroup(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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<StatementContext *> statement();
|
|
StatementContext* statement(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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 antlrcpp::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<EnumListEntryContext *> enumListEntry();
|
|
EnumListEntryContext* enumListEntry(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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<SwitchLabelContext *> switchLabel();
|
|
SwitchLabelContext* switchLabel(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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();
|
|
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 antlrcpp::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 antlrcpp::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<ExpressionContext *> 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 antlrcpp::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<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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<VariableDeclarationContext *> variableDeclaration();
|
|
VariableDeclarationContext* variableDeclaration(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
VariableDeclarationContext* variableDeclaration();
|
|
|
|
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 antlrcpp::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<ProgramParameterContext *> programParameter();
|
|
ProgramParameterContext* programParameter(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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 antlrcpp::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<FunctionParameterContext *> functionParameter();
|
|
FunctionParameterContext* functionParameter(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 *ASSIGN();
|
|
ExpressionContext *expression();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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 *IDENTIFIER();
|
|
antlr4::tree::TerminalNode *COLONCOLON();
|
|
FunctionCallContext *functionCall();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ScopedFunctionCallContext* scopedFunctionCall();
|
|
|
|
class FunctionReferenceContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FunctionReferenceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *AT();
|
|
antlr4::tree::TerminalNode *IDENTIFIER();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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<ExpressionContext *> 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 *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 antlrcpp::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();
|
|
antlr4::tree::TerminalNode *IDENTIFIER();
|
|
FunctionReferenceContext *functionReference();
|
|
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 antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
PrimaryContext* primary();
|
|
|
|
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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::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<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ExpressionListContext* expressionList();
|
|
|
|
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();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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();
|
|
ExpressionListContext *expressionList();
|
|
antlr4::tree::TerminalNode *RBRACK();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
IndexingSuffixContext* indexingSuffix();
|
|
|
|
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();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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 antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
MethodCallSuffixContext* methodCallSuffix();
|
|
|
|
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 antlrcpp::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();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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<StructInitializerExpressionContext *> structInitializerExpression();
|
|
StructInitializerExpressionContext* structInitializerExpression(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
antlr4::tree::TerminalNode *ARROW();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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<DictInitializerExpressionContext *> dictInitializerExpression();
|
|
DictInitializerExpressionContext* dictInitializerExpression(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> 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 antlrcpp::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 antlrcpp::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 antlrcpp::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();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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<InterpolatedStringPartContext *> interpolatedStringPart();
|
|
InterpolatedStringPartContext* interpolatedStringPart(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
virtual antlrcpp::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 antlrcpp::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 antlrcpp::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 antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FloatLiteralContext* floatLiteral();
|
|
|
|
|
|
virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
|
|
bool expressionSempred(ExpressionContext *_localctx, size_t predicateIndex);
|
|
|
|
private:
|
|
static std::vector<antlr4::dfa::DFA> _decisionToDFA;
|
|
static antlr4::atn::PredictionContextCache _sharedContextCache;
|
|
static std::vector<std::string> _ruleNames;
|
|
static std::vector<std::string> _tokenNames;
|
|
|
|
static std::vector<std::string> _literalNames;
|
|
static std::vector<std::string> _symbolicNames;
|
|
static antlr4::dfa::Vocabulary _vocabulary;
|
|
static antlr4::atn::ATN _atn;
|
|
static std::vector<uint16_t> _serializedATN;
|
|
|
|
|
|
struct Initializer {
|
|
Initializer();
|
|
};
|
|
static Initializer _init;
|
|
};
|
|
|
|
} // namespace EscriptGrammar
|