mirror of
https://github.com/polserver/polserver
synced 2026-08-13 08:23:08 -04:00
d456cc98eb
* Update grammar
- add '=' to grammar so that we can report appropriate errors
- add elvis ?: operator
- add foreachIterableExpression to match old compiler (which only allows certain expressions)
- allow both byref and unused on the same function parameter
- rename methodCall -> functionCall
- rename memberCall -> methodCall
- add named parser rule for functionReference
- move everything that isn't expression(s) with operators into primary
- expression is now just the left-recursive rules and prefix operators
- add named parser rules for struct, dictionary, error, array initialization
- remove special-case for named parameters with := from function call argument, because it is ambiguous with assignment
- Moved array access, object member access, and object method calls to navigationSuffix
* Regen grammar
1580 lines
62 KiB
C++
1580 lines
62 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, DECLARE = 15, FUNCTION = 16, ENDFUNCTION = 17, EXPORTED = 18,
|
|
USE = 19, INCLUDE = 20, BREAK = 21, CONTINUE = 22, FOR = 23, ENDFOR = 24,
|
|
TO = 25, FOREACH = 26, ENDFOREACH = 27, REPEAT = 28, UNTIL = 29, PROGRAM = 30,
|
|
ENDPROGRAM = 31, CASE = 32, DEFAULT = 33, ENDCASE = 34, ENUM = 35, ENDENUM = 36,
|
|
DOWNTO = 37, STEP = 38, REFERENCE = 39, TOK_OUT = 40, INOUT = 41, BYVAL = 42,
|
|
STRING = 43, TOK_LONG = 44, INTEGER = 45, UNSIGNED = 46, SIGNED = 47,
|
|
REAL = 48, FLOAT = 49, DOUBLE = 50, AS = 51, IS = 52, AND_A = 53, AND_B = 54,
|
|
OR_A = 55, OR_B = 56, BANG_A = 57, BANG_B = 58, BYREF = 59, UNUSED = 60,
|
|
TOK_ERROR = 61, HASH = 62, DICTIONARY = 63, STRUCT = 64, ARRAY = 65,
|
|
STACK = 66, TOK_IN = 67, DECIMAL_LITERAL = 68, HEX_LITERAL = 69, OCT_LITERAL = 70,
|
|
BINARY_LITERAL = 71, FLOAT_LITERAL = 72, HEX_FLOAT_LITERAL = 73, CHAR_LITERAL = 74,
|
|
STRING_LITERAL = 75, NULL_LITERAL = 76, LPAREN = 77, RPAREN = 78, LBRACK = 79,
|
|
RBRACK = 80, LBRACE = 81, RBRACE = 82, DOT = 83, ARROW = 84, MUL = 85,
|
|
DIV = 86, MOD = 87, ADD = 88, SUB = 89, ADD_ASSIGN = 90, SUB_ASSIGN = 91,
|
|
MUL_ASSIGN = 92, DIV_ASSIGN = 93, MOD_ASSIGN = 94, LE = 95, LT = 96,
|
|
GE = 97, GT = 98, RSHIFT = 99, LSHIFT = 100, BITAND = 101, CARET = 102,
|
|
BITOR = 103, NOTEQUAL_A = 104, NOTEQUAL_B = 105, EQUAL_DEPRECATED = 106,
|
|
EQUAL = 107, ASSIGN = 108, ADDMEMBER = 109, DELMEMBER = 110, CHKMEMBER = 111,
|
|
SEMI = 112, COMMA = 113, TILDE = 114, AT = 115, COLONCOLON = 116, COLON = 117,
|
|
INC = 118, DEC = 119, ELVIS = 120, WS = 121, COMMENT = 122, LINE_COMMENT = 123,
|
|
IDENTIFIER = 124
|
|
};
|
|
|
|
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, RuleDeclareStatement = 22,
|
|
RuleBreakStatement = 23, RuleContinueStatement = 24, RuleForStatement = 25,
|
|
RuleForeachIterableExpression = 26, RuleForeachStatement = 27, RuleRepeatStatement = 28,
|
|
RuleCaseStatement = 29, RuleEnumStatement = 30, RuleBlock = 31, RuleVariableDeclarationInitializer = 32,
|
|
RuleEnumList = 33, RuleEnumListEntry = 34, RuleSwitchBlockStatementGroup = 35,
|
|
RuleSwitchLabel = 36, RuleForGroup = 37, RuleBasicForStatement = 38,
|
|
RuleCstyleForStatement = 39, RuleIdentifierList = 40, RuleVariableDeclarationList = 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,
|
|
RuleIntegerLiteral = 73, RuleFloatLiteral = 74
|
|
};
|
|
|
|
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 DeclareStatementContext;
|
|
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 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 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();
|
|
DeclareStatementContext *declareStatement();
|
|
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();
|
|
VariableDeclarationContext *variableDeclaration();
|
|
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 DeclareStatementContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
DeclareStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *DECLARE();
|
|
antlr4::tree::TerminalNode *FUNCTION();
|
|
IdentifierListContext *identifierList();
|
|
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;
|
|
|
|
};
|
|
|
|
DeclareStatementContext* declareStatement();
|
|
|
|
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 *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 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 *ELVIS();
|
|
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 *BITAND();
|
|
antlr4::tree::TerminalNode *CARET();
|
|
antlr4::tree::TerminalNode *BITOR();
|
|
antlr4::tree::TerminalNode *TOK_IN();
|
|
antlr4::tree::TerminalNode *AND_A();
|
|
antlr4::tree::TerminalNode *AND_B();
|
|
antlr4::tree::TerminalNode *OR_A();
|
|
antlr4::tree::TerminalNode *OR_B();
|
|
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();
|
|
|
|
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();
|
|
|
|
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();
|
|
|
|
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 *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 *CHAR_LITERAL();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
antlr4::tree::TerminalNode *NULL_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 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
|