662 lines
20 KiB
C++
662 lines
20 KiB
C++
|
|
// Generated from Python3Parser.g4 by ANTLR 4.13.1
|
|
|
|
#pragma once
|
|
|
|
|
|
#include "antlr4-runtime.h"
|
|
|
|
|
|
|
|
|
|
class Python3Parser : public antlr4::Parser {
|
|
public:
|
|
enum {
|
|
INDENT = 1, DEDENT = 2, STRING = 3, NUMBER = 4, INTEGER = 5, DEF = 6,
|
|
RETURN = 7, IF = 8, ELIF = 9, ELSE = 10, WHILE = 11, FOR = 12, IN = 13,
|
|
OR = 14, AND = 15, NOT = 16, NONE = 17, TRUE = 18, FALSE = 19, CONTINUE = 20,
|
|
BREAK = 21, NEWLINE = 22, NAME = 23, STRING_LITERAL = 24, BYTES_LITERAL = 25,
|
|
DECIMAL_INTEGER = 26, OCT_INTEGER = 27, HEX_INTEGER = 28, BIN_INTEGER = 29,
|
|
FLOAT_NUMBER = 30, IMAG_NUMBER = 31, DOT = 32, ELLIPSIS = 33, STAR = 34,
|
|
OPEN_PAREN = 35, CLOSE_PAREN = 36, COMMA = 37, COLON = 38, SEMI_COLON = 39,
|
|
POWER = 40, ASSIGN = 41, OPEN_BRACK = 42, CLOSE_BRACK = 43, OR_OP = 44,
|
|
XOR = 45, AND_OP = 46, LEFT_SHIFT = 47, RIGHT_SHIFT = 48, ADD = 49,
|
|
MINUS = 50, DIV = 51, MOD = 52, IDIV = 53, NOT_OP = 54, OPEN_BRACE = 55,
|
|
CLOSE_BRACE = 56, LESS_THAN = 57, GREATER_THAN = 58, EQUALS = 59, GT_EQ = 60,
|
|
LT_EQ = 61, NOT_EQ_1 = 62, NOT_EQ_2 = 63, AT = 64, ARROW = 65, ADD_ASSIGN = 66,
|
|
SUB_ASSIGN = 67, MULT_ASSIGN = 68, AT_ASSIGN = 69, DIV_ASSIGN = 70,
|
|
MOD_ASSIGN = 71, AND_ASSIGN = 72, OR_ASSIGN = 73, XOR_ASSIGN = 74, LEFT_SHIFT_ASSIGN = 75,
|
|
RIGHT_SHIFT_ASSIGN = 76, POWER_ASSIGN = 77, IDIV_ASSIGN = 78, SKIP_ = 79,
|
|
UNKNOWN_CHAR = 80
|
|
};
|
|
|
|
enum {
|
|
RuleFile_input = 0, RuleFuncdef = 1, RuleParameters = 2, RuleTypedargslist = 3,
|
|
RuleTfpdef = 4, RuleStmt = 5, RuleSimple_stmt = 6, RuleSmall_stmt = 7,
|
|
RuleExpr_stmt = 8, RuleAugassign = 9, RuleFlow_stmt = 10, RuleBreak_stmt = 11,
|
|
RuleContinue_stmt = 12, RuleReturn_stmt = 13, RuleCompound_stmt = 14,
|
|
RuleIf_stmt = 15, RuleWhile_stmt = 16, RuleSuite = 17, RuleTest = 18,
|
|
RuleOr_test = 19, RuleAnd_test = 20, RuleNot_test = 21, RuleComparison = 22,
|
|
RuleComp_op = 23, RuleArith_expr = 24, RuleAddorsub_op = 25, RuleTerm = 26,
|
|
RuleMuldivmod_op = 27, RuleFactor = 28, RuleAtom_expr = 29, RuleTrailer = 30,
|
|
RuleAtom = 31, RuleTestlist = 32, RuleArglist = 33, RuleArgument = 34
|
|
};
|
|
|
|
explicit Python3Parser(antlr4::TokenStream *input);
|
|
|
|
Python3Parser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
|
|
|
|
~Python3Parser() override;
|
|
|
|
std::string getGrammarFileName() const override;
|
|
|
|
const antlr4::atn::ATN& getATN() const override;
|
|
|
|
const std::vector<std::string>& getRuleNames() const override;
|
|
|
|
const antlr4::dfa::Vocabulary& getVocabulary() const override;
|
|
|
|
antlr4::atn::SerializedATNView getSerializedATN() const override;
|
|
|
|
|
|
class File_inputContext;
|
|
class FuncdefContext;
|
|
class ParametersContext;
|
|
class TypedargslistContext;
|
|
class TfpdefContext;
|
|
class StmtContext;
|
|
class Simple_stmtContext;
|
|
class Small_stmtContext;
|
|
class Expr_stmtContext;
|
|
class AugassignContext;
|
|
class Flow_stmtContext;
|
|
class Break_stmtContext;
|
|
class Continue_stmtContext;
|
|
class Return_stmtContext;
|
|
class Compound_stmtContext;
|
|
class If_stmtContext;
|
|
class While_stmtContext;
|
|
class SuiteContext;
|
|
class TestContext;
|
|
class Or_testContext;
|
|
class And_testContext;
|
|
class Not_testContext;
|
|
class ComparisonContext;
|
|
class Comp_opContext;
|
|
class Arith_exprContext;
|
|
class Addorsub_opContext;
|
|
class TermContext;
|
|
class Muldivmod_opContext;
|
|
class FactorContext;
|
|
class Atom_exprContext;
|
|
class TrailerContext;
|
|
class AtomContext;
|
|
class TestlistContext;
|
|
class ArglistContext;
|
|
class ArgumentContext;
|
|
|
|
class File_inputContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
File_inputContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *EOF();
|
|
std::vector<antlr4::tree::TerminalNode *> NEWLINE();
|
|
antlr4::tree::TerminalNode* NEWLINE(size_t i);
|
|
std::vector<StmtContext *> stmt();
|
|
StmtContext* stmt(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
File_inputContext* file_input();
|
|
|
|
class FuncdefContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FuncdefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *DEF();
|
|
antlr4::tree::TerminalNode *NAME();
|
|
ParametersContext *parameters();
|
|
antlr4::tree::TerminalNode *COLON();
|
|
SuiteContext *suite();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncdefContext* funcdef();
|
|
|
|
class ParametersContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ParametersContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *OPEN_PAREN();
|
|
antlr4::tree::TerminalNode *CLOSE_PAREN();
|
|
TypedargslistContext *typedargslist();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ParametersContext* parameters();
|
|
|
|
class TypedargslistContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TypedargslistContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<TfpdefContext *> tfpdef();
|
|
TfpdefContext* tfpdef(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> ASSIGN();
|
|
antlr4::tree::TerminalNode* ASSIGN(size_t i);
|
|
std::vector<TestContext *> test();
|
|
TestContext* test(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TypedargslistContext* typedargslist();
|
|
|
|
class TfpdefContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TfpdefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *NAME();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TfpdefContext* tfpdef();
|
|
|
|
class StmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
Simple_stmtContext *simple_stmt();
|
|
Compound_stmtContext *compound_stmt();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
StmtContext* stmt();
|
|
|
|
class Simple_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Simple_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
Small_stmtContext *small_stmt();
|
|
antlr4::tree::TerminalNode *NEWLINE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Simple_stmtContext* simple_stmt();
|
|
|
|
class Small_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Small_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
Expr_stmtContext *expr_stmt();
|
|
Flow_stmtContext *flow_stmt();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Small_stmtContext* small_stmt();
|
|
|
|
class Expr_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Expr_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<TestlistContext *> testlist();
|
|
TestlistContext* testlist(size_t i);
|
|
AugassignContext *augassign();
|
|
std::vector<antlr4::tree::TerminalNode *> ASSIGN();
|
|
antlr4::tree::TerminalNode* ASSIGN(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Expr_stmtContext* expr_stmt();
|
|
|
|
class AugassignContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
AugassignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ADD_ASSIGN();
|
|
antlr4::tree::TerminalNode *SUB_ASSIGN();
|
|
antlr4::tree::TerminalNode *MULT_ASSIGN();
|
|
antlr4::tree::TerminalNode *DIV_ASSIGN();
|
|
antlr4::tree::TerminalNode *IDIV_ASSIGN();
|
|
antlr4::tree::TerminalNode *MOD_ASSIGN();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
AugassignContext* augassign();
|
|
|
|
class Flow_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Flow_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
Break_stmtContext *break_stmt();
|
|
Continue_stmtContext *continue_stmt();
|
|
Return_stmtContext *return_stmt();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Flow_stmtContext* flow_stmt();
|
|
|
|
class Break_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Break_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *BREAK();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Break_stmtContext* break_stmt();
|
|
|
|
class Continue_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Continue_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *CONTINUE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Continue_stmtContext* continue_stmt();
|
|
|
|
class Return_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Return_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *RETURN();
|
|
TestlistContext *testlist();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Return_stmtContext* return_stmt();
|
|
|
|
class Compound_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Compound_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
If_stmtContext *if_stmt();
|
|
While_stmtContext *while_stmt();
|
|
FuncdefContext *funcdef();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Compound_stmtContext* compound_stmt();
|
|
|
|
class If_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
If_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IF();
|
|
std::vector<TestContext *> test();
|
|
TestContext* test(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COLON();
|
|
antlr4::tree::TerminalNode* COLON(size_t i);
|
|
std::vector<SuiteContext *> suite();
|
|
SuiteContext* suite(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> ELIF();
|
|
antlr4::tree::TerminalNode* ELIF(size_t i);
|
|
antlr4::tree::TerminalNode *ELSE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
If_stmtContext* if_stmt();
|
|
|
|
class While_stmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
While_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WHILE();
|
|
TestContext *test();
|
|
antlr4::tree::TerminalNode *COLON();
|
|
SuiteContext *suite();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
While_stmtContext* while_stmt();
|
|
|
|
class SuiteContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SuiteContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
Simple_stmtContext *simple_stmt();
|
|
antlr4::tree::TerminalNode *NEWLINE();
|
|
antlr4::tree::TerminalNode *INDENT();
|
|
antlr4::tree::TerminalNode *DEDENT();
|
|
std::vector<StmtContext *> stmt();
|
|
StmtContext* stmt(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SuiteContext* suite();
|
|
|
|
class TestContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TestContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
Or_testContext *or_test();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TestContext* test();
|
|
|
|
class Or_testContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Or_testContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<And_testContext *> and_test();
|
|
And_testContext* and_test(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> OR();
|
|
antlr4::tree::TerminalNode* OR(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Or_testContext* or_test();
|
|
|
|
class And_testContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
And_testContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<Not_testContext *> not_test();
|
|
Not_testContext* not_test(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> AND();
|
|
antlr4::tree::TerminalNode* AND(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
And_testContext* and_test();
|
|
|
|
class Not_testContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Not_testContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *NOT();
|
|
Not_testContext *not_test();
|
|
ComparisonContext *comparison();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Not_testContext* not_test();
|
|
|
|
class ComparisonContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ComparisonContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<Arith_exprContext *> arith_expr();
|
|
Arith_exprContext* arith_expr(size_t i);
|
|
std::vector<Comp_opContext *> comp_op();
|
|
Comp_opContext* comp_op(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ComparisonContext* comparison();
|
|
|
|
class Comp_opContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Comp_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LESS_THAN();
|
|
antlr4::tree::TerminalNode *GREATER_THAN();
|
|
antlr4::tree::TerminalNode *EQUALS();
|
|
antlr4::tree::TerminalNode *GT_EQ();
|
|
antlr4::tree::TerminalNode *LT_EQ();
|
|
antlr4::tree::TerminalNode *NOT_EQ_2();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Comp_opContext* comp_op();
|
|
|
|
class Arith_exprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Arith_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<TermContext *> term();
|
|
TermContext* term(size_t i);
|
|
std::vector<Addorsub_opContext *> addorsub_op();
|
|
Addorsub_opContext* addorsub_op(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Arith_exprContext* arith_expr();
|
|
|
|
class Addorsub_opContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Addorsub_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ADD();
|
|
antlr4::tree::TerminalNode *MINUS();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Addorsub_opContext* addorsub_op();
|
|
|
|
class TermContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TermContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<FactorContext *> factor();
|
|
FactorContext* factor(size_t i);
|
|
std::vector<Muldivmod_opContext *> muldivmod_op();
|
|
Muldivmod_opContext* muldivmod_op(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TermContext* term();
|
|
|
|
class Muldivmod_opContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Muldivmod_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *STAR();
|
|
antlr4::tree::TerminalNode *DIV();
|
|
antlr4::tree::TerminalNode *IDIV();
|
|
antlr4::tree::TerminalNode *MOD();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Muldivmod_opContext* muldivmod_op();
|
|
|
|
class FactorContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FactorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
FactorContext *factor();
|
|
antlr4::tree::TerminalNode *ADD();
|
|
antlr4::tree::TerminalNode *MINUS();
|
|
Atom_exprContext *atom_expr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FactorContext* factor();
|
|
|
|
class Atom_exprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
Atom_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
AtomContext *atom();
|
|
TrailerContext *trailer();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
Atom_exprContext* atom_expr();
|
|
|
|
class TrailerContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TrailerContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *OPEN_PAREN();
|
|
antlr4::tree::TerminalNode *CLOSE_PAREN();
|
|
ArglistContext *arglist();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TrailerContext* trailer();
|
|
|
|
class AtomContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
AtomContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *NAME();
|
|
antlr4::tree::TerminalNode *NUMBER();
|
|
antlr4::tree::TerminalNode *NONE();
|
|
antlr4::tree::TerminalNode *TRUE();
|
|
antlr4::tree::TerminalNode *FALSE();
|
|
antlr4::tree::TerminalNode *OPEN_PAREN();
|
|
TestContext *test();
|
|
antlr4::tree::TerminalNode *CLOSE_PAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> STRING();
|
|
antlr4::tree::TerminalNode* STRING(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
AtomContext* atom();
|
|
|
|
class TestlistContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TestlistContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<TestContext *> test();
|
|
TestContext* test(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TestlistContext* testlist();
|
|
|
|
class ArglistContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ArglistContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ArgumentContext *> argument();
|
|
ArgumentContext* argument(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ArglistContext* arglist();
|
|
|
|
class ArgumentContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ArgumentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<TestContext *> test();
|
|
TestContext* test(size_t i);
|
|
antlr4::tree::TerminalNode *ASSIGN();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ArgumentContext* argument();
|
|
|
|
|
|
// By default the static state used to implement the parser is lazily initialized during the first
|
|
// call to the constructor. You can call this function if you wish to initialize the static state
|
|
// ahead of time.
|
|
static void initialize();
|
|
|
|
private:
|
|
};
|
|
|