// 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& 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 NEWLINE(); antlr4::tree::TerminalNode* NEWLINE(size_t i); std::vector 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 tfpdef(); TfpdefContext* tfpdef(size_t i); std::vector ASSIGN(); antlr4::tree::TerminalNode* ASSIGN(size_t i); std::vector test(); TestContext* test(size_t i); std::vector 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 testlist(); TestlistContext* testlist(size_t i); AugassignContext *augassign(); std::vector 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 test(); TestContext* test(size_t i); std::vector COLON(); antlr4::tree::TerminalNode* COLON(size_t i); std::vector suite(); SuiteContext* suite(size_t i); std::vector 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 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_test(); And_testContext* and_test(size_t i); std::vector 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_test(); Not_testContext* not_test(size_t i); std::vector 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_expr(); Arith_exprContext* arith_expr(size_t i); std::vector 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 term(); TermContext* term(size_t i); std::vector 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 factor(); FactorContext* factor(size_t i); std::vector 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 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 test(); TestContext* test(size_t i); std::vector 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 argument(); ArgumentContext* argument(size_t i); std::vector 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 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: };