parser

package
v0.7.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 17, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var BubblerLexerLexerStaticData struct {
	ChannelNames           []string
	ModeNames              []string
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}
View Source 
var BubblerParserStaticData struct {
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}

Functions

func BubblerLexerInit 

func BubblerLexerInit()

bubblerLexerInit initializes any static state used to implement bubblerLexer. By default the static state used to implement the lexer is lazily initialized during the first call to NewbubblerLexer(). You can call this function if you wish to initialize the static state ahead of time.

func BubblerParserInit 

func BubblerParserInit()

bubblerParserInit initializes any static state used to implement bubblerParser. By default the static state used to implement the parser is lazily initialized during the first call to NewbubblerParser(). You can call this function if you wish to initialize the static state ahead of time.

func InitEmptyArrayElementTypeContext 

func InitEmptyArrayElementTypeContext(p *ArrayElementTypeContext)

func InitEmptyArrayTypeContext 

func InitEmptyArrayTypeContext(p *ArrayTypeContext)

func InitEmptyBasicTypeContext 

func InitEmptyBasicTypeContext(p *BasicTypeContext)

func InitEmptyBitSizeContext 

func InitEmptyBitSizeContext(p *BitSizeContext)

func InitEmptyBoolLitContext 

func InitEmptyBoolLitContext(p *BoolLitContext)

func InitEmptyByteSizeContext 

func InitEmptyByteSizeContext(p *ByteSizeContext)

func InitEmptyConstantContext 

func InitEmptyConstantContext(p *ConstantContext)

func InitEmptyEmptyStatement_Context 

func InitEmptyEmptyStatement_Context(p *EmptyStatement_Context)

func InitEmptyEnumBodyContext 

func InitEmptyEnumBodyContext(p *EnumBodyContext)

func InitEmptyEnumDefContext 

func InitEmptyEnumDefContext(p *EnumDefContext)

func InitEmptyEnumElementContext 

func InitEmptyEnumElementContext(p *EnumElementContext)

func InitEmptyEnumNameContext 

func InitEmptyEnumNameContext(p *EnumNameContext)

func InitEmptyEnumTypeContext 

func InitEmptyEnumTypeContext(p *EnumTypeContext)

func InitEmptyEnumValueContext 

func InitEmptyEnumValueContext(p *EnumValueContext)

func InitEmptyEnumValueNameContext 

func InitEmptyEnumValueNameContext(p *EnumValueNameContext)

func InitEmptyEnumValueOptionContext 

func InitEmptyEnumValueOptionContext(p *EnumValueOptionContext)

func InitEmptyEnumValueOptionsContext 

func InitEmptyEnumValueOptionsContext(p *EnumValueOptionsContext)

func InitEmptyExprContext 

func InitEmptyExprContext(p *ExprContext)

func InitEmptyFieldConstantContext 

func InitEmptyFieldConstantContext(p *FieldConstantContext)

func InitEmptyFieldContext 

func InitEmptyFieldContext(p *FieldContext)

func InitEmptyFieldEmbeddedContext 

func InitEmptyFieldEmbeddedContext(p *FieldEmbeddedContext)

func InitEmptyFieldMethodContext 

func InitEmptyFieldMethodContext(p *FieldMethodContext)

func InitEmptyFieldMethodsContext 

func InitEmptyFieldMethodsContext(p *FieldMethodsContext)

func InitEmptyFieldNameContext 

func InitEmptyFieldNameContext(p *FieldNameContext)

func InitEmptyFieldNormalContext 

func InitEmptyFieldNormalContext(p *FieldNormalContext)

func InitEmptyFieldOptionContext 

func InitEmptyFieldOptionContext(p *FieldOptionContext)

func InitEmptyFieldOptionsContext 

func InitEmptyFieldOptionsContext(p *FieldOptionsContext)

func InitEmptyFieldVoidContext 

func InitEmptyFieldVoidContext(p *FieldVoidContext)

func InitEmptyFloatLitContext 

func InitEmptyFloatLitContext(p *FloatLitContext)

func InitEmptyFullIdentContext 

func InitEmptyFullIdentContext(p *FullIdentContext)

func InitEmptyIdentContext 

func InitEmptyIdentContext(p *IdentContext)

func InitEmptyImportStatementContext 

func InitEmptyImportStatementContext(p *ImportStatementContext)

func InitEmptyIntLitContext 

func InitEmptyIntLitContext(p *IntLitContext)

func InitEmptyMethodNameContext 

func InitEmptyMethodNameContext(p *MethodNameContext)

func InitEmptyOptionNameContext 

func InitEmptyOptionNameContext(p *OptionNameContext)

func InitEmptyOptionStatementContext 

func InitEmptyOptionStatementContext(p *OptionStatementContext)

func InitEmptyPackageStatementContext 

func InitEmptyPackageStatementContext(p *PackageStatementContext)

func InitEmptyProtoContext 

func InitEmptyProtoContext(p *ProtoContext)

func InitEmptySize_Context 

func InitEmptySize_Context(p *Size_Context)

func InitEmptyStrLitContext 

func InitEmptyStrLitContext(p *StrLitContext)

func InitEmptyStructBodyContext 

func InitEmptyStructBodyContext(p *StructBodyContext)

func InitEmptyStructDefContext 

func InitEmptyStructDefContext(p *StructDefContext)

func InitEmptyStructElementContext 

func InitEmptyStructElementContext(p *StructElementContext)

func InitEmptyStructNameContext 

func InitEmptyStructNameContext(p *StructNameContext)

func InitEmptyStructTypeContext 

func InitEmptyStructTypeContext(p *StructTypeContext)

func InitEmptyTopLevelDefContext 

func InitEmptyTopLevelDefContext(p *TopLevelDefContext)

func InitEmptyType_Context 

func InitEmptyType_Context(p *Type_Context)

func InitEmptyValueContext 

func InitEmptyValueContext(p *ValueContext)

func NewbubblerLexer 

func NewbubblerLexer(input antlr.CharStream) *bubblerLexer

NewbubblerLexer produces a new lexer instance for the optional input antlr.CharStream.

func NewbubblerParser 

func NewbubblerParser(input antlr.TokenStream) *bubblerParser

NewbubblerParser produces a new parser instance for the optional input antlr.TokenStream.

Types

type ArrayElementTypeContext 

type ArrayElementTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayElementTypeContext 

func NewArrayElementTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayElementTypeContext

func NewEmptyArrayElementTypeContext 

func NewEmptyArrayElementTypeContext() *ArrayElementTypeContext

func (*ArrayElementTypeContext) Accept 

func (s *ArrayElementTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayElementTypeContext) BYTES 

func (s *ArrayElementTypeContext) BYTES() antlr.TerminalNode

func (*ArrayElementTypeContext) BasicType 

func (s *ArrayElementTypeContext) BasicType() IBasicTypeContext

func (*ArrayElementTypeContext) EnumType 

func (s *ArrayElementTypeContext) EnumType() IEnumTypeContext

func (*ArrayElementTypeContext) GetParser 

func (s *ArrayElementTypeContext) GetParser() antlr.Parser

func (*ArrayElementTypeContext) GetRuleContext 

func (s *ArrayElementTypeContext) GetRuleContext() antlr.RuleContext

func (*ArrayElementTypeContext) Ident 

func (s *ArrayElementTypeContext) Ident() IIdentContext

func (*ArrayElementTypeContext) IsArrayElementTypeContext 

func (*ArrayElementTypeContext) IsArrayElementTypeContext()

func (*ArrayElementTypeContext) STRING 

func (s *ArrayElementTypeContext) STRING() antlr.TerminalNode

func (*ArrayElementTypeContext) StructType 

func (s *ArrayElementTypeContext) StructType() IStructTypeContext

func (*ArrayElementTypeContext) ToStringTree 

func (s *ArrayElementTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ArrayTypeContext 

type ArrayTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayTypeContext 

func NewArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayTypeContext

func NewEmptyArrayTypeContext 

func NewEmptyArrayTypeContext() *ArrayTypeContext

func (*ArrayTypeContext) Accept 

func (s *ArrayTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayTypeContext) ArrayElementType 

func (s *ArrayTypeContext) ArrayElementType() IArrayElementTypeContext

func (*ArrayTypeContext) GT 

func (s *ArrayTypeContext) GT() antlr.TerminalNode

func (*ArrayTypeContext) GetParser 

func (s *ArrayTypeContext) GetParser() antlr.Parser

func (*ArrayTypeContext) GetRuleContext 

func (s *ArrayTypeContext) GetRuleContext() antlr.RuleContext

func (*ArrayTypeContext) IntLit 

func (s *ArrayTypeContext) IntLit() IIntLitContext

func (*ArrayTypeContext) IsArrayTypeContext 

func (*ArrayTypeContext) IsArrayTypeContext()

func (*ArrayTypeContext) LT 

func (s *ArrayTypeContext) LT() antlr.TerminalNode

func (*ArrayTypeContext) ToStringTree 

func (s *ArrayTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BasebubblerVisitor 

type BasebubblerVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BasebubblerVisitor) VisitArrayElementType 

func (v *BasebubblerVisitor) VisitArrayElementType(ctx *ArrayElementTypeContext) interface{}

func (*BasebubblerVisitor) VisitArrayType 

func (v *BasebubblerVisitor) VisitArrayType(ctx *ArrayTypeContext) interface{}

func (*BasebubblerVisitor) VisitBasicType 

func (v *BasebubblerVisitor) VisitBasicType(ctx *BasicTypeContext) interface{}

func (*BasebubblerVisitor) VisitBitSize 

func (v *BasebubblerVisitor) VisitBitSize(ctx *BitSizeContext) interface{}

func (*BasebubblerVisitor) VisitBoolLit 

func (v *BasebubblerVisitor) VisitBoolLit(ctx *BoolLitContext) interface{}

func (*BasebubblerVisitor) VisitByteSize 

func (v *BasebubblerVisitor) VisitByteSize(ctx *ByteSizeContext) interface{}

func (*BasebubblerVisitor) VisitConstant 

func (v *BasebubblerVisitor) VisitConstant(ctx *ConstantContext) interface{}

func (*BasebubblerVisitor) VisitEmptyStatement_ 

func (v *BasebubblerVisitor) VisitEmptyStatement_(ctx *EmptyStatement_Context) interface{}

func (*BasebubblerVisitor) VisitEnumBody 

func (v *BasebubblerVisitor) VisitEnumBody(ctx *EnumBodyContext) interface{}

func (*BasebubblerVisitor) VisitEnumDef 

func (v *BasebubblerVisitor) VisitEnumDef(ctx *EnumDefContext) interface{}

func (*BasebubblerVisitor) VisitEnumElement 

func (v *BasebubblerVisitor) VisitEnumElement(ctx *EnumElementContext) interface{}

func (*BasebubblerVisitor) VisitEnumName 

func (v *BasebubblerVisitor) VisitEnumName(ctx *EnumNameContext) interface{}

func (*BasebubblerVisitor) VisitEnumType 

func (v *BasebubblerVisitor) VisitEnumType(ctx *EnumTypeContext) interface{}

func (*BasebubblerVisitor) VisitEnumValue 

func (v *BasebubblerVisitor) VisitEnumValue(ctx *EnumValueContext) interface{}

func (*BasebubblerVisitor) VisitEnumValueName 

func (v *BasebubblerVisitor) VisitEnumValueName(ctx *EnumValueNameContext) interface{}

func (*BasebubblerVisitor) VisitEnumValueOption 

func (v *BasebubblerVisitor) VisitEnumValueOption(ctx *EnumValueOptionContext) interface{}

func (*BasebubblerVisitor) VisitEnumValueOptions 

func (v *BasebubblerVisitor) VisitEnumValueOptions(ctx *EnumValueOptionsContext) interface{}

func (*BasebubblerVisitor) VisitExprAddSub 

func (v *BasebubblerVisitor) VisitExprAddSub(ctx *ExprAddSubContext) interface{}

func (*BasebubblerVisitor) VisitExprBitAnd 

func (v *BasebubblerVisitor) VisitExprBitAnd(ctx *ExprBitAndContext) interface{}

func (*BasebubblerVisitor) VisitExprBitOr 

func (v *BasebubblerVisitor) VisitExprBitOr(ctx *ExprBitOrContext) interface{}

func (*BasebubblerVisitor) VisitExprBitXor 

func (v *BasebubblerVisitor) VisitExprBitXor(ctx *ExprBitXorContext) interface{}

func (*BasebubblerVisitor) VisitExprCast 

func (v *BasebubblerVisitor) VisitExprCast(ctx *ExprCastContext) interface{}

func (*BasebubblerVisitor) VisitExprConstant 

func (v *BasebubblerVisitor) VisitExprConstant(ctx *ExprConstantContext) interface{}

func (*BasebubblerVisitor) VisitExprEquality 

func (v *BasebubblerVisitor) VisitExprEquality(ctx *ExprEqualityContext) interface{}

func (*BasebubblerVisitor) VisitExprLogicalAnd 

func (v *BasebubblerVisitor) VisitExprLogicalAnd(ctx *ExprLogicalAndContext) interface{}

func (*BasebubblerVisitor) VisitExprLogicalOr 

func (v *BasebubblerVisitor) VisitExprLogicalOr(ctx *ExprLogicalOrContext) interface{}

func (*BasebubblerVisitor) VisitExprMulDivMod 

func (v *BasebubblerVisitor) VisitExprMulDivMod(ctx *ExprMulDivModContext) interface{}

func (*BasebubblerVisitor) VisitExprParens 

func (v *BasebubblerVisitor) VisitExprParens(ctx *ExprParensContext) interface{}

func (*BasebubblerVisitor) VisitExprPower 

func (v *BasebubblerVisitor) VisitExprPower(ctx *ExprPowerContext) interface{}

func (*BasebubblerVisitor) VisitExprRelational 

func (v *BasebubblerVisitor) VisitExprRelational(ctx *ExprRelationalContext) interface{}

func (*BasebubblerVisitor) VisitExprShift 

func (v *BasebubblerVisitor) VisitExprShift(ctx *ExprShiftContext) interface{}

func (*BasebubblerVisitor) VisitExprTernary 

func (v *BasebubblerVisitor) VisitExprTernary(ctx *ExprTernaryContext) interface{}

func (*BasebubblerVisitor) VisitExprUnary 

func (v *BasebubblerVisitor) VisitExprUnary(ctx *ExprUnaryContext) interface{}

func (*BasebubblerVisitor) VisitExprValue 

func (v *BasebubblerVisitor) VisitExprValue(ctx *ExprValueContext) interface{}

func (*BasebubblerVisitor) VisitField 

func (v *BasebubblerVisitor) VisitField(ctx *FieldContext) interface{}

func (*BasebubblerVisitor) VisitFieldConstant 

func (v *BasebubblerVisitor) VisitFieldConstant(ctx *FieldConstantContext) interface{}

func (*BasebubblerVisitor) VisitFieldEmbedded 

func (v *BasebubblerVisitor) VisitFieldEmbedded(ctx *FieldEmbeddedContext) interface{}

func (*BasebubblerVisitor) VisitFieldMethod 

func (v *BasebubblerVisitor) VisitFieldMethod(ctx *FieldMethodContext) interface{}

func (*BasebubblerVisitor) VisitFieldMethods 

func (v *BasebubblerVisitor) VisitFieldMethods(ctx *FieldMethodsContext) interface{}

func (*BasebubblerVisitor) VisitFieldName 

func (v *BasebubblerVisitor) VisitFieldName(ctx *FieldNameContext) interface{}

func (*BasebubblerVisitor) VisitFieldNormal 

func (v *BasebubblerVisitor) VisitFieldNormal(ctx *FieldNormalContext) interface{}

func (*BasebubblerVisitor) VisitFieldOption 

func (v *BasebubblerVisitor) VisitFieldOption(ctx *FieldOptionContext) interface{}

func (*BasebubblerVisitor) VisitFieldOptions 

func (v *BasebubblerVisitor) VisitFieldOptions(ctx *FieldOptionsContext) interface{}

func (*BasebubblerVisitor) VisitFieldVoid 

func (v *BasebubblerVisitor) VisitFieldVoid(ctx *FieldVoidContext) interface{}

func (*BasebubblerVisitor) VisitFloatLit 

func (v *BasebubblerVisitor) VisitFloatLit(ctx *FloatLitContext) interface{}

func (*BasebubblerVisitor) VisitFullIdent 

func (v *BasebubblerVisitor) VisitFullIdent(ctx *FullIdentContext) interface{}

func (*BasebubblerVisitor) VisitIdent 

func (v *BasebubblerVisitor) VisitIdent(ctx *IdentContext) interface{}

func (*BasebubblerVisitor) VisitImportStatement 

func (v *BasebubblerVisitor) VisitImportStatement(ctx *ImportStatementContext) interface{}

func (*BasebubblerVisitor) VisitIntLit 

func (v *BasebubblerVisitor) VisitIntLit(ctx *IntLitContext) interface{}

func (*BasebubblerVisitor) VisitMethodName 

func (v *BasebubblerVisitor) VisitMethodName(ctx *MethodNameContext) interface{}

func (*BasebubblerVisitor) VisitOptionName 

func (v *BasebubblerVisitor) VisitOptionName(ctx *OptionNameContext) interface{}

func (*BasebubblerVisitor) VisitOptionStatement 

func (v *BasebubblerVisitor) VisitOptionStatement(ctx *OptionStatementContext) interface{}

func (*BasebubblerVisitor) VisitPackageStatement 

func (v *BasebubblerVisitor) VisitPackageStatement(ctx *PackageStatementContext) interface{}

func (*BasebubblerVisitor) VisitProto 

func (v *BasebubblerVisitor) VisitProto(ctx *ProtoContext) interface{}

func (*BasebubblerVisitor) VisitSize_ 

func (v *BasebubblerVisitor) VisitSize_(ctx *Size_Context) interface{}

func (*BasebubblerVisitor) VisitStrLit 

func (v *BasebubblerVisitor) VisitStrLit(ctx *StrLitContext) interface{}

func (*BasebubblerVisitor) VisitStructBody 

func (v *BasebubblerVisitor) VisitStructBody(ctx *StructBodyContext) interface{}

func (*BasebubblerVisitor) VisitStructDef 

func (v *BasebubblerVisitor) VisitStructDef(ctx *StructDefContext) interface{}

func (*BasebubblerVisitor) VisitStructElement 

func (v *BasebubblerVisitor) VisitStructElement(ctx *StructElementContext) interface{}

func (*BasebubblerVisitor) VisitStructName 

func (v *BasebubblerVisitor) VisitStructName(ctx *StructNameContext) interface{}

func (*BasebubblerVisitor) VisitStructType 

func (v *BasebubblerVisitor) VisitStructType(ctx *StructTypeContext) interface{}

func (*BasebubblerVisitor) VisitTopLevelDef 

func (v *BasebubblerVisitor) VisitTopLevelDef(ctx *TopLevelDefContext) interface{}

func (*BasebubblerVisitor) VisitType_ 

func (v *BasebubblerVisitor) VisitType_(ctx *Type_Context) interface{}

func (*BasebubblerVisitor) VisitValue 

func (v *BasebubblerVisitor) VisitValue(ctx *ValueContext) interface{}

type BasicTypeContext 

type BasicTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBasicTypeContext 

func NewBasicTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BasicTypeContext

func NewEmptyBasicTypeContext 

func NewEmptyBasicTypeContext() *BasicTypeContext

func (*BasicTypeContext) Accept 

func (s *BasicTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BasicTypeContext) BOOL 

func (s *BasicTypeContext) BOOL() antlr.TerminalNode

func (*BasicTypeContext) FLOAT32 

func (s *BasicTypeContext) FLOAT32() antlr.TerminalNode

func (*BasicTypeContext) FLOAT64 

func (s *BasicTypeContext) FLOAT64() antlr.TerminalNode

func (*BasicTypeContext) GetParser 

func (s *BasicTypeContext) GetParser() antlr.Parser

func (*BasicTypeContext) GetRuleContext 

func (s *BasicTypeContext) GetRuleContext() antlr.RuleContext

func (*BasicTypeContext) INT16 

func (s *BasicTypeContext) INT16() antlr.TerminalNode

func (*BasicTypeContext) INT32 

func (s *BasicTypeContext) INT32() antlr.TerminalNode

func (*BasicTypeContext) INT64 

func (s *BasicTypeContext) INT64() antlr.TerminalNode

func (*BasicTypeContext) INT8 

func (s *BasicTypeContext) INT8() antlr.TerminalNode

func (*BasicTypeContext) IsBasicTypeContext 

func (*BasicTypeContext) IsBasicTypeContext()

func (*BasicTypeContext) ToStringTree 

func (s *BasicTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*BasicTypeContext) UINT16 

func (s *BasicTypeContext) UINT16() antlr.TerminalNode

func (*BasicTypeContext) UINT32 

func (s *BasicTypeContext) UINT32() antlr.TerminalNode

func (*BasicTypeContext) UINT64 

func (s *BasicTypeContext) UINT64() antlr.TerminalNode

func (*BasicTypeContext) UINT8 

func (s *BasicTypeContext) UINT8() antlr.TerminalNode

type BitSizeContext 

type BitSizeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBitSizeContext 

func NewBitSizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitSizeContext

func NewEmptyBitSizeContext 

func NewEmptyBitSizeContext() *BitSizeContext

func (*BitSizeContext) Accept 

func (s *BitSizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitSizeContext) GetParser 

func (s *BitSizeContext) GetParser() antlr.Parser

func (*BitSizeContext) GetRuleContext 

func (s *BitSizeContext) GetRuleContext() antlr.RuleContext

func (*BitSizeContext) IntLit 

func (s *BitSizeContext) IntLit() IIntLitContext

func (*BitSizeContext) IsBitSizeContext 

func (*BitSizeContext) IsBitSizeContext()

func (*BitSizeContext) ToStringTree 

func (s *BitSizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BoolLitContext 

type BoolLitContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBoolLitContext 

func NewBoolLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BoolLitContext

func NewEmptyBoolLitContext 

func NewEmptyBoolLitContext() *BoolLitContext

func (*BoolLitContext) Accept 

func (s *BoolLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BoolLitContext) BOOL_LIT 

func (s *BoolLitContext) BOOL_LIT() antlr.TerminalNode

func (*BoolLitContext) GetParser 

func (s *BoolLitContext) GetParser() antlr.Parser

func (*BoolLitContext) GetRuleContext 

func (s *BoolLitContext) GetRuleContext() antlr.RuleContext

func (*BoolLitContext) IsBoolLitContext 

func (*BoolLitContext) IsBoolLitContext()

func (*BoolLitContext) ToStringTree 

func (s *BoolLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ByteSizeContext 

type ByteSizeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewByteSizeContext 

func NewByteSizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ByteSizeContext

func NewEmptyByteSizeContext 

func NewEmptyByteSizeContext() *ByteSizeContext

func (*ByteSizeContext) Accept 

func (s *ByteSizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ByteSizeContext) GetParser 

func (s *ByteSizeContext) GetParser() antlr.Parser

func (*ByteSizeContext) GetRuleContext 

func (s *ByteSizeContext) GetRuleContext() antlr.RuleContext

func (*ByteSizeContext) IntLit 

func (s *ByteSizeContext) IntLit() IIntLitContext

func (*ByteSizeContext) IsByteSizeContext 

func (*ByteSizeContext) IsByteSizeContext()

func (*ByteSizeContext) ToStringTree 

func (s *ByteSizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ConstantContext 

type ConstantContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewConstantContext 

func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext

func NewEmptyConstantContext 

func NewEmptyConstantContext() *ConstantContext

func (*ConstantContext) ADD 

func (s *ConstantContext) ADD() antlr.TerminalNode

func (*ConstantContext) Accept 

func (s *ConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ConstantContext) BoolLit 

func (s *ConstantContext) BoolLit() IBoolLitContext

func (*ConstantContext) FloatLit 

func (s *ConstantContext) FloatLit() IFloatLitContext

func (*ConstantContext) GetParser 

func (s *ConstantContext) GetParser() antlr.Parser

func (*ConstantContext) GetRuleContext 

func (s *ConstantContext) GetRuleContext() antlr.RuleContext

func (*ConstantContext) IntLit 

func (s *ConstantContext) IntLit() IIntLitContext

func (*ConstantContext) IsConstantContext 

func (*ConstantContext) IsConstantContext()

func (*ConstantContext) SUB 

func (s *ConstantContext) SUB() antlr.TerminalNode

func (*ConstantContext) StrLit 

func (s *ConstantContext) StrLit() IStrLitContext

func (*ConstantContext) ToStringTree 

func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EmptyStatement_Context 

type EmptyStatement_Context struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEmptyStatement_Context 

func NewEmptyEmptyStatement_Context() *EmptyStatement_Context

func NewEmptyStatement_Context 

func NewEmptyStatement_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EmptyStatement_Context

func (*EmptyStatement_Context) Accept 

func (s *EmptyStatement_Context) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EmptyStatement_Context) GetParser 

func (s *EmptyStatement_Context) GetParser() antlr.Parser

func (*EmptyStatement_Context) GetRuleContext 

func (s *EmptyStatement_Context) GetRuleContext() antlr.RuleContext

func (*EmptyStatement_Context) IsEmptyStatement_Context 

func (*EmptyStatement_Context) IsEmptyStatement_Context()

func (*EmptyStatement_Context) SEMI 

func (s *EmptyStatement_Context) SEMI() antlr.TerminalNode

func (*EmptyStatement_Context) ToStringTree 

func (s *EmptyStatement_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumBodyContext 

type EnumBodyContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumBodyContext 

func NewEmptyEnumBodyContext() *EnumBodyContext

func NewEnumBodyContext 

func NewEnumBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumBodyContext

func (*EnumBodyContext) Accept 

func (s *EnumBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumBodyContext) AllEnumElement 

func (s *EnumBodyContext) AllEnumElement() []IEnumElementContext

func (*EnumBodyContext) EnumElement 

func (s *EnumBodyContext) EnumElement(i int) IEnumElementContext

func (*EnumBodyContext) GetParser 

func (s *EnumBodyContext) GetParser() antlr.Parser

func (*EnumBodyContext) GetRuleContext 

func (s *EnumBodyContext) GetRuleContext() antlr.RuleContext

func (*EnumBodyContext) IsEnumBodyContext 

func (*EnumBodyContext) IsEnumBodyContext()

func (*EnumBodyContext) LC 

func (s *EnumBodyContext) LC() antlr.TerminalNode

func (*EnumBodyContext) RC 

func (s *EnumBodyContext) RC() antlr.TerminalNode

func (*EnumBodyContext) ToStringTree 

func (s *EnumBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumDefContext 

type EnumDefContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumDefContext 

func NewEmptyEnumDefContext() *EnumDefContext

func NewEnumDefContext 

func NewEnumDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumDefContext

func (*EnumDefContext) Accept 

func (s *EnumDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumDefContext) EnumBody 

func (s *EnumDefContext) EnumBody() IEnumBodyContext

func (*EnumDefContext) EnumName 

func (s *EnumDefContext) EnumName() IEnumNameContext

func (*EnumDefContext) GetParser 

func (s *EnumDefContext) GetParser() antlr.Parser

func (*EnumDefContext) GetRuleContext 

func (s *EnumDefContext) GetRuleContext() antlr.RuleContext

func (*EnumDefContext) IsEnumDefContext 

func (*EnumDefContext) IsEnumDefContext()

func (*EnumDefContext) Size_ 

func (s *EnumDefContext) Size_() ISize_Context

func (*EnumDefContext) ToStringTree 

func (s *EnumDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumElementContext 

type EnumElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumElementContext 

func NewEmptyEnumElementContext() *EnumElementContext

func NewEnumElementContext 

func NewEnumElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumElementContext

func (*EnumElementContext) Accept 

func (s *EnumElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumElementContext) EmptyStatement_ 

func (s *EnumElementContext) EmptyStatement_() IEmptyStatement_Context

func (*EnumElementContext) EnumValue 

func (s *EnumElementContext) EnumValue() IEnumValueContext

func (*EnumElementContext) GetParser 

func (s *EnumElementContext) GetParser() antlr.Parser

func (*EnumElementContext) GetRuleContext 

func (s *EnumElementContext) GetRuleContext() antlr.RuleContext

func (*EnumElementContext) IsEnumElementContext 

func (*EnumElementContext) IsEnumElementContext()

func (*EnumElementContext) ToStringTree 

func (s *EnumElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumNameContext 

type EnumNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumNameContext 

func NewEmptyEnumNameContext() *EnumNameContext

func NewEnumNameContext 

func NewEnumNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumNameContext

func (*EnumNameContext) Accept 

func (s *EnumNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumNameContext) ENUM 

func (s *EnumNameContext) ENUM() antlr.TerminalNode

func (*EnumNameContext) GetParser 

func (s *EnumNameContext) GetParser() antlr.Parser

func (*EnumNameContext) GetRuleContext 

func (s *EnumNameContext) GetRuleContext() antlr.RuleContext

func (*EnumNameContext) Ident 

func (s *EnumNameContext) Ident() IIdentContext

func (*EnumNameContext) IsEnumNameContext 

func (*EnumNameContext) IsEnumNameContext()

func (*EnumNameContext) ToStringTree 

func (s *EnumNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumTypeContext 

type EnumTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumTypeContext 

func NewEmptyEnumTypeContext() *EnumTypeContext

func NewEnumTypeContext 

func NewEnumTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumTypeContext

func (*EnumTypeContext) Accept 

func (s *EnumTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumTypeContext) EnumName 

func (s *EnumTypeContext) EnumName() IEnumNameContext

func (*EnumTypeContext) GetParser 

func (s *EnumTypeContext) GetParser() antlr.Parser

func (*EnumTypeContext) GetRuleContext 

func (s *EnumTypeContext) GetRuleContext() antlr.RuleContext

func (*EnumTypeContext) IsEnumTypeContext 

func (*EnumTypeContext) IsEnumTypeContext()

func (*EnumTypeContext) ToStringTree 

func (s *EnumTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumValueContext 

type EnumValueContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumValueContext 

func NewEmptyEnumValueContext() *EnumValueContext

func NewEnumValueContext 

func NewEnumValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumValueContext

func (*EnumValueContext) ASSIGN 

func (s *EnumValueContext) ASSIGN() antlr.TerminalNode

func (*EnumValueContext) Accept 

func (s *EnumValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumValueContext) COMMA 

func (s *EnumValueContext) COMMA() antlr.TerminalNode

func (*EnumValueContext) Constant 

func (s *EnumValueContext) Constant() IConstantContext

func (*EnumValueContext) EnumValueName 

func (s *EnumValueContext) EnumValueName() IEnumValueNameContext

func (*EnumValueContext) EnumValueOptions 

func (s *EnumValueContext) EnumValueOptions() IEnumValueOptionsContext

func (*EnumValueContext) GetParser 

func (s *EnumValueContext) GetParser() antlr.Parser

func (*EnumValueContext) GetRuleContext 

func (s *EnumValueContext) GetRuleContext() antlr.RuleContext

func (*EnumValueContext) IsEnumValueContext 

func (*EnumValueContext) IsEnumValueContext()

func (*EnumValueContext) SEMI 

func (s *EnumValueContext) SEMI() antlr.TerminalNode

func (*EnumValueContext) ToStringTree 

func (s *EnumValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumValueNameContext 

type EnumValueNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumValueNameContext 

func NewEmptyEnumValueNameContext() *EnumValueNameContext

func NewEnumValueNameContext 

func NewEnumValueNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumValueNameContext

func (*EnumValueNameContext) Accept 

func (s *EnumValueNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumValueNameContext) GetParser 

func (s *EnumValueNameContext) GetParser() antlr.Parser

func (*EnumValueNameContext) GetRuleContext 

func (s *EnumValueNameContext) GetRuleContext() antlr.RuleContext

func (*EnumValueNameContext) Ident 

func (s *EnumValueNameContext) Ident() IIdentContext

func (*EnumValueNameContext) IsEnumValueNameContext 

func (*EnumValueNameContext) IsEnumValueNameContext()

func (*EnumValueNameContext) ToStringTree 

func (s *EnumValueNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumValueOptionContext 

type EnumValueOptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumValueOptionContext 

func NewEmptyEnumValueOptionContext() *EnumValueOptionContext

func NewEnumValueOptionContext 

func NewEnumValueOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumValueOptionContext

func (*EnumValueOptionContext) ASSIGN 

func (s *EnumValueOptionContext) ASSIGN() antlr.TerminalNode

func (*EnumValueOptionContext) Accept 

func (s *EnumValueOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumValueOptionContext) Constant 

func (s *EnumValueOptionContext) Constant() IConstantContext

func (*EnumValueOptionContext) GetParser 

func (s *EnumValueOptionContext) GetParser() antlr.Parser

func (*EnumValueOptionContext) GetRuleContext 

func (s *EnumValueOptionContext) GetRuleContext() antlr.RuleContext

func (*EnumValueOptionContext) IsEnumValueOptionContext 

func (*EnumValueOptionContext) IsEnumValueOptionContext()

func (*EnumValueOptionContext) OptionName 

func (s *EnumValueOptionContext) OptionName() IOptionNameContext

func (*EnumValueOptionContext) ToStringTree 

func (s *EnumValueOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumValueOptionsContext 

type EnumValueOptionsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumValueOptionsContext 

func NewEmptyEnumValueOptionsContext() *EnumValueOptionsContext

func NewEnumValueOptionsContext 

func NewEnumValueOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumValueOptionsContext

func (*EnumValueOptionsContext) Accept 

func (s *EnumValueOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumValueOptionsContext) AllCOMMA 

func (s *EnumValueOptionsContext) AllCOMMA() []antlr.TerminalNode

func (*EnumValueOptionsContext) AllEnumValueOption 

func (s *EnumValueOptionsContext) AllEnumValueOption() []IEnumValueOptionContext

func (*EnumValueOptionsContext) COMMA 

func (s *EnumValueOptionsContext) COMMA(i int) antlr.TerminalNode

func (*EnumValueOptionsContext) EnumValueOption 

func (s *EnumValueOptionsContext) EnumValueOption(i int) IEnumValueOptionContext

func (*EnumValueOptionsContext) GetParser 

func (s *EnumValueOptionsContext) GetParser() antlr.Parser

func (*EnumValueOptionsContext) GetRuleContext 

func (s *EnumValueOptionsContext) GetRuleContext() antlr.RuleContext

func (*EnumValueOptionsContext) IsEnumValueOptionsContext 

func (*EnumValueOptionsContext) IsEnumValueOptionsContext()

func (*EnumValueOptionsContext) LB 

func (s *EnumValueOptionsContext) LB() antlr.TerminalNode

func (*EnumValueOptionsContext) RB 

func (s *EnumValueOptionsContext) RB() antlr.TerminalNode

func (*EnumValueOptionsContext) ToStringTree 

func (s *EnumValueOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExprAddSubContext 

type ExprAddSubContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprAddSubContext 

func NewExprAddSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprAddSubContext

func (*ExprAddSubContext) ADD 

func (s *ExprAddSubContext) ADD() antlr.TerminalNode

func (*ExprAddSubContext) Accept 

func (s *ExprAddSubContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprAddSubContext) AllExpr 

func (s *ExprAddSubContext) AllExpr() []IExprContext

func (*ExprAddSubContext) Expr 

func (s *ExprAddSubContext) Expr(i int) IExprContext

func (*ExprAddSubContext) GetOp 

func (s *ExprAddSubContext) GetOp() antlr.Token

func (*ExprAddSubContext) GetRuleContext 

func (s *ExprAddSubContext) GetRuleContext() antlr.RuleContext

func (*ExprAddSubContext) SUB 

func (s *ExprAddSubContext) SUB() antlr.TerminalNode

func (*ExprAddSubContext) SetOp 

func (s *ExprAddSubContext) SetOp(v antlr.Token)

type ExprBitAndContext 

type ExprBitAndContext struct {
	ExprContext
}

func NewExprBitAndContext 

func NewExprBitAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitAndContext

func (*ExprBitAndContext) Accept 

func (s *ExprBitAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprBitAndContext) AllExpr 

func (s *ExprBitAndContext) AllExpr() []IExprContext

func (*ExprBitAndContext) BAND 

func (s *ExprBitAndContext) BAND() antlr.TerminalNode

func (*ExprBitAndContext) Expr 

func (s *ExprBitAndContext) Expr(i int) IExprContext

func (*ExprBitAndContext) GetRuleContext 

func (s *ExprBitAndContext) GetRuleContext() antlr.RuleContext

type ExprBitOrContext 

type ExprBitOrContext struct {
	ExprContext
}

func NewExprBitOrContext 

func NewExprBitOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitOrContext

func (*ExprBitOrContext) Accept 

func (s *ExprBitOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprBitOrContext) AllExpr 

func (s *ExprBitOrContext) AllExpr() []IExprContext

func (*ExprBitOrContext) BOR 

func (s *ExprBitOrContext) BOR() antlr.TerminalNode

func (*ExprBitOrContext) Expr 

func (s *ExprBitOrContext) Expr(i int) IExprContext

func (*ExprBitOrContext) GetRuleContext 

func (s *ExprBitOrContext) GetRuleContext() antlr.RuleContext

type ExprBitXorContext 

type ExprBitXorContext struct {
	ExprContext
}

func NewExprBitXorContext 

func NewExprBitXorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprBitXorContext

func (*ExprBitXorContext) Accept 

func (s *ExprBitXorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprBitXorContext) AllExpr 

func (s *ExprBitXorContext) AllExpr() []IExprContext

func (*ExprBitXorContext) BXOR 

func (s *ExprBitXorContext) BXOR() antlr.TerminalNode

func (*ExprBitXorContext) Expr 

func (s *ExprBitXorContext) Expr(i int) IExprContext

func (*ExprBitXorContext) GetRuleContext 

func (s *ExprBitXorContext) GetRuleContext() antlr.RuleContext

type ExprCastContext 

type ExprCastContext struct {
	ExprContext
}

func NewExprCastContext 

func NewExprCastContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprCastContext

func (*ExprCastContext) Accept 

func (s *ExprCastContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprCastContext) BasicType 

func (s *ExprCastContext) BasicType() IBasicTypeContext

func (*ExprCastContext) Expr 

func (s *ExprCastContext) Expr() IExprContext

func (*ExprCastContext) GetRuleContext 

func (s *ExprCastContext) GetRuleContext() antlr.RuleContext

func (*ExprCastContext) LP 

func (s *ExprCastContext) LP() antlr.TerminalNode

func (*ExprCastContext) RP 

func (s *ExprCastContext) RP() antlr.TerminalNode

type ExprConstantContext 

type ExprConstantContext struct {
	ExprContext
}

func NewExprConstantContext 

func NewExprConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprConstantContext

func (*ExprConstantContext) Accept 

func (s *ExprConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprConstantContext) Constant 

func (s *ExprConstantContext) Constant() IConstantContext

func (*ExprConstantContext) GetRuleContext 

func (s *ExprConstantContext) GetRuleContext() antlr.RuleContext

type ExprContext 

type ExprContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExprContext 

func NewEmptyExprContext() *ExprContext

func NewExprContext 

func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext

func (*ExprContext) CopyAll 

func (s *ExprContext) CopyAll(ctx *ExprContext)

func (*ExprContext) GetParser 

func (s *ExprContext) GetParser() antlr.Parser

func (*ExprContext) GetRuleContext 

func (s *ExprContext) GetRuleContext() antlr.RuleContext

func (*ExprContext) IsExprContext 

func (*ExprContext) IsExprContext()

func (*ExprContext) ToStringTree 

func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExprEqualityContext 

type ExprEqualityContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprEqualityContext 

func NewExprEqualityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprEqualityContext

func (*ExprEqualityContext) Accept 

func (s *ExprEqualityContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprEqualityContext) AllExpr 

func (s *ExprEqualityContext) AllExpr() []IExprContext

func (*ExprEqualityContext) EQ 

func (s *ExprEqualityContext) EQ() antlr.TerminalNode

func (*ExprEqualityContext) Expr 

func (s *ExprEqualityContext) Expr(i int) IExprContext

func (*ExprEqualityContext) GetOp 

func (s *ExprEqualityContext) GetOp() antlr.Token

func (*ExprEqualityContext) GetRuleContext 

func (s *ExprEqualityContext) GetRuleContext() antlr.RuleContext

func (*ExprEqualityContext) NE 

func (s *ExprEqualityContext) NE() antlr.TerminalNode

func (*ExprEqualityContext) SetOp 

func (s *ExprEqualityContext) SetOp(v antlr.Token)

type ExprLogicalAndContext 

type ExprLogicalAndContext struct {
	ExprContext
}

func NewExprLogicalAndContext 

func NewExprLogicalAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicalAndContext

func (*ExprLogicalAndContext) AND 

func (s *ExprLogicalAndContext) AND() antlr.TerminalNode

func (*ExprLogicalAndContext) Accept 

func (s *ExprLogicalAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprLogicalAndContext) AllExpr 

func (s *ExprLogicalAndContext) AllExpr() []IExprContext

func (*ExprLogicalAndContext) Expr 

func (s *ExprLogicalAndContext) Expr(i int) IExprContext

func (*ExprLogicalAndContext) GetRuleContext 

func (s *ExprLogicalAndContext) GetRuleContext() antlr.RuleContext

type ExprLogicalOrContext 

type ExprLogicalOrContext struct {
	ExprContext
}

func NewExprLogicalOrContext 

func NewExprLogicalOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprLogicalOrContext

func (*ExprLogicalOrContext) Accept 

func (s *ExprLogicalOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprLogicalOrContext) AllExpr 

func (s *ExprLogicalOrContext) AllExpr() []IExprContext

func (*ExprLogicalOrContext) Expr 

func (s *ExprLogicalOrContext) Expr(i int) IExprContext

func (*ExprLogicalOrContext) GetRuleContext 

func (s *ExprLogicalOrContext) GetRuleContext() antlr.RuleContext

func (*ExprLogicalOrContext) OR 

func (s *ExprLogicalOrContext) OR() antlr.TerminalNode

type ExprMulDivModContext 

type ExprMulDivModContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprMulDivModContext 

func NewExprMulDivModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprMulDivModContext

func (*ExprMulDivModContext) Accept 

func (s *ExprMulDivModContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprMulDivModContext) AllExpr 

func (s *ExprMulDivModContext) AllExpr() []IExprContext

func (*ExprMulDivModContext) DIV 

func (s *ExprMulDivModContext) DIV() antlr.TerminalNode

func (*ExprMulDivModContext) Expr 

func (s *ExprMulDivModContext) Expr(i int) IExprContext

func (*ExprMulDivModContext) GetOp 

func (s *ExprMulDivModContext) GetOp() antlr.Token

func (*ExprMulDivModContext) GetRuleContext 

func (s *ExprMulDivModContext) GetRuleContext() antlr.RuleContext

func (*ExprMulDivModContext) MOD 

func (s *ExprMulDivModContext) MOD() antlr.TerminalNode

func (*ExprMulDivModContext) MUL 

func (s *ExprMulDivModContext) MUL() antlr.TerminalNode

func (*ExprMulDivModContext) SetOp 

func (s *ExprMulDivModContext) SetOp(v antlr.Token)

type ExprParensContext 

type ExprParensContext struct {
	ExprContext
}

func NewExprParensContext 

func NewExprParensContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprParensContext

func (*ExprParensContext) Accept 

func (s *ExprParensContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprParensContext) Expr 

func (s *ExprParensContext) Expr() IExprContext

func (*ExprParensContext) GetRuleContext 

func (s *ExprParensContext) GetRuleContext() antlr.RuleContext

func (*ExprParensContext) LP 

func (s *ExprParensContext) LP() antlr.TerminalNode

func (*ExprParensContext) RP 

func (s *ExprParensContext) RP() antlr.TerminalNode

type ExprPowerContext 

type ExprPowerContext struct {
	ExprContext
}

func NewExprPowerContext 

func NewExprPowerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprPowerContext

func (*ExprPowerContext) Accept 

func (s *ExprPowerContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprPowerContext) AllExpr 

func (s *ExprPowerContext) AllExpr() []IExprContext

func (*ExprPowerContext) Expr 

func (s *ExprPowerContext) Expr(i int) IExprContext

func (*ExprPowerContext) GetRuleContext 

func (s *ExprPowerContext) GetRuleContext() antlr.RuleContext

func (*ExprPowerContext) POW 

func (s *ExprPowerContext) POW() antlr.TerminalNode

type ExprRelationalContext 

type ExprRelationalContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprRelationalContext 

func NewExprRelationalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprRelationalContext

func (*ExprRelationalContext) Accept 

func (s *ExprRelationalContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprRelationalContext) AllExpr 

func (s *ExprRelationalContext) AllExpr() []IExprContext

func (*ExprRelationalContext) Expr 

func (s *ExprRelationalContext) Expr(i int) IExprContext

func (*ExprRelationalContext) GE 

func (s *ExprRelationalContext) GE() antlr.TerminalNode

func (*ExprRelationalContext) GT 

func (s *ExprRelationalContext) GT() antlr.TerminalNode

func (*ExprRelationalContext) GetOp 

func (s *ExprRelationalContext) GetOp() antlr.Token

func (*ExprRelationalContext) GetRuleContext 

func (s *ExprRelationalContext) GetRuleContext() antlr.RuleContext

func (*ExprRelationalContext) LE 

func (s *ExprRelationalContext) LE() antlr.TerminalNode

func (*ExprRelationalContext) LT 

func (s *ExprRelationalContext) LT() antlr.TerminalNode

func (*ExprRelationalContext) SetOp 

func (s *ExprRelationalContext) SetOp(v antlr.Token)

type ExprShiftContext 

type ExprShiftContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprShiftContext 

func NewExprShiftContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprShiftContext

func (*ExprShiftContext) Accept 

func (s *ExprShiftContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprShiftContext) AllExpr 

func (s *ExprShiftContext) AllExpr() []IExprContext

func (*ExprShiftContext) Expr 

func (s *ExprShiftContext) Expr(i int) IExprContext

func (*ExprShiftContext) GetOp 

func (s *ExprShiftContext) GetOp() antlr.Token

func (*ExprShiftContext) GetRuleContext 

func (s *ExprShiftContext) GetRuleContext() antlr.RuleContext

func (*ExprShiftContext) SHL 

func (s *ExprShiftContext) SHL() antlr.TerminalNode

func (*ExprShiftContext) SHR 

func (s *ExprShiftContext) SHR() antlr.TerminalNode

func (*ExprShiftContext) SetOp 

func (s *ExprShiftContext) SetOp(v antlr.Token)

type ExprTernaryContext 

type ExprTernaryContext struct {
	ExprContext
}

func NewExprTernaryContext 

func NewExprTernaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprTernaryContext

func (*ExprTernaryContext) Accept 

func (s *ExprTernaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprTernaryContext) AllExpr 

func (s *ExprTernaryContext) AllExpr() []IExprContext

func (*ExprTernaryContext) COLON 

func (s *ExprTernaryContext) COLON() antlr.TerminalNode

func (*ExprTernaryContext) Expr 

func (s *ExprTernaryContext) Expr(i int) IExprContext

func (*ExprTernaryContext) GetRuleContext 

func (s *ExprTernaryContext) GetRuleContext() antlr.RuleContext

func (*ExprTernaryContext) QUESTION 

func (s *ExprTernaryContext) QUESTION() antlr.TerminalNode

type ExprUnaryContext 

type ExprUnaryContext struct {
	ExprContext
	// contains filtered or unexported fields
}

func NewExprUnaryContext 

func NewExprUnaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprUnaryContext

func (*ExprUnaryContext) ADD 

func (s *ExprUnaryContext) ADD() antlr.TerminalNode

func (*ExprUnaryContext) Accept 

func (s *ExprUnaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprUnaryContext) BNOT 

func (s *ExprUnaryContext) BNOT() antlr.TerminalNode

func (*ExprUnaryContext) Expr 

func (s *ExprUnaryContext) Expr() IExprContext

func (*ExprUnaryContext) GetOp 

func (s *ExprUnaryContext) GetOp() antlr.Token

func (*ExprUnaryContext) GetRuleContext 

func (s *ExprUnaryContext) GetRuleContext() antlr.RuleContext

func (*ExprUnaryContext) NOT 

func (s *ExprUnaryContext) NOT() antlr.TerminalNode

func (*ExprUnaryContext) SUB 

func (s *ExprUnaryContext) SUB() antlr.TerminalNode

func (*ExprUnaryContext) SetOp 

func (s *ExprUnaryContext) SetOp(v antlr.Token)

type ExprValueContext 

type ExprValueContext struct {
	ExprContext
}

func NewExprValueContext 

func NewExprValueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprValueContext

func (*ExprValueContext) Accept 

func (s *ExprValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExprValueContext) GetRuleContext 

func (s *ExprValueContext) GetRuleContext() antlr.RuleContext

func (*ExprValueContext) Value 

func (s *ExprValueContext) Value() IValueContext

type FieldConstantContext 

type FieldConstantContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldConstantContext 

func NewEmptyFieldConstantContext() *FieldConstantContext

func NewFieldConstantContext 

func NewFieldConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldConstantContext

func (*FieldConstantContext) ASSIGN 

func (s *FieldConstantContext) ASSIGN() antlr.TerminalNode

func (*FieldConstantContext) Accept 

func (s *FieldConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldConstantContext) BasicType 

func (s *FieldConstantContext) BasicType() IBasicTypeContext

func (*FieldConstantContext) Constant 

func (s *FieldConstantContext) Constant() IConstantContext

func (*FieldConstantContext) FieldName 

func (s *FieldConstantContext) FieldName() IFieldNameContext

func (*FieldConstantContext) FieldOptions 

func (s *FieldConstantContext) FieldOptions() IFieldOptionsContext

func (*FieldConstantContext) GetParser 

func (s *FieldConstantContext) GetParser() antlr.Parser

func (*FieldConstantContext) GetRuleContext 

func (s *FieldConstantContext) GetRuleContext() antlr.RuleContext

func (*FieldConstantContext) IsFieldConstantContext 

func (*FieldConstantContext) IsFieldConstantContext()

func (*FieldConstantContext) SEMI 

func (s *FieldConstantContext) SEMI() antlr.TerminalNode

func (*FieldConstantContext) Size_ 

func (s *FieldConstantContext) Size_() ISize_Context

func (*FieldConstantContext) ToStringTree 

func (s *FieldConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FieldContext 

type FieldContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldContext 

func NewEmptyFieldContext() *FieldContext

func NewFieldContext 

func NewFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldContext

func (*FieldContext) Accept 

func (s *FieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldContext) FieldConstant 

func (s *FieldContext) FieldConstant() IFieldConstantContext

func (*FieldContext) FieldEmbedded 

func (s *FieldContext) FieldEmbedded() IFieldEmbeddedContext

func (*FieldContext) FieldNormal 

func (s *FieldContext) FieldNormal() IFieldNormalContext

func (*FieldContext) FieldVoid 

func (s *FieldContext) FieldVoid() IFieldVoidContext

func (*FieldContext) GetParser 

func (s *FieldContext) GetParser() antlr.Parser

func (*FieldContext) GetRuleContext 

func (s *FieldContext) GetRuleContext() antlr.RuleContext

func (*FieldContext) IsFieldContext 

func (*FieldContext) IsFieldContext()

func (*FieldContext) ToStringTree 

func (s *FieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FieldEmbeddedContext 

type FieldEmbeddedContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldEmbeddedContext 

func NewEmptyFieldEmbeddedContext() *FieldEmbeddedContext

func NewFieldEmbeddedContext 

func NewFieldEmbeddedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldEmbeddedContext

func (*FieldEmbeddedContext) Accept 

func (s *FieldEmbeddedContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldEmbeddedContext) FieldOptions 

func (s *FieldEmbeddedContext) FieldOptions() IFieldOptionsContext

func (*FieldEmbeddedContext) GetParser 

func (s *FieldEmbeddedContext) GetParser() antlr.Parser

func (*FieldEmbeddedContext) GetRuleContext 

func (s *FieldEmbeddedContext) GetRuleContext() antlr.RuleContext

func (*FieldEmbeddedContext) IsFieldEmbeddedContext 

func (*FieldEmbeddedContext) IsFieldEmbeddedContext()

func (*FieldEmbeddedContext) SEMI 

func (s *FieldEmbeddedContext) SEMI() antlr.TerminalNode

func (*FieldEmbeddedContext) ToStringTree 

func (s *FieldEmbeddedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FieldEmbeddedContext) Type_ 

func (s *FieldEmbeddedContext) Type_() IType_Context

type FieldMethodContext 

type FieldMethodContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldMethodContext 

func NewEmptyFieldMethodContext() *FieldMethodContext

func NewFieldMethodContext 

func NewFieldMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldMethodContext

func (*FieldMethodContext) Accept 

func (s *FieldMethodContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldMethodContext) BasicType 

func (s *FieldMethodContext) BasicType() IBasicTypeContext

func (*FieldMethodContext) COLON 

func (s *FieldMethodContext) COLON() antlr.TerminalNode

func (*FieldMethodContext) Expr 

func (s *FieldMethodContext) Expr() IExprContext

func (*FieldMethodContext) GET 

func (s *FieldMethodContext) GET() antlr.TerminalNode

func (*FieldMethodContext) GetOp 

func (s *FieldMethodContext) GetOp() antlr.Token

func (*FieldMethodContext) GetParser 

func (s *FieldMethodContext) GetParser() antlr.Parser

func (*FieldMethodContext) GetRuleContext 

func (s *FieldMethodContext) GetRuleContext() antlr.RuleContext

func (*FieldMethodContext) IsFieldMethodContext 

func (*FieldMethodContext) IsFieldMethodContext()

func (*FieldMethodContext) LP 

func (s *FieldMethodContext) LP() antlr.TerminalNode

func (*FieldMethodContext) MethodName 

func (s *FieldMethodContext) MethodName() IMethodNameContext

func (*FieldMethodContext) RP 

func (s *FieldMethodContext) RP() antlr.TerminalNode

func (*FieldMethodContext) SEMI 

func (s *FieldMethodContext) SEMI() antlr.TerminalNode

func (*FieldMethodContext) SET 

func (s *FieldMethodContext) SET() antlr.TerminalNode

func (*FieldMethodContext) SetOp 

func (s *FieldMethodContext) SetOp(v antlr.Token)

func (*FieldMethodContext) ToStringTree 

func (s *FieldMethodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FieldMethodsContext 

type FieldMethodsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldMethodsContext 

func NewEmptyFieldMethodsContext() *FieldMethodsContext

func NewFieldMethodsContext 

func NewFieldMethodsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldMethodsContext

func (*FieldMethodsContext) Accept 

func (s *FieldMethodsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldMethodsContext) AllFieldMethod 

func (s *FieldMethodsContext) AllFieldMethod() []IFieldMethodContext

func (*FieldMethodsContext) FieldMethod 

func (s *FieldMethodsContext) FieldMethod(i int) IFieldMethodContext

func (*FieldMethodsContext) GetParser 

func (s *FieldMethodsContext) GetParser() antlr.Parser

func (*FieldMethodsContext) GetRuleContext 

func (s *FieldMethodsContext) GetRuleContext() antlr.RuleContext

func (*FieldMethodsContext) IsFieldMethodsContext 

func (*FieldMethodsContext) IsFieldMethodsContext()

func (*FieldMethodsContext) LC 

func (s *FieldMethodsContext) LC() antlr.TerminalNode

func (*FieldMethodsContext) RC 

func (s *FieldMethodsContext) RC() antlr.TerminalNode

func (*FieldMethodsContext) ToStringTree 

func (s *FieldMethodsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FieldNameContext 

type FieldNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldNameContext 

func NewEmptyFieldNameContext() *FieldNameContext

func NewFieldNameContext 

func NewFieldNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldNameContext

func (*FieldNameContext) Accept 

func (s *FieldNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldNameContext) GetParser 

func (s *FieldNameContext) GetParser() antlr.Parser

func (*FieldNameContext) GetRuleContext 

func (s *FieldNameContext) GetRuleContext() antlr.RuleContext

func (*FieldNameContext) Ident 

func (s *FieldNameContext) Ident() IIdentContext

func (*FieldNameContext) IsFieldNameContext 

func (*FieldNameContext) IsFieldNameContext()

func (*FieldNameContext) ToStringTree 

func (s *FieldNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FieldNormalContext 

type FieldNormalContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldNormalContext 

func NewEmptyFieldNormalContext() *FieldNormalContext

func NewFieldNormalContext 

func NewFieldNormalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldNormalContext

func (*FieldNormalContext) Accept 

func (s *FieldNormalContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldNormalContext) FieldMethods 

func (s *FieldNormalContext) FieldMethods() IFieldMethodsContext

func (*FieldNormalContext) FieldName 

func (s *FieldNormalContext) FieldName() IFieldNameContext

func (*FieldNormalContext) FieldOptions 

func (s *FieldNormalContext) FieldOptions() IFieldOptionsContext

func (*FieldNormalContext) GetParser 

func (s *FieldNormalContext) GetParser() antlr.Parser

func (*FieldNormalContext) GetRuleContext 

func (s *FieldNormalContext) GetRuleContext() antlr.RuleContext

func (*FieldNormalContext) IsFieldNormalContext 

func (*FieldNormalContext) IsFieldNormalContext()

func (*FieldNormalContext) SEMI 

func (s *FieldNormalContext) SEMI() antlr.TerminalNode

func (*FieldNormalContext) Size_ 

func (s *FieldNormalContext) Size_() ISize_Context

func (*FieldNormalContext) ToStringTree 

func (s *FieldNormalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FieldNormalContext) Type_ 

func (s *FieldNormalContext) Type_() IType_Context

type FieldOptionContext 

type FieldOptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldOptionContext 

func NewEmptyFieldOptionContext() *FieldOptionContext

func NewFieldOptionContext 

func NewFieldOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldOptionContext

func (*FieldOptionContext) ASSIGN 

func (s *FieldOptionContext) ASSIGN() antlr.TerminalNode

func (*FieldOptionContext) Accept 

func (s *FieldOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldOptionContext) Constant 

func (s *FieldOptionContext) Constant() IConstantContext

func (*FieldOptionContext) GetParser 

func (s *FieldOptionContext) GetParser() antlr.Parser

func (*FieldOptionContext) GetRuleContext 

func (s *FieldOptionContext) GetRuleContext() antlr.RuleContext

func (*FieldOptionContext) IsFieldOptionContext 

func (*FieldOptionContext) IsFieldOptionContext()

func (*FieldOptionContext) OptionName 

func (s *FieldOptionContext) OptionName() IOptionNameContext

func (*FieldOptionContext) ToStringTree 

func (s *FieldOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FieldOptionsContext 

type FieldOptionsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldOptionsContext 

func NewEmptyFieldOptionsContext() *FieldOptionsContext

func NewFieldOptionsContext 

func NewFieldOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldOptionsContext

func (*FieldOptionsContext) Accept 

func (s *FieldOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldOptionsContext) AllCOMMA 

func (s *FieldOptionsContext) AllCOMMA() []antlr.TerminalNode

func (*FieldOptionsContext) AllFieldOption 

func (s *FieldOptionsContext) AllFieldOption() []IFieldOptionContext

func (*FieldOptionsContext) COMMA 

func (s *FieldOptionsContext) COMMA(i int) antlr.TerminalNode

func (*FieldOptionsContext) FieldOption 

func (s *FieldOptionsContext) FieldOption(i int) IFieldOptionContext

func (*FieldOptionsContext) GetParser 

func (s *FieldOptionsContext) GetParser() antlr.Parser

func (*FieldOptionsContext) GetRuleContext 

func (s *FieldOptionsContext) GetRuleContext() antlr.RuleContext

func (*FieldOptionsContext) IsFieldOptionsContext 

func (*FieldOptionsContext) IsFieldOptionsContext()

func (*FieldOptionsContext) LB 

func (s *FieldOptionsContext) LB() antlr.TerminalNode

func (*FieldOptionsContext) RB 

func (s *FieldOptionsContext) RB() antlr.TerminalNode

func (*FieldOptionsContext) ToStringTree 

func (s *FieldOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FieldVoidContext 

type FieldVoidContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldVoidContext 

func NewEmptyFieldVoidContext() *FieldVoidContext

func NewFieldVoidContext 

func NewFieldVoidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldVoidContext

func (*FieldVoidContext) Accept 

func (s *FieldVoidContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldVoidContext) FieldOptions 

func (s *FieldVoidContext) FieldOptions() IFieldOptionsContext

func (*FieldVoidContext) GetParser 

func (s *FieldVoidContext) GetParser() antlr.Parser

func (*FieldVoidContext) GetRuleContext 

func (s *FieldVoidContext) GetRuleContext() antlr.RuleContext

func (*FieldVoidContext) IsFieldVoidContext 

func (*FieldVoidContext) IsFieldVoidContext()

func (*FieldVoidContext) SEMI 

func (s *FieldVoidContext) SEMI() antlr.TerminalNode

func (*FieldVoidContext) Size_ 

func (s *FieldVoidContext) Size_() ISize_Context

func (*FieldVoidContext) ToStringTree 

func (s *FieldVoidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FieldVoidContext) VOID 

func (s *FieldVoidContext) VOID() antlr.TerminalNode

type FloatLitContext 

type FloatLitContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFloatLitContext 

func NewEmptyFloatLitContext() *FloatLitContext

func NewFloatLitContext 

func NewFloatLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatLitContext

func (*FloatLitContext) Accept 

func (s *FloatLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FloatLitContext) FLOAT_LIT 

func (s *FloatLitContext) FLOAT_LIT() antlr.TerminalNode

func (*FloatLitContext) GetParser 

func (s *FloatLitContext) GetParser() antlr.Parser

func (*FloatLitContext) GetRuleContext 

func (s *FloatLitContext) GetRuleContext() antlr.RuleContext

func (*FloatLitContext) IsFloatLitContext 

func (*FloatLitContext) IsFloatLitContext()

func (*FloatLitContext) ToStringTree 

func (s *FloatLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FullIdentContext 

type FullIdentContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFullIdentContext 

func NewEmptyFullIdentContext() *FullIdentContext

func NewFullIdentContext 

func NewFullIdentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullIdentContext

func (*FullIdentContext) Accept 

func (s *FullIdentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FullIdentContext) AllDOT 

func (s *FullIdentContext) AllDOT() []antlr.TerminalNode

func (*FullIdentContext) AllIdent 

func (s *FullIdentContext) AllIdent() []IIdentContext

func (*FullIdentContext) DOT 

func (s *FullIdentContext) DOT(i int) antlr.TerminalNode

func (*FullIdentContext) GetParser 

func (s *FullIdentContext) GetParser() antlr.Parser

func (*FullIdentContext) GetRuleContext 

func (s *FullIdentContext) GetRuleContext() antlr.RuleContext

func (*FullIdentContext) Ident 

func (s *FullIdentContext) Ident(i int) IIdentContext

func (*FullIdentContext) IsFullIdentContext 

func (*FullIdentContext) IsFullIdentContext()

func (*FullIdentContext) ToStringTree 

func (s *FullIdentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IArrayElementTypeContext 

type IArrayElementTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BasicType() IBasicTypeContext
	STRING() antlr.TerminalNode
	BYTES() antlr.TerminalNode
	StructType() IStructTypeContext
	EnumType() IEnumTypeContext
	Ident() IIdentContext

	// IsArrayElementTypeContext differentiates from other interfaces.
	IsArrayElementTypeContext()
}

IArrayElementTypeContext is an interface to support dynamic dispatch.

type IArrayTypeContext 

type IArrayTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ArrayElementType() IArrayElementTypeContext
	LT() antlr.TerminalNode
	IntLit() IIntLitContext
	GT() antlr.TerminalNode

	// IsArrayTypeContext differentiates from other interfaces.
	IsArrayTypeContext()
}

IArrayTypeContext is an interface to support dynamic dispatch.

type IBasicTypeContext 

type IBasicTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BOOL() antlr.TerminalNode
	INT8() antlr.TerminalNode
	INT16() antlr.TerminalNode
	INT32() antlr.TerminalNode
	INT64() antlr.TerminalNode
	UINT8() antlr.TerminalNode
	UINT16() antlr.TerminalNode
	UINT32() antlr.TerminalNode
	UINT64() antlr.TerminalNode
	FLOAT32() antlr.TerminalNode
	FLOAT64() antlr.TerminalNode

	// IsBasicTypeContext differentiates from other interfaces.
	IsBasicTypeContext()
}

IBasicTypeContext is an interface to support dynamic dispatch.

type IBitSizeContext 

type IBitSizeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IntLit() IIntLitContext

	// IsBitSizeContext differentiates from other interfaces.
	IsBitSizeContext()
}

IBitSizeContext is an interface to support dynamic dispatch.

type IBoolLitContext 

type IBoolLitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BOOL_LIT() antlr.TerminalNode

	// IsBoolLitContext differentiates from other interfaces.
	IsBoolLitContext()
}

IBoolLitContext is an interface to support dynamic dispatch.

type IByteSizeContext 

type IByteSizeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IntLit() IIntLitContext

	// IsByteSizeContext differentiates from other interfaces.
	IsByteSizeContext()
}

IByteSizeContext is an interface to support dynamic dispatch.

type IConstantContext 

type IConstantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IntLit() IIntLitContext
	SUB() antlr.TerminalNode
	ADD() antlr.TerminalNode
	FloatLit() IFloatLitContext
	StrLit() IStrLitContext
	BoolLit() IBoolLitContext

	// IsConstantContext differentiates from other interfaces.
	IsConstantContext()
}

IConstantContext is an interface to support dynamic dispatch.

type IEmptyStatement_Context 

type IEmptyStatement_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SEMI() antlr.TerminalNode

	// IsEmptyStatement_Context differentiates from other interfaces.
	IsEmptyStatement_Context()
}

IEmptyStatement_Context is an interface to support dynamic dispatch.

type IEnumBodyContext 

type IEnumBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LC() antlr.TerminalNode
	RC() antlr.TerminalNode
	AllEnumElement() []IEnumElementContext
	EnumElement(i int) IEnumElementContext

	// IsEnumBodyContext differentiates from other interfaces.
	IsEnumBodyContext()
}

IEnumBodyContext is an interface to support dynamic dispatch.

type IEnumDefContext 

type IEnumDefContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EnumName() IEnumNameContext
	Size_() ISize_Context
	EnumBody() IEnumBodyContext

	// IsEnumDefContext differentiates from other interfaces.
	IsEnumDefContext()
}

IEnumDefContext is an interface to support dynamic dispatch.

type IEnumElementContext 

type IEnumElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EnumValue() IEnumValueContext
	EmptyStatement_() IEmptyStatement_Context

	// IsEnumElementContext differentiates from other interfaces.
	IsEnumElementContext()
}

IEnumElementContext is an interface to support dynamic dispatch.

type IEnumNameContext 

type IEnumNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ENUM() antlr.TerminalNode
	Ident() IIdentContext

	// IsEnumNameContext differentiates from other interfaces.
	IsEnumNameContext()
}

IEnumNameContext is an interface to support dynamic dispatch.

type IEnumTypeContext 

type IEnumTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EnumName() IEnumNameContext

	// IsEnumTypeContext differentiates from other interfaces.
	IsEnumTypeContext()
}

IEnumTypeContext is an interface to support dynamic dispatch.

type IEnumValueContext 

type IEnumValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EnumValueName() IEnumValueNameContext
	SEMI() antlr.TerminalNode
	COMMA() antlr.TerminalNode
	ASSIGN() antlr.TerminalNode
	Constant() IConstantContext
	EnumValueOptions() IEnumValueOptionsContext

	// IsEnumValueContext differentiates from other interfaces.
	IsEnumValueContext()
}

IEnumValueContext is an interface to support dynamic dispatch.

type IEnumValueNameContext 

type IEnumValueNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Ident() IIdentContext

	// IsEnumValueNameContext differentiates from other interfaces.
	IsEnumValueNameContext()
}

IEnumValueNameContext is an interface to support dynamic dispatch.

type IEnumValueOptionContext 

type IEnumValueOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OptionName() IOptionNameContext
	ASSIGN() antlr.TerminalNode
	Constant() IConstantContext

	// IsEnumValueOptionContext differentiates from other interfaces.
	IsEnumValueOptionContext()
}

IEnumValueOptionContext is an interface to support dynamic dispatch.

type IEnumValueOptionsContext 

type IEnumValueOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LB() antlr.TerminalNode
	AllEnumValueOption() []IEnumValueOptionContext
	EnumValueOption(i int) IEnumValueOptionContext
	RB() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsEnumValueOptionsContext differentiates from other interfaces.
	IsEnumValueOptionsContext()
}

IEnumValueOptionsContext is an interface to support dynamic dispatch.

type IExprContext 

type IExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsExprContext differentiates from other interfaces.
	IsExprContext()
}

IExprContext is an interface to support dynamic dispatch.

type IFieldConstantContext 

type IFieldConstantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BasicType() IBasicTypeContext
	ASSIGN() antlr.TerminalNode
	Constant() IConstantContext
	SEMI() antlr.TerminalNode
	FieldName() IFieldNameContext
	Size_() ISize_Context
	FieldOptions() IFieldOptionsContext

	// IsFieldConstantContext differentiates from other interfaces.
	IsFieldConstantContext()
}

IFieldConstantContext is an interface to support dynamic dispatch.

type IFieldContext 

type IFieldContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FieldVoid() IFieldVoidContext
	FieldConstant() IFieldConstantContext
	FieldEmbedded() IFieldEmbeddedContext
	FieldNormal() IFieldNormalContext

	// IsFieldContext differentiates from other interfaces.
	IsFieldContext()
}

IFieldContext is an interface to support dynamic dispatch.

type IFieldEmbeddedContext 

type IFieldEmbeddedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Type_() IType_Context
	SEMI() antlr.TerminalNode
	FieldOptions() IFieldOptionsContext

	// IsFieldEmbeddedContext differentiates from other interfaces.
	IsFieldEmbeddedContext()
}

IFieldEmbeddedContext is an interface to support dynamic dispatch.

type IFieldMethodContext 

type IFieldMethodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOp returns the op token.
	GetOp() antlr.Token

	// SetOp sets the op token.
	SetOp(antlr.Token)

	// Getter signatures
	LP() antlr.TerminalNode
	BasicType() IBasicTypeContext
	RP() antlr.TerminalNode
	COLON() antlr.TerminalNode
	Expr() IExprContext
	SEMI() antlr.TerminalNode
	GET() antlr.TerminalNode
	SET() antlr.TerminalNode
	MethodName() IMethodNameContext

	// IsFieldMethodContext differentiates from other interfaces.
	IsFieldMethodContext()
}

IFieldMethodContext is an interface to support dynamic dispatch.

type IFieldMethodsContext 

type IFieldMethodsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LC() antlr.TerminalNode
	RC() antlr.TerminalNode
	AllFieldMethod() []IFieldMethodContext
	FieldMethod(i int) IFieldMethodContext

	// IsFieldMethodsContext differentiates from other interfaces.
	IsFieldMethodsContext()
}

IFieldMethodsContext is an interface to support dynamic dispatch.

type IFieldNameContext 

type IFieldNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Ident() IIdentContext

	// IsFieldNameContext differentiates from other interfaces.
	IsFieldNameContext()
}

IFieldNameContext is an interface to support dynamic dispatch.

type IFieldNormalContext 

type IFieldNormalContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Type_() IType_Context
	FieldName() IFieldNameContext
	SEMI() antlr.TerminalNode
	Size_() ISize_Context
	FieldOptions() IFieldOptionsContext
	FieldMethods() IFieldMethodsContext

	// IsFieldNormalContext differentiates from other interfaces.
	IsFieldNormalContext()
}

IFieldNormalContext is an interface to support dynamic dispatch.

type IFieldOptionContext 

type IFieldOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OptionName() IOptionNameContext
	ASSIGN() antlr.TerminalNode
	Constant() IConstantContext

	// IsFieldOptionContext differentiates from other interfaces.
	IsFieldOptionContext()
}

IFieldOptionContext is an interface to support dynamic dispatch.

type IFieldOptionsContext 

type IFieldOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LB() antlr.TerminalNode
	AllFieldOption() []IFieldOptionContext
	FieldOption(i int) IFieldOptionContext
	RB() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFieldOptionsContext differentiates from other interfaces.
	IsFieldOptionsContext()
}

IFieldOptionsContext is an interface to support dynamic dispatch.

type IFieldVoidContext 

type IFieldVoidContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VOID() antlr.TerminalNode
	Size_() ISize_Context
	SEMI() antlr.TerminalNode
	FieldOptions() IFieldOptionsContext

	// IsFieldVoidContext differentiates from other interfaces.
	IsFieldVoidContext()
}

IFieldVoidContext is an interface to support dynamic dispatch.

type IFloatLitContext 

type IFloatLitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FLOAT_LIT() antlr.TerminalNode

	// IsFloatLitContext differentiates from other interfaces.
	IsFloatLitContext()
}

IFloatLitContext is an interface to support dynamic dispatch.

type IFullIdentContext 

type IFullIdentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIdent() []IIdentContext
	Ident(i int) IIdentContext
	AllDOT() []antlr.TerminalNode
	DOT(i int) antlr.TerminalNode

	// IsFullIdentContext differentiates from other interfaces.
	IsFullIdentContext()
}

IFullIdentContext is an interface to support dynamic dispatch.

type IIdentContext 

type IIdentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IDENTIFIER() antlr.TerminalNode

	// IsIdentContext differentiates from other interfaces.
	IsIdentContext()
}

IIdentContext is an interface to support dynamic dispatch.

type IImportStatementContext 

type IImportStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IMPORT() antlr.TerminalNode
	StrLit() IStrLitContext
	SEMI() antlr.TerminalNode

	// IsImportStatementContext differentiates from other interfaces.
	IsImportStatementContext()
}

IImportStatementContext is an interface to support dynamic dispatch.

type IIntLitContext 

type IIntLitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INT_LIT() antlr.TerminalNode

	// IsIntLitContext differentiates from other interfaces.
	IsIntLitContext()
}

IIntLitContext is an interface to support dynamic dispatch.

type IMethodNameContext 

type IMethodNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Ident() IIdentContext

	// IsMethodNameContext differentiates from other interfaces.
	IsMethodNameContext()
}

IMethodNameContext is an interface to support dynamic dispatch.

type IOptionNameContext 

type IOptionNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Ident() IIdentContext

	// IsOptionNameContext differentiates from other interfaces.
	IsOptionNameContext()
}

IOptionNameContext is an interface to support dynamic dispatch.

type IOptionStatementContext 

type IOptionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTION() antlr.TerminalNode
	OptionName() IOptionNameContext
	ASSIGN() antlr.TerminalNode
	Constant() IConstantContext
	SEMI() antlr.TerminalNode

	// IsOptionStatementContext differentiates from other interfaces.
	IsOptionStatementContext()
}

IOptionStatementContext is an interface to support dynamic dispatch.

type IPackageStatementContext 

type IPackageStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PACKAGE() antlr.TerminalNode
	FullIdent() IFullIdentContext
	SEMI() antlr.TerminalNode

	// IsPackageStatementContext differentiates from other interfaces.
	IsPackageStatementContext()
}

IPackageStatementContext is an interface to support dynamic dispatch.

type IProtoContext 

type IProtoContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EOF() antlr.TerminalNode
	AllImportStatement() []IImportStatementContext
	ImportStatement(i int) IImportStatementContext
	AllPackageStatement() []IPackageStatementContext
	PackageStatement(i int) IPackageStatementContext
	AllOptionStatement() []IOptionStatementContext
	OptionStatement(i int) IOptionStatementContext
	AllTopLevelDef() []ITopLevelDefContext
	TopLevelDef(i int) ITopLevelDefContext
	AllEmptyStatement_() []IEmptyStatement_Context
	EmptyStatement_(i int) IEmptyStatement_Context

	// IsProtoContext differentiates from other interfaces.
	IsProtoContext()
}

IProtoContext is an interface to support dynamic dispatch.

type ISize_Context 

type ISize_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LB() antlr.TerminalNode
	RB() antlr.TerminalNode
	ByteSize() IByteSizeContext
	HASH() antlr.TerminalNode
	BitSize() IBitSizeContext

	// IsSize_Context differentiates from other interfaces.
	IsSize_Context()
}

ISize_Context is an interface to support dynamic dispatch.

type IStrLitContext 

type IStrLitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	STR_LIT() antlr.TerminalNode

	// IsStrLitContext differentiates from other interfaces.
	IsStrLitContext()
}

IStrLitContext is an interface to support dynamic dispatch.

type IStructBodyContext 

type IStructBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LC() antlr.TerminalNode
	RC() antlr.TerminalNode
	AllStructElement() []IStructElementContext
	StructElement(i int) IStructElementContext

	// IsStructBodyContext differentiates from other interfaces.
	IsStructBodyContext()
}

IStructBodyContext is an interface to support dynamic dispatch.

type IStructDefContext 

type IStructDefContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	StructName() IStructNameContext
	StructBody() IStructBodyContext
	Size_() ISize_Context

	// IsStructDefContext differentiates from other interfaces.
	IsStructDefContext()
}

IStructDefContext is an interface to support dynamic dispatch.

type IStructElementContext 

type IStructElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Field() IFieldContext
	EmptyStatement_() IEmptyStatement_Context

	// IsStructElementContext differentiates from other interfaces.
	IsStructElementContext()
}

IStructElementContext is an interface to support dynamic dispatch.

type IStructNameContext 

type IStructNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	STRUCT() antlr.TerminalNode
	Ident() IIdentContext

	// IsStructNameContext differentiates from other interfaces.
	IsStructNameContext()
}

IStructNameContext is an interface to support dynamic dispatch.

type IStructTypeContext 

type IStructTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	StructName() IStructNameContext
	StructDef() IStructDefContext

	// IsStructTypeContext differentiates from other interfaces.
	IsStructTypeContext()
}

IStructTypeContext is an interface to support dynamic dispatch.

type ITopLevelDefContext 

type ITopLevelDefContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EnumDef() IEnumDefContext
	StructDef() IStructDefContext

	// IsTopLevelDefContext differentiates from other interfaces.
	IsTopLevelDefContext()
}

ITopLevelDefContext is an interface to support dynamic dispatch.

type IType_Context 

type IType_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BasicType() IBasicTypeContext
	STRING() antlr.TerminalNode
	BYTES() antlr.TerminalNode
	ArrayType() IArrayTypeContext
	StructType() IStructTypeContext
	EnumType() IEnumTypeContext
	Ident() IIdentContext

	// IsType_Context differentiates from other interfaces.
	IsType_Context()
}

IType_Context is an interface to support dynamic dispatch.

type IValueContext 

type IValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VALUE() antlr.TerminalNode

	// IsValueContext differentiates from other interfaces.
	IsValueContext()
}

IValueContext is an interface to support dynamic dispatch.

type IdentContext 

type IdentContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIdentContext 

func NewEmptyIdentContext() *IdentContext

func NewIdentContext 

func NewIdentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentContext

func (*IdentContext) Accept 

func (s *IdentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IdentContext) GetParser 

func (s *IdentContext) GetParser() antlr.Parser

func (*IdentContext) GetRuleContext 

func (s *IdentContext) GetRuleContext() antlr.RuleContext

func (*IdentContext) IDENTIFIER 

func (s *IdentContext) IDENTIFIER() antlr.TerminalNode

func (*IdentContext) IsIdentContext 

func (*IdentContext) IsIdentContext()

func (*IdentContext) ToStringTree 

func (s *IdentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ImportStatementContext 

type ImportStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportStatementContext 

func NewEmptyImportStatementContext() *ImportStatementContext

func NewImportStatementContext 

func NewImportStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportStatementContext

func (*ImportStatementContext) Accept 

func (s *ImportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportStatementContext) GetParser 

func (s *ImportStatementContext) GetParser() antlr.Parser

func (*ImportStatementContext) GetRuleContext 

func (s *ImportStatementContext) GetRuleContext() antlr.RuleContext

func (*ImportStatementContext) IMPORT 

func (s *ImportStatementContext) IMPORT() antlr.TerminalNode

func (*ImportStatementContext) IsImportStatementContext 

func (*ImportStatementContext) IsImportStatementContext()

func (*ImportStatementContext) SEMI 

func (s *ImportStatementContext) SEMI() antlr.TerminalNode

func (*ImportStatementContext) StrLit 

func (s *ImportStatementContext) StrLit() IStrLitContext

func (*ImportStatementContext) ToStringTree 

func (s *ImportStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IntLitContext 

type IntLitContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIntLitContext 

func NewEmptyIntLitContext() *IntLitContext

func NewIntLitContext 

func NewIntLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntLitContext

func (*IntLitContext) Accept 

func (s *IntLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IntLitContext) GetParser 

func (s *IntLitContext) GetParser() antlr.Parser

func (*IntLitContext) GetRuleContext 

func (s *IntLitContext) GetRuleContext() antlr.RuleContext

func (*IntLitContext) INT_LIT 

func (s *IntLitContext) INT_LIT() antlr.TerminalNode

func (*IntLitContext) IsIntLitContext 

func (*IntLitContext) IsIntLitContext()

func (*IntLitContext) ToStringTree 

func (s *IntLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type MethodNameContext 

type MethodNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMethodNameContext 

func NewEmptyMethodNameContext() *MethodNameContext

func NewMethodNameContext 

func NewMethodNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodNameContext

func (*MethodNameContext) Accept 

func (s *MethodNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MethodNameContext) GetParser 

func (s *MethodNameContext) GetParser() antlr.Parser

func (*MethodNameContext) GetRuleContext 

func (s *MethodNameContext) GetRuleContext() antlr.RuleContext

func (*MethodNameContext) Ident 

func (s *MethodNameContext) Ident() IIdentContext

func (*MethodNameContext) IsMethodNameContext 

func (*MethodNameContext) IsMethodNameContext()

func (*MethodNameContext) ToStringTree 

func (s *MethodNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OptionNameContext 

type OptionNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOptionNameContext 

func NewEmptyOptionNameContext() *OptionNameContext

func NewOptionNameContext 

func NewOptionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionNameContext

func (*OptionNameContext) Accept 

func (s *OptionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OptionNameContext) GetParser 

func (s *OptionNameContext) GetParser() antlr.Parser

func (*OptionNameContext) GetRuleContext 

func (s *OptionNameContext) GetRuleContext() antlr.RuleContext

func (*OptionNameContext) Ident 

func (s *OptionNameContext) Ident() IIdentContext

func (*OptionNameContext) IsOptionNameContext 

func (*OptionNameContext) IsOptionNameContext()

func (*OptionNameContext) ToStringTree 

func (s *OptionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OptionStatementContext 

type OptionStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOptionStatementContext 

func NewEmptyOptionStatementContext() *OptionStatementContext

func NewOptionStatementContext 

func NewOptionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionStatementContext

func (*OptionStatementContext) ASSIGN 

func (s *OptionStatementContext) ASSIGN() antlr.TerminalNode

func (*OptionStatementContext) Accept 

func (s *OptionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OptionStatementContext) Constant 

func (s *OptionStatementContext) Constant() IConstantContext

func (*OptionStatementContext) GetParser 

func (s *OptionStatementContext) GetParser() antlr.Parser

func (*OptionStatementContext) GetRuleContext 

func (s *OptionStatementContext) GetRuleContext() antlr.RuleContext

func (*OptionStatementContext) IsOptionStatementContext 

func (*OptionStatementContext) IsOptionStatementContext()

func (*OptionStatementContext) OPTION 

func (s *OptionStatementContext) OPTION() antlr.TerminalNode

func (*OptionStatementContext) OptionName 

func (s *OptionStatementContext) OptionName() IOptionNameContext

func (*OptionStatementContext) SEMI 

func (s *OptionStatementContext) SEMI() antlr.TerminalNode

func (*OptionStatementContext) ToStringTree 

func (s *OptionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PackageStatementContext 

type PackageStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPackageStatementContext 

func NewEmptyPackageStatementContext() *PackageStatementContext

func NewPackageStatementContext 

func NewPackageStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PackageStatementContext

func (*PackageStatementContext) Accept 

func (s *PackageStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PackageStatementContext) FullIdent 

func (s *PackageStatementContext) FullIdent() IFullIdentContext

func (*PackageStatementContext) GetParser 

func (s *PackageStatementContext) GetParser() antlr.Parser

func (*PackageStatementContext) GetRuleContext 

func (s *PackageStatementContext) GetRuleContext() antlr.RuleContext

func (*PackageStatementContext) IsPackageStatementContext 

func (*PackageStatementContext) IsPackageStatementContext()

func (*PackageStatementContext) PACKAGE 

func (s *PackageStatementContext) PACKAGE() antlr.TerminalNode

func (*PackageStatementContext) SEMI 

func (s *PackageStatementContext) SEMI() antlr.TerminalNode

func (*PackageStatementContext) ToStringTree 

func (s *PackageStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ProtoContext 

type ProtoContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyProtoContext 

func NewEmptyProtoContext() *ProtoContext

func NewProtoContext 

func NewProtoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProtoContext

func (*ProtoContext) Accept 

func (s *ProtoContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ProtoContext) AllEmptyStatement_ 

func (s *ProtoContext) AllEmptyStatement_() []IEmptyStatement_Context

func (*ProtoContext) AllImportStatement 

func (s *ProtoContext) AllImportStatement() []IImportStatementContext

func (*ProtoContext) AllOptionStatement 

func (s *ProtoContext) AllOptionStatement() []IOptionStatementContext

func (*ProtoContext) AllPackageStatement 

func (s *ProtoContext) AllPackageStatement() []IPackageStatementContext

func (*ProtoContext) AllTopLevelDef 

func (s *ProtoContext) AllTopLevelDef() []ITopLevelDefContext

func (*ProtoContext) EOF 

func (s *ProtoContext) EOF() antlr.TerminalNode

func (*ProtoContext) EmptyStatement_ 

func (s *ProtoContext) EmptyStatement_(i int) IEmptyStatement_Context

func (*ProtoContext) GetParser 

func (s *ProtoContext) GetParser() antlr.Parser

func (*ProtoContext) GetRuleContext 

func (s *ProtoContext) GetRuleContext() antlr.RuleContext

func (*ProtoContext) ImportStatement 

func (s *ProtoContext) ImportStatement(i int) IImportStatementContext

func (*ProtoContext) IsProtoContext 

func (*ProtoContext) IsProtoContext()

func (*ProtoContext) OptionStatement 

func (s *ProtoContext) OptionStatement(i int) IOptionStatementContext

func (*ProtoContext) PackageStatement 

func (s *ProtoContext) PackageStatement(i int) IPackageStatementContext

func (*ProtoContext) ToStringTree 

func (s *ProtoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ProtoContext) TopLevelDef 

func (s *ProtoContext) TopLevelDef(i int) ITopLevelDefContext

type Size_Context 

type Size_Context struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySize_Context 

func NewEmptySize_Context() *Size_Context

func NewSize_Context 

func NewSize_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Size_Context

func (*Size_Context) Accept 

func (s *Size_Context) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*Size_Context) BitSize 

func (s *Size_Context) BitSize() IBitSizeContext

func (*Size_Context) ByteSize 

func (s *Size_Context) ByteSize() IByteSizeContext

func (*Size_Context) GetParser 

func (s *Size_Context) GetParser() antlr.Parser

func (*Size_Context) GetRuleContext 

func (s *Size_Context) GetRuleContext() antlr.RuleContext

func (*Size_Context) HASH 

func (s *Size_Context) HASH() antlr.TerminalNode

func (*Size_Context) IsSize_Context 

func (*Size_Context) IsSize_Context()

func (*Size_Context) LB 

func (s *Size_Context) LB() antlr.TerminalNode

func (*Size_Context) RB 

func (s *Size_Context) RB() antlr.TerminalNode

func (*Size_Context) ToStringTree 

func (s *Size_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StrLitContext 

type StrLitContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStrLitContext 

func NewEmptyStrLitContext() *StrLitContext

func NewStrLitContext 

func NewStrLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StrLitContext

func (*StrLitContext) Accept 

func (s *StrLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StrLitContext) GetParser 

func (s *StrLitContext) GetParser() antlr.Parser

func (*StrLitContext) GetRuleContext 

func (s *StrLitContext) GetRuleContext() antlr.RuleContext

func (*StrLitContext) IsStrLitContext 

func (*StrLitContext) IsStrLitContext()

func (*StrLitContext) STR_LIT 

func (s *StrLitContext) STR_LIT() antlr.TerminalNode

func (*StrLitContext) ToStringTree 

func (s *StrLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StructBodyContext 

type StructBodyContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStructBodyContext 

func NewEmptyStructBodyContext() *StructBodyContext

func NewStructBodyContext 

func NewStructBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructBodyContext

func (*StructBodyContext) Accept 

func (s *StructBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StructBodyContext) AllStructElement 

func (s *StructBodyContext) AllStructElement() []IStructElementContext

func (*StructBodyContext) GetParser 

func (s *StructBodyContext) GetParser() antlr.Parser

func (*StructBodyContext) GetRuleContext 

func (s *StructBodyContext) GetRuleContext() antlr.RuleContext

func (*StructBodyContext) IsStructBodyContext 

func (*StructBodyContext) IsStructBodyContext()

func (*StructBodyContext) LC 

func (s *StructBodyContext) LC() antlr.TerminalNode

func (*StructBodyContext) RC 

func (s *StructBodyContext) RC() antlr.TerminalNode

func (*StructBodyContext) StructElement 

func (s *StructBodyContext) StructElement(i int) IStructElementContext

func (*StructBodyContext) ToStringTree 

func (s *StructBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StructDefContext 

type StructDefContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStructDefContext 

func NewEmptyStructDefContext() *StructDefContext

func NewStructDefContext 

func NewStructDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructDefContext

func (*StructDefContext) Accept 

func (s *StructDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StructDefContext) GetParser 

func (s *StructDefContext) GetParser() antlr.Parser

func (*StructDefContext) GetRuleContext 

func (s *StructDefContext) GetRuleContext() antlr.RuleContext

func (*StructDefContext) IsStructDefContext 

func (*StructDefContext) IsStructDefContext()

func (*StructDefContext) Size_ 

func (s *StructDefContext) Size_() ISize_Context

func (*StructDefContext) StructBody 

func (s *StructDefContext) StructBody() IStructBodyContext

func (*StructDefContext) StructName 

func (s *StructDefContext) StructName() IStructNameContext

func (*StructDefContext) ToStringTree 

func (s *StructDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StructElementContext 

type StructElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStructElementContext 

func NewEmptyStructElementContext() *StructElementContext

func NewStructElementContext 

func NewStructElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructElementContext

func (*StructElementContext) Accept 

func (s *StructElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StructElementContext) EmptyStatement_ 

func (s *StructElementContext) EmptyStatement_() IEmptyStatement_Context

func (*StructElementContext) Field 

func (s *StructElementContext) Field() IFieldContext

func (*StructElementContext) GetParser 

func (s *StructElementContext) GetParser() antlr.Parser

func (*StructElementContext) GetRuleContext 

func (s *StructElementContext) GetRuleContext() antlr.RuleContext

func (*StructElementContext) IsStructElementContext 

func (*StructElementContext) IsStructElementContext()

func (*StructElementContext) ToStringTree 

func (s *StructElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StructNameContext 

type StructNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStructNameContext 

func NewEmptyStructNameContext() *StructNameContext

func NewStructNameContext 

func NewStructNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructNameContext

func (*StructNameContext) Accept 

func (s *StructNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StructNameContext) GetParser 

func (s *StructNameContext) GetParser() antlr.Parser

func (*StructNameContext) GetRuleContext 

func (s *StructNameContext) GetRuleContext() antlr.RuleContext

func (*StructNameContext) Ident 

func (s *StructNameContext) Ident() IIdentContext

func (*StructNameContext) IsStructNameContext 

func (*StructNameContext) IsStructNameContext()

func (*StructNameContext) STRUCT 

func (s *StructNameContext) STRUCT() antlr.TerminalNode

func (*StructNameContext) ToStringTree 

func (s *StructNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StructTypeContext 

type StructTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStructTypeContext 

func NewEmptyStructTypeContext() *StructTypeContext

func NewStructTypeContext 

func NewStructTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructTypeContext

func (*StructTypeContext) Accept 

func (s *StructTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StructTypeContext) GetParser 

func (s *StructTypeContext) GetParser() antlr.Parser

func (*StructTypeContext) GetRuleContext 

func (s *StructTypeContext) GetRuleContext() antlr.RuleContext

func (*StructTypeContext) IsStructTypeContext 

func (*StructTypeContext) IsStructTypeContext()

func (*StructTypeContext) StructDef 

func (s *StructTypeContext) StructDef() IStructDefContext

func (*StructTypeContext) StructName 

func (s *StructTypeContext) StructName() IStructNameContext

func (*StructTypeContext) ToStringTree 

func (s *StructTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TopLevelDefContext 

type TopLevelDefContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTopLevelDefContext 

func NewEmptyTopLevelDefContext() *TopLevelDefContext

func NewTopLevelDefContext 

func NewTopLevelDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TopLevelDefContext

func (*TopLevelDefContext) Accept 

func (s *TopLevelDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TopLevelDefContext) EnumDef 

func (s *TopLevelDefContext) EnumDef() IEnumDefContext

func (*TopLevelDefContext) GetParser 

func (s *TopLevelDefContext) GetParser() antlr.Parser

func (*TopLevelDefContext) GetRuleContext 

func (s *TopLevelDefContext) GetRuleContext() antlr.RuleContext

func (*TopLevelDefContext) IsTopLevelDefContext 

func (*TopLevelDefContext) IsTopLevelDefContext()

func (*TopLevelDefContext) StructDef 

func (s *TopLevelDefContext) StructDef() IStructDefContext

func (*TopLevelDefContext) ToStringTree 

func (s *TopLevelDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Type_Context 

type Type_Context struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyType_Context 

func NewEmptyType_Context() *Type_Context

func NewType_Context 

func NewType_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_Context

func (*Type_Context) Accept 

func (s *Type_Context) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*Type_Context) ArrayType 

func (s *Type_Context) ArrayType() IArrayTypeContext

func (*Type_Context) BYTES 

func (s *Type_Context) BYTES() antlr.TerminalNode

func (*Type_Context) BasicType 

func (s *Type_Context) BasicType() IBasicTypeContext

func (*Type_Context) EnumType 

func (s *Type_Context) EnumType() IEnumTypeContext

func (*Type_Context) GetParser 

func (s *Type_Context) GetParser() antlr.Parser

func (*Type_Context) GetRuleContext 

func (s *Type_Context) GetRuleContext() antlr.RuleContext

func (*Type_Context) Ident 

func (s *Type_Context) Ident() IIdentContext

func (*Type_Context) IsType_Context 

func (*Type_Context) IsType_Context()

func (*Type_Context) STRING 

func (s *Type_Context) STRING() antlr.TerminalNode

func (*Type_Context) StructType 

func (s *Type_Context) StructType() IStructTypeContext

func (*Type_Context) ToStringTree 

func (s *Type_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ValueContext 

type ValueContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyValueContext 

func NewEmptyValueContext() *ValueContext

func NewValueContext 

func NewValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueContext

func (*ValueContext) Accept 

func (s *ValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ValueContext) GetParser 

func (s *ValueContext) GetParser() antlr.Parser

func (*ValueContext) GetRuleContext 

func (s *ValueContext) GetRuleContext() antlr.RuleContext

func (*ValueContext) IsValueContext 

func (*ValueContext) IsValueContext()

func (*ValueContext) ToStringTree 

func (s *ValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ValueContext) VALUE 

func (s *ValueContext) VALUE() antlr.TerminalNode

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.