1902 lines
68 KiB
C++
1902 lines
68 KiB
C++
|
|
// 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<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
|
|
virtual const std::vector<std::string>& getRuleNames() const override;
|
|
virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
|
|
|
|
|
|
class 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<EossContext *> eoss();
|
|
EossContext* eoss(size_t i);
|
|
std::vector<ImportDeclContext *> importDecl();
|
|
ImportDeclContext* importDecl(size_t i);
|
|
std::vector<FunctionDeclContext *> functionDecl();
|
|
FunctionDeclContext* functionDecl(size_t i);
|
|
std::vector<MethodDeclContext *> methodDecl();
|
|
MethodDeclContext* methodDecl(size_t i);
|
|
std::vector<DeclarationContext *> 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<ImportSpecContext *> importSpec();
|
|
ImportSpecContext* importSpec(size_t i);
|
|
antlr4::tree::TerminalNode *L_PAREN();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
std::vector<EossContext *> 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<ConstSpecContext *> constSpec();
|
|
ConstSpecContext* constSpec(size_t i);
|
|
antlr4::tree::TerminalNode *L_PAREN();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
std::vector<EossContext *> 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<antlr4::tree::TerminalNode *> IDENTIFIER();
|
|
antlr4::tree::TerminalNode* IDENTIFIER(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
};
|
|
|
|
IdentifierListContext* identifierList();
|
|
|
|
class ExpressionListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ExpressionListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
};
|
|
|
|
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<TypeSpecContext *> typeSpec();
|
|
TypeSpecContext* typeSpec(size_t i);
|
|
antlr4::tree::TerminalNode *L_PAREN();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
std::vector<EossContext *> 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<VarSpecContext *> varSpec();
|
|
VarSpecContext* varSpec(size_t i);
|
|
antlr4::tree::TerminalNode *L_PAREN();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
std::vector<EossContext *> 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<EossContext *> 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<StatementContext *> statement();
|
|
StatementContext* statement(size_t i);
|
|
std::vector<EossContext *> 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<ExpressionContext *> 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<ExpressionListContext *> 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<BlockContext *> 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<ExprCaseClauseContext *> 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<TypeCaseClauseContext *> 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_Context *> type_();
|
|
Type_Context* type_(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> NIL_LIT();
|
|
antlr4::tree::TerminalNode* NIL_LIT(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
};
|
|
|
|
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<CommClauseContext *> 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<EossContext *> eoss();
|
|
EossContext* eoss(size_t i);
|
|
ExpressionContext *expression();
|
|
std::vector<SimpleStmtContext *> 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<EossContext *> eoss();
|
|
EossContext* eoss(size_t i);
|
|
std::vector<MethodSpecContext *> methodSpec();
|
|
MethodSpecContext* methodSpec(size_t i);
|
|
std::vector<TypeNameContext *> 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<ParameterDeclContext *> parameterDecl();
|
|
ParameterDeclContext* parameterDecl(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
};
|
|
|
|
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<ExpressionContext *> 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<ExpressionContext *> 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<ExpressionContext *> 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<ExpressionContext *> 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<ExpressionContext *> 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<antlr4::tree::TerminalNode *> 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<KeyedElementContext *> keyedElement();
|
|
KeyedElementContext* keyedElement(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
};
|
|
|
|
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<FieldDeclContext *> fieldDecl();
|
|
FieldDeclContext* fieldDecl(size_t i);
|
|
std::vector<EossContext *> 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<antlr4::tree::TerminalNode *> COLON();
|
|
antlr4::tree::TerminalNode* COLON(size_t i);
|
|
std::vector<ExpressionContext *> 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<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
|
|
|
};
|
|
|
|
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<antlr4::dfa::DFA> _decisionToDFA;
|
|
static antlr4::atn::PredictionContextCache _sharedContextCache;
|
|
static std::vector<std::string> _ruleNames;
|
|
static std::vector<std::string> _tokenNames;
|
|
|
|
static std::vector<std::string> _literalNames;
|
|
static std::vector<std::string> _symbolicNames;
|
|
static antlr4::dfa::Vocabulary _vocabulary;
|
|
static antlr4::atn::ATN _atn;
|
|
static std::vector<uint16_t> _serializedATN;
|
|
|
|
|
|
struct Initializer {
|
|
Initializer();
|
|
};
|
|
static Initializer _init;
|
|
};
|
|
|