// Generated from /workspace/millet-porridge-III/grammar/GoParser.g4 by ANTLR 4.9.3 #pragma once #include "antlr4-runtime.h" class GoParser : public antlr4::Parser { public: enum { BREAK = 1, DEFAULT = 2, FUNC = 3, INTERFACE = 4, SELECT = 5, CASE = 6, DEFER = 7, GO = 8, MAP = 9, STRUCT = 10, CHAN = 11, ELSE = 12, GOTO = 13, PACKAGE = 14, SWITCH = 15, CONST = 16, FALLTHROUGH = 17, IF = 18, RANGE = 19, TYPE = 20, CONTINUE = 21, FOR = 22, IMPORT = 23, RETURN = 24, VAR = 25, NIL_LIT = 26, IDENTIFIER = 27, L_PAREN = 28, R_PAREN = 29, L_CURLY = 30, R_CURLY = 31, L_BRACKET = 32, R_BRACKET = 33, ASSIGN = 34, COMMA = 35, SEMI = 36, HUANHANG = 37, HUANHANGG = 38, COLON = 39, DOT = 40, PLUS_PLUS = 41, MINUS_MINUS = 42, DECLARE_ASSIGN = 43, ELLIPSIS = 44, EOSSS = 45, LOGICAL_OR = 46, LOGICAL_AND = 47, EQUALS = 48, NOT_EQUALS = 49, LESS = 50, LESS_OR_EQUALS = 51, GREATER = 52, GREATER_OR_EQUALS = 53, OR = 54, DIV = 55, MOD = 56, LSHIFT = 57, RSHIFT = 58, BIT_CLEAR = 59, EXCLAMATION = 60, PLUS = 61, MINUS = 62, CARET = 63, STAR = 64, AMPERSAND = 65, RECEIVE = 66, DECIMAL_LIT = 67, BINARY_LIT = 68, OCTAL_LIT = 69, HEX_LIT = 70, FLOAT_LIT = 71, DECIMAL_FLOAT_LIT = 72, HEX_FLOAT_LIT = 73, IMAGINARY_LIT = 74, RUNE_LIT = 75, BYTE_VALUE = 76, OCTAL_BYTE_VALUE = 77, HEX_BYTE_VALUE = 78, LITTLE_U_VALUE = 79, BIG_U_VALUE = 80, RAW_STRING_LIT = 81, INTERPRETED_STRING_LIT = 82, WS = 83, COMMENT = 84, TERMINATOR = 85, LINE_COMMENT = 86, WS_NLSEMI = 87, COMMENT_NLSEMI = 88, LINE_COMMENT_NLSEMI = 89 }; enum { RuleSourceFile = 0, RulePackageClause = 1, RuleImportDecl = 2, RuleImportSpec = 3, RuleImportPath = 4, RuleDeclaration = 5, RuleConstDecl = 6, RuleConstSpec = 7, RuleIdentifierList = 8, RuleExpressionList = 9, RuleTypeDecl = 10, RuleTypeSpec = 11, RuleFunctionDecl = 12, RuleMethodDecl = 13, RuleReceiver = 14, RuleVarDecl = 15, RuleVarSpec = 16, RuleBlock = 17, RuleStatementList = 18, RuleStatement = 19, RuleSimpleStmt = 20, RuleExpressionStmt = 21, RuleSendStmt = 22, RuleIncDecStmt = 23, RuleAssignment = 24, RuleAssign_op = 25, RuleShortVarDecl = 26, RuleEmptyStmt = 27, RuleLabeledStmt = 28, RuleReturnStmt = 29, RuleBreakStmt = 30, RuleContinueStmt = 31, RuleGotoStmt = 32, RuleFallthroughStmt = 33, RuleDeferStmt = 34, RuleIfStmt = 35, RuleSwitchStmt = 36, RuleExprSwitchStmt = 37, RuleExprCaseClause = 38, RuleExprSwitchCase = 39, RuleTypeSwitchStmt = 40, RuleTypeSwitchGuard = 41, RuleTypeCaseClause = 42, RuleTypeSwitchCase = 43, RuleTypeList = 44, RuleSelectStmt = 45, RuleCommClause = 46, RuleCommCase = 47, RuleRecvStmt = 48, RuleForStmt = 49, RuleForClause = 50, RuleRangeClause = 51, RuleGoStmt = 52, RuleType_ = 53, RuleTypeName = 54, RuleTypeLit = 55, RuleArrayType = 56, RuleArrayLength = 57, RuleElementType = 58, RulePointerType = 59, RuleInterfaceType = 60, RuleSliceType = 61, RuleMapType = 62, RuleChannelType = 63, RuleMethodSpec = 64, RuleFunctionType = 65, RuleSignature = 66, RuleResult = 67, RuleParameters = 68, RuleParameterDecl = 69, RuleExpression = 70, RulePrimaryExpr = 71, RuleConversion = 72, RuleNonNamedType = 73, RuleOperand = 74, RuleLiteral = 75, RuleBasicLit = 76, RuleInteger = 77, RuleOperandName = 78, RuleQualifiedIdent = 79, RuleCompositeLit = 80, RuleLiteralType = 81, RuleLiteralValue = 82, RuleElementList = 83, RuleKeyedElement = 84, RuleKey = 85, RuleElement = 86, RuleStructType = 87, RuleFieldDecl = 88, RuleString_ = 89, RuleEmbeddedField = 90, RuleFunctionLit = 91, RuleIndex = 92, RuleSlice_ = 93, RuleTypeAssertion = 94, RuleArguments = 95, RuleMethodExpr = 96, RuleReceiverType = 97, RuleEoss = 98 }; explicit GoParser(antlr4::TokenStream *input); ~GoParser(); 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 SourceFileContext; class PackageClauseContext; class ImportDeclContext; class ImportSpecContext; class ImportPathContext; class DeclarationContext; class ConstDeclContext; class ConstSpecContext; class IdentifierListContext; class ExpressionListContext; class TypeDeclContext; class TypeSpecContext; class FunctionDeclContext; class MethodDeclContext; class ReceiverContext; class VarDeclContext; class VarSpecContext; class BlockContext; class StatementListContext; class StatementContext; class SimpleStmtContext; class ExpressionStmtContext; class SendStmtContext; class IncDecStmtContext; class AssignmentContext; class Assign_opContext; class ShortVarDeclContext; class EmptyStmtContext; class LabeledStmtContext; class ReturnStmtContext; class BreakStmtContext; class ContinueStmtContext; class GotoStmtContext; class FallthroughStmtContext; class DeferStmtContext; class IfStmtContext; class SwitchStmtContext; class ExprSwitchStmtContext; class ExprCaseClauseContext; class ExprSwitchCaseContext; class TypeSwitchStmtContext; class TypeSwitchGuardContext; class TypeCaseClauseContext; class TypeSwitchCaseContext; class TypeListContext; class SelectStmtContext; class CommClauseContext; class CommCaseContext; class RecvStmtContext; class ForStmtContext; class ForClauseContext; class RangeClauseContext; class GoStmtContext; class Type_Context; class TypeNameContext; class TypeLitContext; class ArrayTypeContext; class ArrayLengthContext; class ElementTypeContext; class PointerTypeContext; class InterfaceTypeContext; class SliceTypeContext; class MapTypeContext; class ChannelTypeContext; class MethodSpecContext; class FunctionTypeContext; class SignatureContext; class ResultContext; class ParametersContext; class ParameterDeclContext; class ExpressionContext; class PrimaryExprContext; class ConversionContext; class NonNamedTypeContext; class OperandContext; class LiteralContext; class BasicLitContext; class IntegerContext; class OperandNameContext; class QualifiedIdentContext; class CompositeLitContext; class LiteralTypeContext; class LiteralValueContext; class ElementListContext; class KeyedElementContext; class KeyContext; class ElementContext; class StructTypeContext; class FieldDeclContext; class String_Context; class EmbeddedFieldContext; class FunctionLitContext; class IndexContext; class Slice_Context; class TypeAssertionContext; class ArgumentsContext; class MethodExprContext; class ReceiverTypeContext; class EossContext; class SourceFileContext : public antlr4::ParserRuleContext { public: SourceFileContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; PackageClauseContext *packageClause(); antlr4::tree::TerminalNode *EOF(); std::vector eoss(); EossContext* eoss(size_t i); std::vector importDecl(); ImportDeclContext* importDecl(size_t i); std::vector functionDecl(); FunctionDeclContext* functionDecl(size_t i); std::vector methodDecl(); MethodDeclContext* methodDecl(size_t i); std::vector declaration(); DeclarationContext* declaration(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; SourceFileContext* sourceFile(); class PackageClauseContext : public antlr4::ParserRuleContext { public: antlr4::Token *packageName = nullptr; PackageClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *PACKAGE(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; PackageClauseContext* packageClause(); class ImportDeclContext : public antlr4::ParserRuleContext { public: ImportDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IMPORT(); std::vector importSpec(); ImportSpecContext* importSpec(size_t i); antlr4::tree::TerminalNode *L_PAREN(); antlr4::tree::TerminalNode *R_PAREN(); std::vector eoss(); EossContext* eoss(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ImportDeclContext* importDecl(); class ImportSpecContext : public antlr4::ParserRuleContext { public: antlr4::Token *alias = nullptr; ImportSpecContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ImportPathContext *importPath(); antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ImportSpecContext* importSpec(); class ImportPathContext : public antlr4::ParserRuleContext { public: ImportPathContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; String_Context *string_(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ImportPathContext* importPath(); class DeclarationContext : public antlr4::ParserRuleContext { public: DeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ConstDeclContext *constDecl(); TypeDeclContext *typeDecl(); VarDeclContext *varDecl(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; DeclarationContext* declaration(); class ConstDeclContext : public antlr4::ParserRuleContext { public: ConstDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CONST(); std::vector constSpec(); ConstSpecContext* constSpec(size_t i); antlr4::tree::TerminalNode *L_PAREN(); antlr4::tree::TerminalNode *R_PAREN(); std::vector eoss(); EossContext* eoss(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ConstDeclContext* constDecl(); class ConstSpecContext : public antlr4::ParserRuleContext { public: ConstSpecContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; IdentifierListContext *identifierList(); antlr4::tree::TerminalNode *ASSIGN(); ExpressionListContext *expressionList(); Type_Context *type_(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ConstSpecContext* constSpec(); class IdentifierListContext : public antlr4::ParserRuleContext { public: IdentifierListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector IDENTIFIER(); antlr4::tree::TerminalNode* IDENTIFIER(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; }; IdentifierListContext* identifierList(); class ExpressionListContext : public antlr4::ParserRuleContext { public: ExpressionListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector expression(); ExpressionContext* expression(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; }; ExpressionListContext* expressionList(); class TypeDeclContext : public antlr4::ParserRuleContext { public: TypeDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *TYPE(); std::vector typeSpec(); TypeSpecContext* typeSpec(size_t i); antlr4::tree::TerminalNode *L_PAREN(); antlr4::tree::TerminalNode *R_PAREN(); std::vector eoss(); EossContext* eoss(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeDeclContext* typeDecl(); class TypeSpecContext : public antlr4::ParserRuleContext { public: TypeSpecContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); Type_Context *type_(); antlr4::tree::TerminalNode *ASSIGN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeSpecContext* typeSpec(); class FunctionDeclContext : public antlr4::ParserRuleContext { public: FunctionDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FUNC(); antlr4::tree::TerminalNode *IDENTIFIER(); SignatureContext *signature(); BlockContext *block(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; FunctionDeclContext* functionDecl(); class MethodDeclContext : public antlr4::ParserRuleContext { public: MethodDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FUNC(); ReceiverContext *receiver(); antlr4::tree::TerminalNode *IDENTIFIER(); SignatureContext *signature(); BlockContext *block(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; MethodDeclContext* methodDecl(); class ReceiverContext : public antlr4::ParserRuleContext { public: ReceiverContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ParametersContext *parameters(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ReceiverContext* receiver(); class VarDeclContext : public antlr4::ParserRuleContext { public: VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *VAR(); std::vector varSpec(); VarSpecContext* varSpec(size_t i); antlr4::tree::TerminalNode *L_PAREN(); antlr4::tree::TerminalNode *R_PAREN(); std::vector eoss(); EossContext* eoss(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; VarDeclContext* varDecl(); class VarSpecContext : public antlr4::ParserRuleContext { public: VarSpecContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; IdentifierListContext *identifierList(); Type_Context *type_(); antlr4::tree::TerminalNode *ASSIGN(); ExpressionListContext *expressionList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; VarSpecContext* varSpec(); class BlockContext : public antlr4::ParserRuleContext { public: BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_CURLY(); antlr4::tree::TerminalNode *R_CURLY(); std::vector eoss(); EossContext* eoss(size_t i); StatementListContext *statementList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; BlockContext* block(); class StatementListContext : public antlr4::ParserRuleContext { public: StatementListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector statement(); StatementContext* statement(size_t i); std::vector eoss(); EossContext* eoss(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; StatementListContext* statementList(); class StatementContext : public antlr4::ParserRuleContext { public: StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; DeclarationContext *declaration(); LabeledStmtContext *labeledStmt(); SimpleStmtContext *simpleStmt(); GoStmtContext *goStmt(); ReturnStmtContext *returnStmt(); BreakStmtContext *breakStmt(); ContinueStmtContext *continueStmt(); GotoStmtContext *gotoStmt(); FallthroughStmtContext *fallthroughStmt(); BlockContext *block(); IfStmtContext *ifStmt(); SwitchStmtContext *switchStmt(); SelectStmtContext *selectStmt(); ForStmtContext *forStmt(); DeferStmtContext *deferStmt(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; StatementContext* statement(); class SimpleStmtContext : public antlr4::ParserRuleContext { public: SimpleStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; SendStmtContext *sendStmt(); IncDecStmtContext *incDecStmt(); AssignmentContext *assignment(); ExpressionStmtContext *expressionStmt(); ShortVarDeclContext *shortVarDecl(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; SimpleStmtContext* simpleStmt(); class ExpressionStmtContext : public antlr4::ParserRuleContext { public: ExpressionStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ExpressionStmtContext* expressionStmt(); class SendStmtContext : public antlr4::ParserRuleContext { public: GoParser::ExpressionContext *channel = nullptr; SendStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *RECEIVE(); std::vector expression(); ExpressionContext* expression(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; SendStmtContext* sendStmt(); class IncDecStmtContext : public antlr4::ParserRuleContext { public: IncDecStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); antlr4::tree::TerminalNode *PLUS_PLUS(); antlr4::tree::TerminalNode *MINUS_MINUS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; IncDecStmtContext* incDecStmt(); class AssignmentContext : public antlr4::ParserRuleContext { public: AssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector expressionList(); ExpressionListContext* expressionList(size_t i); Assign_opContext *assign_op(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; AssignmentContext* assignment(); class Assign_opContext : public antlr4::ParserRuleContext { public: Assign_opContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *ASSIGN(); antlr4::tree::TerminalNode *PLUS(); antlr4::tree::TerminalNode *MINUS(); antlr4::tree::TerminalNode *OR(); antlr4::tree::TerminalNode *CARET(); antlr4::tree::TerminalNode *STAR(); antlr4::tree::TerminalNode *DIV(); antlr4::tree::TerminalNode *MOD(); antlr4::tree::TerminalNode *LSHIFT(); antlr4::tree::TerminalNode *RSHIFT(); antlr4::tree::TerminalNode *AMPERSAND(); antlr4::tree::TerminalNode *BIT_CLEAR(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; Assign_opContext* assign_op(); class ShortVarDeclContext : public antlr4::ParserRuleContext { public: ShortVarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; IdentifierListContext *identifierList(); antlr4::tree::TerminalNode *DECLARE_ASSIGN(); ExpressionListContext *expressionList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ShortVarDeclContext* shortVarDecl(); class EmptyStmtContext : public antlr4::ParserRuleContext { public: EmptyStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *EOSSS(); antlr4::tree::TerminalNode *SEMI(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; EmptyStmtContext* emptyStmt(); class LabeledStmtContext : public antlr4::ParserRuleContext { public: LabeledStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *COLON(); StatementContext *statement(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; LabeledStmtContext* labeledStmt(); class ReturnStmtContext : public antlr4::ParserRuleContext { public: ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *RETURN(); ExpressionListContext *expressionList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ReturnStmtContext* returnStmt(); class BreakStmtContext : public antlr4::ParserRuleContext { public: BreakStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *BREAK(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; BreakStmtContext* breakStmt(); class ContinueStmtContext : public antlr4::ParserRuleContext { public: ContinueStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CONTINUE(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ContinueStmtContext* continueStmt(); class GotoStmtContext : public antlr4::ParserRuleContext { public: GotoStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *GOTO(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; GotoStmtContext* gotoStmt(); class FallthroughStmtContext : public antlr4::ParserRuleContext { public: FallthroughStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FALLTHROUGH(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; FallthroughStmtContext* fallthroughStmt(); class DeferStmtContext : public antlr4::ParserRuleContext { public: DeferStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DEFER(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; DeferStmtContext* deferStmt(); class IfStmtContext : public antlr4::ParserRuleContext { public: IfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IF(); std::vector block(); BlockContext* block(size_t i); ExpressionContext *expression(); EossContext *eoss(); SimpleStmtContext *simpleStmt(); antlr4::tree::TerminalNode *ELSE(); IfStmtContext *ifStmt(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; IfStmtContext* ifStmt(); class SwitchStmtContext : public antlr4::ParserRuleContext { public: SwitchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExprSwitchStmtContext *exprSwitchStmt(); TypeSwitchStmtContext *typeSwitchStmt(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; SwitchStmtContext* switchStmt(); class ExprSwitchStmtContext : public antlr4::ParserRuleContext { public: ExprSwitchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *SWITCH(); antlr4::tree::TerminalNode *L_CURLY(); antlr4::tree::TerminalNode *R_CURLY(); EossContext *eoss(); std::vector exprCaseClause(); ExprCaseClauseContext* exprCaseClause(size_t i); ExpressionContext *expression(); SimpleStmtContext *simpleStmt(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ExprSwitchStmtContext* exprSwitchStmt(); class ExprCaseClauseContext : public antlr4::ParserRuleContext { public: ExprCaseClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExprSwitchCaseContext *exprSwitchCase(); antlr4::tree::TerminalNode *COLON(); StatementListContext *statementList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ExprCaseClauseContext* exprCaseClause(); class ExprSwitchCaseContext : public antlr4::ParserRuleContext { public: ExprSwitchCaseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CASE(); ExpressionListContext *expressionList(); antlr4::tree::TerminalNode *DEFAULT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ExprSwitchCaseContext* exprSwitchCase(); class TypeSwitchStmtContext : public antlr4::ParserRuleContext { public: TypeSwitchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *SWITCH(); antlr4::tree::TerminalNode *L_CURLY(); antlr4::tree::TerminalNode *R_CURLY(); TypeSwitchGuardContext *typeSwitchGuard(); EossContext *eoss(); SimpleStmtContext *simpleStmt(); std::vector typeCaseClause(); TypeCaseClauseContext* typeCaseClause(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeSwitchStmtContext* typeSwitchStmt(); class TypeSwitchGuardContext : public antlr4::ParserRuleContext { public: TypeSwitchGuardContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; PrimaryExprContext *primaryExpr(); antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *L_PAREN(); antlr4::tree::TerminalNode *TYPE(); antlr4::tree::TerminalNode *R_PAREN(); antlr4::tree::TerminalNode *IDENTIFIER(); antlr4::tree::TerminalNode *DECLARE_ASSIGN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeSwitchGuardContext* typeSwitchGuard(); class TypeCaseClauseContext : public antlr4::ParserRuleContext { public: TypeCaseClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; TypeSwitchCaseContext *typeSwitchCase(); antlr4::tree::TerminalNode *COLON(); StatementListContext *statementList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeCaseClauseContext* typeCaseClause(); class TypeSwitchCaseContext : public antlr4::ParserRuleContext { public: TypeSwitchCaseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CASE(); TypeListContext *typeList(); antlr4::tree::TerminalNode *DEFAULT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeSwitchCaseContext* typeSwitchCase(); class TypeListContext : public antlr4::ParserRuleContext { public: TypeListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector type_(); Type_Context* type_(size_t i); std::vector NIL_LIT(); antlr4::tree::TerminalNode* NIL_LIT(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; }; TypeListContext* typeList(); class SelectStmtContext : public antlr4::ParserRuleContext { public: SelectStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *SELECT(); antlr4::tree::TerminalNode *L_CURLY(); antlr4::tree::TerminalNode *R_CURLY(); std::vector commClause(); CommClauseContext* commClause(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; SelectStmtContext* selectStmt(); class CommClauseContext : public antlr4::ParserRuleContext { public: CommClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; CommCaseContext *commCase(); antlr4::tree::TerminalNode *COLON(); StatementListContext *statementList(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; CommClauseContext* commClause(); class CommCaseContext : public antlr4::ParserRuleContext { public: CommCaseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *CASE(); SendStmtContext *sendStmt(); RecvStmtContext *recvStmt(); antlr4::tree::TerminalNode *DEFAULT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; CommCaseContext* commCase(); class RecvStmtContext : public antlr4::ParserRuleContext { public: GoParser::ExpressionContext *recvExpr = nullptr; RecvStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); ExpressionListContext *expressionList(); antlr4::tree::TerminalNode *ASSIGN(); IdentifierListContext *identifierList(); antlr4::tree::TerminalNode *DECLARE_ASSIGN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; RecvStmtContext* recvStmt(); class ForStmtContext : public antlr4::ParserRuleContext { public: ForStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FOR(); BlockContext *block(); ExpressionContext *expression(); ForClauseContext *forClause(); RangeClauseContext *rangeClause(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ForStmtContext* forStmt(); class ForClauseContext : public antlr4::ParserRuleContext { public: GoParser::SimpleStmtContext *initStmt = nullptr; GoParser::SimpleStmtContext *postStmt = nullptr; ForClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector eoss(); EossContext* eoss(size_t i); ExpressionContext *expression(); std::vector simpleStmt(); SimpleStmtContext* simpleStmt(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ForClauseContext* forClause(); class RangeClauseContext : public antlr4::ParserRuleContext { public: RangeClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *RANGE(); ExpressionContext *expression(); ExpressionListContext *expressionList(); antlr4::tree::TerminalNode *ASSIGN(); IdentifierListContext *identifierList(); antlr4::tree::TerminalNode *DECLARE_ASSIGN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; RangeClauseContext* rangeClause(); class GoStmtContext : public antlr4::ParserRuleContext { public: GoStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *GO(); ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; GoStmtContext* goStmt(); class Type_Context : public antlr4::ParserRuleContext { public: Type_Context(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; TypeNameContext *typeName(); TypeLitContext *typeLit(); antlr4::tree::TerminalNode *L_PAREN(); Type_Context *type_(); antlr4::tree::TerminalNode *R_PAREN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; Type_Context* type_(); class TypeNameContext : public antlr4::ParserRuleContext { public: TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; QualifiedIdentContext *qualifiedIdent(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeNameContext* typeName(); class TypeLitContext : public antlr4::ParserRuleContext { public: TypeLitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ArrayTypeContext *arrayType(); StructTypeContext *structType(); PointerTypeContext *pointerType(); FunctionTypeContext *functionType(); InterfaceTypeContext *interfaceType(); SliceTypeContext *sliceType(); MapTypeContext *mapType(); ChannelTypeContext *channelType(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeLitContext* typeLit(); class ArrayTypeContext : public antlr4::ParserRuleContext { public: ArrayTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_BRACKET(); ArrayLengthContext *arrayLength(); antlr4::tree::TerminalNode *R_BRACKET(); ElementTypeContext *elementType(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ArrayTypeContext* arrayType(); class ArrayLengthContext : public antlr4::ParserRuleContext { public: ArrayLengthContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ArrayLengthContext* arrayLength(); class ElementTypeContext : public antlr4::ParserRuleContext { public: ElementTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Type_Context *type_(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ElementTypeContext* elementType(); class PointerTypeContext : public antlr4::ParserRuleContext { public: PointerTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *STAR(); Type_Context *type_(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; PointerTypeContext* pointerType(); class InterfaceTypeContext : public antlr4::ParserRuleContext { public: InterfaceTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *INTERFACE(); antlr4::tree::TerminalNode *L_CURLY(); antlr4::tree::TerminalNode *R_CURLY(); std::vector eoss(); EossContext* eoss(size_t i); std::vector methodSpec(); MethodSpecContext* methodSpec(size_t i); std::vector typeName(); TypeNameContext* typeName(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; InterfaceTypeContext* interfaceType(); class SliceTypeContext : public antlr4::ParserRuleContext { public: SliceTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_BRACKET(); antlr4::tree::TerminalNode *R_BRACKET(); ElementTypeContext *elementType(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; SliceTypeContext* sliceType(); class MapTypeContext : public antlr4::ParserRuleContext { public: MapTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *MAP(); antlr4::tree::TerminalNode *L_BRACKET(); Type_Context *type_(); antlr4::tree::TerminalNode *R_BRACKET(); ElementTypeContext *elementType(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; MapTypeContext* mapType(); class ChannelTypeContext : public antlr4::ParserRuleContext { public: ChannelTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ElementTypeContext *elementType(); antlr4::tree::TerminalNode *CHAN(); antlr4::tree::TerminalNode *RECEIVE(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ChannelTypeContext* channelType(); class MethodSpecContext : public antlr4::ParserRuleContext { public: MethodSpecContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); ParametersContext *parameters(); ResultContext *result(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; MethodSpecContext* methodSpec(); class FunctionTypeContext : public antlr4::ParserRuleContext { public: FunctionTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FUNC(); SignatureContext *signature(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; FunctionTypeContext* functionType(); class SignatureContext : public antlr4::ParserRuleContext { public: SignatureContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ParametersContext *parameters(); ResultContext *result(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; SignatureContext* signature(); class ResultContext : public antlr4::ParserRuleContext { public: ResultContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ParametersContext *parameters(); Type_Context *type_(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ResultContext* result(); class ParametersContext : public antlr4::ParserRuleContext { public: ParametersContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_PAREN(); antlr4::tree::TerminalNode *R_PAREN(); std::vector parameterDecl(); ParameterDeclContext* parameterDecl(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; }; ParametersContext* parameters(); class ParameterDeclContext : public antlr4::ParserRuleContext { public: ParameterDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Type_Context *type_(); IdentifierListContext *identifierList(); antlr4::tree::TerminalNode *ELLIPSIS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ParameterDeclContext* parameterDecl(); class ExpressionContext : public antlr4::ParserRuleContext { public: ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); ExpressionContext() = default; void copyFrom(ExpressionContext *context); using antlr4::ParserRuleContext::copyFrom; virtual size_t getRuleIndex() const override; }; class LogicalAndOperationContext : public ExpressionContext { public: LogicalAndOperationContext(ExpressionContext *ctx); std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *LOGICAL_AND(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; class UnaryOperationContext : public ExpressionContext { public: UnaryOperationContext(ExpressionContext *ctx); antlr4::Token *unary_op = nullptr; ExpressionContext *expression(); antlr4::tree::TerminalNode *PLUS(); antlr4::tree::TerminalNode *MINUS(); antlr4::tree::TerminalNode *EXCLAMATION(); antlr4::tree::TerminalNode *CARET(); antlr4::tree::TerminalNode *STAR(); antlr4::tree::TerminalNode *AMPERSAND(); antlr4::tree::TerminalNode *RECEIVE(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; class PrimaryExpressionContext : public ExpressionContext { public: PrimaryExpressionContext(ExpressionContext *ctx); PrimaryExprContext *primaryExpr(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; class PlusMinusOperationContext : public ExpressionContext { public: PlusMinusOperationContext(ExpressionContext *ctx); antlr4::Token *add_op = nullptr; std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *PLUS(); antlr4::tree::TerminalNode *MINUS(); antlr4::tree::TerminalNode *OR(); antlr4::tree::TerminalNode *CARET(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; class RelationOperationContext : public ExpressionContext { public: RelationOperationContext(ExpressionContext *ctx); antlr4::Token *rel_op = nullptr; std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *EQUALS(); antlr4::tree::TerminalNode *NOT_EQUALS(); antlr4::tree::TerminalNode *LESS(); antlr4::tree::TerminalNode *LESS_OR_EQUALS(); antlr4::tree::TerminalNode *GREATER(); antlr4::tree::TerminalNode *GREATER_OR_EQUALS(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; class MulDivOperationContext : public ExpressionContext { public: MulDivOperationContext(ExpressionContext *ctx); antlr4::Token *mul_op = nullptr; std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *STAR(); antlr4::tree::TerminalNode *DIV(); antlr4::tree::TerminalNode *MOD(); antlr4::tree::TerminalNode *LSHIFT(); antlr4::tree::TerminalNode *RSHIFT(); antlr4::tree::TerminalNode *AMPERSAND(); antlr4::tree::TerminalNode *BIT_CLEAR(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; class LogicalOrOperationContext : public ExpressionContext { public: LogicalOrOperationContext(ExpressionContext *ctx); std::vector expression(); ExpressionContext* expression(size_t i); antlr4::tree::TerminalNode *LOGICAL_OR(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ExpressionContext* expression(); ExpressionContext* expression(int precedence); class PrimaryExprContext : public antlr4::ParserRuleContext { public: PrimaryExprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; OperandContext *operand(); ConversionContext *conversion(); MethodExprContext *methodExpr(); PrimaryExprContext *primaryExpr(); IndexContext *index(); Slice_Context *slice_(); TypeAssertionContext *typeAssertion(); ArgumentsContext *arguments(); antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; PrimaryExprContext* primaryExpr(); PrimaryExprContext* primaryExpr(int precedence); class ConversionContext : public antlr4::ParserRuleContext { public: ConversionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; NonNamedTypeContext *nonNamedType(); antlr4::tree::TerminalNode *L_PAREN(); ExpressionContext *expression(); antlr4::tree::TerminalNode *R_PAREN(); antlr4::tree::TerminalNode *COMMA(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ConversionContext* conversion(); class NonNamedTypeContext : public antlr4::ParserRuleContext { public: NonNamedTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; TypeLitContext *typeLit(); antlr4::tree::TerminalNode *L_PAREN(); NonNamedTypeContext *nonNamedType(); antlr4::tree::TerminalNode *R_PAREN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; NonNamedTypeContext* nonNamedType(); class OperandContext : public antlr4::ParserRuleContext { public: OperandContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; LiteralContext *literal(); OperandNameContext *operandName(); antlr4::tree::TerminalNode *L_PAREN(); ExpressionContext *expression(); antlr4::tree::TerminalNode *R_PAREN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; OperandContext* operand(); class LiteralContext : public antlr4::ParserRuleContext { public: LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; BasicLitContext *basicLit(); CompositeLitContext *compositeLit(); FunctionLitContext *functionLit(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; LiteralContext* literal(); class BasicLitContext : public antlr4::ParserRuleContext { public: BasicLitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *NIL_LIT(); IntegerContext *integer(); String_Context *string_(); antlr4::tree::TerminalNode *FLOAT_LIT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; BasicLitContext* basicLit(); class IntegerContext : public antlr4::ParserRuleContext { public: IntegerContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DECIMAL_LIT(); antlr4::tree::TerminalNode *BINARY_LIT(); antlr4::tree::TerminalNode *OCTAL_LIT(); antlr4::tree::TerminalNode *HEX_LIT(); antlr4::tree::TerminalNode *IMAGINARY_LIT(); antlr4::tree::TerminalNode *RUNE_LIT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; IntegerContext* integer(); class OperandNameContext : public antlr4::ParserRuleContext { public: OperandNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; OperandNameContext* operandName(); class QualifiedIdentContext : public antlr4::ParserRuleContext { public: QualifiedIdentContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector IDENTIFIER(); antlr4::tree::TerminalNode* IDENTIFIER(size_t i); antlr4::tree::TerminalNode *DOT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; QualifiedIdentContext* qualifiedIdent(); class CompositeLitContext : public antlr4::ParserRuleContext { public: CompositeLitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; LiteralTypeContext *literalType(); LiteralValueContext *literalValue(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; CompositeLitContext* compositeLit(); class LiteralTypeContext : public antlr4::ParserRuleContext { public: LiteralTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; StructTypeContext *structType(); ArrayTypeContext *arrayType(); antlr4::tree::TerminalNode *L_BRACKET(); antlr4::tree::TerminalNode *ELLIPSIS(); antlr4::tree::TerminalNode *R_BRACKET(); ElementTypeContext *elementType(); SliceTypeContext *sliceType(); MapTypeContext *mapType(); TypeNameContext *typeName(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; LiteralTypeContext* literalType(); class LiteralValueContext : public antlr4::ParserRuleContext { public: LiteralValueContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_CURLY(); antlr4::tree::TerminalNode *R_CURLY(); ElementListContext *elementList(); antlr4::tree::TerminalNode *COMMA(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; LiteralValueContext* literalValue(); class ElementListContext : public antlr4::ParserRuleContext { public: ElementListContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; std::vector keyedElement(); KeyedElementContext* keyedElement(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; }; ElementListContext* elementList(); class KeyedElementContext : public antlr4::ParserRuleContext { public: KeyedElementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ElementContext *element(); KeyContext *key(); antlr4::tree::TerminalNode *COLON(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; KeyedElementContext* keyedElement(); class KeyContext : public antlr4::ParserRuleContext { public: KeyContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); LiteralValueContext *literalValue(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; KeyContext* key(); class ElementContext : public antlr4::ParserRuleContext { public: ElementContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; ExpressionContext *expression(); LiteralValueContext *literalValue(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ElementContext* element(); class StructTypeContext : public antlr4::ParserRuleContext { public: StructTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *STRUCT(); antlr4::tree::TerminalNode *L_CURLY(); antlr4::tree::TerminalNode *R_CURLY(); std::vector fieldDecl(); FieldDeclContext* fieldDecl(size_t i); std::vector eoss(); EossContext* eoss(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; StructTypeContext* structType(); class FieldDeclContext : public antlr4::ParserRuleContext { public: GoParser::String_Context *tag = nullptr; FieldDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; IdentifierListContext *identifierList(); Type_Context *type_(); EmbeddedFieldContext *embeddedField(); String_Context *string_(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; FieldDeclContext* fieldDecl(); class String_Context : public antlr4::ParserRuleContext { public: String_Context(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *RAW_STRING_LIT(); antlr4::tree::TerminalNode *INTERPRETED_STRING_LIT(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; String_Context* string_(); class EmbeddedFieldContext : public antlr4::ParserRuleContext { public: EmbeddedFieldContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; TypeNameContext *typeName(); antlr4::tree::TerminalNode *STAR(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; EmbeddedFieldContext* embeddedField(); class FunctionLitContext : public antlr4::ParserRuleContext { public: FunctionLitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *FUNC(); SignatureContext *signature(); BlockContext *block(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; FunctionLitContext* functionLit(); class IndexContext : public antlr4::ParserRuleContext { public: IndexContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_BRACKET(); ExpressionContext *expression(); antlr4::tree::TerminalNode *R_BRACKET(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; IndexContext* index(); class Slice_Context : public antlr4::ParserRuleContext { public: Slice_Context(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_BRACKET(); antlr4::tree::TerminalNode *R_BRACKET(); std::vector COLON(); antlr4::tree::TerminalNode* COLON(size_t i); std::vector expression(); ExpressionContext* expression(size_t i); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; Slice_Context* slice_(); class TypeAssertionContext : public antlr4::ParserRuleContext { public: TypeAssertionContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *L_PAREN(); Type_Context *type_(); antlr4::tree::TerminalNode *R_PAREN(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; TypeAssertionContext* typeAssertion(); class ArgumentsContext : public antlr4::ParserRuleContext { public: ArgumentsContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *L_PAREN(); antlr4::tree::TerminalNode *R_PAREN(); ExpressionListContext *expressionList(); NonNamedTypeContext *nonNamedType(); antlr4::tree::TerminalNode *ELLIPSIS(); 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; }; ArgumentsContext* arguments(); class MethodExprContext : public antlr4::ParserRuleContext { public: MethodExprContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; NonNamedTypeContext *nonNamedType(); antlr4::tree::TerminalNode *DOT(); antlr4::tree::TerminalNode *IDENTIFIER(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; MethodExprContext* methodExpr(); class ReceiverTypeContext : public antlr4::ParserRuleContext { public: ReceiverTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; Type_Context *type_(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; ReceiverTypeContext* receiverType(); class EossContext : public antlr4::ParserRuleContext { public: EossContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *SEMI(); antlr4::tree::TerminalNode *EOSSS(); antlr4::tree::TerminalNode *HUANHANG(); antlr4::tree::TerminalNode *HUANHANGG(); virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; }; EossContext* eoss(); virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; bool expressionSempred(ExpressionContext *_localctx, size_t predicateIndex); bool primaryExprSempred(PrimaryExprContext *_localctx, size_t predicateIndex); 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; };