// Generated from Python3Parser.g4 by ANTLR 4.8 #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, RAISE = 8, FROM = 9, IMPORT = 10, AS = 11, GLOBAL = 12, NONLOCAL = 13, ASSERT = 14, IF = 15, ELIF = 16, ELSE = 17, WHILE = 18, FOR = 19, IN = 20, TRY = 21, FINALLY = 22, WITH = 23, EXCEPT = 24, LAMBDA = 25, OR = 26, AND = 27, NOT = 28, IS = 29, NONE = 30, TRUE = 31, FALSE = 32, CLASS = 33, YIELD = 34, DEL = 35, PASS = 36, CONTINUE = 37, BREAK = 38, ASYNC = 39, AWAIT = 40, NEWLINE = 41, NAME = 42, STRING_LITERAL = 43, BYTES_LITERAL = 44, DECIMAL_INTEGER = 45, OCT_INTEGER = 46, HEX_INTEGER = 47, BIN_INTEGER = 48, FLOAT_NUMBER = 49, IMAG_NUMBER = 50, DOT = 51, ELLIPSIS = 52, STAR = 53, OPEN_PAREN = 54, CLOSE_PAREN = 55, COMMA = 56, COLON = 57, SEMI_COLON = 58, POWER = 59, ASSIGN = 60, OPEN_BRACK = 61, CLOSE_BRACK = 62, OR_OP = 63, XOR = 64, AND_OP = 65, LEFT_SHIFT = 66, RIGHT_SHIFT = 67, ADD = 68, MINUS = 69, DIV = 70, MOD = 71, IDIV = 72, NOT_OP = 73, OPEN_BRACE = 74, CLOSE_BRACE = 75, LESS_THAN = 76, GREATER_THAN = 77, EQUALS = 78, GT_EQ = 79, LT_EQ = 80, NOT_EQ_1 = 81, NOT_EQ_2 = 82, AT = 83, ARROW = 84, ADD_ASSIGN = 85, SUB_ASSIGN = 86, MULT_ASSIGN = 87, AT_ASSIGN = 88, DIV_ASSIGN = 89, MOD_ASSIGN = 90, AND_ASSIGN = 91, OR_ASSIGN = 92, XOR_ASSIGN = 93, LEFT_SHIFT_ASSIGN = 94, RIGHT_SHIFT_ASSIGN = 95, POWER_ASSIGN = 96, IDIV_ASSIGN = 97, SKIP_ = 98, UNKNOWN_CHAR = 99 }; enum { RuleSingle_input = 0, RuleFile_input = 1, RuleEval_input = 2, RuleDecorator = 3, RuleDecorators = 4, RuleDecorated = 5, RuleAsync_funcdef = 6, RuleFuncdef = 7, RuleParameters = 8, RuleTypedargslist = 9, RuleTfpdef = 10, RuleVarargslist = 11, RuleVfpdef = 12, RuleStmt = 13, RuleSimple_stmt = 14, RuleSmall_stmt = 15, RuleExpr_stmt = 16, RuleAnnassign = 17, RuleTestlist_star_expr = 18, RuleAugassign = 19, RuleDel_stmt = 20, RulePass_stmt = 21, RuleFlow_stmt = 22, RuleBreak_stmt = 23, RuleContinue_stmt = 24, RuleReturn_stmt = 25, RuleYield_stmt = 26, RuleRaise_stmt = 27, RuleImport_stmt = 28, RuleImport_name = 29, RuleImport_from = 30, RuleImport_as_name = 31, RuleDotted_as_name = 32, RuleImport_as_names = 33, RuleDotted_as_names = 34, RuleDotted_name = 35, RuleGlobal_stmt = 36, RuleNonlocal_stmt = 37, RuleAssert_stmt = 38, RuleCompound_stmt = 39, RuleAsync_stmt = 40, RuleIf_stmt = 41, RuleWhile_stmt = 42, RuleFor_stmt = 43, RuleTry_stmt = 44, RuleWith_stmt = 45, RuleWith_item = 46, RuleExcept_clause = 47, RuleSuite = 48, RuleTest = 49, RuleTest_nocond = 50, RuleLambdef = 51, RuleLambdef_nocond = 52, RuleOr_test = 53, RuleAnd_test = 54, RuleNot_test = 55, RuleComparison = 56, RuleComp_op = 57, RuleStar_expr = 58, RuleExpr = 59, RuleXor_expr = 60, RuleAnd_expr = 61, RuleShift_expr = 62, RuleArith_expr = 63, RuleTerm = 64, RuleFactor = 65, RulePower = 66, RuleAtom_expr = 67, RuleAtom = 68, RuleTestlist_comp = 69, RuleTrailer = 70, RuleSubscriptlist = 71, RuleSubscript = 72, RuleSliceop = 73, RuleExprlist = 74, RuleTestlist = 75, RuleDictorsetmaker = 76, RuleClassdef = 77, RuleArglist = 78, RuleArgument = 79, RuleComp_iter = 80, RuleComp_for = 81, RuleComp_if = 82, RuleEncoding_decl = 83, RuleYield_expr = 84, RuleYield_arg = 85 }; Python3Parser(antlr4::TokenStream *input); ~Python3Parser(); virtual std::string getGrammarFileName() const override; virtual const antlr4::atn::ATN& getATN() const override { return _atn; }; virtual const std::vector& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead. virtual const std::vector& getRuleNames() const override; virtual antlr4::dfa::Vocabulary& getVocabulary() const override; class Single_inputContext; class File_inputContext; class Eval_inputContext; class DecoratorContext; class DecoratorsContext; class DecoratedContext; class Async_funcdefContext; class FuncdefContext; class ParametersContext; class TypedargslistContext; class TfpdefContext; class VarargslistContext; class VfpdefContext; class StmtContext; class Simple_stmtContext; class Small_stmtContext; class Expr_stmtContext; class AnnassignContext; class Testlist_star_exprContext; class AugassignContext; class Del_stmtContext; class Pass_stmtContext; class Flow_stmtContext; class Break_stmtContext; class Continue_stmtContext; class Return_stmtContext; class Yield_stmtContext; class Raise_stmtContext; class Import_stmtContext; class Import_nameContext; class Import_fromContext; class Import_as_nameContext; class Dotted_as_nameContext; class Import_as_namesContext; class Dotted_as_namesContext; class Dotted_nameContext; class Global_stmtContext; class Nonlocal_stmtContext; class Assert_stmtContext; class Compound_stmtContext; class Async_stmtContext; class If_stmtContext; class While_stmtContext; class For_stmtContext; class Try_stmtContext; class With_stmtContext; class With_itemContext; class Except_clauseContext; class SuiteContext; class TestContext; class Test_nocondContext; class LambdefContext; class Lambdef_nocondContext; class Or_testContext; class And_testContext; class Not_testContext; class ComparisonContext; class Comp_opContext; class Star_exprContext; class ExprContext; class Xor_exprContext; class And_exprContext; class Shift_exprContext; class Arith_exprContext; class TermContext; class FactorContext; class PowerContext; class Atom_exprContext; class AtomContext; class Testlist_compContext; class TrailerContext; class SubscriptlistContext; class SubscriptContext; class SliceopContext; class ExprlistContext; class TestlistContext; class DictorsetmakerContext; class ClassdefContext; class ArglistContext; class ArgumentContext; class Comp_iterContext; class Comp_forContext; class Comp_ifContext; class Encoding_declContext; class Yield_exprContext; class Yield_argContext; class Single_inputContext : public antlr4::ParserRuleContext { public: Single_inputContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *NEWLINE(); Simple_stmtContext *simple_stmt(); Compound_stmtContext *compound_stmt(); 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; }; Single_inputContext* single_input(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; File_inputContext* file_input(); class Eval_inputContext : public antlr4::ParserRuleContext { public: Eval_inputContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; TestlistContext *testlist(); antlr4::tree::TerminalNode *EOF(); std::vector NEWLINE(); antlr4::tree::TerminalNode* NEWLINE(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; }; Eval_inputContext* eval_input(); class DecoratorContext : public antlr4::ParserRuleContext { public: DecoratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *AT(); Dotted_nameContext *dotted_name(); antlr4::tree::TerminalNode *NEWLINE(); antlr4::tree::TerminalNode *OPEN_PAREN(); antlr4::tree::TerminalNode *CLOSE_PAREN(); ArglistContext *arglist(); 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; }; DecoratorContext* decorator(); class DecoratorsContext : public antlr4::ParserRuleContext { public: DecoratorsContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector decorator(); DecoratorContext* decorator(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; }; DecoratorsContext* decorators(); class DecoratedContext : public antlr4::ParserRuleContext { public: DecoratedContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; DecoratorsContext *decorators(); ClassdefContext *classdef(); FuncdefContext *funcdef(); Async_funcdefContext *async_funcdef(); 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; }; DecoratedContext* decorated(); class Async_funcdefContext : public antlr4::ParserRuleContext { public: Async_funcdefContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ASYNC(); FuncdefContext *funcdef(); 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; }; Async_funcdefContext* async_funcdef(); 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(); antlr4::tree::TerminalNode *ARROW(); TestContext *test(); 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; }; 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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); antlr4::tree::TerminalNode *STAR(); antlr4::tree::TerminalNode *POWER(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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(); antlr4::tree::TerminalNode *COLON(); TestContext *test(); 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; }; TfpdefContext* tfpdef(); class VarargslistContext : public antlr4::ParserRuleContext { public: VarargslistContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector vfpdef(); VfpdefContext* vfpdef(size_t i); antlr4::tree::TerminalNode *STAR(); antlr4::tree::TerminalNode *POWER(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; VarargslistContext* varargslist(); class VfpdefContext : public antlr4::ParserRuleContext { public: VfpdefContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *NAME(); 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; }; VfpdefContext* vfpdef(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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; std::vector small_stmt(); Small_stmtContext* small_stmt(size_t i); antlr4::tree::TerminalNode *NEWLINE(); std::vector SEMI_COLON(); antlr4::tree::TerminalNode* SEMI_COLON(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; }; 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(); Del_stmtContext *del_stmt(); Pass_stmtContext *pass_stmt(); Flow_stmtContext *flow_stmt(); Import_stmtContext *import_stmt(); Global_stmtContext *global_stmt(); Nonlocal_stmtContext *nonlocal_stmt(); Assert_stmtContext *assert_stmt(); 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; }; 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_star_expr(); Testlist_star_exprContext* testlist_star_expr(size_t i); AnnassignContext *annassign(); AugassignContext *augassign(); std::vector yield_expr(); Yield_exprContext* yield_expr(size_t i); TestlistContext *testlist(); std::vector ASSIGN(); antlr4::tree::TerminalNode* ASSIGN(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; }; Expr_stmtContext* expr_stmt(); class AnnassignContext : public antlr4::ParserRuleContext { public: AnnassignContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *COLON(); std::vector test(); TestContext* test(size_t i); antlr4::tree::TerminalNode *ASSIGN(); 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; }; AnnassignContext* annassign(); class Testlist_star_exprContext : public antlr4::ParserRuleContext { public: Testlist_star_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector test(); TestContext* test(size_t i); std::vector star_expr(); Star_exprContext* star_expr(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; Testlist_star_exprContext* testlist_star_expr(); 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 *AT_ASSIGN(); antlr4::tree::TerminalNode *DIV_ASSIGN(); antlr4::tree::TerminalNode *MOD_ASSIGN(); antlr4::tree::TerminalNode *AND_ASSIGN(); antlr4::tree::TerminalNode *OR_ASSIGN(); antlr4::tree::TerminalNode *XOR_ASSIGN(); antlr4::tree::TerminalNode *LEFT_SHIFT_ASSIGN(); antlr4::tree::TerminalNode *RIGHT_SHIFT_ASSIGN(); antlr4::tree::TerminalNode *POWER_ASSIGN(); antlr4::tree::TerminalNode *IDIV_ASSIGN(); 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; }; AugassignContext* augassign(); class Del_stmtContext : public antlr4::ParserRuleContext { public: Del_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DEL(); ExprlistContext *exprlist(); 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; }; Del_stmtContext* del_stmt(); class Pass_stmtContext : public antlr4::ParserRuleContext { public: Pass_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *PASS(); 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; }; Pass_stmtContext* pass_stmt(); 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(); Raise_stmtContext *raise_stmt(); Yield_stmtContext *yield_stmt(); 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; }; 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; Return_stmtContext* return_stmt(); class Yield_stmtContext : public antlr4::ParserRuleContext { public: Yield_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Yield_exprContext *yield_expr(); 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; }; Yield_stmtContext* yield_stmt(); class Raise_stmtContext : public antlr4::ParserRuleContext { public: Raise_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *RAISE(); std::vector test(); TestContext* test(size_t i); antlr4::tree::TerminalNode *FROM(); 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; }; Raise_stmtContext* raise_stmt(); class Import_stmtContext : public antlr4::ParserRuleContext { public: Import_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Import_nameContext *import_name(); Import_fromContext *import_from(); 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; }; Import_stmtContext* import_stmt(); class Import_nameContext : public antlr4::ParserRuleContext { public: Import_nameContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IMPORT(); Dotted_as_namesContext *dotted_as_names(); 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; }; Import_nameContext* import_name(); class Import_fromContext : public antlr4::ParserRuleContext { public: Import_fromContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FROM(); antlr4::tree::TerminalNode *IMPORT(); Dotted_nameContext *dotted_name(); antlr4::tree::TerminalNode *STAR(); antlr4::tree::TerminalNode *OPEN_PAREN(); Import_as_namesContext *import_as_names(); antlr4::tree::TerminalNode *CLOSE_PAREN(); std::vector DOT(); antlr4::tree::TerminalNode* DOT(size_t i); std::vector ELLIPSIS(); antlr4::tree::TerminalNode* ELLIPSIS(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; }; Import_fromContext* import_from(); class Import_as_nameContext : public antlr4::ParserRuleContext { public: Import_as_nameContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector NAME(); antlr4::tree::TerminalNode* NAME(size_t i); antlr4::tree::TerminalNode *AS(); 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; }; Import_as_nameContext* import_as_name(); class Dotted_as_nameContext : public antlr4::ParserRuleContext { public: Dotted_as_nameContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Dotted_nameContext *dotted_name(); antlr4::tree::TerminalNode *AS(); antlr4::tree::TerminalNode *NAME(); 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; }; Dotted_as_nameContext* dotted_as_name(); class Import_as_namesContext : public antlr4::ParserRuleContext { public: Import_as_namesContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector import_as_name(); Import_as_nameContext* import_as_name(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; Import_as_namesContext* import_as_names(); class Dotted_as_namesContext : public antlr4::ParserRuleContext { public: Dotted_as_namesContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector dotted_as_name(); Dotted_as_nameContext* dotted_as_name(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; Dotted_as_namesContext* dotted_as_names(); class Dotted_nameContext : public antlr4::ParserRuleContext { public: Dotted_nameContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector NAME(); antlr4::tree::TerminalNode* NAME(size_t i); std::vector DOT(); antlr4::tree::TerminalNode* DOT(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; }; Dotted_nameContext* dotted_name(); class Global_stmtContext : public antlr4::ParserRuleContext { public: Global_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *GLOBAL(); std::vector NAME(); antlr4::tree::TerminalNode* NAME(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; Global_stmtContext* global_stmt(); class Nonlocal_stmtContext : public antlr4::ParserRuleContext { public: Nonlocal_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *NONLOCAL(); std::vector NAME(); antlr4::tree::TerminalNode* NAME(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; Nonlocal_stmtContext* nonlocal_stmt(); class Assert_stmtContext : public antlr4::ParserRuleContext { public: Assert_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ASSERT(); std::vector test(); TestContext* test(size_t i); 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; }; Assert_stmtContext* assert_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(); For_stmtContext *for_stmt(); Try_stmtContext *try_stmt(); With_stmtContext *with_stmt(); FuncdefContext *funcdef(); ClassdefContext *classdef(); DecoratedContext *decorated(); Async_stmtContext *async_stmt(); 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; }; Compound_stmtContext* compound_stmt(); class Async_stmtContext : public antlr4::ParserRuleContext { public: Async_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ASYNC(); FuncdefContext *funcdef(); With_stmtContext *with_stmt(); For_stmtContext *for_stmt(); 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; }; Async_stmtContext* async_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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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(); std::vector COLON(); antlr4::tree::TerminalNode* COLON(size_t i); std::vector suite(); SuiteContext* suite(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; }; While_stmtContext* while_stmt(); class For_stmtContext : public antlr4::ParserRuleContext { public: For_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FOR(); ExprlistContext *exprlist(); antlr4::tree::TerminalNode *IN(); TestlistContext *testlist(); std::vector COLON(); antlr4::tree::TerminalNode* COLON(size_t i); std::vector suite(); SuiteContext* suite(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; }; For_stmtContext* for_stmt(); class Try_stmtContext : public antlr4::ParserRuleContext { public: Try_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *TRY(); std::vector COLON(); antlr4::tree::TerminalNode* COLON(size_t i); std::vector suite(); SuiteContext* suite(size_t i); antlr4::tree::TerminalNode *FINALLY(); std::vector except_clause(); Except_clauseContext* except_clause(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; }; Try_stmtContext* try_stmt(); class With_stmtContext : public antlr4::ParserRuleContext { public: With_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *WITH(); std::vector with_item(); With_itemContext* with_item(size_t i); antlr4::tree::TerminalNode *COLON(); SuiteContext *suite(); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; With_stmtContext* with_stmt(); class With_itemContext : public antlr4::ParserRuleContext { public: With_itemContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; TestContext *test(); antlr4::tree::TerminalNode *AS(); ExprContext *expr(); 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; }; With_itemContext* with_item(); class Except_clauseContext : public antlr4::ParserRuleContext { public: Except_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *EXCEPT(); TestContext *test(); antlr4::tree::TerminalNode *AS(); antlr4::tree::TerminalNode *NAME(); 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; }; Except_clauseContext* except_clause(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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; std::vector or_test(); Or_testContext* or_test(size_t i); antlr4::tree::TerminalNode *IF(); antlr4::tree::TerminalNode *ELSE(); TestContext *test(); LambdefContext *lambdef(); 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; }; TestContext* test(); class Test_nocondContext : public antlr4::ParserRuleContext { public: Test_nocondContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Or_testContext *or_test(); Lambdef_nocondContext *lambdef_nocond(); 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; }; Test_nocondContext* test_nocond(); class LambdefContext : public antlr4::ParserRuleContext { public: LambdefContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LAMBDA(); antlr4::tree::TerminalNode *COLON(); TestContext *test(); VarargslistContext *varargslist(); 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; }; LambdefContext* lambdef(); class Lambdef_nocondContext : public antlr4::ParserRuleContext { public: Lambdef_nocondContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *LAMBDA(); antlr4::tree::TerminalNode *COLON(); Test_nocondContext *test_nocond(); VarargslistContext *varargslist(); 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; }; Lambdef_nocondContext* lambdef_nocond(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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 expr(); ExprContext* expr(size_t i); std::vector comp_op(); Comp_opContext* comp_op(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; }; 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_1(); antlr4::tree::TerminalNode *NOT_EQ_2(); antlr4::tree::TerminalNode *IN(); antlr4::tree::TerminalNode *NOT(); antlr4::tree::TerminalNode *IS(); 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; }; Comp_opContext* comp_op(); class Star_exprContext : public antlr4::ParserRuleContext { public: Star_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *STAR(); ExprContext *expr(); 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; }; Star_exprContext* star_expr(); class ExprContext : public antlr4::ParserRuleContext { public: ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector xor_expr(); Xor_exprContext* xor_expr(size_t i); std::vector OR_OP(); antlr4::tree::TerminalNode* OR_OP(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; }; ExprContext* expr(); class Xor_exprContext : public antlr4::ParserRuleContext { public: Xor_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector and_expr(); And_exprContext* and_expr(size_t i); std::vector XOR(); antlr4::tree::TerminalNode* XOR(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; }; Xor_exprContext* xor_expr(); class And_exprContext : public antlr4::ParserRuleContext { public: And_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector shift_expr(); Shift_exprContext* shift_expr(size_t i); std::vector AND_OP(); antlr4::tree::TerminalNode* AND_OP(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; }; And_exprContext* and_expr(); class Shift_exprContext : public antlr4::ParserRuleContext { public: Shift_exprContext(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 LEFT_SHIFT(); antlr4::tree::TerminalNode* LEFT_SHIFT(size_t i); std::vector RIGHT_SHIFT(); antlr4::tree::TerminalNode* RIGHT_SHIFT(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; }; Shift_exprContext* shift_expr(); 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 ADD(); antlr4::tree::TerminalNode* ADD(size_t i); std::vector MINUS(); antlr4::tree::TerminalNode* MINUS(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; }; Arith_exprContext* arith_expr(); 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 STAR(); antlr4::tree::TerminalNode* STAR(size_t i); std::vector AT(); antlr4::tree::TerminalNode* AT(size_t i); std::vector DIV(); antlr4::tree::TerminalNode* DIV(size_t i); std::vector MOD(); antlr4::tree::TerminalNode* MOD(size_t i); std::vector IDIV(); antlr4::tree::TerminalNode* IDIV(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; }; TermContext* term(); 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(); antlr4::tree::TerminalNode *NOT_OP(); PowerContext *power(); 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; }; FactorContext* factor(); class PowerContext : public antlr4::ParserRuleContext { public: PowerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Atom_exprContext *atom_expr(); antlr4::tree::TerminalNode *POWER(); FactorContext *factor(); 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; }; PowerContext* power(); class Atom_exprContext : public antlr4::ParserRuleContext { public: Atom_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; AtomContext *atom(); antlr4::tree::TerminalNode *AWAIT(); std::vector trailer(); TrailerContext* trailer(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; }; Atom_exprContext* atom_expr(); class AtomContext : public antlr4::ParserRuleContext { public: AtomContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *OPEN_PAREN(); antlr4::tree::TerminalNode *CLOSE_PAREN(); antlr4::tree::TerminalNode *OPEN_BRACK(); antlr4::tree::TerminalNode *CLOSE_BRACK(); antlr4::tree::TerminalNode *OPEN_BRACE(); antlr4::tree::TerminalNode *CLOSE_BRACE(); antlr4::tree::TerminalNode *NAME(); antlr4::tree::TerminalNode *NUMBER(); antlr4::tree::TerminalNode *ELLIPSIS(); antlr4::tree::TerminalNode *NONE(); antlr4::tree::TerminalNode *TRUE(); antlr4::tree::TerminalNode *FALSE(); Yield_exprContext *yield_expr(); Testlist_compContext *testlist_comp(); DictorsetmakerContext *dictorsetmaker(); std::vector STRING(); antlr4::tree::TerminalNode* STRING(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; }; AtomContext* atom(); class Testlist_compContext : public antlr4::ParserRuleContext { public: Testlist_compContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector test(); TestContext* test(size_t i); std::vector star_expr(); Star_exprContext* star_expr(size_t i); Comp_forContext *comp_for(); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; Testlist_compContext* testlist_comp(); 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(); antlr4::tree::TerminalNode *OPEN_BRACK(); SubscriptlistContext *subscriptlist(); antlr4::tree::TerminalNode *CLOSE_BRACK(); antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *NAME(); 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; }; TrailerContext* trailer(); class SubscriptlistContext : public antlr4::ParserRuleContext { public: SubscriptlistContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector subscript(); SubscriptContext* subscript(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; SubscriptlistContext* subscriptlist(); class SubscriptContext : public antlr4::ParserRuleContext { public: SubscriptContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector test(); TestContext* test(size_t i); antlr4::tree::TerminalNode *COLON(); SliceopContext *sliceop(); 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; }; SubscriptContext* subscript(); class SliceopContext : public antlr4::ParserRuleContext { public: SliceopContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *COLON(); TestContext *test(); 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; }; SliceopContext* sliceop(); class ExprlistContext : public antlr4::ParserRuleContext { public: ExprlistContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector expr(); ExprContext* expr(size_t i); std::vector star_expr(); Star_exprContext* star_expr(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; ExprlistContext* exprlist(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; TestlistContext* testlist(); class DictorsetmakerContext : public antlr4::ParserRuleContext { public: DictorsetmakerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector test(); TestContext* test(size_t i); std::vector COLON(); antlr4::tree::TerminalNode* COLON(size_t i); std::vector POWER(); antlr4::tree::TerminalNode* POWER(size_t i); std::vector expr(); ExprContext* expr(size_t i); Comp_forContext *comp_for(); std::vector star_expr(); Star_exprContext* star_expr(size_t i); std::vector COMMA(); antlr4::tree::TerminalNode* COMMA(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; DictorsetmakerContext* dictorsetmaker(); class ClassdefContext : public antlr4::ParserRuleContext { public: ClassdefContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CLASS(); antlr4::tree::TerminalNode *NAME(); antlr4::tree::TerminalNode *COLON(); SuiteContext *suite(); antlr4::tree::TerminalNode *OPEN_PAREN(); antlr4::tree::TerminalNode *CLOSE_PAREN(); ArglistContext *arglist(); 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; }; ClassdefContext* classdef(); 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 void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; virtual antlrcpp::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(); antlr4::tree::TerminalNode *POWER(); antlr4::tree::TerminalNode *STAR(); Comp_forContext *comp_for(); 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; }; ArgumentContext* argument(); class Comp_iterContext : public antlr4::ParserRuleContext { public: Comp_iterContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Comp_forContext *comp_for(); Comp_ifContext *comp_if(); 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; }; Comp_iterContext* comp_iter(); class Comp_forContext : public antlr4::ParserRuleContext { public: Comp_forContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FOR(); ExprlistContext *exprlist(); antlr4::tree::TerminalNode *IN(); Or_testContext *or_test(); antlr4::tree::TerminalNode *ASYNC(); Comp_iterContext *comp_iter(); 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; }; Comp_forContext* comp_for(); class Comp_ifContext : public antlr4::ParserRuleContext { public: Comp_ifContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IF(); Test_nocondContext *test_nocond(); Comp_iterContext *comp_iter(); 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; }; Comp_ifContext* comp_if(); class Encoding_declContext : public antlr4::ParserRuleContext { public: Encoding_declContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *NAME(); 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; }; Encoding_declContext* encoding_decl(); class Yield_exprContext : public antlr4::ParserRuleContext { public: Yield_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *YIELD(); Yield_argContext *yield_arg(); 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; }; Yield_exprContext* yield_expr(); class Yield_argContext : public antlr4::ParserRuleContext { public: Yield_argContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FROM(); TestContext *test(); TestlistContext *testlist(); 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; }; Yield_argContext* yield_arg(); private: static std::vector _decisionToDFA; static antlr4::atn::PredictionContextCache _sharedContextCache; static std::vector _ruleNames; static std::vector _tokenNames; static std::vector _literalNames; static std::vector _symbolicNames; static antlr4::dfa::Vocabulary _vocabulary; static antlr4::atn::ATN _atn; static std::vector _serializedATN; struct Initializer { Initializer(); }; static Initializer _init; };