parser

package

Go to main page

Versions in this module

v1

v1.0.2

Apr 1, 2025

v1.0.1

Feb 26, 2025

Changes in this version

+ const PLANParserRULE_compoundStmt

+ const PLANParserRULE_fnStmt

+ const PLANParserRULE_idxs

+ const PLANParserRULE_includeStmt

+ const PLANParserRULE_progFile

+ const PLANParserRULE_simpleStmt

+ const PLANParserRULE_stmts

+ func InitEmptyCompoundStmtContext(p *CompoundStmtContext)

+ func InitEmptyFnStmtContext(p *FnStmtContext)

+ func InitEmptyIdxsContext(p *IdxsContext)

+ func InitEmptyIncludeStmtContext(p *IncludeStmtContext)

+ func InitEmptyProgFileContext(p *ProgFileContext)

+ func InitEmptySimpleStmtContext(p *SimpleStmtContext)

+ func InitEmptyStmtsContext(p *StmtsContext)

+ type AssignIdxsDivContext struct

+ func NewAssignIdxsDivContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxsDivContext

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

+ func (s *AssignIdxsDivContext) AssDiv() antlr.TerminalNode

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

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

+ func (s *AssignIdxsDivContext) Exp() IExpContext

+ func (s *AssignIdxsDivContext) GetName() antlr.Token

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

+ func (s *AssignIdxsDivContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxsDivContext) Idxs() IIdxsContext

+ func (s *AssignIdxsDivContext) SetName(v antlr.Token)

+ type AssignIdxsModContext struct

+ func NewAssignIdxsModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxsModContext

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

+ func (s *AssignIdxsModContext) AssMod() antlr.TerminalNode

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

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

+ func (s *AssignIdxsModContext) Exp() IExpContext

+ func (s *AssignIdxsModContext) GetName() antlr.Token

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

+ func (s *AssignIdxsModContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxsModContext) Idxs() IIdxsContext

+ func (s *AssignIdxsModContext) SetName(v antlr.Token)

+ type AssignIdxsMulContext struct

+ func NewAssignIdxsMulContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxsMulContext

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

+ func (s *AssignIdxsMulContext) AssMul() antlr.TerminalNode

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

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

+ func (s *AssignIdxsMulContext) Exp() IExpContext

+ func (s *AssignIdxsMulContext) GetName() antlr.Token

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

+ func (s *AssignIdxsMulContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxsMulContext) Idxs() IIdxsContext

+ func (s *AssignIdxsMulContext) SetName(v antlr.Token)

+ type AssignIdxsPowContext struct

+ func NewAssignIdxsPowContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxsPowContext

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

+ func (s *AssignIdxsPowContext) AssPow() antlr.TerminalNode

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

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

+ func (s *AssignIdxsPowContext) Exp() IExpContext

+ func (s *AssignIdxsPowContext) GetName() antlr.Token

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

+ func (s *AssignIdxsPowContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxsPowContext) Idxs() IIdxsContext

+ func (s *AssignIdxsPowContext) SetName(v antlr.Token)

+ type AssignIdxsRegularContext struct

+ func NewAssignIdxsRegularContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxsRegularContext

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

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

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

+ func (s *AssignIdxsRegularContext) Exp() IExpContext

+ func (s *AssignIdxsRegularContext) GetName() antlr.Token

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

+ func (s *AssignIdxsRegularContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxsRegularContext) Idxs() IIdxsContext

+ func (s *AssignIdxsRegularContext) SetName(v antlr.Token)

+ type AssignIdxsSubContext struct

+ func NewAssignIdxsSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxsSubContext

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

+ func (s *AssignIdxsSubContext) AssSub() antlr.TerminalNode

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

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

+ func (s *AssignIdxsSubContext) Exp() IExpContext

+ func (s *AssignIdxsSubContext) GetName() antlr.Token

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

+ func (s *AssignIdxsSubContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxsSubContext) Idxs() IIdxsContext

+ func (s *AssignIdxsSubContext) SetName(v antlr.Token)

+ type AssignIdxsSumContext struct

+ func NewAssignIdxsSumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxsSumContext

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

+ func (s *AssignIdxsSumContext) AssSum() antlr.TerminalNode

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

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

+ func (s *AssignIdxsSumContext) Exp() IExpContext

+ func (s *AssignIdxsSumContext) GetName() antlr.Token

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

+ func (s *AssignIdxsSumContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxsSumContext) Idxs() IIdxsContext

+ func (s *AssignIdxsSumContext) SetName(v antlr.Token)

type BasePLANListener

+ func (s *BasePLANListener) EnterAssignIdxsDiv(ctx *AssignIdxsDivContext)

+ func (s *BasePLANListener) EnterAssignIdxsMod(ctx *AssignIdxsModContext)

+ func (s *BasePLANListener) EnterAssignIdxsMul(ctx *AssignIdxsMulContext)

+ func (s *BasePLANListener) EnterAssignIdxsPow(ctx *AssignIdxsPowContext)

+ func (s *BasePLANListener) EnterAssignIdxsRegular(ctx *AssignIdxsRegularContext)

+ func (s *BasePLANListener) EnterAssignIdxsSub(ctx *AssignIdxsSubContext)

+ func (s *BasePLANListener) EnterAssignIdxsSum(ctx *AssignIdxsSumContext)

+ func (s *BasePLANListener) EnterCompoundStmt(ctx *CompoundStmtContext)

+ func (s *BasePLANListener) EnterFnStmt(ctx *FnStmtContext)

+ func (s *BasePLANListener) EnterIdxs(ctx *IdxsContext)

+ func (s *BasePLANListener) EnterIncludeStmt(ctx *IncludeStmtContext)

+ func (s *BasePLANListener) EnterProgFile(ctx *ProgFileContext)

+ func (s *BasePLANListener) EnterSimpleStmt(ctx *SimpleStmtContext)

+ func (s *BasePLANListener) EnterStmts(ctx *StmtsContext)

+ func (s *BasePLANListener) ExitAssignIdxsDiv(ctx *AssignIdxsDivContext)

+ func (s *BasePLANListener) ExitAssignIdxsMod(ctx *AssignIdxsModContext)

+ func (s *BasePLANListener) ExitAssignIdxsMul(ctx *AssignIdxsMulContext)

+ func (s *BasePLANListener) ExitAssignIdxsPow(ctx *AssignIdxsPowContext)

+ func (s *BasePLANListener) ExitAssignIdxsRegular(ctx *AssignIdxsRegularContext)

+ func (s *BasePLANListener) ExitAssignIdxsSub(ctx *AssignIdxsSubContext)

+ func (s *BasePLANListener) ExitAssignIdxsSum(ctx *AssignIdxsSumContext)

+ func (s *BasePLANListener) ExitCompoundStmt(ctx *CompoundStmtContext)

+ func (s *BasePLANListener) ExitFnStmt(ctx *FnStmtContext)

+ func (s *BasePLANListener) ExitIdxs(ctx *IdxsContext)

+ func (s *BasePLANListener) ExitIncludeStmt(ctx *IncludeStmtContext)

+ func (s *BasePLANListener) ExitProgFile(ctx *ProgFileContext)

+ func (s *BasePLANListener) ExitSimpleStmt(ctx *SimpleStmtContext)

+ func (s *BasePLANListener) ExitStmts(ctx *StmtsContext)

type BasePLANVisitor

+ func (v *BasePLANVisitor) VisitAssignIdxsDiv(ctx *AssignIdxsDivContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignIdxsMod(ctx *AssignIdxsModContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignIdxsMul(ctx *AssignIdxsMulContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignIdxsPow(ctx *AssignIdxsPowContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignIdxsRegular(ctx *AssignIdxsRegularContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignIdxsSub(ctx *AssignIdxsSubContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignIdxsSum(ctx *AssignIdxsSumContext) interface{}

+ func (v *BasePLANVisitor) VisitCompoundStmt(ctx *CompoundStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitFnStmt(ctx *FnStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitIdxs(ctx *IdxsContext) interface{}

+ func (v *BasePLANVisitor) VisitIncludeStmt(ctx *IncludeStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitProgFile(ctx *ProgFileContext) interface{}

+ func (v *BasePLANVisitor) VisitSimpleStmt(ctx *SimpleStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitStmts(ctx *StmtsContext) interface{}

+ type CompoundStmtContext struct

+ func NewCompoundStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompoundStmtContext

+ func NewEmptyCompoundStmtContext() *CompoundStmtContext

+ func (*CompoundStmtContext) IsCompoundStmtContext()

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

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

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

+ func (s *CompoundStmtContext) FnStmt() IFnStmtContext

+ func (s *CompoundStmtContext) ForStmt() IForStmtContext

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

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

+ func (s *CompoundStmtContext) IfStmt() IIfStmtContext

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

+ func (s *CompoundStmtContext) WhileStmt() IWhileStmtContext

+ type FnStmtContext struct

+ func NewEmptyFnStmtContext() *FnStmtContext

+ func NewFnStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnStmtContext

+ func (*FnStmtContext) IsFnStmtContext()

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

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

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

+ func (s *FnStmtContext) FnBody() IFnBodyContext

+ func (s *FnStmtContext) GetName() antlr.Token

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

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

+ func (s *FnStmtContext) Identifier() antlr.TerminalNode

+ func (s *FnStmtContext) SetName(v antlr.Token)

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

+ type ICompoundStmtContext interface

+ FnStmt func() IFnStmtContext

+ ForStmt func() IForStmtContext

+ GetParser func() antlr.Parser

+ IfStmt func() IIfStmtContext

+ IsCompoundStmtContext func()

+ WhileStmt func() IWhileStmtContext

+ type IFnStmtContext interface

+ FnBody func() IFnBodyContext

+ GetName func() antlr.Token

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsFnStmtContext func()

+ SetName func(antlr.Token)

+ type IIdxsContext interface

+ AllIdx func() []IIdxContext

+ GetParser func() antlr.Parser

+ Idx func(i int) IIdxContext

+ IsIdxsContext func()

+ type IIncludeStmtContext interface

+ Exp func() IExpContext

+ GetParser func() antlr.Parser

+ IsIncludeStmtContext func()

+ type IProgFileContext interface

+ EOF func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsProgFileContext func()

+ Stmts func() IStmtsContext

+ type ISimpleStmtContext interface

+ Assignment func() IAssignmentContext

+ BreakStmt func() IBreakStmtContext

+ ContinueStmt func() IContinueStmtContext

+ CsInvoke func() ICsInvokeContext

+ FnInvoke func() IFnInvokeContext

+ GetParser func() antlr.Parser

+ IncludeStmt func() IIncludeStmtContext

+ IsSimpleStmtContext func()

+ MethodInvoke func() IMethodInvokeContext

+ ReturnStmt func() IReturnStmtContext

type IStmtContext

+ CompoundStmt func() ICompoundStmtContext

+ SimpleStmt func() ISimpleStmtContext

+ type IStmtsContext interface

+ AllStmt func() []IStmtContext

+ GetParser func() antlr.Parser

+ IsStmtsContext func()

+ Stmt func(i int) IStmtContext

+ type IdxsContext struct

+ func NewEmptyIdxsContext() *IdxsContext

+ func NewIdxsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdxsContext

+ func (*IdxsContext) IsIdxsContext()

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

+ func (s *IdxsContext) AllIdx() []IIdxContext

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

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

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

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

+ func (s *IdxsContext) Idx(i int) IIdxContext

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

+ type IncludeStmtContext struct

+ func NewEmptyIncludeStmtContext() *IncludeStmtContext

+ func NewIncludeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IncludeStmtContext

+ func (*IncludeStmtContext) IsIncludeStmtContext()

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

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

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

+ func (s *IncludeStmtContext) Exp() IExpContext

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

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

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

type PLANListener

+ EnterAssignIdxsDiv func(c *AssignIdxsDivContext)

+ EnterAssignIdxsMod func(c *AssignIdxsModContext)

+ EnterAssignIdxsMul func(c *AssignIdxsMulContext)

+ EnterAssignIdxsPow func(c *AssignIdxsPowContext)

+ EnterAssignIdxsRegular func(c *AssignIdxsRegularContext)

+ EnterAssignIdxsSub func(c *AssignIdxsSubContext)

+ EnterAssignIdxsSum func(c *AssignIdxsSumContext)

+ EnterCompoundStmt func(c *CompoundStmtContext)

+ EnterFnStmt func(c *FnStmtContext)

+ EnterIdxs func(c *IdxsContext)

+ EnterIncludeStmt func(c *IncludeStmtContext)

+ EnterProgFile func(c *ProgFileContext)

+ EnterSimpleStmt func(c *SimpleStmtContext)

+ EnterStmts func(c *StmtsContext)

+ ExitAssignIdxsDiv func(c *AssignIdxsDivContext)

+ ExitAssignIdxsMod func(c *AssignIdxsModContext)

+ ExitAssignIdxsMul func(c *AssignIdxsMulContext)

+ ExitAssignIdxsPow func(c *AssignIdxsPowContext)

+ ExitAssignIdxsRegular func(c *AssignIdxsRegularContext)

+ ExitAssignIdxsSub func(c *AssignIdxsSubContext)

+ ExitAssignIdxsSum func(c *AssignIdxsSumContext)

+ ExitCompoundStmt func(c *CompoundStmtContext)

+ ExitFnStmt func(c *FnStmtContext)

+ ExitIdxs func(c *IdxsContext)

+ ExitIncludeStmt func(c *IncludeStmtContext)

+ ExitProgFile func(c *ProgFileContext)

+ ExitSimpleStmt func(c *SimpleStmtContext)

+ ExitStmts func(c *StmtsContext)

type PLANParser

+ func (p *PLANParser) CompoundStmt() (localctx ICompoundStmtContext)

+ func (p *PLANParser) FnStmt() (localctx IFnStmtContext)

+ func (p *PLANParser) Idxs() (localctx IIdxsContext)

+ func (p *PLANParser) IncludeStmt() (localctx IIncludeStmtContext)

+ func (p *PLANParser) ProgFile() (localctx IProgFileContext)

+ func (p *PLANParser) SimpleStmt() (localctx ISimpleStmtContext)

+ func (p *PLANParser) Stmts() (localctx IStmtsContext)

type PLANVisitor

+ VisitAssignIdxsDiv func(ctx *AssignIdxsDivContext) interface{}

+ VisitAssignIdxsMod func(ctx *AssignIdxsModContext) interface{}

+ VisitAssignIdxsMul func(ctx *AssignIdxsMulContext) interface{}

+ VisitAssignIdxsPow func(ctx *AssignIdxsPowContext) interface{}

+ VisitAssignIdxsRegular func(ctx *AssignIdxsRegularContext) interface{}

+ VisitAssignIdxsSub func(ctx *AssignIdxsSubContext) interface{}

+ VisitAssignIdxsSum func(ctx *AssignIdxsSumContext) interface{}

+ VisitCompoundStmt func(ctx *CompoundStmtContext) interface{}

+ VisitFnStmt func(ctx *FnStmtContext) interface{}

+ VisitIdxs func(ctx *IdxsContext) interface{}

+ VisitIncludeStmt func(ctx *IncludeStmtContext) interface{}

+ VisitProgFile func(ctx *ProgFileContext) interface{}

+ VisitSimpleStmt func(ctx *SimpleStmtContext) interface{}

+ VisitStmts func(ctx *StmtsContext) interface{}

+ type ProgFileContext struct

+ func NewEmptyProgFileContext() *ProgFileContext

+ func NewProgFileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgFileContext

+ func (*ProgFileContext) IsProgFileContext()

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

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

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

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

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

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

+ func (s *ProgFileContext) Stmts() IStmtsContext

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

+ type SimpleStmtContext struct

+ func NewEmptySimpleStmtContext() *SimpleStmtContext

+ func NewSimpleStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleStmtContext

+ func (*SimpleStmtContext) IsSimpleStmtContext()

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

+ func (s *SimpleStmtContext) Assignment() IAssignmentContext

+ func (s *SimpleStmtContext) BreakStmt() IBreakStmtContext

+ func (s *SimpleStmtContext) ContinueStmt() IContinueStmtContext

+ func (s *SimpleStmtContext) CsInvoke() ICsInvokeContext

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

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

+ func (s *SimpleStmtContext) FnInvoke() IFnInvokeContext

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

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

+ func (s *SimpleStmtContext) IncludeStmt() IIncludeStmtContext

+ func (s *SimpleStmtContext) MethodInvoke() IMethodInvokeContext

+ func (s *SimpleStmtContext) ReturnStmt() IReturnStmtContext

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

type StmtContext

+ func (s *StmtContext) CompoundStmt() ICompoundStmtContext

+ func (s *StmtContext) SimpleStmt() ISimpleStmtContext

+ type StmtsContext struct

+ func NewEmptyStmtsContext() *StmtsContext

+ func NewStmtsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtsContext

+ func (*StmtsContext) IsStmtsContext()

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

+ func (s *StmtsContext) AllStmt() []IStmtContext

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

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

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

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

+ func (s *StmtsContext) Stmt(i int) IStmtContext

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

v1.0.0

Jan 12, 2025

Changes in this version

+ const PLANLexerAdd

+ const PLANLexerAnd

+ const PLANLexerAssDiv

+ const PLANLexerAssMod

+ const PLANLexerAssMul

+ const PLANLexerAssPow

+ const PLANLexerAssSub

+ const PLANLexerAssSum

+ const PLANLexerBool

+ const PLANLexerClosure

+ const PLANLexerComment

+ const PLANLexerDivision

+ const PLANLexerEq

+ const PLANLexerFloat

+ const PLANLexerGt

+ const PLANLexerGtEq

+ const PLANLexerIdentifier

+ const PLANLexerInteger

+ const PLANLexerIntegerHex

+ const PLANLexerLt

+ const PLANLexerLtEq

+ const PLANLexerModulus

+ const PLANLexerMultiply

+ const PLANLexerNeq

+ const PLANLexerNot

+ const PLANLexerNull

+ const PLANLexerOr

+ const PLANLexerPow

+ const PLANLexerString_

+ const PLANLexerSubtract

+ const PLANLexerT__0

+ const PLANLexerT__1

+ const PLANLexerT__10

+ const PLANLexerT__11

+ const PLANLexerT__12

+ const PLANLexerT__13

+ const PLANLexerT__14

+ const PLANLexerT__15

+ const PLANLexerT__16

+ const PLANLexerT__17

+ const PLANLexerT__18

+ const PLANLexerT__19

+ const PLANLexerT__2

+ const PLANLexerT__20

+ const PLANLexerT__3

+ const PLANLexerT__4

+ const PLANLexerT__5

+ const PLANLexerT__6

+ const PLANLexerT__7

+ const PLANLexerT__8

+ const PLANLexerT__9

+ const PLANLexerWS

+ const PLANLexerXor

+ const PLANParserAdd

+ const PLANParserAnd

+ const PLANParserAssDiv

+ const PLANParserAssMod

+ const PLANParserAssMul

+ const PLANParserAssPow

+ const PLANParserAssSub

+ const PLANParserAssSum

+ const PLANParserBool

+ const PLANParserClosure

+ const PLANParserComment

+ const PLANParserDivision

+ const PLANParserEOF

+ const PLANParserEq

+ const PLANParserFloat

+ const PLANParserGt

+ const PLANParserGtEq

+ const PLANParserIdentifier

+ const PLANParserInteger

+ const PLANParserIntegerHex

+ const PLANParserLt

+ const PLANParserLtEq

+ const PLANParserModulus

+ const PLANParserMultiply

+ const PLANParserNeq

+ const PLANParserNot

+ const PLANParserNull

+ const PLANParserOr

+ const PLANParserPow

+ const PLANParserRULE_assignment

+ const PLANParserRULE_breakStmt

+ const PLANParserRULE_closure

+ const PLANParserRULE_continueStmt

+ const PLANParserRULE_csInvoke

+ const PLANParserRULE_dict

+ const PLANParserRULE_dictUnit

+ const PLANParserRULE_elifBlock

+ const PLANParserRULE_elseBlock

+ const PLANParserRULE_exp

+ const PLANParserRULE_fn

+ const PLANParserRULE_fnBody

+ const PLANParserRULE_fnInvoke

+ const PLANParserRULE_fnParams

+ const PLANParserRULE_forStmt

+ const PLANParserRULE_idx

+ const PLANParserRULE_ifBlock

+ const PLANParserRULE_ifStmt

+ const PLANParserRULE_include

+ const PLANParserRULE_list

+ const PLANParserRULE_methodInvoke

+ const PLANParserRULE_prog

+ const PLANParserRULE_returnStmt

+ const PLANParserRULE_stmt

+ const PLANParserRULE_whileStmt

+ const PLANParserString_

+ const PLANParserSubtract

+ const PLANParserT__0

+ const PLANParserT__1

+ const PLANParserT__10

+ const PLANParserT__11

+ const PLANParserT__12

+ const PLANParserT__13

+ const PLANParserT__14

+ const PLANParserT__15

+ const PLANParserT__16

+ const PLANParserT__17

+ const PLANParserT__18

+ const PLANParserT__19

+ const PLANParserT__2

+ const PLANParserT__20

+ const PLANParserT__3

+ const PLANParserT__4

+ const PLANParserT__5

+ const PLANParserT__6

+ const PLANParserT__7

+ const PLANParserT__8

+ const PLANParserT__9

+ const PLANParserWS

+ const PLANParserXor

+ var PLANLexerLexerStaticData struct

+ var PLANParserStaticData struct

+ func InitEmptyAssignmentContext(p *AssignmentContext)

+ func InitEmptyBreakStmtContext(p *BreakStmtContext)

+ func InitEmptyClosureContext(p *ClosureContext)

+ func InitEmptyContinueStmtContext(p *ContinueStmtContext)

+ func InitEmptyCsInvokeContext(p *CsInvokeContext)

+ func InitEmptyDictContext(p *DictContext)

+ func InitEmptyDictUnitContext(p *DictUnitContext)

+ func InitEmptyElifBlockContext(p *ElifBlockContext)

+ func InitEmptyElseBlockContext(p *ElseBlockContext)

+ func InitEmptyExpContext(p *ExpContext)

+ func InitEmptyFnBodyContext(p *FnBodyContext)

+ func InitEmptyFnContext(p *FnContext)

+ func InitEmptyFnInvokeContext(p *FnInvokeContext)

+ func InitEmptyFnParamsContext(p *FnParamsContext)

+ func InitEmptyForStmtContext(p *ForStmtContext)

+ func InitEmptyIdxContext(p *IdxContext)

+ func InitEmptyIfBlockContext(p *IfBlockContext)

+ func InitEmptyIfStmtContext(p *IfStmtContext)

+ func InitEmptyIncludeContext(p *IncludeContext)

+ func InitEmptyListContext(p *ListContext)

+ func InitEmptyMethodInvokeContext(p *MethodInvokeContext)

+ func InitEmptyProgContext(p *ProgContext)

+ func InitEmptyReturnStmtContext(p *ReturnStmtContext)

+ func InitEmptyStmtContext(p *StmtContext)

+ func InitEmptyWhileStmtContext(p *WhileStmtContext)

+ func PLANLexerInit()

+ func PLANParserInit()

+ type AssignDivContext struct

+ func NewAssignDivContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignDivContext

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

+ func (s *AssignDivContext) AssDiv() antlr.TerminalNode

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

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

+ func (s *AssignDivContext) Exp() IExpContext

+ func (s *AssignDivContext) GetName() antlr.Token

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

+ func (s *AssignDivContext) Identifier() antlr.TerminalNode

+ func (s *AssignDivContext) SetName(v antlr.Token)

+ type AssignIdxRegularContext struct

+ func NewAssignIdxRegularContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignIdxRegularContext

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

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

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

+ func (s *AssignIdxRegularContext) Exp() IExpContext

+ func (s *AssignIdxRegularContext) GetName() antlr.Token

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

+ func (s *AssignIdxRegularContext) Identifier() antlr.TerminalNode

+ func (s *AssignIdxRegularContext) Idx() IIdxContext

+ func (s *AssignIdxRegularContext) SetName(v antlr.Token)

+ type AssignModContext struct

+ func NewAssignModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignModContext

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

+ func (s *AssignModContext) AssMod() antlr.TerminalNode

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

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

+ func (s *AssignModContext) Exp() IExpContext

+ func (s *AssignModContext) GetName() antlr.Token

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

+ func (s *AssignModContext) Identifier() antlr.TerminalNode

+ func (s *AssignModContext) SetName(v antlr.Token)

+ type AssignMulContext struct

+ func NewAssignMulContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignMulContext

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

+ func (s *AssignMulContext) AssMul() antlr.TerminalNode

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

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

+ func (s *AssignMulContext) Exp() IExpContext

+ func (s *AssignMulContext) GetName() antlr.Token

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

+ func (s *AssignMulContext) Identifier() antlr.TerminalNode

+ func (s *AssignMulContext) SetName(v antlr.Token)

+ type AssignPowContext struct

+ func NewAssignPowContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignPowContext

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

+ func (s *AssignPowContext) AssPow() antlr.TerminalNode

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

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

+ func (s *AssignPowContext) Exp() IExpContext

+ func (s *AssignPowContext) GetName() antlr.Token

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

+ func (s *AssignPowContext) Identifier() antlr.TerminalNode

+ func (s *AssignPowContext) SetName(v antlr.Token)

+ type AssignRegularContext struct

+ func NewAssignRegularContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignRegularContext

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

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

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

+ func (s *AssignRegularContext) Exp() IExpContext

+ func (s *AssignRegularContext) GetName() antlr.Token

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

+ func (s *AssignRegularContext) Identifier() antlr.TerminalNode

+ func (s *AssignRegularContext) SetName(v antlr.Token)

+ type AssignSubContext struct

+ func NewAssignSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignSubContext

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

+ func (s *AssignSubContext) AssSub() antlr.TerminalNode

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

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

+ func (s *AssignSubContext) Exp() IExpContext

+ func (s *AssignSubContext) GetName() antlr.Token

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

+ func (s *AssignSubContext) Identifier() antlr.TerminalNode

+ func (s *AssignSubContext) SetName(v antlr.Token)

+ type AssignSumContext struct

+ func NewAssignSumContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignSumContext

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

+ func (s *AssignSumContext) AssSum() antlr.TerminalNode

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

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

+ func (s *AssignSumContext) Exp() IExpContext

+ func (s *AssignSumContext) GetName() antlr.Token

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

+ func (s *AssignSumContext) Identifier() antlr.TerminalNode

+ func (s *AssignSumContext) SetName(v antlr.Token)

+ type AssignmentContext struct

+ func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentContext

+ func NewEmptyAssignmentContext() *AssignmentContext

+ func (*AssignmentContext) IsAssignmentContext()

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

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

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

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

+ type BasePLANListener struct

+ func (s *BasePLANListener) EnterAssignDiv(ctx *AssignDivContext)

+ func (s *BasePLANListener) EnterAssignIdxRegular(ctx *AssignIdxRegularContext)

+ func (s *BasePLANListener) EnterAssignMod(ctx *AssignModContext)

+ func (s *BasePLANListener) EnterAssignMul(ctx *AssignMulContext)

+ func (s *BasePLANListener) EnterAssignPow(ctx *AssignPowContext)

+ func (s *BasePLANListener) EnterAssignRegular(ctx *AssignRegularContext)

+ func (s *BasePLANListener) EnterAssignSub(ctx *AssignSubContext)

+ func (s *BasePLANListener) EnterAssignSum(ctx *AssignSumContext)

+ func (s *BasePLANListener) EnterBreakStmt(ctx *BreakStmtContext)

+ func (s *BasePLANListener) EnterClosure(ctx *ClosureContext)

+ func (s *BasePLANListener) EnterContinueStmt(ctx *ContinueStmtContext)

+ func (s *BasePLANListener) EnterDict(ctx *DictContext)

+ func (s *BasePLANListener) EnterDictUnit(ctx *DictUnitContext)

+ func (s *BasePLANListener) EnterElifBlockStmt(ctx *ElifBlockStmtContext)

+ func (s *BasePLANListener) EnterElseBlockStmt(ctx *ElseBlockStmtContext)

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

+ func (s *BasePLANListener) EnterExpBool(ctx *ExpBoolContext)

+ func (s *BasePLANListener) EnterExpComparison(ctx *ExpComparisonContext)

+ func (s *BasePLANListener) EnterExpCs(ctx *ExpCsContext)

+ func (s *BasePLANListener) EnterExpCsInvoke(ctx *ExpCsInvokeContext)

+ func (s *BasePLANListener) EnterExpDict(ctx *ExpDictContext)

+ func (s *BasePLANListener) EnterExpEqual(ctx *ExpEqualContext)

+ func (s *BasePLANListener) EnterExpFloat(ctx *ExpFloatContext)

+ func (s *BasePLANListener) EnterExpFnInvoke(ctx *ExpFnInvokeContext)

+ func (s *BasePLANListener) EnterExpIdentifier(ctx *ExpIdentifierContext)

+ func (s *BasePLANListener) EnterExpIdx(ctx *ExpIdxContext)

+ func (s *BasePLANListener) EnterExpInteger(ctx *ExpIntegerContext)

+ func (s *BasePLANListener) EnterExpIntegerHex(ctx *ExpIntegerHexContext)

+ func (s *BasePLANListener) EnterExpList(ctx *ExpListContext)

+ func (s *BasePLANListener) EnterExpLogicalAnd(ctx *ExpLogicalAndContext)

+ func (s *BasePLANListener) EnterExpLogicalNot(ctx *ExpLogicalNotContext)

+ func (s *BasePLANListener) EnterExpLogicalOr(ctx *ExpLogicalOrContext)

+ func (s *BasePLANListener) EnterExpMethodInvoke(ctx *ExpMethodInvokeContext)

+ func (s *BasePLANListener) EnterExpMulDivMod(ctx *ExpMulDivModContext)

+ func (s *BasePLANListener) EnterExpNeg(ctx *ExpNegContext)

+ func (s *BasePLANListener) EnterExpNull(ctx *ExpNullContext)

+ func (s *BasePLANListener) EnterExpParentheses(ctx *ExpParenthesesContext)

+ func (s *BasePLANListener) EnterExpPow(ctx *ExpPowContext)

+ func (s *BasePLANListener) EnterExpString(ctx *ExpStringContext)

+ func (s *BasePLANListener) EnterExpSumSub(ctx *ExpSumSubContext)

+ func (s *BasePLANListener) EnterExpXor(ctx *ExpXorContext)

+ func (s *BasePLANListener) EnterFn(ctx *FnContext)

+ func (s *BasePLANListener) EnterFnBody(ctx *FnBodyContext)

+ func (s *BasePLANListener) EnterFnParams(ctx *FnParamsContext)

+ func (s *BasePLANListener) EnterForStmt(ctx *ForStmtContext)

+ func (s *BasePLANListener) EnterIdentifierCsInvoke(ctx *IdentifierCsInvokeContext)

+ func (s *BasePLANListener) EnterIdentifierFnInvoke(ctx *IdentifierFnInvokeContext)

+ func (s *BasePLANListener) EnterIdentifierMethodInvoke(ctx *IdentifierMethodInvokeContext)

+ func (s *BasePLANListener) EnterIdx(ctx *IdxContext)

+ func (s *BasePLANListener) EnterIfBlockStmt(ctx *IfBlockStmtContext)

+ func (s *BasePLANListener) EnterIfStmt(ctx *IfStmtContext)

+ func (s *BasePLANListener) EnterInclude(ctx *IncludeContext)

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

+ func (s *BasePLANListener) EnterProg(ctx *ProgContext)

+ func (s *BasePLANListener) EnterReturnStmt(ctx *ReturnStmtContext)

+ func (s *BasePLANListener) EnterStmt(ctx *StmtContext)

+ func (s *BasePLANListener) EnterWhileStmt(ctx *WhileStmtContext)

+ func (s *BasePLANListener) ExitAssignDiv(ctx *AssignDivContext)

+ func (s *BasePLANListener) ExitAssignIdxRegular(ctx *AssignIdxRegularContext)

+ func (s *BasePLANListener) ExitAssignMod(ctx *AssignModContext)

+ func (s *BasePLANListener) ExitAssignMul(ctx *AssignMulContext)

+ func (s *BasePLANListener) ExitAssignPow(ctx *AssignPowContext)

+ func (s *BasePLANListener) ExitAssignRegular(ctx *AssignRegularContext)

+ func (s *BasePLANListener) ExitAssignSub(ctx *AssignSubContext)

+ func (s *BasePLANListener) ExitAssignSum(ctx *AssignSumContext)

+ func (s *BasePLANListener) ExitBreakStmt(ctx *BreakStmtContext)

+ func (s *BasePLANListener) ExitClosure(ctx *ClosureContext)

+ func (s *BasePLANListener) ExitContinueStmt(ctx *ContinueStmtContext)

+ func (s *BasePLANListener) ExitDict(ctx *DictContext)

+ func (s *BasePLANListener) ExitDictUnit(ctx *DictUnitContext)

+ func (s *BasePLANListener) ExitElifBlockStmt(ctx *ElifBlockStmtContext)

+ func (s *BasePLANListener) ExitElseBlockStmt(ctx *ElseBlockStmtContext)

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

+ func (s *BasePLANListener) ExitExpBool(ctx *ExpBoolContext)

+ func (s *BasePLANListener) ExitExpComparison(ctx *ExpComparisonContext)

+ func (s *BasePLANListener) ExitExpCs(ctx *ExpCsContext)

+ func (s *BasePLANListener) ExitExpCsInvoke(ctx *ExpCsInvokeContext)

+ func (s *BasePLANListener) ExitExpDict(ctx *ExpDictContext)

+ func (s *BasePLANListener) ExitExpEqual(ctx *ExpEqualContext)

+ func (s *BasePLANListener) ExitExpFloat(ctx *ExpFloatContext)

+ func (s *BasePLANListener) ExitExpFnInvoke(ctx *ExpFnInvokeContext)

+ func (s *BasePLANListener) ExitExpIdentifier(ctx *ExpIdentifierContext)

+ func (s *BasePLANListener) ExitExpIdx(ctx *ExpIdxContext)

+ func (s *BasePLANListener) ExitExpInteger(ctx *ExpIntegerContext)

+ func (s *BasePLANListener) ExitExpIntegerHex(ctx *ExpIntegerHexContext)

+ func (s *BasePLANListener) ExitExpList(ctx *ExpListContext)

+ func (s *BasePLANListener) ExitExpLogicalAnd(ctx *ExpLogicalAndContext)

+ func (s *BasePLANListener) ExitExpLogicalNot(ctx *ExpLogicalNotContext)

+ func (s *BasePLANListener) ExitExpLogicalOr(ctx *ExpLogicalOrContext)

+ func (s *BasePLANListener) ExitExpMethodInvoke(ctx *ExpMethodInvokeContext)

+ func (s *BasePLANListener) ExitExpMulDivMod(ctx *ExpMulDivModContext)

+ func (s *BasePLANListener) ExitExpNeg(ctx *ExpNegContext)

+ func (s *BasePLANListener) ExitExpNull(ctx *ExpNullContext)

+ func (s *BasePLANListener) ExitExpParentheses(ctx *ExpParenthesesContext)

+ func (s *BasePLANListener) ExitExpPow(ctx *ExpPowContext)

+ func (s *BasePLANListener) ExitExpString(ctx *ExpStringContext)

+ func (s *BasePLANListener) ExitExpSumSub(ctx *ExpSumSubContext)

+ func (s *BasePLANListener) ExitExpXor(ctx *ExpXorContext)

+ func (s *BasePLANListener) ExitFn(ctx *FnContext)

+ func (s *BasePLANListener) ExitFnBody(ctx *FnBodyContext)

+ func (s *BasePLANListener) ExitFnParams(ctx *FnParamsContext)

+ func (s *BasePLANListener) ExitForStmt(ctx *ForStmtContext)

+ func (s *BasePLANListener) ExitIdentifierCsInvoke(ctx *IdentifierCsInvokeContext)

+ func (s *BasePLANListener) ExitIdentifierFnInvoke(ctx *IdentifierFnInvokeContext)

+ func (s *BasePLANListener) ExitIdentifierMethodInvoke(ctx *IdentifierMethodInvokeContext)

+ func (s *BasePLANListener) ExitIdx(ctx *IdxContext)

+ func (s *BasePLANListener) ExitIfBlockStmt(ctx *IfBlockStmtContext)

+ func (s *BasePLANListener) ExitIfStmt(ctx *IfStmtContext)

+ func (s *BasePLANListener) ExitInclude(ctx *IncludeContext)

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

+ func (s *BasePLANListener) ExitProg(ctx *ProgContext)

+ func (s *BasePLANListener) ExitReturnStmt(ctx *ReturnStmtContext)

+ func (s *BasePLANListener) ExitStmt(ctx *StmtContext)

+ func (s *BasePLANListener) ExitWhileStmt(ctx *WhileStmtContext)

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

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

+ type BasePLANVisitor struct

+ func (v *BasePLANVisitor) VisitAssignDiv(ctx *AssignDivContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignIdxRegular(ctx *AssignIdxRegularContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignMod(ctx *AssignModContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignMul(ctx *AssignMulContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignPow(ctx *AssignPowContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignRegular(ctx *AssignRegularContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignSub(ctx *AssignSubContext) interface{}

+ func (v *BasePLANVisitor) VisitAssignSum(ctx *AssignSumContext) interface{}

+ func (v *BasePLANVisitor) VisitBreakStmt(ctx *BreakStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitClosure(ctx *ClosureContext) interface{}

+ func (v *BasePLANVisitor) VisitContinueStmt(ctx *ContinueStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitDict(ctx *DictContext) interface{}

+ func (v *BasePLANVisitor) VisitDictUnit(ctx *DictUnitContext) interface{}

+ func (v *BasePLANVisitor) VisitElifBlockStmt(ctx *ElifBlockStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitElseBlockStmt(ctx *ElseBlockStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitExpBool(ctx *ExpBoolContext) interface{}

+ func (v *BasePLANVisitor) VisitExpComparison(ctx *ExpComparisonContext) interface{}

+ func (v *BasePLANVisitor) VisitExpCs(ctx *ExpCsContext) interface{}

+ func (v *BasePLANVisitor) VisitExpCsInvoke(ctx *ExpCsInvokeContext) interface{}

+ func (v *BasePLANVisitor) VisitExpDict(ctx *ExpDictContext) interface{}

+ func (v *BasePLANVisitor) VisitExpEqual(ctx *ExpEqualContext) interface{}

+ func (v *BasePLANVisitor) VisitExpFloat(ctx *ExpFloatContext) interface{}

+ func (v *BasePLANVisitor) VisitExpFnInvoke(ctx *ExpFnInvokeContext) interface{}

+ func (v *BasePLANVisitor) VisitExpIdentifier(ctx *ExpIdentifierContext) interface{}

+ func (v *BasePLANVisitor) VisitExpIdx(ctx *ExpIdxContext) interface{}

+ func (v *BasePLANVisitor) VisitExpInteger(ctx *ExpIntegerContext) interface{}

+ func (v *BasePLANVisitor) VisitExpIntegerHex(ctx *ExpIntegerHexContext) interface{}

+ func (v *BasePLANVisitor) VisitExpList(ctx *ExpListContext) interface{}

+ func (v *BasePLANVisitor) VisitExpLogicalAnd(ctx *ExpLogicalAndContext) interface{}

+ func (v *BasePLANVisitor) VisitExpLogicalNot(ctx *ExpLogicalNotContext) interface{}

+ func (v *BasePLANVisitor) VisitExpLogicalOr(ctx *ExpLogicalOrContext) interface{}

+ func (v *BasePLANVisitor) VisitExpMethodInvoke(ctx *ExpMethodInvokeContext) interface{}

+ func (v *BasePLANVisitor) VisitExpMulDivMod(ctx *ExpMulDivModContext) interface{}

+ func (v *BasePLANVisitor) VisitExpNeg(ctx *ExpNegContext) interface{}

+ func (v *BasePLANVisitor) VisitExpNull(ctx *ExpNullContext) interface{}

+ func (v *BasePLANVisitor) VisitExpParentheses(ctx *ExpParenthesesContext) interface{}

+ func (v *BasePLANVisitor) VisitExpPow(ctx *ExpPowContext) interface{}

+ func (v *BasePLANVisitor) VisitExpString(ctx *ExpStringContext) interface{}

+ func (v *BasePLANVisitor) VisitExpSumSub(ctx *ExpSumSubContext) interface{}

+ func (v *BasePLANVisitor) VisitExpXor(ctx *ExpXorContext) interface{}

+ func (v *BasePLANVisitor) VisitFn(ctx *FnContext) interface{}

+ func (v *BasePLANVisitor) VisitFnBody(ctx *FnBodyContext) interface{}

+ func (v *BasePLANVisitor) VisitFnParams(ctx *FnParamsContext) interface{}

+ func (v *BasePLANVisitor) VisitForStmt(ctx *ForStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitIdentifierCsInvoke(ctx *IdentifierCsInvokeContext) interface{}

+ func (v *BasePLANVisitor) VisitIdentifierFnInvoke(ctx *IdentifierFnInvokeContext) interface{}

+ func (v *BasePLANVisitor) VisitIdentifierMethodInvoke(ctx *IdentifierMethodInvokeContext) interface{}

+ func (v *BasePLANVisitor) VisitIdx(ctx *IdxContext) interface{}

+ func (v *BasePLANVisitor) VisitIfBlockStmt(ctx *IfBlockStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitIfStmt(ctx *IfStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitInclude(ctx *IncludeContext) interface{}

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

+ func (v *BasePLANVisitor) VisitProg(ctx *ProgContext) interface{}

+ func (v *BasePLANVisitor) VisitReturnStmt(ctx *ReturnStmtContext) interface{}

+ func (v *BasePLANVisitor) VisitStmt(ctx *StmtContext) interface{}

+ func (v *BasePLANVisitor) VisitWhileStmt(ctx *WhileStmtContext) interface{}

+ type BreakStmtContext struct

+ func NewBreakStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BreakStmtContext

+ func NewEmptyBreakStmtContext() *BreakStmtContext

+ func (*BreakStmtContext) IsBreakStmtContext()

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

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

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

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

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

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

+ type ClosureContext struct

+ func NewClosureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClosureContext

+ func NewEmptyClosureContext() *ClosureContext

+ func (*ClosureContext) IsClosureContext()

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

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

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

+ func (s *ClosureContext) FnBody() IFnBodyContext

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

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

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

+ type ContinueStmtContext struct

+ func NewContinueStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinueStmtContext

+ func NewEmptyContinueStmtContext() *ContinueStmtContext

+ func (*ContinueStmtContext) IsContinueStmtContext()

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

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

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

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

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

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

+ type CsInvokeContext struct

+ func NewCsInvokeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CsInvokeContext

+ func NewEmptyCsInvokeContext() *CsInvokeContext

+ func (*CsInvokeContext) IsCsInvokeContext()

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

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

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

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

+ type DictContext struct

+ func NewDictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictContext

+ func NewEmptyDictContext() *DictContext

+ func (*DictContext) IsDictContext()

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

+ func (s *DictContext) AllDictUnit() []IDictUnitContext

+ func (s *DictContext) DictUnit(i int) IDictUnitContext

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

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

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

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

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

+ type DictUnitContext struct

+ func NewDictUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictUnitContext

+ func NewEmptyDictUnitContext() *DictUnitContext

+ func (*DictUnitContext) IsDictUnitContext()

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

+ func (s *DictUnitContext) AllExp() []IExpContext

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

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

+ func (s *DictUnitContext) Exp(i int) IExpContext

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

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

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

+ type ElifBlockContext struct

+ func NewElifBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElifBlockContext

+ func NewEmptyElifBlockContext() *ElifBlockContext

+ func (*ElifBlockContext) IsElifBlockContext()

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

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

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

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

+ type ElifBlockStmtContext struct

+ func NewElifBlockStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ElifBlockStmtContext

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

+ func (s *ElifBlockStmtContext) AllStmt() []IStmtContext

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

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

+ func (s *ElifBlockStmtContext) Exp() IExpContext

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

+ func (s *ElifBlockStmtContext) Stmt(i int) IStmtContext

+ type ElseBlockContext struct

+ func NewElseBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElseBlockContext

+ func NewEmptyElseBlockContext() *ElseBlockContext

+ func (*ElseBlockContext) IsElseBlockContext()

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

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

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

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

+ type ElseBlockStmtContext struct

+ func NewElseBlockStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ElseBlockStmtContext

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

+ func (s *ElseBlockStmtContext) AllStmt() []IStmtContext

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

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

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

+ func (s *ElseBlockStmtContext) Stmt(i int) IStmtContext

+ type ExpBoolContext struct

+ func NewExpBoolContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpBoolContext

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

+ func (s *ExpBoolContext) Bool() antlr.TerminalNode

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

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

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

+ type ExpComparisonContext struct

+ func NewExpComparisonContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpComparisonContext

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

+ func (s *ExpComparisonContext) AllExp() []IExpContext

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

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

+ func (s *ExpComparisonContext) Exp(i int) IExpContext

+ func (s *ExpComparisonContext) GetOp() antlr.Token

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

+ func (s *ExpComparisonContext) Gt() antlr.TerminalNode

+ func (s *ExpComparisonContext) GtEq() antlr.TerminalNode

+ func (s *ExpComparisonContext) Lt() antlr.TerminalNode

+ func (s *ExpComparisonContext) LtEq() antlr.TerminalNode

+ func (s *ExpComparisonContext) SetOp(v antlr.Token)

+ type ExpContext struct

+ func NewEmptyExpContext() *ExpContext

+ func NewExpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpContext

+ func (*ExpContext) IsExpContext()

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

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

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

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

+ type ExpCsContext struct

+ func NewExpCsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpCsContext

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

+ func (s *ExpCsContext) Closure() IClosureContext

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

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

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

+ type ExpCsInvokeContext struct

+ func NewExpCsInvokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpCsInvokeContext

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

+ func (s *ExpCsInvokeContext) CsInvoke() ICsInvokeContext

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

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

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

+ type ExpDictContext struct

+ func NewExpDictContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpDictContext

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

+ func (s *ExpDictContext) Dict() IDictContext

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

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

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

+ type ExpEqualContext struct

+ func NewExpEqualContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpEqualContext

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

+ func (s *ExpEqualContext) AllExp() []IExpContext

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

+ func (s *ExpEqualContext) Eq() antlr.TerminalNode

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

+ func (s *ExpEqualContext) Exp(i int) IExpContext

+ func (s *ExpEqualContext) GetOp() antlr.Token

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

+ func (s *ExpEqualContext) Neq() antlr.TerminalNode

+ func (s *ExpEqualContext) SetOp(v antlr.Token)

+ type ExpFloatContext struct

+ func NewExpFloatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpFloatContext

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

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

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

+ func (s *ExpFloatContext) Float() antlr.TerminalNode

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

+ type ExpFnInvokeContext struct

+ func NewExpFnInvokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpFnInvokeContext

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

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

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

+ func (s *ExpFnInvokeContext) FnInvoke() IFnInvokeContext

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

+ type ExpIdentifierContext struct

+ func NewExpIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpIdentifierContext

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

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

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

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

+ func (s *ExpIdentifierContext) Identifier() antlr.TerminalNode

+ type ExpIdxContext struct

+ func NewExpIdxContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpIdxContext

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

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

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

+ func (s *ExpIdxContext) Exp() IExpContext

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

+ func (s *ExpIdxContext) Idx() IIdxContext

+ type ExpIntegerContext struct

+ func NewExpIntegerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpIntegerContext

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

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

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

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

+ func (s *ExpIntegerContext) Integer() antlr.TerminalNode

+ type ExpIntegerHexContext struct

+ func NewExpIntegerHexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpIntegerHexContext

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

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

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

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

+ func (s *ExpIntegerHexContext) IntegerHex() antlr.TerminalNode

+ type ExpListContext struct

+ func NewExpListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpListContext

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

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

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

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

+ func (s *ExpListContext) List() IListContext

+ type ExpLogicalAndContext struct

+ func NewExpLogicalAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpLogicalAndContext

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

+ func (s *ExpLogicalAndContext) AllExp() []IExpContext

+ func (s *ExpLogicalAndContext) And() antlr.TerminalNode

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

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

+ func (s *ExpLogicalAndContext) Exp(i int) IExpContext

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

+ type ExpLogicalNotContext struct

+ func NewExpLogicalNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpLogicalNotContext

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

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

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

+ func (s *ExpLogicalNotContext) Exp() IExpContext

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

+ func (s *ExpLogicalNotContext) Not() antlr.TerminalNode

+ type ExpLogicalOrContext struct

+ func NewExpLogicalOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpLogicalOrContext

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

+ func (s *ExpLogicalOrContext) AllExp() []IExpContext

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

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

+ func (s *ExpLogicalOrContext) Exp(i int) IExpContext

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

+ func (s *ExpLogicalOrContext) Or() antlr.TerminalNode

+ type ExpMethodInvokeContext struct

+ func NewExpMethodInvokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpMethodInvokeContext

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

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

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

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

+ func (s *ExpMethodInvokeContext) MethodInvoke() IMethodInvokeContext

+ type ExpMulDivModContext struct

+ func NewExpMulDivModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpMulDivModContext

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

+ func (s *ExpMulDivModContext) AllExp() []IExpContext

+ func (s *ExpMulDivModContext) Division() antlr.TerminalNode

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

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

+ func (s *ExpMulDivModContext) Exp(i int) IExpContext

+ func (s *ExpMulDivModContext) GetOp() antlr.Token

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

+ func (s *ExpMulDivModContext) Modulus() antlr.TerminalNode

+ func (s *ExpMulDivModContext) Multiply() antlr.TerminalNode

+ func (s *ExpMulDivModContext) SetOp(v antlr.Token)

+ type ExpNegContext struct

+ func NewExpNegContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpNegContext

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

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

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

+ func (s *ExpNegContext) Exp() IExpContext

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

+ func (s *ExpNegContext) Subtract() antlr.TerminalNode

+ type ExpNullContext struct

+ func NewExpNullContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpNullContext

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

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

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

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

+ func (s *ExpNullContext) Null() antlr.TerminalNode

+ type ExpParenthesesContext struct

+ func NewExpParenthesesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpParenthesesContext

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

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

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

+ func (s *ExpParenthesesContext) Exp() IExpContext

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

+ type ExpPowContext struct

+ func NewExpPowContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpPowContext

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

+ func (s *ExpPowContext) AllExp() []IExpContext

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

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

+ func (s *ExpPowContext) Exp(i int) IExpContext

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

+ func (s *ExpPowContext) Pow() antlr.TerminalNode

+ type ExpStringContext struct

+ func NewExpStringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpStringContext

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

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

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

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

+ func (s *ExpStringContext) String_() antlr.TerminalNode

+ type ExpSumSubContext struct

+ func NewExpSumSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpSumSubContext

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

+ func (s *ExpSumSubContext) Add() antlr.TerminalNode

+ func (s *ExpSumSubContext) AllExp() []IExpContext

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

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

+ func (s *ExpSumSubContext) Exp(i int) IExpContext

+ func (s *ExpSumSubContext) GetOp() antlr.Token

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

+ func (s *ExpSumSubContext) SetOp(v antlr.Token)

+ func (s *ExpSumSubContext) Subtract() antlr.TerminalNode

+ type ExpXorContext struct

+ func NewExpXorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpXorContext

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

+ func (s *ExpXorContext) AllExp() []IExpContext

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

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

+ func (s *ExpXorContext) Exp(i int) IExpContext

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

+ func (s *ExpXorContext) Xor() antlr.TerminalNode

+ type FnBodyContext struct

+ func NewEmptyFnBodyContext() *FnBodyContext

+ func NewFnBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnBodyContext

+ func (*FnBodyContext) IsFnBodyContext()

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

+ func (s *FnBodyContext) AllStmt() []IStmtContext

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

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

+ func (s *FnBodyContext) FnParams() IFnParamsContext

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

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

+ func (s *FnBodyContext) Stmt(i int) IStmtContext

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

+ type FnContext struct

+ func NewEmptyFnContext() *FnContext

+ func NewFnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnContext

+ func (*FnContext) IsFnContext()

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

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

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

+ func (s *FnContext) FnBody() IFnBodyContext

+ func (s *FnContext) GetName() antlr.Token

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

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

+ func (s *FnContext) Identifier() antlr.TerminalNode

+ func (s *FnContext) SetName(v antlr.Token)

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

+ type FnInvokeContext struct

+ func NewEmptyFnInvokeContext() *FnInvokeContext

+ func NewFnInvokeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnInvokeContext

+ func (*FnInvokeContext) IsFnInvokeContext()

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

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

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

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

+ type FnParamsContext struct

+ func NewEmptyFnParamsContext() *FnParamsContext

+ func NewFnParamsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnParamsContext

+ func (*FnParamsContext) IsFnParamsContext()

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

+ func (s *FnParamsContext) AllIdentifier() []antlr.TerminalNode

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

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

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

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

+ func (s *FnParamsContext) Identifier(i int) antlr.TerminalNode

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

+ type ForStmtContext struct

+ func NewEmptyForStmtContext() *ForStmtContext

+ func NewForStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForStmtContext

+ func (*ForStmtContext) IsForStmtContext()

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

+ func (s *ForStmtContext) AllAssignment() []IAssignmentContext

+ func (s *ForStmtContext) AllStmt() []IStmtContext

+ func (s *ForStmtContext) Assignment(i int) IAssignmentContext

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

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

+ func (s *ForStmtContext) Exp() IExpContext

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

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

+ func (s *ForStmtContext) Stmt(i int) IStmtContext

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

+ type IAssignmentContext interface

+ GetParser func() antlr.Parser

+ IsAssignmentContext func()

+ type IBreakStmtContext interface

+ GetParser func() antlr.Parser

+ IsBreakStmtContext func()

+ type IClosureContext interface

+ FnBody func() IFnBodyContext

+ GetParser func() antlr.Parser

+ IsClosureContext func()

+ type IContinueStmtContext interface

+ GetParser func() antlr.Parser

+ IsContinueStmtContext func()

+ type ICsInvokeContext interface

+ GetParser func() antlr.Parser

+ IsCsInvokeContext func()

+ type IDictContext interface

+ AllDictUnit func() []IDictUnitContext

+ DictUnit func(i int) IDictUnitContext

+ GetParser func() antlr.Parser

+ IsDictContext func()

+ type IDictUnitContext interface

+ AllExp func() []IExpContext

+ Exp func(i int) IExpContext

+ GetParser func() antlr.Parser

+ IsDictUnitContext func()

+ type IElifBlockContext interface

+ GetParser func() antlr.Parser

+ IsElifBlockContext func()

+ type IElseBlockContext interface

+ GetParser func() antlr.Parser

+ IsElseBlockContext func()

+ type IExpContext interface

+ GetParser func() antlr.Parser

+ IsExpContext func()

+ type IFnBodyContext interface

+ AllStmt func() []IStmtContext

+ FnParams func() IFnParamsContext

+ GetParser func() antlr.Parser

+ IsFnBodyContext func()

+ Stmt func(i int) IStmtContext

+ type IFnContext interface

+ FnBody func() IFnBodyContext

+ GetName func() antlr.Token

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsFnContext func()

+ SetName func(antlr.Token)

+ type IFnInvokeContext interface

+ GetParser func() antlr.Parser

+ IsFnInvokeContext func()

+ type IFnParamsContext interface

+ AllIdentifier func() []antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func(i int) antlr.TerminalNode

+ IsFnParamsContext func()

+ type IForStmtContext interface

+ AllAssignment func() []IAssignmentContext

+ AllStmt func() []IStmtContext

+ Assignment func(i int) IAssignmentContext

+ Exp func() IExpContext

+ GetParser func() antlr.Parser

+ IsForStmtContext func()

+ Stmt func(i int) IStmtContext

+ type IIdxContext interface

+ Exp func() IExpContext

+ GetParser func() antlr.Parser

+ IsIdxContext func()

+ type IIfBlockContext interface

+ GetParser func() antlr.Parser

+ IsIfBlockContext func()

+ type IIfStmtContext interface

+ AllElifBlock func() []IElifBlockContext

+ ElifBlock func(i int) IElifBlockContext

+ ElseBlock func() IElseBlockContext

+ GetParser func() antlr.Parser

+ IfBlock func() IIfBlockContext

+ IsIfStmtContext func()

+ type IIncludeContext interface

+ Exp func() IExpContext

+ GetParser func() antlr.Parser

+ IsIncludeContext func()

+ type IListContext interface

+ AllExp func() []IExpContext

+ Exp func(i int) IExpContext

+ GetParser func() antlr.Parser

+ IsListContext func()

+ type IMethodInvokeContext interface

+ GetParser func() antlr.Parser

+ IsMethodInvokeContext func()

+ type IProgContext interface

+ AllFn func() []IFnContext

+ AllInclude func() []IIncludeContext

+ AllStmt func() []IStmtContext

+ EOF func() antlr.TerminalNode

+ Fn func(i int) IFnContext

+ GetParser func() antlr.Parser

+ Include func(i int) IIncludeContext

+ IsProgContext func()

+ Stmt func(i int) IStmtContext

+ type IReturnStmtContext interface

+ Exp func() IExpContext

+ GetParser func() antlr.Parser

+ IsReturnStmtContext func()

+ type IStmtContext interface

+ Assignment func() IAssignmentContext

+ BreakStmt func() IBreakStmtContext

+ ContinueStmt func() IContinueStmtContext

+ CsInvoke func() ICsInvokeContext

+ FnInvoke func() IFnInvokeContext

+ ForStmt func() IForStmtContext

+ GetParser func() antlr.Parser

+ IfStmt func() IIfStmtContext

+ IsStmtContext func()

+ MethodInvoke func() IMethodInvokeContext

+ ReturnStmt func() IReturnStmtContext

+ WhileStmt func() IWhileStmtContext

+ type IWhileStmtContext interface

+ AllStmt func() []IStmtContext

+ Exp func() IExpContext

+ GetParser func() antlr.Parser

+ IsWhileStmtContext func()

+ Stmt func(i int) IStmtContext

+ type IdentifierCsInvokeContext struct

+ func NewIdentifierCsInvokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierCsInvokeContext

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

+ func (s *IdentifierCsInvokeContext) AllExp() []IExpContext

+ func (s *IdentifierCsInvokeContext) Closure() antlr.TerminalNode

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

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

+ func (s *IdentifierCsInvokeContext) Exp(i int) IExpContext

+ func (s *IdentifierCsInvokeContext) GetName() antlr.Token

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

+ func (s *IdentifierCsInvokeContext) Identifier() antlr.TerminalNode

+ func (s *IdentifierCsInvokeContext) SetName(v antlr.Token)

+ type IdentifierFnInvokeContext struct

+ func NewIdentifierFnInvokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierFnInvokeContext

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

+ func (s *IdentifierFnInvokeContext) AllExp() []IExpContext

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

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

+ func (s *IdentifierFnInvokeContext) Exp(i int) IExpContext

+ func (s *IdentifierFnInvokeContext) GetName() antlr.Token

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

+ func (s *IdentifierFnInvokeContext) Identifier() antlr.TerminalNode

+ func (s *IdentifierFnInvokeContext) SetName(v antlr.Token)

+ type IdentifierMethodInvokeContext struct

+ func NewIdentifierMethodInvokeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierMethodInvokeContext

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

+ func (s *IdentifierMethodInvokeContext) AllExp() []IExpContext

+ func (s *IdentifierMethodInvokeContext) AllIdentifier() []antlr.TerminalNode

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

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

+ func (s *IdentifierMethodInvokeContext) Exp(i int) IExpContext

+ func (s *IdentifierMethodInvokeContext) GetName() antlr.Token

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

+ func (s *IdentifierMethodInvokeContext) GetVar_() antlr.Token

+ func (s *IdentifierMethodInvokeContext) Identifier(i int) antlr.TerminalNode

+ func (s *IdentifierMethodInvokeContext) SetName(v antlr.Token)

+ func (s *IdentifierMethodInvokeContext) SetVar_(v antlr.Token)

+ type IdxContext struct

+ func NewEmptyIdxContext() *IdxContext

+ func NewIdxContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdxContext

+ func (*IdxContext) IsIdxContext()

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

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

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

+ func (s *IdxContext) Exp() IExpContext

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

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

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

+ type IfBlockContext struct

+ func NewEmptyIfBlockContext() *IfBlockContext

+ func NewIfBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfBlockContext

+ func (*IfBlockContext) IsIfBlockContext()

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

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

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

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

+ type IfBlockStmtContext struct

+ func NewIfBlockStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IfBlockStmtContext

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

+ func (s *IfBlockStmtContext) AllStmt() []IStmtContext

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

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

+ func (s *IfBlockStmtContext) Exp() IExpContext

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

+ func (s *IfBlockStmtContext) Stmt(i int) IStmtContext

+ type IfStmtContext struct

+ func NewEmptyIfStmtContext() *IfStmtContext

+ func NewIfStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStmtContext

+ func (*IfStmtContext) IsIfStmtContext()

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

+ func (s *IfStmtContext) AllElifBlock() []IElifBlockContext

+ func (s *IfStmtContext) ElifBlock(i int) IElifBlockContext

+ func (s *IfStmtContext) ElseBlock() IElseBlockContext

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

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

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

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

+ func (s *IfStmtContext) IfBlock() IIfBlockContext

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

+ type IncludeContext struct

+ func NewEmptyIncludeContext() *IncludeContext

+ func NewIncludeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IncludeContext

+ func (*IncludeContext) IsIncludeContext()

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

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

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

+ func (s *IncludeContext) Exp() IExpContext

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

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

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

+ type ListContext struct

+ func NewEmptyListContext() *ListContext

+ func NewListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListContext

+ func (*ListContext) IsListContext()

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

+ func (s *ListContext) AllExp() []IExpContext

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

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

+ func (s *ListContext) Exp(i int) IExpContext

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

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

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

+ type MethodInvokeContext struct

+ func NewEmptyMethodInvokeContext() *MethodInvokeContext

+ func NewMethodInvokeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodInvokeContext

+ func (*MethodInvokeContext) IsMethodInvokeContext()

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

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

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

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

+ type PLANLexer struct

+ func NewPLANLexer(input antlr.CharStream) *PLANLexer

+ type PLANListener interface

+ EnterAssignDiv func(c *AssignDivContext)

+ EnterAssignIdxRegular func(c *AssignIdxRegularContext)

+ EnterAssignMod func(c *AssignModContext)

+ EnterAssignMul func(c *AssignMulContext)

+ EnterAssignPow func(c *AssignPowContext)

+ EnterAssignRegular func(c *AssignRegularContext)

+ EnterAssignSub func(c *AssignSubContext)

+ EnterAssignSum func(c *AssignSumContext)

+ EnterBreakStmt func(c *BreakStmtContext)

+ EnterClosure func(c *ClosureContext)

+ EnterContinueStmt func(c *ContinueStmtContext)

+ EnterDict func(c *DictContext)

+ EnterDictUnit func(c *DictUnitContext)

+ EnterElifBlockStmt func(c *ElifBlockStmtContext)

+ EnterElseBlockStmt func(c *ElseBlockStmtContext)

+ EnterExpBool func(c *ExpBoolContext)

+ EnterExpComparison func(c *ExpComparisonContext)

+ EnterExpCs func(c *ExpCsContext)

+ EnterExpCsInvoke func(c *ExpCsInvokeContext)

+ EnterExpDict func(c *ExpDictContext)

+ EnterExpEqual func(c *ExpEqualContext)

+ EnterExpFloat func(c *ExpFloatContext)

+ EnterExpFnInvoke func(c *ExpFnInvokeContext)

+ EnterExpIdentifier func(c *ExpIdentifierContext)

+ EnterExpIdx func(c *ExpIdxContext)

+ EnterExpInteger func(c *ExpIntegerContext)

+ EnterExpIntegerHex func(c *ExpIntegerHexContext)

+ EnterExpList func(c *ExpListContext)

+ EnterExpLogicalAnd func(c *ExpLogicalAndContext)

+ EnterExpLogicalNot func(c *ExpLogicalNotContext)

+ EnterExpLogicalOr func(c *ExpLogicalOrContext)

+ EnterExpMethodInvoke func(c *ExpMethodInvokeContext)

+ EnterExpMulDivMod func(c *ExpMulDivModContext)

+ EnterExpNeg func(c *ExpNegContext)

+ EnterExpNull func(c *ExpNullContext)

+ EnterExpParentheses func(c *ExpParenthesesContext)

+ EnterExpPow func(c *ExpPowContext)

+ EnterExpString func(c *ExpStringContext)

+ EnterExpSumSub func(c *ExpSumSubContext)

+ EnterExpXor func(c *ExpXorContext)

+ EnterFn func(c *FnContext)

+ EnterFnBody func(c *FnBodyContext)

+ EnterFnParams func(c *FnParamsContext)

+ EnterForStmt func(c *ForStmtContext)

+ EnterIdentifierCsInvoke func(c *IdentifierCsInvokeContext)

+ EnterIdentifierFnInvoke func(c *IdentifierFnInvokeContext)

+ EnterIdentifierMethodInvoke func(c *IdentifierMethodInvokeContext)

+ EnterIdx func(c *IdxContext)

+ EnterIfBlockStmt func(c *IfBlockStmtContext)

+ EnterIfStmt func(c *IfStmtContext)

+ EnterInclude func(c *IncludeContext)

+ EnterList func(c *ListContext)

+ EnterProg func(c *ProgContext)

+ EnterReturnStmt func(c *ReturnStmtContext)

+ EnterStmt func(c *StmtContext)

+ EnterWhileStmt func(c *WhileStmtContext)

+ ExitAssignDiv func(c *AssignDivContext)

+ ExitAssignIdxRegular func(c *AssignIdxRegularContext)

+ ExitAssignMod func(c *AssignModContext)

+ ExitAssignMul func(c *AssignMulContext)

+ ExitAssignPow func(c *AssignPowContext)

+ ExitAssignRegular func(c *AssignRegularContext)

+ ExitAssignSub func(c *AssignSubContext)

+ ExitAssignSum func(c *AssignSumContext)

+ ExitBreakStmt func(c *BreakStmtContext)

+ ExitClosure func(c *ClosureContext)

+ ExitContinueStmt func(c *ContinueStmtContext)

+ ExitDict func(c *DictContext)

+ ExitDictUnit func(c *DictUnitContext)

+ ExitElifBlockStmt func(c *ElifBlockStmtContext)

+ ExitElseBlockStmt func(c *ElseBlockStmtContext)

+ ExitExpBool func(c *ExpBoolContext)

+ ExitExpComparison func(c *ExpComparisonContext)

+ ExitExpCs func(c *ExpCsContext)

+ ExitExpCsInvoke func(c *ExpCsInvokeContext)

+ ExitExpDict func(c *ExpDictContext)

+ ExitExpEqual func(c *ExpEqualContext)

+ ExitExpFloat func(c *ExpFloatContext)

+ ExitExpFnInvoke func(c *ExpFnInvokeContext)

+ ExitExpIdentifier func(c *ExpIdentifierContext)

+ ExitExpIdx func(c *ExpIdxContext)

+ ExitExpInteger func(c *ExpIntegerContext)

+ ExitExpIntegerHex func(c *ExpIntegerHexContext)

+ ExitExpList func(c *ExpListContext)

+ ExitExpLogicalAnd func(c *ExpLogicalAndContext)

+ ExitExpLogicalNot func(c *ExpLogicalNotContext)

+ ExitExpLogicalOr func(c *ExpLogicalOrContext)

+ ExitExpMethodInvoke func(c *ExpMethodInvokeContext)

+ ExitExpMulDivMod func(c *ExpMulDivModContext)

+ ExitExpNeg func(c *ExpNegContext)

+ ExitExpNull func(c *ExpNullContext)

+ ExitExpParentheses func(c *ExpParenthesesContext)

+ ExitExpPow func(c *ExpPowContext)

+ ExitExpString func(c *ExpStringContext)

+ ExitExpSumSub func(c *ExpSumSubContext)

+ ExitExpXor func(c *ExpXorContext)

+ ExitFn func(c *FnContext)

+ ExitFnBody func(c *FnBodyContext)

+ ExitFnParams func(c *FnParamsContext)

+ ExitForStmt func(c *ForStmtContext)

+ ExitIdentifierCsInvoke func(c *IdentifierCsInvokeContext)

+ ExitIdentifierFnInvoke func(c *IdentifierFnInvokeContext)

+ ExitIdentifierMethodInvoke func(c *IdentifierMethodInvokeContext)

+ ExitIdx func(c *IdxContext)

+ ExitIfBlockStmt func(c *IfBlockStmtContext)

+ ExitIfStmt func(c *IfStmtContext)

+ ExitInclude func(c *IncludeContext)

+ ExitList func(c *ListContext)

+ ExitProg func(c *ProgContext)

+ ExitReturnStmt func(c *ReturnStmtContext)

+ ExitStmt func(c *StmtContext)

+ ExitWhileStmt func(c *WhileStmtContext)

+ type PLANParser struct

+ func NewPLANParser(input antlr.TokenStream) *PLANParser

+ func (p *PLANParser) Assignment() (localctx IAssignmentContext)

+ func (p *PLANParser) BreakStmt() (localctx IBreakStmtContext)

+ func (p *PLANParser) Closure() (localctx IClosureContext)

+ func (p *PLANParser) ContinueStmt() (localctx IContinueStmtContext)

+ func (p *PLANParser) CsInvoke() (localctx ICsInvokeContext)

+ func (p *PLANParser) Dict() (localctx IDictContext)

+ func (p *PLANParser) DictUnit() (localctx IDictUnitContext)

+ func (p *PLANParser) ElifBlock() (localctx IElifBlockContext)

+ func (p *PLANParser) ElseBlock() (localctx IElseBlockContext)

+ func (p *PLANParser) Exp() (localctx IExpContext)

+ func (p *PLANParser) Exp_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *PLANParser) Fn() (localctx IFnContext)

+ func (p *PLANParser) FnBody() (localctx IFnBodyContext)

+ func (p *PLANParser) FnInvoke() (localctx IFnInvokeContext)

+ func (p *PLANParser) FnParams() (localctx IFnParamsContext)

+ func (p *PLANParser) ForStmt() (localctx IForStmtContext)

+ func (p *PLANParser) Idx() (localctx IIdxContext)

+ func (p *PLANParser) IfBlock() (localctx IIfBlockContext)

+ func (p *PLANParser) IfStmt() (localctx IIfStmtContext)

+ func (p *PLANParser) Include() (localctx IIncludeContext)

+ func (p *PLANParser) List() (localctx IListContext)

+ func (p *PLANParser) MethodInvoke() (localctx IMethodInvokeContext)

+ func (p *PLANParser) Prog() (localctx IProgContext)

+ func (p *PLANParser) ReturnStmt() (localctx IReturnStmtContext)

+ func (p *PLANParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *PLANParser) Stmt() (localctx IStmtContext)

+ func (p *PLANParser) WhileStmt() (localctx IWhileStmtContext)

+ type PLANVisitor interface

+ VisitAssignDiv func(ctx *AssignDivContext) interface{}

+ VisitAssignIdxRegular func(ctx *AssignIdxRegularContext) interface{}

+ VisitAssignMod func(ctx *AssignModContext) interface{}

+ VisitAssignMul func(ctx *AssignMulContext) interface{}

+ VisitAssignPow func(ctx *AssignPowContext) interface{}

+ VisitAssignRegular func(ctx *AssignRegularContext) interface{}

+ VisitAssignSub func(ctx *AssignSubContext) interface{}

+ VisitAssignSum func(ctx *AssignSumContext) interface{}

+ VisitBreakStmt func(ctx *BreakStmtContext) interface{}

+ VisitClosure func(ctx *ClosureContext) interface{}

+ VisitContinueStmt func(ctx *ContinueStmtContext) interface{}

+ VisitDict func(ctx *DictContext) interface{}

+ VisitDictUnit func(ctx *DictUnitContext) interface{}

+ VisitElifBlockStmt func(ctx *ElifBlockStmtContext) interface{}

+ VisitElseBlockStmt func(ctx *ElseBlockStmtContext) interface{}

+ VisitExpBool func(ctx *ExpBoolContext) interface{}

+ VisitExpComparison func(ctx *ExpComparisonContext) interface{}

+ VisitExpCs func(ctx *ExpCsContext) interface{}

+ VisitExpCsInvoke func(ctx *ExpCsInvokeContext) interface{}

+ VisitExpDict func(ctx *ExpDictContext) interface{}

+ VisitExpEqual func(ctx *ExpEqualContext) interface{}

+ VisitExpFloat func(ctx *ExpFloatContext) interface{}

+ VisitExpFnInvoke func(ctx *ExpFnInvokeContext) interface{}

+ VisitExpIdentifier func(ctx *ExpIdentifierContext) interface{}

+ VisitExpIdx func(ctx *ExpIdxContext) interface{}

+ VisitExpInteger func(ctx *ExpIntegerContext) interface{}

+ VisitExpIntegerHex func(ctx *ExpIntegerHexContext) interface{}

+ VisitExpList func(ctx *ExpListContext) interface{}

+ VisitExpLogicalAnd func(ctx *ExpLogicalAndContext) interface{}

+ VisitExpLogicalNot func(ctx *ExpLogicalNotContext) interface{}

+ VisitExpLogicalOr func(ctx *ExpLogicalOrContext) interface{}

+ VisitExpMethodInvoke func(ctx *ExpMethodInvokeContext) interface{}

+ VisitExpMulDivMod func(ctx *ExpMulDivModContext) interface{}

+ VisitExpNeg func(ctx *ExpNegContext) interface{}

+ VisitExpNull func(ctx *ExpNullContext) interface{}

+ VisitExpParentheses func(ctx *ExpParenthesesContext) interface{}

+ VisitExpPow func(ctx *ExpPowContext) interface{}

+ VisitExpString func(ctx *ExpStringContext) interface{}

+ VisitExpSumSub func(ctx *ExpSumSubContext) interface{}

+ VisitExpXor func(ctx *ExpXorContext) interface{}

+ VisitFn func(ctx *FnContext) interface{}

+ VisitFnBody func(ctx *FnBodyContext) interface{}

+ VisitFnParams func(ctx *FnParamsContext) interface{}

+ VisitForStmt func(ctx *ForStmtContext) interface{}

+ VisitIdentifierCsInvoke func(ctx *IdentifierCsInvokeContext) interface{}

+ VisitIdentifierFnInvoke func(ctx *IdentifierFnInvokeContext) interface{}

+ VisitIdentifierMethodInvoke func(ctx *IdentifierMethodInvokeContext) interface{}

+ VisitIdx func(ctx *IdxContext) interface{}

+ VisitIfBlockStmt func(ctx *IfBlockStmtContext) interface{}

+ VisitIfStmt func(ctx *IfStmtContext) interface{}

+ VisitInclude func(ctx *IncludeContext) interface{}

+ VisitList func(ctx *ListContext) interface{}

+ VisitProg func(ctx *ProgContext) interface{}

+ VisitReturnStmt func(ctx *ReturnStmtContext) interface{}

+ VisitStmt func(ctx *StmtContext) interface{}

+ VisitWhileStmt func(ctx *WhileStmtContext) interface{}

+ type ProgContext struct

+ func NewEmptyProgContext() *ProgContext

+ func NewProgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgContext

+ func (*ProgContext) IsProgContext()

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

+ func (s *ProgContext) AllFn() []IFnContext

+ func (s *ProgContext) AllInclude() []IIncludeContext

+ func (s *ProgContext) AllStmt() []IStmtContext

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

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

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

+ func (s *ProgContext) Fn(i int) IFnContext

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

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

+ func (s *ProgContext) Include(i int) IIncludeContext

+ func (s *ProgContext) Stmt(i int) IStmtContext

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

+ type ReturnStmtContext struct

+ func NewEmptyReturnStmtContext() *ReturnStmtContext

+ func NewReturnStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStmtContext

+ func (*ReturnStmtContext) IsReturnStmtContext()

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

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

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

+ func (s *ReturnStmtContext) Exp() IExpContext

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

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

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

+ type StmtContext struct

+ func NewEmptyStmtContext() *StmtContext

+ func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext

+ func (*StmtContext) IsStmtContext()

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

+ func (s *StmtContext) Assignment() IAssignmentContext

+ func (s *StmtContext) BreakStmt() IBreakStmtContext

+ func (s *StmtContext) ContinueStmt() IContinueStmtContext

+ func (s *StmtContext) CsInvoke() ICsInvokeContext

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

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

+ func (s *StmtContext) FnInvoke() IFnInvokeContext

+ func (s *StmtContext) ForStmt() IForStmtContext

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

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

+ func (s *StmtContext) IfStmt() IIfStmtContext

+ func (s *StmtContext) MethodInvoke() IMethodInvokeContext

+ func (s *StmtContext) ReturnStmt() IReturnStmtContext

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

+ func (s *StmtContext) WhileStmt() IWhileStmtContext

+ type WhileStmtContext struct

+ func NewEmptyWhileStmtContext() *WhileStmtContext

+ func NewWhileStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStmtContext

+ func (*WhileStmtContext) IsWhileStmtContext()

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

+ func (s *WhileStmtContext) AllStmt() []IStmtContext

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

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

+ func (s *WhileStmtContext) Exp() IExpContext

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

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

+ func (s *WhileStmtContext) Stmt(i int) IStmtContext

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

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