kubernetes/vendor/github.com/antlr4-go/antlr/v4/tree.go

var TreeInvalidInterval

type Tree

type SyntaxTree

type ParseTree

type RuleNode

type TerminalNode

type ErrorNode

type ParseTreeVisitor

type BaseParseTreeVisitor

var _

func (v *BaseParseTreeVisitor) Visit(tree ParseTree) interface{}

func (v *BaseParseTreeVisitor) VisitChildren(_ RuleNode) interface{}

func (v *BaseParseTreeVisitor) VisitTerminal(_ TerminalNode) interface{}

func (v *BaseParseTreeVisitor) VisitErrorNode(_ ErrorNode) interface{}

type ParseTreeListener

type BaseParseTreeListener

var _

func (l *BaseParseTreeListener) VisitTerminal(_ TerminalNode)       {}

func (l *BaseParseTreeListener) VisitErrorNode(_ ErrorNode)         {}

func (l *BaseParseTreeListener) EnterEveryRule(_ ParserRuleContext) {}

func (l *BaseParseTreeListener) ExitEveryRule(_ ParserRuleContext)  {}

type TerminalNodeImpl

var _

func NewTerminalNodeImpl(symbol Token) *TerminalNodeImpl {}

func (t *TerminalNodeImpl) GetChild(_ int) Tree {}

func (t *TerminalNodeImpl) GetChildren() []Tree {}

func (t *TerminalNodeImpl) SetChildren(_ []Tree) {}

func (t *TerminalNodeImpl) GetSymbol() Token {}

func (t *TerminalNodeImpl) GetParent() Tree {}

func (t *TerminalNodeImpl) SetParent(tree Tree) {}

func (t *TerminalNodeImpl) GetPayload() interface{}

func (t *TerminalNodeImpl) GetSourceInterval() Interval {}

func (t *TerminalNodeImpl) GetChildCount() int {}

func (t *TerminalNodeImpl) Accept(v ParseTreeVisitor) interface{}

func (t *TerminalNodeImpl) GetText() string {}

func (t *TerminalNodeImpl) String() string {}

func (t *TerminalNodeImpl) ToStringTree(_ []string, _ Recognizer) string {}

type ErrorNodeImpl

var _

func NewErrorNodeImpl(token Token) *ErrorNodeImpl {}

func (e *ErrorNodeImpl) errorNode() {}

func (e *ErrorNodeImpl) Accept(v ParseTreeVisitor) interface{}

type ParseTreeWalker

func NewParseTreeWalker() *ParseTreeWalker {}

// Walk performs a walk on the given parse tree starting at the root and going down recursively
// with depth-first search. On each node, [EnterRule] is called before
// recursively walking down into child nodes, then [ExitRule] is called after the recursive call to wind up.
func (p *ParseTreeWalker) Walk(listener ParseTreeListener, t Tree) {}

// EnterRule enters a grammar rule by first triggering the generic event [ParseTreeListener].[EnterEveryRule]
// then by triggering the event specific to the given parse tree node
func (p *ParseTreeWalker) EnterRule(listener ParseTreeListener, r RuleNode) {}

// ExitRule exits a grammar rule by first triggering the event specific to the given parse tree node
// then by triggering the generic event [ParseTreeListener].ExitEveryRule
func (p *ParseTreeWalker) ExitRule(listener ParseTreeListener, r RuleNode) {}

var ParseTreeWalkerDefault

type IterativeParseTreeWalker

//goland:noinspection GoUnusedExportedFunction
func NewIterativeParseTreeWalker() *IterativeParseTreeWalker {}

func (i *IterativeParseTreeWalker) Walk(listener ParseTreeListener, t Tree) {}