gen

package

Go to main page

Versions in this module

v0

v0.2.0

Aug 14, 2024

Changes in this version

+ const MangleLexerBYTESTRING

+ const MangleParserBYTESTRING

+ type BStrContext struct

+ func NewBStrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BStrContext

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

+ func (s *BStrContext) BYTESTRING() antlr.TerminalNode

+ func (s *BStrContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *BStrContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *BStrContext) GetRuleContext() antlr.RuleContext

type BaseMangleListener

+ func (s *BaseMangleListener) EnterBStr(ctx *BStrContext)

+ func (s *BaseMangleListener) ExitBStr(ctx *BStrContext)

type BaseMangleVisitor

+ func (v *BaseMangleVisitor) VisitBStr(ctx *BStrContext) interface{}

type MangleListener

+ EnterBStr func(c *BStrContext)

+ ExitBStr func(c *BStrContext)

type MangleVisitor

+ VisitBStr func(ctx *BStrContext) interface{}

v0.1.0

Dec 15, 2023

Changes in this version

+ const MangleLexerBANG

+ const MangleLexerBANGEQ

+ const MangleLexerBOUND

+ const MangleLexerCOLONDASH

+ const MangleLexerCOMMA

+ const MangleLexerCOMMENT

+ const MangleLexerCONSTANT

+ const MangleLexerDECL

+ const MangleLexerDO

+ const MangleLexerEQ

+ const MangleLexerFLOAT

+ const MangleLexerGREATER

+ const MangleLexerGREATEREQ

+ const MangleLexerLBRACKET

+ const MangleLexerLESS

+ const MangleLexerLESSEQ

+ const MangleLexerLET

+ const MangleLexerLPAREN

+ const MangleLexerNAME

+ const MangleLexerNEWLINE

+ const MangleLexerNUMBER

+ const MangleLexerPACKAGE

+ const MangleLexerPIPEGREATER

+ const MangleLexerRBRACKET

+ const MangleLexerRPAREN

+ const MangleLexerSTRING

+ const MangleLexerT__0

+ const MangleLexerT__1

+ const MangleLexerT__2

+ const MangleLexerT__3

+ const MangleLexerT__4

+ const MangleLexerT__5

+ const MangleLexerUSE

+ const MangleLexerVARIABLE

+ const MangleLexerWHITESPACE

+ const MangleParserBANG

+ const MangleParserBANGEQ

+ const MangleParserBOUND

+ const MangleParserCOLONDASH

+ const MangleParserCOMMA

+ const MangleParserCOMMENT

+ const MangleParserCONSTANT

+ const MangleParserDECL

+ const MangleParserDO

+ const MangleParserEOF

+ const MangleParserEQ

+ const MangleParserFLOAT

+ const MangleParserGREATER

+ const MangleParserGREATEREQ

+ const MangleParserLBRACKET

+ const MangleParserLESS

+ const MangleParserLESSEQ

+ const MangleParserLET

+ const MangleParserLPAREN

+ const MangleParserNAME

+ const MangleParserNEWLINE

+ const MangleParserNUMBER

+ const MangleParserPACKAGE

+ const MangleParserPIPEGREATER

+ const MangleParserRBRACKET

+ const MangleParserRPAREN

+ const MangleParserRULE_atom

+ const MangleParserRULE_atoms

+ const MangleParserRULE_boundsBlock

+ const MangleParserRULE_clause

+ const MangleParserRULE_clauseBody

+ const MangleParserRULE_constraintsBlock

+ const MangleParserRULE_decl

+ const MangleParserRULE_descrBlock

+ const MangleParserRULE_letStmt

+ const MangleParserRULE_literalOrFml

+ const MangleParserRULE_packageDecl

+ const MangleParserRULE_program

+ const MangleParserRULE_start

+ const MangleParserRULE_term

+ const MangleParserRULE_transform

+ const MangleParserRULE_useDecl

+ const MangleParserSTRING

+ const MangleParserT__0

+ const MangleParserT__1

+ const MangleParserT__2

+ const MangleParserT__3

+ const MangleParserT__4

+ const MangleParserT__5

+ const MangleParserUSE

+ const MangleParserVARIABLE

+ const MangleParserWHITESPACE

+ var MangleLexerLexerStaticData struct

+ var MangleParserStaticData struct

+ func InitEmptyAtomContext(p *AtomContext)

+ func InitEmptyAtomsContext(p *AtomsContext)

+ func InitEmptyBoundsBlockContext(p *BoundsBlockContext)

+ func InitEmptyClauseBodyContext(p *ClauseBodyContext)

+ func InitEmptyClauseContext(p *ClauseContext)

+ func InitEmptyConstraintsBlockContext(p *ConstraintsBlockContext)

+ func InitEmptyDeclContext(p *DeclContext)

+ func InitEmptyDescrBlockContext(p *DescrBlockContext)

+ func InitEmptyLetStmtContext(p *LetStmtContext)

+ func InitEmptyLiteralOrFmlContext(p *LiteralOrFmlContext)

+ func InitEmptyPackageDeclContext(p *PackageDeclContext)

+ func InitEmptyProgramContext(p *ProgramContext)

+ func InitEmptyStartContext(p *StartContext)

+ func InitEmptyTermContext(p *TermContext)

+ func InitEmptyTransformContext(p *TransformContext)

+ func InitEmptyUseDeclContext(p *UseDeclContext)

+ func MangleLexerInit()

+ func MangleParserInit()

+ type ApplContext struct

+ func NewApplContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ApplContext

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

+ func (s *ApplContext) AllCOMMA() []antlr.TerminalNode

+ func (s *ApplContext) AllTerm() []ITermContext

+ func (s *ApplContext) COMMA(i int) antlr.TerminalNode

+ func (s *ApplContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ApplContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ApplContext) GetRuleContext() antlr.RuleContext

+ func (s *ApplContext) LPAREN() antlr.TerminalNode

+ func (s *ApplContext) NAME() antlr.TerminalNode

+ func (s *ApplContext) RPAREN() antlr.TerminalNode

+ func (s *ApplContext) Term(i int) ITermContext

+ type AtomContext struct

+ func NewAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomContext

+ func NewEmptyAtomContext() *AtomContext

+ func (*AtomContext) IsAtomContext()

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

+ func (s *AtomContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AtomContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AtomContext) GetParser() antlr.Parser

+ func (s *AtomContext) GetRuleContext() antlr.RuleContext

+ func (s *AtomContext) Term() ITermContext

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

+ type AtomsContext struct

+ func NewAtomsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomsContext

+ func NewEmptyAtomsContext() *AtomsContext

+ func (*AtomsContext) IsAtomsContext()

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

+ func (s *AtomsContext) AllAtom() []IAtomContext

+ func (s *AtomsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *AtomsContext) Atom(i int) IAtomContext

+ func (s *AtomsContext) COMMA(i int) antlr.TerminalNode

+ func (s *AtomsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AtomsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AtomsContext) GetParser() antlr.Parser

+ func (s *AtomsContext) GetRuleContext() antlr.RuleContext

+ func (s *AtomsContext) LBRACKET() antlr.TerminalNode

+ func (s *AtomsContext) RBRACKET() antlr.TerminalNode

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

+ type BaseMangleListener struct

+ func (s *BaseMangleListener) EnterAppl(ctx *ApplContext)

+ func (s *BaseMangleListener) EnterAtom(ctx *AtomContext)

+ func (s *BaseMangleListener) EnterAtoms(ctx *AtomsContext)

+ func (s *BaseMangleListener) EnterBoundsBlock(ctx *BoundsBlockContext)

+ func (s *BaseMangleListener) EnterClause(ctx *ClauseContext)

+ func (s *BaseMangleListener) EnterClauseBody(ctx *ClauseBodyContext)

+ func (s *BaseMangleListener) EnterConst(ctx *ConstContext)

+ func (s *BaseMangleListener) EnterConstraintsBlock(ctx *ConstraintsBlockContext)

+ func (s *BaseMangleListener) EnterDecl(ctx *DeclContext)

+ func (s *BaseMangleListener) EnterDescrBlock(ctx *DescrBlockContext)

+ func (s *BaseMangleListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseMangleListener) EnterFloat(ctx *FloatContext)

+ func (s *BaseMangleListener) EnterLetStmt(ctx *LetStmtContext)

+ func (s *BaseMangleListener) EnterList(ctx *ListContext)

+ func (s *BaseMangleListener) EnterLiteralOrFml(ctx *LiteralOrFmlContext)

+ func (s *BaseMangleListener) EnterMap(ctx *MapContext)

+ func (s *BaseMangleListener) EnterNum(ctx *NumContext)

+ func (s *BaseMangleListener) EnterPackageDecl(ctx *PackageDeclContext)

+ func (s *BaseMangleListener) EnterProgram(ctx *ProgramContext)

+ func (s *BaseMangleListener) EnterStart(ctx *StartContext)

+ func (s *BaseMangleListener) EnterStr(ctx *StrContext)

+ func (s *BaseMangleListener) EnterStruct(ctx *StructContext)

+ func (s *BaseMangleListener) EnterTransform(ctx *TransformContext)

+ func (s *BaseMangleListener) EnterUseDecl(ctx *UseDeclContext)

+ func (s *BaseMangleListener) EnterVar(ctx *VarContext)

+ func (s *BaseMangleListener) ExitAppl(ctx *ApplContext)

+ func (s *BaseMangleListener) ExitAtom(ctx *AtomContext)

+ func (s *BaseMangleListener) ExitAtoms(ctx *AtomsContext)

+ func (s *BaseMangleListener) ExitBoundsBlock(ctx *BoundsBlockContext)

+ func (s *BaseMangleListener) ExitClause(ctx *ClauseContext)

+ func (s *BaseMangleListener) ExitClauseBody(ctx *ClauseBodyContext)

+ func (s *BaseMangleListener) ExitConst(ctx *ConstContext)

+ func (s *BaseMangleListener) ExitConstraintsBlock(ctx *ConstraintsBlockContext)

+ func (s *BaseMangleListener) ExitDecl(ctx *DeclContext)

+ func (s *BaseMangleListener) ExitDescrBlock(ctx *DescrBlockContext)

+ func (s *BaseMangleListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseMangleListener) ExitFloat(ctx *FloatContext)

+ func (s *BaseMangleListener) ExitLetStmt(ctx *LetStmtContext)

+ func (s *BaseMangleListener) ExitList(ctx *ListContext)

+ func (s *BaseMangleListener) ExitLiteralOrFml(ctx *LiteralOrFmlContext)

+ func (s *BaseMangleListener) ExitMap(ctx *MapContext)

+ func (s *BaseMangleListener) ExitNum(ctx *NumContext)

+ func (s *BaseMangleListener) ExitPackageDecl(ctx *PackageDeclContext)

+ func (s *BaseMangleListener) ExitProgram(ctx *ProgramContext)

+ func (s *BaseMangleListener) ExitStart(ctx *StartContext)

+ func (s *BaseMangleListener) ExitStr(ctx *StrContext)

+ func (s *BaseMangleListener) ExitStruct(ctx *StructContext)

+ func (s *BaseMangleListener) ExitTransform(ctx *TransformContext)

+ func (s *BaseMangleListener) ExitUseDecl(ctx *UseDeclContext)

+ func (s *BaseMangleListener) ExitVar(ctx *VarContext)

+ func (s *BaseMangleListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseMangleListener) VisitTerminal(node antlr.TerminalNode)

+ type BaseMangleVisitor struct

+ func (v *BaseMangleVisitor) VisitAppl(ctx *ApplContext) interface{}

+ func (v *BaseMangleVisitor) VisitAtom(ctx *AtomContext) interface{}

+ func (v *BaseMangleVisitor) VisitAtoms(ctx *AtomsContext) interface{}

+ func (v *BaseMangleVisitor) VisitBoundsBlock(ctx *BoundsBlockContext) interface{}

+ func (v *BaseMangleVisitor) VisitClause(ctx *ClauseContext) interface{}

+ func (v *BaseMangleVisitor) VisitClauseBody(ctx *ClauseBodyContext) interface{}

+ func (v *BaseMangleVisitor) VisitConst(ctx *ConstContext) interface{}

+ func (v *BaseMangleVisitor) VisitConstraintsBlock(ctx *ConstraintsBlockContext) interface{}

+ func (v *BaseMangleVisitor) VisitDecl(ctx *DeclContext) interface{}

+ func (v *BaseMangleVisitor) VisitDescrBlock(ctx *DescrBlockContext) interface{}

+ func (v *BaseMangleVisitor) VisitFloat(ctx *FloatContext) interface{}

+ func (v *BaseMangleVisitor) VisitLetStmt(ctx *LetStmtContext) interface{}

+ func (v *BaseMangleVisitor) VisitList(ctx *ListContext) interface{}

+ func (v *BaseMangleVisitor) VisitLiteralOrFml(ctx *LiteralOrFmlContext) interface{}

+ func (v *BaseMangleVisitor) VisitMap(ctx *MapContext) interface{}

+ func (v *BaseMangleVisitor) VisitNum(ctx *NumContext) interface{}

+ func (v *BaseMangleVisitor) VisitPackageDecl(ctx *PackageDeclContext) interface{}

+ func (v *BaseMangleVisitor) VisitProgram(ctx *ProgramContext) interface{}

+ func (v *BaseMangleVisitor) VisitStart(ctx *StartContext) interface{}

+ func (v *BaseMangleVisitor) VisitStr(ctx *StrContext) interface{}

+ func (v *BaseMangleVisitor) VisitStruct(ctx *StructContext) interface{}

+ func (v *BaseMangleVisitor) VisitTransform(ctx *TransformContext) interface{}

+ func (v *BaseMangleVisitor) VisitUseDecl(ctx *UseDeclContext) interface{}

+ func (v *BaseMangleVisitor) VisitVar(ctx *VarContext) interface{}

+ type BoundsBlockContext struct

+ func NewBoundsBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BoundsBlockContext

+ func NewEmptyBoundsBlockContext() *BoundsBlockContext

+ func (*BoundsBlockContext) IsBoundsBlockContext()

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

+ func (s *BoundsBlockContext) AllCOMMA() []antlr.TerminalNode

+ func (s *BoundsBlockContext) AllTerm() []ITermContext

+ func (s *BoundsBlockContext) BOUND() antlr.TerminalNode

+ func (s *BoundsBlockContext) COMMA(i int) antlr.TerminalNode

+ func (s *BoundsBlockContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *BoundsBlockContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *BoundsBlockContext) GetParser() antlr.Parser

+ func (s *BoundsBlockContext) GetRuleContext() antlr.RuleContext

+ func (s *BoundsBlockContext) LBRACKET() antlr.TerminalNode

+ func (s *BoundsBlockContext) RBRACKET() antlr.TerminalNode

+ func (s *BoundsBlockContext) Term(i int) ITermContext

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

+ type ClauseBodyContext struct

+ func NewClauseBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClauseBodyContext

+ func NewEmptyClauseBodyContext() *ClauseBodyContext

+ func (*ClauseBodyContext) IsClauseBodyContext()

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

+ func (s *ClauseBodyContext) AllCOMMA() []antlr.TerminalNode

+ func (s *ClauseBodyContext) AllLiteralOrFml() []ILiteralOrFmlContext

+ func (s *ClauseBodyContext) COMMA(i int) antlr.TerminalNode

+ func (s *ClauseBodyContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ClauseBodyContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ClauseBodyContext) GetParser() antlr.Parser

+ func (s *ClauseBodyContext) GetRuleContext() antlr.RuleContext

+ func (s *ClauseBodyContext) LiteralOrFml(i int) ILiteralOrFmlContext

+ func (s *ClauseBodyContext) PIPEGREATER() antlr.TerminalNode

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

+ func (s *ClauseBodyContext) Transform() ITransformContext

+ type ClauseContext struct

+ func NewClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClauseContext

+ func NewEmptyClauseContext() *ClauseContext

+ func (*ClauseContext) IsClauseContext()

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

+ func (s *ClauseContext) Atom() IAtomContext

+ func (s *ClauseContext) COLONDASH() antlr.TerminalNode

+ func (s *ClauseContext) ClauseBody() IClauseBodyContext

+ func (s *ClauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ClauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ClauseContext) GetParser() antlr.Parser

+ func (s *ClauseContext) GetRuleContext() antlr.RuleContext

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

+ type ConstContext struct

+ func NewConstContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstContext

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

+ func (s *ConstContext) CONSTANT() antlr.TerminalNode

+ func (s *ConstContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ConstContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ConstContext) GetRuleContext() antlr.RuleContext

+ type ConstraintsBlockContext struct

+ func NewConstraintsBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintsBlockContext

+ func NewEmptyConstraintsBlockContext() *ConstraintsBlockContext

+ func (*ConstraintsBlockContext) IsConstraintsBlockContext()

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

+ func (s *ConstraintsBlockContext) Atoms() IAtomsContext

+ func (s *ConstraintsBlockContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ConstraintsBlockContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ConstraintsBlockContext) GetParser() antlr.Parser

+ func (s *ConstraintsBlockContext) GetRuleContext() antlr.RuleContext

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

+ type DeclContext struct

+ func NewDeclContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclContext

+ func NewEmptyDeclContext() *DeclContext

+ func (*DeclContext) IsDeclContext()

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

+ func (s *DeclContext) AllBoundsBlock() []IBoundsBlockContext

+ func (s *DeclContext) Atom() IAtomContext

+ func (s *DeclContext) BoundsBlock(i int) IBoundsBlockContext

+ func (s *DeclContext) ConstraintsBlock() IConstraintsBlockContext

+ func (s *DeclContext) DECL() antlr.TerminalNode

+ func (s *DeclContext) DescrBlock() IDescrBlockContext

+ func (s *DeclContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *DeclContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *DeclContext) GetParser() antlr.Parser

+ func (s *DeclContext) GetRuleContext() antlr.RuleContext

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

+ type DescrBlockContext struct

+ func NewDescrBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DescrBlockContext

+ func NewEmptyDescrBlockContext() *DescrBlockContext

+ func (*DescrBlockContext) IsDescrBlockContext()

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

+ func (s *DescrBlockContext) Atoms() IAtomsContext

+ func (s *DescrBlockContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *DescrBlockContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *DescrBlockContext) GetParser() antlr.Parser

+ func (s *DescrBlockContext) GetRuleContext() antlr.RuleContext

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

+ type FloatContext struct

+ func NewFloatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FloatContext

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

+ func (s *FloatContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *FloatContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *FloatContext) FLOAT() antlr.TerminalNode

+ func (s *FloatContext) GetRuleContext() antlr.RuleContext

+ type IAtomContext interface

+ GetParser func() antlr.Parser

+ IsAtomContext func()

+ Term func() ITermContext

+ type IAtomsContext interface

+ AllAtom func() []IAtomContext

+ AllCOMMA func() []antlr.TerminalNode

+ Atom func(i int) IAtomContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsAtomsContext func()

+ LBRACKET func() antlr.TerminalNode

+ RBRACKET func() antlr.TerminalNode

+ type IBoundsBlockContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllTerm func() []ITermContext

+ BOUND func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsBoundsBlockContext func()

+ LBRACKET func() antlr.TerminalNode

+ RBRACKET func() antlr.TerminalNode

+ Term func(i int) ITermContext

+ type IClauseBodyContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllLiteralOrFml func() []ILiteralOrFmlContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsClauseBodyContext func()

+ LiteralOrFml func(i int) ILiteralOrFmlContext

+ PIPEGREATER func() antlr.TerminalNode

+ Transform func() ITransformContext

+ type IClauseContext interface

+ Atom func() IAtomContext

+ COLONDASH func() antlr.TerminalNode

+ ClauseBody func() IClauseBodyContext

+ GetParser func() antlr.Parser

+ IsClauseContext func()

+ type IConstraintsBlockContext interface

+ Atoms func() IAtomsContext

+ GetParser func() antlr.Parser

+ IsConstraintsBlockContext func()

+ type IDeclContext interface

+ AllBoundsBlock func() []IBoundsBlockContext

+ Atom func() IAtomContext

+ BoundsBlock func(i int) IBoundsBlockContext

+ ConstraintsBlock func() IConstraintsBlockContext

+ DECL func() antlr.TerminalNode

+ DescrBlock func() IDescrBlockContext

+ GetParser func() antlr.Parser

+ IsDeclContext func()

+ type IDescrBlockContext interface

+ Atoms func() IAtomsContext

+ GetParser func() antlr.Parser

+ IsDescrBlockContext func()

+ type ILetStmtContext interface

+ EQ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsLetStmtContext func()

+ LET func() antlr.TerminalNode

+ Term func() ITermContext

+ VARIABLE func() antlr.TerminalNode

+ type ILiteralOrFmlContext interface

+ AllTerm func() []ITermContext

+ BANG func() antlr.TerminalNode

+ BANGEQ func() antlr.TerminalNode

+ EQ func() antlr.TerminalNode

+ GREATER func() antlr.TerminalNode

+ GREATEREQ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsLiteralOrFmlContext func()

+ LESS func() antlr.TerminalNode

+ LESSEQ func() antlr.TerminalNode

+ Term func(i int) ITermContext

+ type IPackageDeclContext interface

+ Atoms func() IAtomsContext

+ BANG func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsPackageDeclContext func()

+ NAME func() antlr.TerminalNode

+ PACKAGE func() antlr.TerminalNode

+ type IProgramContext interface

+ AllClause func() []IClauseContext

+ AllDecl func() []IDeclContext

+ AllUseDecl func() []IUseDeclContext

+ Clause func(i int) IClauseContext

+ Decl func(i int) IDeclContext

+ GetParser func() antlr.Parser

+ IsProgramContext func()

+ PackageDecl func() IPackageDeclContext

+ UseDecl func(i int) IUseDeclContext

+ type IStartContext interface

+ EOF func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsStartContext func()

+ Program func() IProgramContext

+ type ITermContext interface

+ GetParser func() antlr.Parser

+ IsTermContext func()

+ type ITransformContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllLetStmt func() []ILetStmtContext

+ COMMA func(i int) antlr.TerminalNode

+ DO func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsTransformContext func()

+ LetStmt func(i int) ILetStmtContext

+ Term func() ITermContext

+ type IUseDeclContext interface

+ Atoms func() IAtomsContext

+ BANG func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsUseDeclContext func()

+ NAME func() antlr.TerminalNode

+ USE func() antlr.TerminalNode

+ type LetStmtContext struct

+ func NewEmptyLetStmtContext() *LetStmtContext

+ func NewLetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LetStmtContext

+ func (*LetStmtContext) IsLetStmtContext()

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

+ func (s *LetStmtContext) EQ() antlr.TerminalNode

+ func (s *LetStmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *LetStmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *LetStmtContext) GetParser() antlr.Parser

+ func (s *LetStmtContext) GetRuleContext() antlr.RuleContext

+ func (s *LetStmtContext) LET() antlr.TerminalNode

+ func (s *LetStmtContext) Term() ITermContext

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

+ func (s *LetStmtContext) VARIABLE() antlr.TerminalNode

+ type ListContext struct

+ func NewListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ListContext

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

+ func (s *ListContext) AllCOMMA() []antlr.TerminalNode

+ func (s *ListContext) AllTerm() []ITermContext

+ func (s *ListContext) COMMA(i int) antlr.TerminalNode

+ func (s *ListContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ListContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ListContext) GetRuleContext() antlr.RuleContext

+ func (s *ListContext) LBRACKET() antlr.TerminalNode

+ func (s *ListContext) RBRACKET() antlr.TerminalNode

+ func (s *ListContext) Term(i int) ITermContext

+ type LiteralOrFmlContext struct

+ func NewEmptyLiteralOrFmlContext() *LiteralOrFmlContext

+ func NewLiteralOrFmlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralOrFmlContext

+ func (*LiteralOrFmlContext) IsLiteralOrFmlContext()

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

+ func (s *LiteralOrFmlContext) AllTerm() []ITermContext

+ func (s *LiteralOrFmlContext) BANG() antlr.TerminalNode

+ func (s *LiteralOrFmlContext) BANGEQ() antlr.TerminalNode

+ func (s *LiteralOrFmlContext) EQ() antlr.TerminalNode

+ func (s *LiteralOrFmlContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *LiteralOrFmlContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *LiteralOrFmlContext) GREATER() antlr.TerminalNode

+ func (s *LiteralOrFmlContext) GREATEREQ() antlr.TerminalNode

+ func (s *LiteralOrFmlContext) GetParser() antlr.Parser

+ func (s *LiteralOrFmlContext) GetRuleContext() antlr.RuleContext

+ func (s *LiteralOrFmlContext) LESS() antlr.TerminalNode

+ func (s *LiteralOrFmlContext) LESSEQ() antlr.TerminalNode

+ func (s *LiteralOrFmlContext) Term(i int) ITermContext

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

+ type MangleLexer struct

+ func NewMangleLexer(input antlr.CharStream) *MangleLexer

+ type MangleListener interface

+ EnterAppl func(c *ApplContext)

+ EnterAtom func(c *AtomContext)

+ EnterAtoms func(c *AtomsContext)

+ EnterBoundsBlock func(c *BoundsBlockContext)

+ EnterClause func(c *ClauseContext)

+ EnterClauseBody func(c *ClauseBodyContext)

+ EnterConst func(c *ConstContext)

+ EnterConstraintsBlock func(c *ConstraintsBlockContext)

+ EnterDecl func(c *DeclContext)

+ EnterDescrBlock func(c *DescrBlockContext)

+ EnterFloat func(c *FloatContext)

+ EnterLetStmt func(c *LetStmtContext)

+ EnterList func(c *ListContext)

+ EnterLiteralOrFml func(c *LiteralOrFmlContext)

+ EnterMap func(c *MapContext)

+ EnterNum func(c *NumContext)

+ EnterPackageDecl func(c *PackageDeclContext)

+ EnterProgram func(c *ProgramContext)

+ EnterStart func(c *StartContext)

+ EnterStr func(c *StrContext)

+ EnterStruct func(c *StructContext)

+ EnterTransform func(c *TransformContext)

+ EnterUseDecl func(c *UseDeclContext)

+ EnterVar func(c *VarContext)

+ ExitAppl func(c *ApplContext)

+ ExitAtom func(c *AtomContext)

+ ExitAtoms func(c *AtomsContext)

+ ExitBoundsBlock func(c *BoundsBlockContext)

+ ExitClause func(c *ClauseContext)

+ ExitClauseBody func(c *ClauseBodyContext)

+ ExitConst func(c *ConstContext)

+ ExitConstraintsBlock func(c *ConstraintsBlockContext)

+ ExitDecl func(c *DeclContext)

+ ExitDescrBlock func(c *DescrBlockContext)

+ ExitFloat func(c *FloatContext)

+ ExitLetStmt func(c *LetStmtContext)

+ ExitList func(c *ListContext)

+ ExitLiteralOrFml func(c *LiteralOrFmlContext)

+ ExitMap func(c *MapContext)

+ ExitNum func(c *NumContext)

+ ExitPackageDecl func(c *PackageDeclContext)

+ ExitProgram func(c *ProgramContext)

+ ExitStart func(c *StartContext)

+ ExitStr func(c *StrContext)

+ ExitStruct func(c *StructContext)

+ ExitTransform func(c *TransformContext)

+ ExitUseDecl func(c *UseDeclContext)

+ ExitVar func(c *VarContext)

+ type MangleParser struct

+ func NewMangleParser(input antlr.TokenStream) *MangleParser

+ func (p *MangleParser) Atom() (localctx IAtomContext)

+ func (p *MangleParser) Atoms() (localctx IAtomsContext)

+ func (p *MangleParser) BoundsBlock() (localctx IBoundsBlockContext)

+ func (p *MangleParser) Clause() (localctx IClauseContext)

+ func (p *MangleParser) ClauseBody() (localctx IClauseBodyContext)

+ func (p *MangleParser) ConstraintsBlock() (localctx IConstraintsBlockContext)

+ func (p *MangleParser) Decl() (localctx IDeclContext)

+ func (p *MangleParser) DescrBlock() (localctx IDescrBlockContext)

+ func (p *MangleParser) LetStmt() (localctx ILetStmtContext)

+ func (p *MangleParser) LiteralOrFml() (localctx ILiteralOrFmlContext)

+ func (p *MangleParser) PackageDecl() (localctx IPackageDeclContext)

+ func (p *MangleParser) Program() (localctx IProgramContext)

+ func (p *MangleParser) Start_() (localctx IStartContext)

+ func (p *MangleParser) Term() (localctx ITermContext)

+ func (p *MangleParser) Transform() (localctx ITransformContext)

+ func (p *MangleParser) UseDecl() (localctx IUseDeclContext)

+ type MangleVisitor interface

+ VisitAppl func(ctx *ApplContext) interface{}

+ VisitAtom func(ctx *AtomContext) interface{}

+ VisitAtoms func(ctx *AtomsContext) interface{}

+ VisitBoundsBlock func(ctx *BoundsBlockContext) interface{}

+ VisitClause func(ctx *ClauseContext) interface{}

+ VisitClauseBody func(ctx *ClauseBodyContext) interface{}

+ VisitConst func(ctx *ConstContext) interface{}

+ VisitConstraintsBlock func(ctx *ConstraintsBlockContext) interface{}

+ VisitDecl func(ctx *DeclContext) interface{}

+ VisitDescrBlock func(ctx *DescrBlockContext) interface{}

+ VisitFloat func(ctx *FloatContext) interface{}

+ VisitLetStmt func(ctx *LetStmtContext) interface{}

+ VisitList func(ctx *ListContext) interface{}

+ VisitLiteralOrFml func(ctx *LiteralOrFmlContext) interface{}

+ VisitMap func(ctx *MapContext) interface{}

+ VisitNum func(ctx *NumContext) interface{}

+ VisitPackageDecl func(ctx *PackageDeclContext) interface{}

+ VisitProgram func(ctx *ProgramContext) interface{}

+ VisitStart func(ctx *StartContext) interface{}

+ VisitStr func(ctx *StrContext) interface{}

+ VisitStruct func(ctx *StructContext) interface{}

+ VisitTransform func(ctx *TransformContext) interface{}

+ VisitUseDecl func(ctx *UseDeclContext) interface{}

+ VisitVar func(ctx *VarContext) interface{}

+ type MapContext struct

+ func NewMapContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MapContext

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

+ func (s *MapContext) AllCOMMA() []antlr.TerminalNode

+ func (s *MapContext) AllTerm() []ITermContext

+ func (s *MapContext) COMMA(i int) antlr.TerminalNode

+ func (s *MapContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *MapContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *MapContext) GetRuleContext() antlr.RuleContext

+ func (s *MapContext) LBRACKET() antlr.TerminalNode

+ func (s *MapContext) RBRACKET() antlr.TerminalNode

+ func (s *MapContext) Term(i int) ITermContext

+ type NumContext struct

+ func NewNumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NumContext

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

+ func (s *NumContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NumContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NumContext) GetRuleContext() antlr.RuleContext

+ func (s *NumContext) NUMBER() antlr.TerminalNode

+ type PackageDeclContext struct

+ func NewEmptyPackageDeclContext() *PackageDeclContext

+ func NewPackageDeclContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PackageDeclContext

+ func (*PackageDeclContext) IsPackageDeclContext()

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

+ func (s *PackageDeclContext) Atoms() IAtomsContext

+ func (s *PackageDeclContext) BANG() antlr.TerminalNode

+ func (s *PackageDeclContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PackageDeclContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PackageDeclContext) GetParser() antlr.Parser

+ func (s *PackageDeclContext) GetRuleContext() antlr.RuleContext

+ func (s *PackageDeclContext) NAME() antlr.TerminalNode

+ func (s *PackageDeclContext) PACKAGE() antlr.TerminalNode

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

+ type ProgramContext struct

+ func NewEmptyProgramContext() *ProgramContext

+ func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext

+ func (*ProgramContext) IsProgramContext()

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

+ func (s *ProgramContext) AllClause() []IClauseContext

+ func (s *ProgramContext) AllDecl() []IDeclContext

+ func (s *ProgramContext) AllUseDecl() []IUseDeclContext

+ func (s *ProgramContext) Clause(i int) IClauseContext

+ func (s *ProgramContext) Decl(i int) IDeclContext

+ func (s *ProgramContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ProgramContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ProgramContext) GetParser() antlr.Parser

+ func (s *ProgramContext) GetRuleContext() antlr.RuleContext

+ func (s *ProgramContext) PackageDecl() IPackageDeclContext

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

+ func (s *ProgramContext) UseDecl(i int) IUseDeclContext

+ type StartContext struct

+ func NewEmptyStartContext() *StartContext

+ func NewStartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartContext

+ func (*StartContext) IsStartContext()

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

+ func (s *StartContext) EOF() antlr.TerminalNode

+ func (s *StartContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StartContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StartContext) GetParser() antlr.Parser

+ func (s *StartContext) GetRuleContext() antlr.RuleContext

+ func (s *StartContext) Program() IProgramContext

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

+ type StrContext struct

+ func NewStrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StrContext

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

+ func (s *StrContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StrContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StrContext) GetRuleContext() antlr.RuleContext

+ func (s *StrContext) STRING() antlr.TerminalNode

+ type StructContext struct

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

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

+ func (s *StructContext) AllCOMMA() []antlr.TerminalNode

+ func (s *StructContext) AllTerm() []ITermContext

+ func (s *StructContext) COMMA(i int) antlr.TerminalNode

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

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

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

+ func (s *StructContext) Term(i int) ITermContext

+ type TermContext struct

+ func NewEmptyTermContext() *TermContext

+ func NewTermContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TermContext

+ func (*TermContext) IsTermContext()

+ func (s *TermContext) CopyAll(ctx *TermContext)

+ func (s *TermContext) GetParser() antlr.Parser

+ func (s *TermContext) GetRuleContext() antlr.RuleContext

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

+ type TransformContext struct

+ func NewEmptyTransformContext() *TransformContext

+ func NewTransformContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransformContext

+ func (*TransformContext) IsTransformContext()

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

+ func (s *TransformContext) AllCOMMA() []antlr.TerminalNode

+ func (s *TransformContext) AllLetStmt() []ILetStmtContext

+ func (s *TransformContext) COMMA(i int) antlr.TerminalNode

+ func (s *TransformContext) DO() antlr.TerminalNode

+ func (s *TransformContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TransformContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TransformContext) GetParser() antlr.Parser

+ func (s *TransformContext) GetRuleContext() antlr.RuleContext

+ func (s *TransformContext) LetStmt(i int) ILetStmtContext

+ func (s *TransformContext) Term() ITermContext

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

+ type UseDeclContext struct

+ func NewEmptyUseDeclContext() *UseDeclContext

+ func NewUseDeclContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseDeclContext

+ func (*UseDeclContext) IsUseDeclContext()

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

+ func (s *UseDeclContext) Atoms() IAtomsContext

+ func (s *UseDeclContext) BANG() antlr.TerminalNode

+ func (s *UseDeclContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *UseDeclContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *UseDeclContext) GetParser() antlr.Parser

+ func (s *UseDeclContext) GetRuleContext() antlr.RuleContext

+ func (s *UseDeclContext) NAME() antlr.TerminalNode

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

+ func (s *UseDeclContext) USE() antlr.TerminalNode

+ type VarContext struct

+ func NewVarContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VarContext

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

+ func (s *VarContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *VarContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *VarContext) GetRuleContext() antlr.RuleContext

+ func (s *VarContext) VARIABLE() antlr.TerminalNode

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL