adlwi

package
v1.0.10 Latest Latest
Warning

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

 Go to latest Published: Jul 17, 2019 License: MIT Imports: 4 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	AdlWiEOF                 = antlr.TokenEOF
	AdlWiLCUR                = 1
	AdlWiRCUR                = 2
	AdlWiLSQ                 = 3
	AdlWiRSQ                 = 4
	AdlWiEQ                  = 5
	AdlWiDQ                  = 6
	AdlWiSQ                  = 7
	AdlWiSEMI                = 8
	AdlWiDCOLON              = 9
	AdlWiCOLON               = 10
	AdlWiDOT                 = 11
	AdlWiCOMMA               = 12
	AdlWiLCHEVR              = 13
	AdlWiRCHEVR              = 14
	AdlWiSTAR                = 15
	AdlWiAT                  = 16
	AdlWiSTR                 = 17
	AdlWiID                  = 18
	AdlWiINT                 = 19
	AdlWiFLT                 = 20
	AdlWiWS                  = 21
	AdlWiLINE_DOC            = 22
	AdlWiLINE_COMMENT        = 23
	AdlWiDOWN                = 24
	AdlWiUP                  = 25
	AdlWiROOT                = 26
	AdlWiERROR               = 27
	AdlWiADL                 = 28
	AdlWiModule              = 29
	AdlWiImport              = 30
	AdlWiImportModule        = 31
	AdlWiImportScopedName    = 32
	AdlWiDecl                = 33
	AdlWiScopedName          = 34
	AdlWiDeclType            = 35
	AdlWiTypeDef             = 36
	AdlWiNewType             = 37
	AdlWiTypeExpr            = 38
	AdlWiAnnotation          = 39
	AdlWiAnnotationNotScoped = 40
	AdlWiAnnotationScoped    = 41
	AdlWiPrimitive           = 42
	AdlWiStruct              = 43
	AdlWiUnion               = 44
	AdlWiNewtype             = 45
	AdlWiType                = 46
	AdlWiTypeParam           = 47
	AdlWiTypeExprSimple      = 48
	AdlWiTypeExprGeneric     = 49
	AdlWiField               = 50
	AdlWiJson                = 51
	AdlWiJsonStr             = 52
	AdlWiJsonBool            = 53
	AdlWiJsonNull            = 54
	AdlWiJsonInt             = 55
	AdlWiJsonFloat           = 56
	AdlWiJsonArray           = 57
	AdlWiJsonObj             = 58
	AdlWiJsonObjKey          = 59
	AdlWiModuleAnno          = 60
	AdlWiDeclAnno            = 61
	AdlWiFieldAnno           = 62
	AdlWiDNAC                = 63
	AdlWiName                = 64
	AdlWiExnotation          = 65
)

AdlWi tokens.

View Source 
const (
	AdlWiRULE_adl        = 0
	AdlWiRULE_json       = 1
	AdlWiRULE_module     = 2
	AdlWiRULE_import_    = 3
	AdlWiRULE_tld        = 4
	AdlWiRULE_nameBody   = 5
	AdlWiRULE_annotation = 6
	AdlWiRULE_typeExpr_  = 7
	AdlWiRULE_jsonVal    = 8
)

AdlWi rules.

Variables

This section is empty.

Functions

This section is empty.

Types

type AdlContext 

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

func NewAdlContext 

func NewAdlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdlContext

func NewEmptyAdlContext 

func NewEmptyAdlContext() *AdlContext

func (*AdlContext) ADL 

func (s *AdlContext) ADL() antlr.TerminalNode

func (*AdlContext) AllDOWN 

func (s *AdlContext) AllDOWN() []antlr.TerminalNode

Getters

func (*AdlContext) AllUP 

func (s *AdlContext) AllUP() []antlr.TerminalNode

func (*AdlContext) DOWN 

func (s *AdlContext) DOWN(i int) antlr.TerminalNode

func (*AdlContext) EOF 

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

func (*AdlContext) EnterRule 

func (s *AdlContext) EnterRule(listener antlr.ParseTreeListener)

dispatchMethods

func (*AdlContext) ExitRule 

func (s *AdlContext) ExitRule(listener antlr.ParseTreeListener)

func (*AdlContext) GetParser 

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

func (*AdlContext) GetRuleContext 

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

provideCopyFrom

func (*AdlContext) GetTok 

func (s *AdlContext) GetTok() antlr.Token

StructDecl tokenDecls

func (*AdlContext) IsAdlContext 

func (*AdlContext) IsAdlContext()

func (*AdlContext) Module 

func (s *AdlContext) Module() IModuleContext

func (*AdlContext) SetTok 

func (s *AdlContext) SetTok(v antlr.Token)

func (*AdlContext) ToStringTree 

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

func (*AdlContext) UP 

func (s *AdlContext) UP(i int) antlr.TerminalNode

func (*AdlContext) Visit 

func (s *AdlContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*AdlContext) VisitFunc 

func (s *AdlContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type AdlContextVisitor 

type AdlContextVisitor interface {
	VisitAdl(ctx IAdlContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type AdlEntryListener 

type AdlEntryListener interface {
	EnterAdl(c *AdlContext)
}

Rules with unnamed alternatives

type AdlExitListener 

type AdlExitListener interface {
	ExitAdl(c *AdlContext)
}

type AdlWi 

type AdlWi struct {
	*antlr.BaseParser
}

func NewAdlWi 

func NewAdlWi(input antlr.TokenStream) *AdlWi

func (*AdlWi) Adl 

func (p *AdlWi) Adl() (localctx IAdlContext)

func (*AdlWi) Annotation 

func (p *AdlWi) Annotation() (localctx IAnnotationContext)

func (*AdlWi) Import_ 

func (p *AdlWi) Import_() (localctx IImport_Context)

func (*AdlWi) Json 

func (p *AdlWi) Json() (localctx IJsonContext)

func (*AdlWi) JsonVal 

func (p *AdlWi) JsonVal() (localctx IJsonValContext)

func (*AdlWi) Module 

func (p *AdlWi) Module() (localctx IModuleContext)

func (*AdlWi) NameBody 

func (p *AdlWi) NameBody() (localctx INameBodyContext)

func (*AdlWi) Tld 

func (p *AdlWi) Tld() (localctx ITldContext)

func (*AdlWi) TypeExpr_ 

func (p *AdlWi) TypeExpr_() (localctx ITypeExpr_Context)

type AdlWiHandlers 

type AdlWiHandlers struct {
	EnterEveryRule func(ctx antlr.RuleNode)
	ExitEveryRule  func(ctx antlr.RuleNode)

	Adl                func(ctx IAdlContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Json               func(ctx IJsonContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Module             func(ctx IModuleContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	ImportModule       func(ctx IImportModuleContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	ImportScopedModule func(ctx IImportScopedModuleContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	ImportError        func(ctx IImportErrorContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Struct             func(ctx IStructContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Union              func(ctx IUnionContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Type               func(ctx ITypeContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Newtype            func(ctx INewtypeContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	ModAnno            func(ctx IModAnnoContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	DeclAnno           func(ctx IDeclAnnoContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	FieldAnno          func(ctx IFieldAnnoContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	TypeParamError     func(ctx ITypeParamErrorContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	TLDError           func(ctx ITLDErrorContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Field              func(ctx IFieldContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	Annotation         func(ctx IAnnotationContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	TypeExprSimple     func(ctx ITypeExprSimpleContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	TypeExprGeneric    func(ctx ITypeExprGenericContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonStr            func(ctx IJsonStrContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonBool           func(ctx IJsonBoolContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonNull           func(ctx IJsonNullContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonInt            func(ctx IJsonIntContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonFloat          func(ctx IJsonFloatContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonArray          func(ctx IJsonArrayContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonObj            func(ctx IJsonObjContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
	JsonError          func(ctx IJsonErrorContext, this *AdlWiHandlers, args ...interface{}) (result interface{})
}

Struct of Handlers

type AdlWiListener 

type AdlWiListener interface {
	antlr.ParseTreeListener

	AdlEntryListener
	AdlExitListener

	JsonEntryListener
	JsonExitListener

	ModuleEntryListener
	ModuleExitListener

	AnnotationEntryListener
	AnnotationExitListener

	ImportModuleEntryListener
	ImportModuleExitListener

	ImportScopedModuleEntryListener
	ImportScopedModuleExitListener

	ImportErrorEntryListener
	ImportErrorExitListener

	StructEntryListener
	StructExitListener

	UnionEntryListener
	UnionExitListener

	TypeEntryListener
	TypeExitListener

	NewtypeEntryListener
	NewtypeExitListener

	ModAnnoEntryListener
	ModAnnoExitListener

	DeclAnnoEntryListener
	DeclAnnoExitListener

	FieldAnnoEntryListener
	FieldAnnoExitListener

	TypeParamErrorEntryListener
	TypeParamErrorExitListener

	TLDErrorEntryListener
	TLDErrorExitListener

	FieldEntryListener
	FieldExitListener

	TypeExprSimpleEntryListener
	TypeExprSimpleExitListener

	TypeExprGenericEntryListener
	TypeExprGenericExitListener

	JsonStrEntryListener
	JsonStrExitListener

	JsonBoolEntryListener
	JsonBoolExitListener

	JsonNullEntryListener
	JsonNullExitListener

	JsonIntEntryListener
	JsonIntExitListener

	JsonFloatEntryListener
	JsonFloatExitListener

	JsonArrayEntryListener
	JsonArrayExitListener

	JsonObjEntryListener
	JsonObjExitListener

	JsonErrorEntryListener
	JsonErrorExitListener
}

AdlWiListener is a complete listener for a parse tree produced by AdlWi.

type AdlWiVisitor 

type AdlWiVisitor interface {
	antlr.ParseTreeVisitor
	AdlContextVisitor
	JsonContextVisitor
	ModuleContextVisitor
	ImportModuleContextVisitor
	ImportScopedModuleContextVisitor
	ImportErrorContextVisitor
	StructContextVisitor
	UnionContextVisitor
	TypeContextVisitor
	NewtypeContextVisitor
	ModAnnoContextVisitor
	DeclAnnoContextVisitor
	FieldAnnoContextVisitor
	TypeParamErrorContextVisitor
	TLDErrorContextVisitor
	FieldContextVisitor
	AnnotationContextVisitor
	TypeExprSimpleContextVisitor
	TypeExprGenericContextVisitor
	JsonStrContextVisitor
	JsonBoolContextVisitor
	JsonNullContextVisitor
	JsonIntContextVisitor
	JsonFloatContextVisitor
	JsonArrayContextVisitor
	JsonObjContextVisitor
	JsonErrorContextVisitor
}

A complete Visitor for a parse tree produced by AdlWi.

type AnnotationContext 

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

func NewAnnotationContext 

func NewAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationContext

func NewEmptyAnnotationContext 

func NewEmptyAnnotationContext() *AnnotationContext

func (*AnnotationContext) Annotation 

func (s *AnnotationContext) Annotation() antlr.TerminalNode

Getters

func (*AnnotationContext) AnnotationNotScoped 

func (s *AnnotationContext) AnnotationNotScoped() antlr.TerminalNode

func (*AnnotationContext) AnnotationScoped 

func (s *AnnotationContext) AnnotationScoped() antlr.TerminalNode

func (*AnnotationContext) DOWN 

func (s *AnnotationContext) DOWN() antlr.TerminalNode

func (*AnnotationContext) EnterRule 

func (s *AnnotationContext) EnterRule(listener antlr.ParseTreeListener)

dispatchMethods

func (*AnnotationContext) ExitRule 

func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener)

func (*AnnotationContext) GetParser 

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

func (*AnnotationContext) GetRuleContext 

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

provideCopyFrom

func (*AnnotationContext) GetTok 

func (s *AnnotationContext) GetTok() antlr.Token

StructDecl tokenDecls

func (*AnnotationContext) IsAnnotationContext 

func (*AnnotationContext) IsAnnotationContext()

func (*AnnotationContext) JsonVal 

func (s *AnnotationContext) JsonVal() IJsonValContext

func (*AnnotationContext) SetTok 

func (s *AnnotationContext) SetTok(v antlr.Token)

func (*AnnotationContext) ToStringTree 

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

func (*AnnotationContext) UP 

func (s *AnnotationContext) UP() antlr.TerminalNode

func (*AnnotationContext) Visit 

func (s *AnnotationContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*AnnotationContext) VisitFunc 

func (s *AnnotationContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type AnnotationContextVisitor 

type AnnotationContextVisitor interface {
	VisitAnnotation(ctx IAnnotationContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type AnnotationEntryListener 

type AnnotationEntryListener interface {
	EnterAnnotation(c *AnnotationContext)
}

type AnnotationExitListener 

type AnnotationExitListener interface {
	ExitAnnotation(c *AnnotationContext)
}

type DeclAnnoContext 

type DeclAnnoContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewDeclAnnoContext 

func NewDeclAnnoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DeclAnnoContext

func (*DeclAnnoContext) DOWN 

func (s *DeclAnnoContext) DOWN() antlr.TerminalNode

getters

func (*DeclAnnoContext) DeclAnno 

func (s *DeclAnnoContext) DeclAnno() antlr.TerminalNode

func (*DeclAnnoContext) EnterRule 

func (s *DeclAnnoContext) EnterRule(listener antlr.ParseTreeListener)

func (*DeclAnnoContext) ExitRule 

func (s *DeclAnnoContext) ExitRule(listener antlr.ParseTreeListener)

func (*DeclAnnoContext) GetRuleContext 

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

getRuleContext

func (*DeclAnnoContext) GetTok 

func (s *DeclAnnoContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*DeclAnnoContext) IsDeclAnnoContext 

func (*DeclAnnoContext) IsDeclAnnoContext()

func (*DeclAnnoContext) JsonVal 

func (s *DeclAnnoContext) JsonVal() IJsonValContext

func (*DeclAnnoContext) SetTok 

func (s *DeclAnnoContext) SetTok(v antlr.Token)

func (*DeclAnnoContext) UP 

func (s *DeclAnnoContext) UP() antlr.TerminalNode

func (*DeclAnnoContext) Visit 

func (s *DeclAnnoContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*DeclAnnoContext) VisitFunc 

func (s *DeclAnnoContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type DeclAnnoContextVisitor 

type DeclAnnoContextVisitor interface {
	VisitDeclAnno(ctx IDeclAnnoContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type DeclAnnoEntryListener 

type DeclAnnoEntryListener interface {
	EnterDeclAnno(c *DeclAnnoContext)
}

From Rule 'tld'

type DeclAnnoExitListener 

type DeclAnnoExitListener interface {
	ExitDeclAnno(c *DeclAnnoContext)
}

type FieldAnnoContext 

type FieldAnnoContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewFieldAnnoContext 

func NewFieldAnnoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FieldAnnoContext

func (*FieldAnnoContext) DOWN 

func (s *FieldAnnoContext) DOWN() antlr.TerminalNode

getters

func (*FieldAnnoContext) EnterRule 

func (s *FieldAnnoContext) EnterRule(listener antlr.ParseTreeListener)

func (*FieldAnnoContext) ExitRule 

func (s *FieldAnnoContext) ExitRule(listener antlr.ParseTreeListener)

func (*FieldAnnoContext) FieldAnno 

func (s *FieldAnnoContext) FieldAnno() antlr.TerminalNode

func (*FieldAnnoContext) GetRuleContext 

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

getRuleContext

func (*FieldAnnoContext) GetTok 

func (s *FieldAnnoContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*FieldAnnoContext) IsFieldAnnoContext 

func (*FieldAnnoContext) IsFieldAnnoContext()

func (*FieldAnnoContext) JsonVal 

func (s *FieldAnnoContext) JsonVal() IJsonValContext

func (*FieldAnnoContext) SetTok 

func (s *FieldAnnoContext) SetTok(v antlr.Token)

func (*FieldAnnoContext) UP 

func (s *FieldAnnoContext) UP() antlr.TerminalNode

func (*FieldAnnoContext) Visit 

func (s *FieldAnnoContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*FieldAnnoContext) VisitFunc 

func (s *FieldAnnoContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type FieldAnnoContextVisitor 

type FieldAnnoContextVisitor interface {
	VisitFieldAnno(ctx IFieldAnnoContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type FieldAnnoEntryListener 

type FieldAnnoEntryListener interface {
	EnterFieldAnno(c *FieldAnnoContext)
}

From Rule 'tld'

type FieldAnnoExitListener 

type FieldAnnoExitListener interface {
	ExitFieldAnno(c *FieldAnnoContext)
}

type FieldContext 

type FieldContext struct {
	*NameBodyContext
	// contains filtered or unexported fields
}

func NewFieldContext 

func NewFieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FieldContext

func (*FieldContext) AllAnnotation 

func (s *FieldContext) AllAnnotation() []IAnnotationContext

func (*FieldContext) Annotation 

func (s *FieldContext) Annotation(i int) IAnnotationContext

func (*FieldContext) DOWN 

func (s *FieldContext) DOWN() antlr.TerminalNode

func (*FieldContext) EnterRule 

func (s *FieldContext) EnterRule(listener antlr.ParseTreeListener)

func (*FieldContext) ExitRule 

func (s *FieldContext) ExitRule(listener antlr.ParseTreeListener)

func (*FieldContext) Field 

func (s *FieldContext) Field() antlr.TerminalNode

getters

func (*FieldContext) GetRuleContext 

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

getRuleContext

func (*FieldContext) GetTok 

func (s *FieldContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*FieldContext) IsFieldContext 

func (*FieldContext) IsFieldContext()

func (*FieldContext) JsonVal 

func (s *FieldContext) JsonVal() IJsonValContext

func (*FieldContext) SetTok 

func (s *FieldContext) SetTok(v antlr.Token)

func (*FieldContext) TypeExpr_ 

func (s *FieldContext) TypeExpr_() ITypeExpr_Context

func (*FieldContext) UP 

func (s *FieldContext) UP() antlr.TerminalNode

func (*FieldContext) Visit 

func (s *FieldContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*FieldContext) VisitFunc 

func (s *FieldContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type FieldContextVisitor 

type FieldContextVisitor interface {
	VisitField(ctx IFieldContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type FieldEntryListener 

type FieldEntryListener interface {
	EnterField(c *FieldContext)
}

From Rule 'nameBody'

type FieldExitListener 

type FieldExitListener interface {
	ExitField(c *FieldContext)
}

type IAdlContext 

type IAdlContext interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser

	// start internal
	//  ruleGetterDecl
	Module() IModuleContext
	//  ruleListGetterDecl
	//  ruleListIndexedGetterDecl
	//  ruleContextDecls
	//  ruleContextListDecls
	// end internal
	//Gets for labeled elements
	//tokenDecls
	GetTok() antlr.Token

	//tokenTypeDecls
	//tokenListDecls
	//attributeDecls
	//tokenGetterDecl
	EOF() antlr.TerminalNode
	ADL() antlr.TerminalNode
	//tokenListGetterDecl
	AllDOWN() []antlr.TerminalNode
	AllUP() []antlr.TerminalNode
	//tokenListIndexedGetterDecl
	DOWN(i int) antlr.TerminalNode
	UP(i int) antlr.TerminalNode
}

type IAnnotationContext 

type IAnnotationContext interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser

	// start internal
	//  ruleGetterDecl
	JsonVal() IJsonValContext
	//  ruleListGetterDecl
	//  ruleListIndexedGetterDecl
	//  ruleContextDecls
	//  ruleContextListDecls
	// end internal
	//Gets for labeled elements
	//tokenDecls
	GetTok() antlr.Token

	//tokenTypeDecls
	//tokenListDecls
	//attributeDecls
	//tokenGetterDecl
	Annotation() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	AnnotationNotScoped() antlr.TerminalNode
	AnnotationScoped() antlr.TerminalNode
}

type IDeclAnnoContext 

type IDeclAnnoContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	JsonVal() IJsonValContext

	//  tokenGetterDecl
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	DeclAnno() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IFieldAnnoContext 

type IFieldAnnoContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	JsonVal() IJsonValContext

	//  tokenGetterDecl
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	FieldAnno() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IFieldContext 

type IFieldContext interface {
	//Current rule
	INameBodyContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	TypeExpr_() ITypeExpr_Context
	JsonVal() IJsonValContext
	//  ruleListGetterDecl
	AllAnnotation() []IAnnotationContext
	//  ruleListIndexedGetterDecl
	Annotation(i int) IAnnotationContext

	//  tokenGetterDecl
	Field() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IImportErrorContext 

type IImportErrorContext interface {
	//Current rule
	IImport_Context

	//  tokenGetterDecl
	ERROR() antlr.TerminalNode
}

type IImportModuleContext 

type IImportModuleContext interface {
	//Current rule
	IImport_Context

	//  tokenGetterDecl
	ImportModule() antlr.TerminalNode
}

type IImportScopedModuleContext 

type IImportScopedModuleContext interface {
	//Current rule
	IImport_Context

	//  tokenGetterDecl
	ImportScopedName() antlr.TerminalNode
}

type IImport_Context 

type IImport_Context interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser
}

type IJsonArrayContext 

type IJsonArrayContext interface {
	//Current rule
	IJsonValContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	//  ruleListGetterDecl
	AllJsonVal() []IJsonValContext
	//  ruleListIndexedGetterDecl
	JsonVal(i int) IJsonValContext

	//  tokenGetterDecl
	JsonArray() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IJsonBoolContext 

type IJsonBoolContext interface {
	//Current rule
	IJsonValContext

	//  tokenGetterDecl
	JsonBool() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IJsonContext 

type IJsonContext interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser

	// start internal
	//  ruleGetterDecl
	JsonVal() IJsonValContext
	//  ruleListGetterDecl
	//  ruleListIndexedGetterDecl
	//  ruleContextDecls
	//  ruleContextListDecls
	// end internal
	//Gets for labeled elements
	//tokenDecls
	//tokenTypeDecls
	//tokenListDecls
	//attributeDecls
	//tokenGetterDecl
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	EOF() antlr.TerminalNode
}

type IJsonErrorContext 

type IJsonErrorContext interface {
	//Current rule
	IJsonValContext

	//  tokenGetterDecl
	ERROR() antlr.TerminalNode
}

type IJsonFloatContext 

type IJsonFloatContext interface {
	//Current rule
	IJsonValContext

	//  tokenGetterDecl
	JsonFloat() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IJsonIntContext 

type IJsonIntContext interface {
	//Current rule
	IJsonValContext

	//  tokenGetterDecl
	JsonInt() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IJsonNullContext 

type IJsonNullContext interface {
	//Current rule
	IJsonValContext

	//  tokenGetterDecl
	JsonNull() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IJsonObjContext 

type IJsonObjContext interface {
	//Current rule
	IJsonValContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	//  ruleListGetterDecl
	AllJsonVal() []IJsonValContext
	//  ruleListIndexedGetterDecl
	JsonVal(i int) IJsonValContext

	//  tokenGetterDecl
	JsonObj() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	//  tokenListGetterDecl
	AllJsonObjKey() []antlr.TerminalNode
	//  tokenListIndexedGetterDecl
	JsonObjKey(i int) antlr.TerminalNode
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IJsonStrContext 

type IJsonStrContext interface {
	//Current rule
	IJsonValContext

	//  tokenGetterDecl
	JsonStr() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IJsonValContext 

type IJsonValContext interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser
}

type IModAnnoContext 

type IModAnnoContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	JsonVal() IJsonValContext

	//  tokenGetterDecl
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	ModuleAnno() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IModuleContext 

type IModuleContext interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser

	// start internal
	//  ruleGetterDecl
	//  ruleListGetterDecl
	AllAnnotation() []IAnnotationContext
	AllImport_() []IImport_Context
	AllTld() []ITldContext
	//  ruleListIndexedGetterDecl
	Annotation(i int) IAnnotationContext
	Import_(i int) IImport_Context
	Tld(i int) ITldContext
	//  ruleContextDecls
	//  ruleContextListDecls
	// end internal
	//Gets for labeled elements
	//tokenDecls
	GetTok() antlr.Token

	//tokenTypeDecls
	//tokenListDecls
	//attributeDecls
	//tokenGetterDecl
	Module() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	ERROR() antlr.TerminalNode
}

type INameBodyContext 

type INameBodyContext interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser
}

type INewtypeContext 

type INewtypeContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	TypeExpr_() ITypeExpr_Context
	//  ruleListGetterDecl
	AllAnnotation() []IAnnotationContext
	AllJsonVal() []IJsonValContext
	//  ruleListIndexedGetterDecl
	Annotation(i int) IAnnotationContext
	JsonVal(i int) IJsonValContext

	//  tokenGetterDecl
	Newtype() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	TypeParam() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IStructContext 

type IStructContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	//  ruleListGetterDecl
	AllAnnotation() []IAnnotationContext
	AllNameBody() []INameBodyContext
	//  ruleListIndexedGetterDecl
	Annotation(i int) IAnnotationContext
	NameBody(i int) INameBodyContext

	//  tokenGetterDecl
	Struct() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	TypeParam() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type ITLDErrorContext 

type ITLDErrorContext interface {
	//Current rule
	ITldContext

	//  tokenGetterDecl
	ERROR() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
}

type ITldContext 

type ITldContext interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser
}

type ITypeContext 

type ITypeContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	TypeExpr_() ITypeExpr_Context
	//  ruleListGetterDecl
	AllAnnotation() []IAnnotationContext
	AllJsonVal() []IJsonValContext
	//  ruleListIndexedGetterDecl
	Annotation(i int) IAnnotationContext
	JsonVal(i int) IJsonValContext

	//  tokenGetterDecl
	Type() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	TypeParam() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type ITypeExprGenericContext added in v1.0.8 

type ITypeExprGenericContext interface {
	//Current rule
	ITypeExpr_Context
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	//  ruleListGetterDecl
	AllTypeExpr_() []ITypeExpr_Context
	//  ruleListIndexedGetterDecl
	TypeExpr_(i int) ITypeExpr_Context

	//  tokenGetterDecl
	TypeExprGeneric() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type ITypeExprSimpleContext added in v1.0.8 

type ITypeExprSimpleContext interface {
	//Current rule
	ITypeExpr_Context

	//  tokenGetterDecl
	TypeExprSimple() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type ITypeExpr_Context 

type ITypeExpr_Context interface {
	antlr.ParserRuleContext
	// GetParser returns the parser.
	GetParser() antlr.Parser
}

type ITypeParamErrorContext 

type ITypeParamErrorContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	TypeExpr_() ITypeExpr_Context
	//  ruleListGetterDecl
	AllAnnotation() []IAnnotationContext
	AllNameBody() []INameBodyContext
	AllJsonVal() []IJsonValContext
	//  ruleListIndexedGetterDecl
	Annotation(i int) IAnnotationContext
	NameBody(i int) INameBodyContext
	JsonVal(i int) IJsonValContext

	//  tokenGetterDecl
	DOWN() antlr.TerminalNode
	ERROR() antlr.TerminalNode
	UP() antlr.TerminalNode
	Struct() antlr.TerminalNode
	Union() antlr.TerminalNode
	Type() antlr.TerminalNode
	Newtype() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type IUnionContext 

type IUnionContext interface {
	//Current rule
	ITldContext
	// start internal
	//Gets for raw elements
	//  ruleGetterDecl
	//  ruleListGetterDecl
	AllAnnotation() []IAnnotationContext
	AllNameBody() []INameBodyContext
	//  ruleListIndexedGetterDecl
	Annotation(i int) IAnnotationContext
	NameBody(i int) INameBodyContext

	//  tokenGetterDecl
	Union() antlr.TerminalNode
	DOWN() antlr.TerminalNode
	UP() antlr.TerminalNode
	TypeParam() antlr.TerminalNode
	//  tokenListGetterDecl
	//  tokenListIndexedGetterDecl
	// end internal
	//
	//Gets for labeled elements
	//  tokenDecls
	GetTok() antlr.Token
}

type ImportErrorContext 

type ImportErrorContext struct {
	*Import_Context
}

func NewImportErrorContext 

func NewImportErrorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportErrorContext

func (*ImportErrorContext) ERROR 

func (s *ImportErrorContext) ERROR() antlr.TerminalNode

getters

func (*ImportErrorContext) EnterRule 

func (s *ImportErrorContext) EnterRule(listener antlr.ParseTreeListener)

func (*ImportErrorContext) ExitRule 

func (s *ImportErrorContext) ExitRule(listener antlr.ParseTreeListener)

func (*ImportErrorContext) GetRuleContext 

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

getRuleContext

func (*ImportErrorContext) IsImportErrorContext 

func (*ImportErrorContext) IsImportErrorContext()

func (*ImportErrorContext) Visit 

func (s *ImportErrorContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*ImportErrorContext) VisitFunc 

func (s *ImportErrorContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type ImportErrorContextVisitor 

type ImportErrorContextVisitor interface {
	VisitImportError(ctx IImportErrorContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type ImportErrorEntryListener 

type ImportErrorEntryListener interface {
	EnterImportError(c *ImportErrorContext)
}

From Rule 'import_'

type ImportErrorExitListener 

type ImportErrorExitListener interface {
	ExitImportError(c *ImportErrorContext)
}

type ImportModuleContext 

type ImportModuleContext struct {
	*Import_Context
}

func NewImportModuleContext 

func NewImportModuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportModuleContext

func (*ImportModuleContext) EnterRule 

func (s *ImportModuleContext) EnterRule(listener antlr.ParseTreeListener)

func (*ImportModuleContext) ExitRule 

func (s *ImportModuleContext) ExitRule(listener antlr.ParseTreeListener)

func (*ImportModuleContext) GetRuleContext 

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

getRuleContext

func (*ImportModuleContext) ImportModule 

func (s *ImportModuleContext) ImportModule() antlr.TerminalNode

getters

func (*ImportModuleContext) IsImportModuleContext 

func (*ImportModuleContext) IsImportModuleContext()

func (*ImportModuleContext) Visit 

func (s *ImportModuleContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*ImportModuleContext) VisitFunc 

func (s *ImportModuleContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type ImportModuleContextVisitor 

type ImportModuleContextVisitor interface {
	VisitImportModule(ctx IImportModuleContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type ImportModuleEntryListener 

type ImportModuleEntryListener interface {
	EnterImportModule(c *ImportModuleContext)
}

Named alternatives

From Rule 'import_'

type ImportModuleExitListener 

type ImportModuleExitListener interface {
	ExitImportModule(c *ImportModuleContext)
}

type ImportScopedModuleContext 

type ImportScopedModuleContext struct {
	*Import_Context
}

func NewImportScopedModuleContext 

func NewImportScopedModuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportScopedModuleContext

func (*ImportScopedModuleContext) EnterRule 

func (s *ImportScopedModuleContext) EnterRule(listener antlr.ParseTreeListener)

func (*ImportScopedModuleContext) ExitRule 

func (s *ImportScopedModuleContext) ExitRule(listener antlr.ParseTreeListener)

func (*ImportScopedModuleContext) GetRuleContext 

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

getRuleContext

func (*ImportScopedModuleContext) ImportScopedName 

func (s *ImportScopedModuleContext) ImportScopedName() antlr.TerminalNode

getters

func (*ImportScopedModuleContext) IsImportScopedModuleContext 

func (*ImportScopedModuleContext) IsImportScopedModuleContext()

func (*ImportScopedModuleContext) Visit 

func (s *ImportScopedModuleContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*ImportScopedModuleContext) VisitFunc 

func (s *ImportScopedModuleContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type ImportScopedModuleContextVisitor 

type ImportScopedModuleContextVisitor interface {
	VisitImportScopedModule(ctx IImportScopedModuleContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type ImportScopedModuleEntryListener 

type ImportScopedModuleEntryListener interface {
	EnterImportScopedModule(c *ImportScopedModuleContext)
}

From Rule 'import_'

type ImportScopedModuleExitListener 

type ImportScopedModuleExitListener interface {
	ExitImportScopedModule(c *ImportScopedModuleContext)
}

type Import_Context 

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

func NewEmptyImport_Context 

func NewEmptyImport_Context() *Import_Context

func NewImport_Context 

func NewImport_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_Context

func (*Import_Context) CopyFrom 

func (s *Import_Context) CopyFrom(ctx *Import_Context)

provideCopyFrom

func (*Import_Context) GetParser 

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

func (*Import_Context) GetRuleContext 

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

func (*Import_Context) IsImport_Context 

func (*Import_Context) IsImport_Context()

func (*Import_Context) ToStringTree 

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

type JsonArrayContext 

type JsonArrayContext struct {
	*JsonValContext
	// contains filtered or unexported fields
}

func NewJsonArrayContext 

func NewJsonArrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonArrayContext

func (*JsonArrayContext) AllJsonVal 

func (s *JsonArrayContext) AllJsonVal() []IJsonValContext

func (*JsonArrayContext) DOWN 

func (s *JsonArrayContext) DOWN() antlr.TerminalNode

func (*JsonArrayContext) EnterRule 

func (s *JsonArrayContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonArrayContext) ExitRule 

func (s *JsonArrayContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonArrayContext) GetRuleContext 

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

getRuleContext

func (*JsonArrayContext) GetTok 

func (s *JsonArrayContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*JsonArrayContext) IsJsonArrayContext 

func (*JsonArrayContext) IsJsonArrayContext()

func (*JsonArrayContext) JsonArray 

func (s *JsonArrayContext) JsonArray() antlr.TerminalNode

getters

func (*JsonArrayContext) JsonVal 

func (s *JsonArrayContext) JsonVal(i int) IJsonValContext

func (*JsonArrayContext) SetTok 

func (s *JsonArrayContext) SetTok(v antlr.Token)

func (*JsonArrayContext) UP 

func (s *JsonArrayContext) UP() antlr.TerminalNode

func (*JsonArrayContext) Visit 

func (s *JsonArrayContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonArrayContext) VisitFunc 

func (s *JsonArrayContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonArrayContextVisitor 

type JsonArrayContextVisitor interface {
	VisitJsonArray(ctx IJsonArrayContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonArrayEntryListener 

type JsonArrayEntryListener interface {
	EnterJsonArray(c *JsonArrayContext)
}

From Rule 'jsonVal'

type JsonArrayExitListener 

type JsonArrayExitListener interface {
	ExitJsonArray(c *JsonArrayContext)
}

type JsonBoolContext 

type JsonBoolContext struct {
	*JsonValContext
	// contains filtered or unexported fields
}

func NewJsonBoolContext 

func NewJsonBoolContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonBoolContext

func (*JsonBoolContext) EnterRule 

func (s *JsonBoolContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonBoolContext) ExitRule 

func (s *JsonBoolContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonBoolContext) GetRuleContext 

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

getRuleContext

func (*JsonBoolContext) GetTok 

func (s *JsonBoolContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*JsonBoolContext) IsJsonBoolContext 

func (*JsonBoolContext) IsJsonBoolContext()

func (*JsonBoolContext) JsonBool 

func (s *JsonBoolContext) JsonBool() antlr.TerminalNode

getters

func (*JsonBoolContext) SetTok 

func (s *JsonBoolContext) SetTok(v antlr.Token)

func (*JsonBoolContext) Visit 

func (s *JsonBoolContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonBoolContext) VisitFunc 

func (s *JsonBoolContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonBoolContextVisitor 

type JsonBoolContextVisitor interface {
	VisitJsonBool(ctx IJsonBoolContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonBoolEntryListener 

type JsonBoolEntryListener interface {
	EnterJsonBool(c *JsonBoolContext)
}

From Rule 'jsonVal'

type JsonBoolExitListener 

type JsonBoolExitListener interface {
	ExitJsonBool(c *JsonBoolContext)
}

type JsonContext 

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

func NewEmptyJsonContext 

func NewEmptyJsonContext() *JsonContext

func NewJsonContext 

func NewJsonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonContext

func (*JsonContext) DOWN 

func (s *JsonContext) DOWN() antlr.TerminalNode

Getters

func (*JsonContext) EOF 

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

func (*JsonContext) EnterRule 

func (s *JsonContext) EnterRule(listener antlr.ParseTreeListener)

dispatchMethods

func (*JsonContext) ExitRule 

func (s *JsonContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonContext) GetParser 

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

func (*JsonContext) GetRuleContext 

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

provideCopyFrom

func (*JsonContext) IsJsonContext 

func (*JsonContext) IsJsonContext()

func (*JsonContext) JsonVal 

func (s *JsonContext) JsonVal() IJsonValContext

func (*JsonContext) ToStringTree 

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

func (*JsonContext) UP 

func (s *JsonContext) UP() antlr.TerminalNode

func (*JsonContext) Visit 

func (s *JsonContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonContext) VisitFunc 

func (s *JsonContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonContextVisitor 

type JsonContextVisitor interface {
	VisitJson(ctx IJsonContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonEntryListener 

type JsonEntryListener interface {
	EnterJson(c *JsonContext)
}

type JsonErrorContext 

type JsonErrorContext struct {
	*JsonValContext
}

func NewJsonErrorContext 

func NewJsonErrorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonErrorContext

func (*JsonErrorContext) ERROR 

func (s *JsonErrorContext) ERROR() antlr.TerminalNode

getters

func (*JsonErrorContext) EnterRule 

func (s *JsonErrorContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonErrorContext) ExitRule 

func (s *JsonErrorContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonErrorContext) GetRuleContext 

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

getRuleContext

func (*JsonErrorContext) IsJsonErrorContext 

func (*JsonErrorContext) IsJsonErrorContext()

func (*JsonErrorContext) Visit 

func (s *JsonErrorContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonErrorContext) VisitFunc 

func (s *JsonErrorContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonErrorContextVisitor 

type JsonErrorContextVisitor interface {
	VisitJsonError(ctx IJsonErrorContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonErrorEntryListener 

type JsonErrorEntryListener interface {
	EnterJsonError(c *JsonErrorContext)
}

From Rule 'jsonVal'

type JsonErrorExitListener 

type JsonErrorExitListener interface {
	ExitJsonError(c *JsonErrorContext)
}

type JsonExitListener 

type JsonExitListener interface {
	ExitJson(c *JsonContext)
}

type JsonFloatContext 

type JsonFloatContext struct {
	*JsonValContext
	// contains filtered or unexported fields
}

func NewJsonFloatContext 

func NewJsonFloatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonFloatContext

func (*JsonFloatContext) EnterRule 

func (s *JsonFloatContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonFloatContext) ExitRule 

func (s *JsonFloatContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonFloatContext) GetRuleContext 

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

getRuleContext

func (*JsonFloatContext) GetTok 

func (s *JsonFloatContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*JsonFloatContext) IsJsonFloatContext 

func (*JsonFloatContext) IsJsonFloatContext()

func (*JsonFloatContext) JsonFloat 

func (s *JsonFloatContext) JsonFloat() antlr.TerminalNode

getters

func (*JsonFloatContext) SetTok 

func (s *JsonFloatContext) SetTok(v antlr.Token)

func (*JsonFloatContext) Visit 

func (s *JsonFloatContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonFloatContext) VisitFunc 

func (s *JsonFloatContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonFloatContextVisitor 

type JsonFloatContextVisitor interface {
	VisitJsonFloat(ctx IJsonFloatContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonFloatEntryListener 

type JsonFloatEntryListener interface {
	EnterJsonFloat(c *JsonFloatContext)
}

From Rule 'jsonVal'

type JsonFloatExitListener 

type JsonFloatExitListener interface {
	ExitJsonFloat(c *JsonFloatContext)
}

type JsonIntContext 

type JsonIntContext struct {
	*JsonValContext
	// contains filtered or unexported fields
}

func NewJsonIntContext 

func NewJsonIntContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonIntContext

func (*JsonIntContext) EnterRule 

func (s *JsonIntContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonIntContext) ExitRule 

func (s *JsonIntContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonIntContext) GetRuleContext 

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

getRuleContext

func (*JsonIntContext) GetTok 

func (s *JsonIntContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*JsonIntContext) IsJsonIntContext 

func (*JsonIntContext) IsJsonIntContext()

func (*JsonIntContext) JsonInt 

func (s *JsonIntContext) JsonInt() antlr.TerminalNode

getters

func (*JsonIntContext) SetTok 

func (s *JsonIntContext) SetTok(v antlr.Token)

func (*JsonIntContext) Visit 

func (s *JsonIntContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonIntContext) VisitFunc 

func (s *JsonIntContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonIntContextVisitor 

type JsonIntContextVisitor interface {
	VisitJsonInt(ctx IJsonIntContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonIntEntryListener 

type JsonIntEntryListener interface {
	EnterJsonInt(c *JsonIntContext)
}

From Rule 'jsonVal'

type JsonIntExitListener 

type JsonIntExitListener interface {
	ExitJsonInt(c *JsonIntContext)
}

type JsonNullContext 

type JsonNullContext struct {
	*JsonValContext
	// contains filtered or unexported fields
}

func NewJsonNullContext 

func NewJsonNullContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonNullContext

func (*JsonNullContext) EnterRule 

func (s *JsonNullContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonNullContext) ExitRule 

func (s *JsonNullContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonNullContext) GetRuleContext 

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

getRuleContext

func (*JsonNullContext) GetTok 

func (s *JsonNullContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*JsonNullContext) IsJsonNullContext 

func (*JsonNullContext) IsJsonNullContext()

func (*JsonNullContext) JsonNull 

func (s *JsonNullContext) JsonNull() antlr.TerminalNode

getters

func (*JsonNullContext) SetTok 

func (s *JsonNullContext) SetTok(v antlr.Token)

func (*JsonNullContext) Visit 

func (s *JsonNullContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonNullContext) VisitFunc 

func (s *JsonNullContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonNullContextVisitor 

type JsonNullContextVisitor interface {
	VisitJsonNull(ctx IJsonNullContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonNullEntryListener 

type JsonNullEntryListener interface {
	EnterJsonNull(c *JsonNullContext)
}

From Rule 'jsonVal'

type JsonNullExitListener 

type JsonNullExitListener interface {
	ExitJsonNull(c *JsonNullContext)
}

type JsonObjContext 

type JsonObjContext struct {
	*JsonValContext
	// contains filtered or unexported fields
}

func NewJsonObjContext 

func NewJsonObjContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonObjContext

func (*JsonObjContext) AllJsonObjKey added in v1.0.9 

func (s *JsonObjContext) AllJsonObjKey() []antlr.TerminalNode

func (*JsonObjContext) AllJsonVal 

func (s *JsonObjContext) AllJsonVal() []IJsonValContext

func (*JsonObjContext) DOWN 

func (s *JsonObjContext) DOWN() antlr.TerminalNode

func (*JsonObjContext) EnterRule 

func (s *JsonObjContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonObjContext) ExitRule 

func (s *JsonObjContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonObjContext) GetRuleContext 

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

getRuleContext

func (*JsonObjContext) GetTok 

func (s *JsonObjContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*JsonObjContext) IsJsonObjContext 

func (*JsonObjContext) IsJsonObjContext()

func (*JsonObjContext) JsonObj 

func (s *JsonObjContext) JsonObj() antlr.TerminalNode

getters

func (*JsonObjContext) JsonObjKey added in v1.0.9 

func (s *JsonObjContext) JsonObjKey(i int) antlr.TerminalNode

func (*JsonObjContext) JsonVal 

func (s *JsonObjContext) JsonVal(i int) IJsonValContext

func (*JsonObjContext) SetTok 

func (s *JsonObjContext) SetTok(v antlr.Token)

func (*JsonObjContext) UP 

func (s *JsonObjContext) UP() antlr.TerminalNode

func (*JsonObjContext) Visit 

func (s *JsonObjContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonObjContext) VisitFunc 

func (s *JsonObjContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonObjContextVisitor 

type JsonObjContextVisitor interface {
	VisitJsonObj(ctx IJsonObjContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonObjEntryListener 

type JsonObjEntryListener interface {
	EnterJsonObj(c *JsonObjContext)
}

From Rule 'jsonVal'

type JsonObjExitListener 

type JsonObjExitListener interface {
	ExitJsonObj(c *JsonObjContext)
}

type JsonStrContext 

type JsonStrContext struct {
	*JsonValContext
	// contains filtered or unexported fields
}

func NewJsonStrContext 

func NewJsonStrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JsonStrContext

func (*JsonStrContext) EnterRule 

func (s *JsonStrContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonStrContext) ExitRule 

func (s *JsonStrContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonStrContext) GetRuleContext 

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

getRuleContext

func (*JsonStrContext) GetTok 

func (s *JsonStrContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*JsonStrContext) IsJsonStrContext 

func (*JsonStrContext) IsJsonStrContext()

func (*JsonStrContext) JsonStr 

func (s *JsonStrContext) JsonStr() antlr.TerminalNode

getters

func (*JsonStrContext) SetTok 

func (s *JsonStrContext) SetTok(v antlr.Token)

func (*JsonStrContext) Visit 

func (s *JsonStrContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*JsonStrContext) VisitFunc 

func (s *JsonStrContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type JsonStrContextVisitor 

type JsonStrContextVisitor interface {
	VisitJsonStr(ctx IJsonStrContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type JsonStrEntryListener 

type JsonStrEntryListener interface {
	EnterJsonStr(c *JsonStrContext)
}

From Rule 'jsonVal'

type JsonStrExitListener 

type JsonStrExitListener interface {
	ExitJsonStr(c *JsonStrContext)
}

type JsonValContext 

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

func NewEmptyJsonValContext 

func NewEmptyJsonValContext() *JsonValContext

func NewJsonValContext 

func NewJsonValContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonValContext

func (*JsonValContext) CopyFrom 

func (s *JsonValContext) CopyFrom(ctx *JsonValContext)

provideCopyFrom

func (*JsonValContext) GetParser 

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

func (*JsonValContext) GetRuleContext 

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

func (*JsonValContext) IsJsonValContext 

func (*JsonValContext) IsJsonValContext()

func (*JsonValContext) ToStringTree 

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

type ModAnnoContext 

type ModAnnoContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewModAnnoContext 

func NewModAnnoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModAnnoContext

func (*ModAnnoContext) DOWN 

func (s *ModAnnoContext) DOWN() antlr.TerminalNode

getters

func (*ModAnnoContext) EnterRule 

func (s *ModAnnoContext) EnterRule(listener antlr.ParseTreeListener)

func (*ModAnnoContext) ExitRule 

func (s *ModAnnoContext) ExitRule(listener antlr.ParseTreeListener)

func (*ModAnnoContext) GetRuleContext 

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

getRuleContext

func (*ModAnnoContext) GetTok 

func (s *ModAnnoContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*ModAnnoContext) IsModAnnoContext 

func (*ModAnnoContext) IsModAnnoContext()

func (*ModAnnoContext) JsonVal 

func (s *ModAnnoContext) JsonVal() IJsonValContext

func (*ModAnnoContext) ModuleAnno 

func (s *ModAnnoContext) ModuleAnno() antlr.TerminalNode

func (*ModAnnoContext) SetTok 

func (s *ModAnnoContext) SetTok(v antlr.Token)

func (*ModAnnoContext) UP 

func (s *ModAnnoContext) UP() antlr.TerminalNode

func (*ModAnnoContext) Visit 

func (s *ModAnnoContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*ModAnnoContext) VisitFunc 

func (s *ModAnnoContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type ModAnnoContextVisitor 

type ModAnnoContextVisitor interface {
	VisitModAnno(ctx IModAnnoContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type ModAnnoEntryListener 

type ModAnnoEntryListener interface {
	EnterModAnno(c *ModAnnoContext)
}

From Rule 'tld'

type ModAnnoExitListener 

type ModAnnoExitListener interface {
	ExitModAnno(c *ModAnnoContext)
}

type ModuleContext 

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

func NewEmptyModuleContext 

func NewEmptyModuleContext() *ModuleContext

func NewModuleContext 

func NewModuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleContext

func (*ModuleContext) AllAnnotation 

func (s *ModuleContext) AllAnnotation() []IAnnotationContext

func (*ModuleContext) AllImport_ 

func (s *ModuleContext) AllImport_() []IImport_Context

func (*ModuleContext) AllTld 

func (s *ModuleContext) AllTld() []ITldContext

func (*ModuleContext) Annotation 

func (s *ModuleContext) Annotation(i int) IAnnotationContext

func (*ModuleContext) DOWN 

func (s *ModuleContext) DOWN() antlr.TerminalNode

func (*ModuleContext) ERROR 

func (s *ModuleContext) ERROR() antlr.TerminalNode

func (*ModuleContext) EnterRule 

func (s *ModuleContext) EnterRule(listener antlr.ParseTreeListener)

dispatchMethods

func (*ModuleContext) ExitRule 

func (s *ModuleContext) ExitRule(listener antlr.ParseTreeListener)

func (*ModuleContext) GetParser 

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

func (*ModuleContext) GetRuleContext 

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

provideCopyFrom

func (*ModuleContext) GetTok 

func (s *ModuleContext) GetTok() antlr.Token

StructDecl tokenDecls

func (*ModuleContext) Import_ 

func (s *ModuleContext) Import_(i int) IImport_Context

func (*ModuleContext) IsModuleContext 

func (*ModuleContext) IsModuleContext()

func (*ModuleContext) Module 

func (s *ModuleContext) Module() antlr.TerminalNode

Getters

func (*ModuleContext) SetTok 

func (s *ModuleContext) SetTok(v antlr.Token)

func (*ModuleContext) Tld 

func (s *ModuleContext) Tld(i int) ITldContext

func (*ModuleContext) ToStringTree 

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

func (*ModuleContext) UP 

func (s *ModuleContext) UP() antlr.TerminalNode

func (*ModuleContext) Visit 

func (s *ModuleContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*ModuleContext) VisitFunc 

func (s *ModuleContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type ModuleContextVisitor 

type ModuleContextVisitor interface {
	VisitModule(ctx IModuleContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type ModuleEntryListener 

type ModuleEntryListener interface {
	EnterModule(c *ModuleContext)
}

type ModuleExitListener 

type ModuleExitListener interface {
	ExitModule(c *ModuleContext)
}

type NameBodyContext 

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

func NewEmptyNameBodyContext 

func NewEmptyNameBodyContext() *NameBodyContext

func NewNameBodyContext 

func NewNameBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameBodyContext

func (*NameBodyContext) CopyFrom 

func (s *NameBodyContext) CopyFrom(ctx *NameBodyContext)

provideCopyFrom

func (*NameBodyContext) GetParser 

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

func (*NameBodyContext) GetRuleContext 

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

func (*NameBodyContext) IsNameBodyContext 

func (*NameBodyContext) IsNameBodyContext()

func (*NameBodyContext) ToStringTree 

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

type NewtypeContext 

type NewtypeContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewNewtypeContext 

func NewNewtypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NewtypeContext

func (*NewtypeContext) AllAnnotation 

func (s *NewtypeContext) AllAnnotation() []IAnnotationContext

func (*NewtypeContext) AllJsonVal 

func (s *NewtypeContext) AllJsonVal() []IJsonValContext

func (*NewtypeContext) Annotation 

func (s *NewtypeContext) Annotation(i int) IAnnotationContext

func (*NewtypeContext) DOWN 

func (s *NewtypeContext) DOWN() antlr.TerminalNode

func (*NewtypeContext) EnterRule 

func (s *NewtypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*NewtypeContext) ExitRule 

func (s *NewtypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*NewtypeContext) GetRuleContext 

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

getRuleContext

func (*NewtypeContext) GetTok 

func (s *NewtypeContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*NewtypeContext) IsNewtypeContext 

func (*NewtypeContext) IsNewtypeContext()

func (*NewtypeContext) JsonVal 

func (s *NewtypeContext) JsonVal(i int) IJsonValContext

func (*NewtypeContext) Newtype 

func (s *NewtypeContext) Newtype() antlr.TerminalNode

getters

func (*NewtypeContext) SetTok 

func (s *NewtypeContext) SetTok(v antlr.Token)

func (*NewtypeContext) TypeExpr_ 

func (s *NewtypeContext) TypeExpr_() ITypeExpr_Context

func (*NewtypeContext) TypeParam 

func (s *NewtypeContext) TypeParam() antlr.TerminalNode

func (*NewtypeContext) UP 

func (s *NewtypeContext) UP() antlr.TerminalNode

func (*NewtypeContext) Visit 

func (s *NewtypeContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*NewtypeContext) VisitFunc 

func (s *NewtypeContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type NewtypeContextVisitor 

type NewtypeContextVisitor interface {
	VisitNewtype(ctx INewtypeContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type NewtypeEntryListener 

type NewtypeEntryListener interface {
	EnterNewtype(c *NewtypeContext)
}

From Rule 'tld'

type NewtypeExitListener 

type NewtypeExitListener interface {
	ExitNewtype(c *NewtypeContext)
}

type StructContext 

type StructContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewStructContext 

func NewStructContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StructContext

func (*StructContext) AllAnnotation 

func (s *StructContext) AllAnnotation() []IAnnotationContext

func (*StructContext) AllNameBody 

func (s *StructContext) AllNameBody() []INameBodyContext

func (*StructContext) Annotation 

func (s *StructContext) Annotation(i int) IAnnotationContext

func (*StructContext) DOWN 

func (s *StructContext) DOWN() antlr.TerminalNode

func (*StructContext) EnterRule 

func (s *StructContext) EnterRule(listener antlr.ParseTreeListener)

func (*StructContext) ExitRule 

func (s *StructContext) ExitRule(listener antlr.ParseTreeListener)

func (*StructContext) GetRuleContext 

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

getRuleContext

func (*StructContext) GetTok 

func (s *StructContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*StructContext) IsStructContext 

func (*StructContext) IsStructContext()

func (*StructContext) NameBody 

func (s *StructContext) NameBody(i int) INameBodyContext

func (*StructContext) SetTok 

func (s *StructContext) SetTok(v antlr.Token)

func (*StructContext) Struct 

func (s *StructContext) Struct() antlr.TerminalNode

getters

func (*StructContext) TypeParam 

func (s *StructContext) TypeParam() antlr.TerminalNode

func (*StructContext) UP 

func (s *StructContext) UP() antlr.TerminalNode

func (*StructContext) Visit 

func (s *StructContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*StructContext) VisitFunc 

func (s *StructContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type StructContextVisitor 

type StructContextVisitor interface {
	VisitStruct(ctx IStructContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type StructEntryListener 

type StructEntryListener interface {
	EnterStruct(c *StructContext)
}

From Rule 'tld'

type StructExitListener 

type StructExitListener interface {
	ExitStruct(c *StructContext)
}

type TLDErrorContext 

type TLDErrorContext struct {
	*TldContext
}

func NewTLDErrorContext 

func NewTLDErrorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TLDErrorContext

func (*TLDErrorContext) DOWN 

func (s *TLDErrorContext) DOWN() antlr.TerminalNode

func (*TLDErrorContext) ERROR 

func (s *TLDErrorContext) ERROR() antlr.TerminalNode

getters

func (*TLDErrorContext) EnterRule 

func (s *TLDErrorContext) EnterRule(listener antlr.ParseTreeListener)

func (*TLDErrorContext) ExitRule 

func (s *TLDErrorContext) ExitRule(listener antlr.ParseTreeListener)

func (*TLDErrorContext) GetRuleContext 

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

getRuleContext

func (*TLDErrorContext) IsTLDErrorContext 

func (*TLDErrorContext) IsTLDErrorContext()

func (*TLDErrorContext) UP 

func (s *TLDErrorContext) UP() antlr.TerminalNode

func (*TLDErrorContext) Visit 

func (s *TLDErrorContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*TLDErrorContext) VisitFunc 

func (s *TLDErrorContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type TLDErrorContextVisitor 

type TLDErrorContextVisitor interface {
	VisitTLDError(ctx ITLDErrorContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type TLDErrorEntryListener 

type TLDErrorEntryListener interface {
	EnterTLDError(c *TLDErrorContext)
}

From Rule 'tld'

type TLDErrorExitListener 

type TLDErrorExitListener interface {
	ExitTLDError(c *TLDErrorContext)
}

type TldContext 

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

func NewEmptyTldContext 

func NewEmptyTldContext() *TldContext

func NewTldContext 

func NewTldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TldContext

func (*TldContext) CopyFrom 

func (s *TldContext) CopyFrom(ctx *TldContext)

provideCopyFrom

func (*TldContext) GetParser 

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

func (*TldContext) GetRuleContext 

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

func (*TldContext) IsTldContext 

func (*TldContext) IsTldContext()

func (*TldContext) ToStringTree 

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

type TypeContext 

type TypeContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewTypeContext 

func NewTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeContext

func (*TypeContext) AllAnnotation 

func (s *TypeContext) AllAnnotation() []IAnnotationContext

func (*TypeContext) AllJsonVal 

func (s *TypeContext) AllJsonVal() []IJsonValContext

func (*TypeContext) Annotation 

func (s *TypeContext) Annotation(i int) IAnnotationContext

func (*TypeContext) DOWN 

func (s *TypeContext) DOWN() antlr.TerminalNode

func (*TypeContext) EnterRule 

func (s *TypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*TypeContext) ExitRule 

func (s *TypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*TypeContext) GetRuleContext 

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

getRuleContext

func (*TypeContext) GetTok 

func (s *TypeContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*TypeContext) IsTypeContext 

func (*TypeContext) IsTypeContext()

func (*TypeContext) JsonVal 

func (s *TypeContext) JsonVal(i int) IJsonValContext

func (*TypeContext) SetTok 

func (s *TypeContext) SetTok(v antlr.Token)

func (*TypeContext) Type 

func (s *TypeContext) Type() antlr.TerminalNode

getters

func (*TypeContext) TypeExpr_ 

func (s *TypeContext) TypeExpr_() ITypeExpr_Context

func (*TypeContext) TypeParam 

func (s *TypeContext) TypeParam() antlr.TerminalNode

func (*TypeContext) UP 

func (s *TypeContext) UP() antlr.TerminalNode

func (*TypeContext) Visit 

func (s *TypeContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*TypeContext) VisitFunc 

func (s *TypeContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type TypeContextVisitor 

type TypeContextVisitor interface {
	VisitType(ctx ITypeContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type TypeEntryListener 

type TypeEntryListener interface {
	EnterType(c *TypeContext)
}

From Rule 'tld'

type TypeExitListener 

type TypeExitListener interface {
	ExitType(c *TypeContext)
}

type TypeExprGenericContext added in v1.0.8 

type TypeExprGenericContext struct {
	*TypeExpr_Context
	// contains filtered or unexported fields
}

func NewTypeExprGenericContext added in v1.0.8 

func NewTypeExprGenericContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeExprGenericContext

func (*TypeExprGenericContext) AllTypeExpr_ added in v1.0.8 

func (s *TypeExprGenericContext) AllTypeExpr_() []ITypeExpr_Context

func (*TypeExprGenericContext) DOWN added in v1.0.8 

func (s *TypeExprGenericContext) DOWN() antlr.TerminalNode

func (*TypeExprGenericContext) EnterRule added in v1.0.8 

func (s *TypeExprGenericContext) EnterRule(listener antlr.ParseTreeListener)

func (*TypeExprGenericContext) ExitRule added in v1.0.8 

func (s *TypeExprGenericContext) ExitRule(listener antlr.ParseTreeListener)

func (*TypeExprGenericContext) GetRuleContext added in v1.0.8 

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

getRuleContext

func (*TypeExprGenericContext) GetTok added in v1.0.8 

func (s *TypeExprGenericContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*TypeExprGenericContext) IsTypeExprGenericContext added in v1.0.8 

func (*TypeExprGenericContext) IsTypeExprGenericContext()

func (*TypeExprGenericContext) SetTok added in v1.0.8 

func (s *TypeExprGenericContext) SetTok(v antlr.Token)

func (*TypeExprGenericContext) TypeExprGeneric added in v1.0.8 

func (s *TypeExprGenericContext) TypeExprGeneric() antlr.TerminalNode

getters

func (*TypeExprGenericContext) TypeExpr_ added in v1.0.8 

func (s *TypeExprGenericContext) TypeExpr_(i int) ITypeExpr_Context

func (*TypeExprGenericContext) UP added in v1.0.8 

func (s *TypeExprGenericContext) UP() antlr.TerminalNode

func (*TypeExprGenericContext) Visit added in v1.0.8 

func (s *TypeExprGenericContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*TypeExprGenericContext) VisitFunc added in v1.0.8 

func (s *TypeExprGenericContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type TypeExprGenericContextVisitor added in v1.0.8 

type TypeExprGenericContextVisitor interface {
	VisitTypeExprGeneric(ctx ITypeExprGenericContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type TypeExprGenericEntryListener added in v1.0.8 

type TypeExprGenericEntryListener interface {
	EnterTypeExprGeneric(c *TypeExprGenericContext)
}

From Rule 'typeExpr_'

type TypeExprGenericExitListener added in v1.0.8 

type TypeExprGenericExitListener interface {
	ExitTypeExprGeneric(c *TypeExprGenericContext)
}

type TypeExprSimpleContext added in v1.0.8 

type TypeExprSimpleContext struct {
	*TypeExpr_Context
	// contains filtered or unexported fields
}

func NewTypeExprSimpleContext added in v1.0.8 

func NewTypeExprSimpleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeExprSimpleContext

func (*TypeExprSimpleContext) EnterRule added in v1.0.8 

func (s *TypeExprSimpleContext) EnterRule(listener antlr.ParseTreeListener)

func (*TypeExprSimpleContext) ExitRule added in v1.0.8 

func (s *TypeExprSimpleContext) ExitRule(listener antlr.ParseTreeListener)

func (*TypeExprSimpleContext) GetRuleContext added in v1.0.8 

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

getRuleContext

func (*TypeExprSimpleContext) GetTok added in v1.0.8 

func (s *TypeExprSimpleContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*TypeExprSimpleContext) IsTypeExprSimpleContext added in v1.0.8 

func (*TypeExprSimpleContext) IsTypeExprSimpleContext()

func (*TypeExprSimpleContext) SetTok added in v1.0.8 

func (s *TypeExprSimpleContext) SetTok(v antlr.Token)

func (*TypeExprSimpleContext) TypeExprSimple added in v1.0.8 

func (s *TypeExprSimpleContext) TypeExprSimple() antlr.TerminalNode

getters

func (*TypeExprSimpleContext) Visit added in v1.0.8 

func (s *TypeExprSimpleContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*TypeExprSimpleContext) VisitFunc added in v1.0.8 

func (s *TypeExprSimpleContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type TypeExprSimpleContextVisitor added in v1.0.8 

type TypeExprSimpleContextVisitor interface {
	VisitTypeExprSimple(ctx ITypeExprSimpleContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type TypeExprSimpleEntryListener added in v1.0.8 

type TypeExprSimpleEntryListener interface {
	EnterTypeExprSimple(c *TypeExprSimpleContext)
}

From Rule 'typeExpr_'

type TypeExprSimpleExitListener added in v1.0.8 

type TypeExprSimpleExitListener interface {
	ExitTypeExprSimple(c *TypeExprSimpleContext)
}

type TypeExpr_Context 

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

func NewEmptyTypeExpr_Context 

func NewEmptyTypeExpr_Context() *TypeExpr_Context

func NewTypeExpr_Context 

func NewTypeExpr_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeExpr_Context

func (*TypeExpr_Context) CopyFrom added in v1.0.8 

func (s *TypeExpr_Context) CopyFrom(ctx *TypeExpr_Context)

provideCopyFrom

func (*TypeExpr_Context) GetParser 

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

func (*TypeExpr_Context) GetRuleContext 

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

func (*TypeExpr_Context) IsTypeExpr_Context 

func (*TypeExpr_Context) IsTypeExpr_Context()

func (*TypeExpr_Context) ToStringTree 

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

type TypeParamErrorContext 

type TypeParamErrorContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewTypeParamErrorContext 

func NewTypeParamErrorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeParamErrorContext

func (*TypeParamErrorContext) AllAnnotation 

func (s *TypeParamErrorContext) AllAnnotation() []IAnnotationContext

func (*TypeParamErrorContext) AllJsonVal 

func (s *TypeParamErrorContext) AllJsonVal() []IJsonValContext

func (*TypeParamErrorContext) AllNameBody 

func (s *TypeParamErrorContext) AllNameBody() []INameBodyContext

func (*TypeParamErrorContext) Annotation 

func (s *TypeParamErrorContext) Annotation(i int) IAnnotationContext

func (*TypeParamErrorContext) DOWN 

func (s *TypeParamErrorContext) DOWN() antlr.TerminalNode

getters

func (*TypeParamErrorContext) ERROR 

func (s *TypeParamErrorContext) ERROR() antlr.TerminalNode

func (*TypeParamErrorContext) EnterRule 

func (s *TypeParamErrorContext) EnterRule(listener antlr.ParseTreeListener)

func (*TypeParamErrorContext) ExitRule 

func (s *TypeParamErrorContext) ExitRule(listener antlr.ParseTreeListener)

func (*TypeParamErrorContext) GetRuleContext 

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

getRuleContext

func (*TypeParamErrorContext) GetTok 

func (s *TypeParamErrorContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*TypeParamErrorContext) IsTypeParamErrorContext 

func (*TypeParamErrorContext) IsTypeParamErrorContext()

func (*TypeParamErrorContext) JsonVal 

func (s *TypeParamErrorContext) JsonVal(i int) IJsonValContext

func (*TypeParamErrorContext) NameBody 

func (s *TypeParamErrorContext) NameBody(i int) INameBodyContext

func (*TypeParamErrorContext) Newtype 

func (s *TypeParamErrorContext) Newtype() antlr.TerminalNode

func (*TypeParamErrorContext) SetTok 

func (s *TypeParamErrorContext) SetTok(v antlr.Token)

func (*TypeParamErrorContext) Struct 

func (s *TypeParamErrorContext) Struct() antlr.TerminalNode

func (*TypeParamErrorContext) Type 

func (s *TypeParamErrorContext) Type() antlr.TerminalNode

func (*TypeParamErrorContext) TypeExpr_ 

func (s *TypeParamErrorContext) TypeExpr_() ITypeExpr_Context

func (*TypeParamErrorContext) UP 

func (s *TypeParamErrorContext) UP() antlr.TerminalNode

func (*TypeParamErrorContext) Union 

func (s *TypeParamErrorContext) Union() antlr.TerminalNode

func (*TypeParamErrorContext) Visit 

func (s *TypeParamErrorContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*TypeParamErrorContext) VisitFunc 

func (s *TypeParamErrorContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type TypeParamErrorContextVisitor 

type TypeParamErrorContextVisitor interface {
	VisitTypeParamError(ctx ITypeParamErrorContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type TypeParamErrorEntryListener 

type TypeParamErrorEntryListener interface {
	EnterTypeParamError(c *TypeParamErrorContext)
}

From Rule 'tld'

type TypeParamErrorExitListener 

type TypeParamErrorExitListener interface {
	ExitTypeParamError(c *TypeParamErrorContext)
}

type UnionContext 

type UnionContext struct {
	*TldContext
	// contains filtered or unexported fields
}

func NewUnionContext 

func NewUnionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnionContext

func (*UnionContext) AllAnnotation 

func (s *UnionContext) AllAnnotation() []IAnnotationContext

func (*UnionContext) AllNameBody 

func (s *UnionContext) AllNameBody() []INameBodyContext

func (*UnionContext) Annotation 

func (s *UnionContext) Annotation(i int) IAnnotationContext

func (*UnionContext) DOWN 

func (s *UnionContext) DOWN() antlr.TerminalNode

func (*UnionContext) EnterRule 

func (s *UnionContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnionContext) ExitRule 

func (s *UnionContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnionContext) GetRuleContext 

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

getRuleContext

func (*UnionContext) GetTok 

func (s *UnionContext) GetTok() antlr.Token

AltLabelStructDecl tokenDecls

func (*UnionContext) IsUnionContext 

func (*UnionContext) IsUnionContext()

func (*UnionContext) NameBody 

func (s *UnionContext) NameBody(i int) INameBodyContext

func (*UnionContext) SetTok 

func (s *UnionContext) SetTok(v antlr.Token)

func (*UnionContext) TypeParam 

func (s *UnionContext) TypeParam() antlr.TerminalNode

func (*UnionContext) UP 

func (s *UnionContext) UP() antlr.TerminalNode

func (*UnionContext) Union 

func (s *UnionContext) Union() antlr.TerminalNode

getters

func (*UnionContext) Visit 

func (s *UnionContext) Visit(delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})

func (*UnionContext) VisitFunc 

func (s *UnionContext) VisitFunc(hdls antlr.ParserTreeVisitorHandlers, args ...interface{}) (result interface{})

type UnionContextVisitor 

type UnionContextVisitor interface {
	VisitUnion(ctx IUnionContext, delegate antlr.ParseTreeVisitor, args ...interface{}) (result interface{})
}

type UnionEntryListener 

type UnionEntryListener interface {
	EnterUnion(c *UnionContext)
}

From Rule 'tld'

type UnionExitListener 

type UnionExitListener interface {
	ExitUnion(c *UnionContext)
}

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.