parser

package
v0.5.0 Latest Latest
Warning

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

 Go to latest Published: Mar 30, 2025 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ClauseExpressionLexerT__0                   = 1
	ClauseExpressionLexerT__1                   = 2
	ClauseExpressionLexerT__2                   = 3
	ClauseExpressionLexerT__3                   = 4
	ClauseExpressionLexerT__4                   = 5
	ClauseExpressionLexerT__5                   = 6
	ClauseExpressionLexerT__6                   = 7
	ClauseExpressionLexerT__7                   = 8
	ClauseExpressionLexerT__8                   = 9
	ClauseExpressionLexerT__9                   = 10
	ClauseExpressionLexerT__10                  = 11
	ClauseExpressionLexerT__11                  = 12
	ClauseExpressionLexerT__12                  = 13
	ClauseExpressionLexerT__13                  = 14
	ClauseExpressionLexerT__14                  = 15
	ClauseExpressionLexerT__15                  = 16
	ClauseExpressionLexerT__16                  = 17
	ClauseExpressionLexerT__17                  = 18
	ClauseExpressionLexerT__18                  = 19
	ClauseExpressionLexerT__19                  = 20
	ClauseExpressionLexerFORALL                 = 21
	ClauseExpressionLexerEXISTS                 = 22
	ClauseExpressionLexerIMPLIES                = 23
	ClauseExpressionLexerIFF                    = 24
	ClauseExpressionLexerIN                     = 25
	ClauseExpressionLexerINDEXOF                = 26
	ClauseExpressionLexerITERATING              = 27
	ClauseExpressionLexerDOT                    = 28
	ClauseExpressionLexerWHITESPACE             = 29
	ClauseExpressionLexerID                     = 30
	ClauseExpressionLexerDECIMAL_LIT            = 31
	ClauseExpressionLexerRAW_STRING_LIT         = 32
	ClauseExpressionLexerINTERPRETED_STRING_LIT = 33
)

ClauseExpressionLexer tokens.

View Source 
const (
	ClauseExpressionParserEOF                    = antlr.TokenEOF
	ClauseExpressionParserT__0                   = 1
	ClauseExpressionParserT__1                   = 2
	ClauseExpressionParserT__2                   = 3
	ClauseExpressionParserT__3                   = 4
	ClauseExpressionParserT__4                   = 5
	ClauseExpressionParserT__5                   = 6
	ClauseExpressionParserT__6                   = 7
	ClauseExpressionParserT__7                   = 8
	ClauseExpressionParserT__8                   = 9
	ClauseExpressionParserT__9                   = 10
	ClauseExpressionParserT__10                  = 11
	ClauseExpressionParserT__11                  = 12
	ClauseExpressionParserT__12                  = 13
	ClauseExpressionParserT__13                  = 14
	ClauseExpressionParserT__14                  = 15
	ClauseExpressionParserT__15                  = 16
	ClauseExpressionParserT__16                  = 17
	ClauseExpressionParserT__17                  = 18
	ClauseExpressionParserT__18                  = 19
	ClauseExpressionParserT__19                  = 20
	ClauseExpressionParserFORALL                 = 21
	ClauseExpressionParserEXISTS                 = 22
	ClauseExpressionParserIMPLIES                = 23
	ClauseExpressionParserIFF                    = 24
	ClauseExpressionParserIN                     = 25
	ClauseExpressionParserINDEXOF                = 26
	ClauseExpressionParserITERATING              = 27
	ClauseExpressionParserDOT                    = 28
	ClauseExpressionParserWHITESPACE             = 29
	ClauseExpressionParserID                     = 30
	ClauseExpressionParserDECIMAL_LIT            = 31
	ClauseExpressionParserRAW_STRING_LIT         = 32
	ClauseExpressionParserINTERPRETED_STRING_LIT = 33
)

ClauseExpressionParser tokens.

View Source 
const (
	ClauseExpressionParserRULE_root                  = 0
	ClauseExpressionParserRULE_clauseExpression      = 1
	ClauseExpressionParserRULE_iterator              = 2
	ClauseExpressionParserRULE_collection            = 3
	ClauseExpressionParserRULE_completeGoExpression  = 4
	ClauseExpressionParserRULE_goExpression          = 5
	ClauseExpressionParserRULE_primaryExpression     = 6
	ClauseExpressionParserRULE_qualifiedIdentifier   = 7
	ClauseExpressionParserRULE_functionCallArguments = 8
	ClauseExpressionParserRULE_sliceIndex            = 9
	ClauseExpressionParserRULE_number                = 10
	ClauseExpressionParserRULE_string                = 11
)

ClauseExpressionParser rules.

Variables

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

Functions

func ClauseExpressionLexerInit 

func ClauseExpressionLexerInit()

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

func ClauseExpressionParserInit 

func ClauseExpressionParserInit()

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

func InitEmptyClauseExpressionContext 

func InitEmptyClauseExpressionContext(p *ClauseExpressionContext)

func InitEmptyCollectionContext 

func InitEmptyCollectionContext(p *CollectionContext)

func InitEmptyCompleteGoExpressionContext 

func InitEmptyCompleteGoExpressionContext(p *CompleteGoExpressionContext)

func InitEmptyFunctionCallArgumentsContext 

func InitEmptyFunctionCallArgumentsContext(p *FunctionCallArgumentsContext)

func InitEmptyGoExpressionContext 

func InitEmptyGoExpressionContext(p *GoExpressionContext)

func InitEmptyIteratorContext 

func InitEmptyIteratorContext(p *IteratorContext)

func InitEmptyNumberContext 

func InitEmptyNumberContext(p *NumberContext)

func InitEmptyPrimaryExpressionContext 

func InitEmptyPrimaryExpressionContext(p *PrimaryExpressionContext)

func InitEmptyQualifiedIdentifierContext 

func InitEmptyQualifiedIdentifierContext(p *QualifiedIdentifierContext)

func InitEmptyRootContext 

func InitEmptyRootContext(p *RootContext)

func InitEmptySliceIndexContext 

func InitEmptySliceIndexContext(p *SliceIndexContext)

func InitEmptyStringContext 

func InitEmptyStringContext(p *StringContext)

Types

type BaseClauseExpressionListener 

type BaseClauseExpressionListener struct{}

BaseClauseExpressionListener is a complete listener for a parse tree produced by ClauseExpressionParser.

func (*BaseClauseExpressionListener) EnterCollection 

func (s *BaseClauseExpressionListener) EnterCollection(ctx *CollectionContext)

EnterCollection is called when production collection is entered.

func (*BaseClauseExpressionListener) EnterCompleteGoExpression 

func (s *BaseClauseExpressionListener) EnterCompleteGoExpression(ctx *CompleteGoExpressionContext)

EnterCompleteGoExpression is called when production completeGoExpression is entered.

func (*BaseClauseExpressionListener) EnterEveryRule 

func (s *BaseClauseExpressionListener) EnterEveryRule(ctx antlr.ParserRuleContext)

EnterEveryRule is called when any rule is entered.

func (*BaseClauseExpressionListener) EnterExistsElement 

func (s *BaseClauseExpressionListener) EnterExistsElement(ctx *ExistsElementContext)

EnterExistsElement is called when production ExistsElement is entered.

func (*BaseClauseExpressionListener) EnterExistsIndex 

func (s *BaseClauseExpressionListener) EnterExistsIndex(ctx *ExistsIndexContext)

EnterExistsIndex is called when production ExistsIndex is entered.

func (*BaseClauseExpressionListener) EnterExistsIterator 

func (s *BaseClauseExpressionListener) EnterExistsIterator(ctx *ExistsIteratorContext)

EnterExistsIterator is called when production ExistsIterator is entered.

func (*BaseClauseExpressionListener) EnterExprInParens 

func (s *BaseClauseExpressionListener) EnterExprInParens(ctx *ExprInParensContext)

EnterExprInParens is called when production ExprInParens is entered.

func (*BaseClauseExpressionListener) EnterForallElement 

func (s *BaseClauseExpressionListener) EnterForallElement(ctx *ForallElementContext)

EnterForallElement is called when production ForallElement is entered.

func (*BaseClauseExpressionListener) EnterForallIndex 

func (s *BaseClauseExpressionListener) EnterForallIndex(ctx *ForallIndexContext)

EnterForallIndex is called when production ForallIndex is entered.

func (*BaseClauseExpressionListener) EnterForallIterator 

func (s *BaseClauseExpressionListener) EnterForallIterator(ctx *ForallIteratorContext)

EnterForallIterator is called when production ForallIterator is entered.

func (*BaseClauseExpressionListener) EnterFunctionCallArguments 

func (s *BaseClauseExpressionListener) EnterFunctionCallArguments(ctx *FunctionCallArgumentsContext)

EnterFunctionCallArguments is called when production functionCallArguments is entered.

func (*BaseClauseExpressionListener) EnterGoExpression 

func (s *BaseClauseExpressionListener) EnterGoExpression(ctx *GoExpressionContext)

EnterGoExpression is called when production goExpression is entered.

func (*BaseClauseExpressionListener) EnterIff 

func (s *BaseClauseExpressionListener) EnterIff(ctx *IffContext)

EnterIff is called when production Iff is entered.

func (*BaseClauseExpressionListener) EnterImplies 

func (s *BaseClauseExpressionListener) EnterImplies(ctx *ImpliesContext)

EnterImplies is called when production Implies is entered.

func (*BaseClauseExpressionListener) EnterIterator 

func (s *BaseClauseExpressionListener) EnterIterator(ctx *IteratorContext)

EnterIterator is called when production iterator is entered.

func (*BaseClauseExpressionListener) EnterNumber 

func (s *BaseClauseExpressionListener) EnterNumber(ctx *NumberContext)

EnterNumber is called when production number is entered.

func (*BaseClauseExpressionListener) EnterPlainGoExpression 

func (s *BaseClauseExpressionListener) EnterPlainGoExpression(ctx *PlainGoExpressionContext)

EnterPlainGoExpression is called when production PlainGoExpression is entered.

func (*BaseClauseExpressionListener) EnterPrimaryExpression 

func (s *BaseClauseExpressionListener) EnterPrimaryExpression(ctx *PrimaryExpressionContext)

EnterPrimaryExpression is called when production primaryExpression is entered.

func (*BaseClauseExpressionListener) EnterQualifiedIdentifier 

func (s *BaseClauseExpressionListener) EnterQualifiedIdentifier(ctx *QualifiedIdentifierContext)

EnterQualifiedIdentifier is called when production qualifiedIdentifier is entered.

func (*BaseClauseExpressionListener) EnterRoot 

func (s *BaseClauseExpressionListener) EnterRoot(ctx *RootContext)

EnterRoot is called when production root is entered.

func (*BaseClauseExpressionListener) EnterSliceIndex 

func (s *BaseClauseExpressionListener) EnterSliceIndex(ctx *SliceIndexContext)

EnterSliceIndex is called when production sliceIndex is entered.

func (*BaseClauseExpressionListener) EnterString 

func (s *BaseClauseExpressionListener) EnterString(ctx *StringContext)

EnterString is called when production string is entered.

func (*BaseClauseExpressionListener) ExitCollection 

func (s *BaseClauseExpressionListener) ExitCollection(ctx *CollectionContext)

ExitCollection is called when production collection is exited.

func (*BaseClauseExpressionListener) ExitCompleteGoExpression 

func (s *BaseClauseExpressionListener) ExitCompleteGoExpression(ctx *CompleteGoExpressionContext)

ExitCompleteGoExpression is called when production completeGoExpression is exited.

func (*BaseClauseExpressionListener) ExitEveryRule 

func (s *BaseClauseExpressionListener) ExitEveryRule(ctx antlr.ParserRuleContext)

ExitEveryRule is called when any rule is exited.

func (*BaseClauseExpressionListener) ExitExistsElement 

func (s *BaseClauseExpressionListener) ExitExistsElement(ctx *ExistsElementContext)

ExitExistsElement is called when production ExistsElement is exited.

func (*BaseClauseExpressionListener) ExitExistsIndex 

func (s *BaseClauseExpressionListener) ExitExistsIndex(ctx *ExistsIndexContext)

ExitExistsIndex is called when production ExistsIndex is exited.

func (*BaseClauseExpressionListener) ExitExistsIterator 

func (s *BaseClauseExpressionListener) ExitExistsIterator(ctx *ExistsIteratorContext)

ExitExistsIterator is called when production ExistsIterator is exited.

func (*BaseClauseExpressionListener) ExitExprInParens 

func (s *BaseClauseExpressionListener) ExitExprInParens(ctx *ExprInParensContext)

ExitExprInParens is called when production ExprInParens is exited.

func (*BaseClauseExpressionListener) ExitForallElement 

func (s *BaseClauseExpressionListener) ExitForallElement(ctx *ForallElementContext)

ExitForallElement is called when production ForallElement is exited.

func (*BaseClauseExpressionListener) ExitForallIndex 

func (s *BaseClauseExpressionListener) ExitForallIndex(ctx *ForallIndexContext)

ExitForallIndex is called when production ForallIndex is exited.

func (*BaseClauseExpressionListener) ExitForallIterator 

func (s *BaseClauseExpressionListener) ExitForallIterator(ctx *ForallIteratorContext)

ExitForallIterator is called when production ForallIterator is exited.

func (*BaseClauseExpressionListener) ExitFunctionCallArguments 

func (s *BaseClauseExpressionListener) ExitFunctionCallArguments(ctx *FunctionCallArgumentsContext)

ExitFunctionCallArguments is called when production functionCallArguments is exited.

func (*BaseClauseExpressionListener) ExitGoExpression 

func (s *BaseClauseExpressionListener) ExitGoExpression(ctx *GoExpressionContext)

ExitGoExpression is called when production goExpression is exited.

func (*BaseClauseExpressionListener) ExitIff 

func (s *BaseClauseExpressionListener) ExitIff(ctx *IffContext)

ExitIff is called when production Iff is exited.

func (*BaseClauseExpressionListener) ExitImplies 

func (s *BaseClauseExpressionListener) ExitImplies(ctx *ImpliesContext)

ExitImplies is called when production Implies is exited.

func (*BaseClauseExpressionListener) ExitIterator 

func (s *BaseClauseExpressionListener) ExitIterator(ctx *IteratorContext)

ExitIterator is called when production iterator is exited.

func (*BaseClauseExpressionListener) ExitNumber 

func (s *BaseClauseExpressionListener) ExitNumber(ctx *NumberContext)

ExitNumber is called when production number is exited.

func (*BaseClauseExpressionListener) ExitPlainGoExpression 

func (s *BaseClauseExpressionListener) ExitPlainGoExpression(ctx *PlainGoExpressionContext)

ExitPlainGoExpression is called when production PlainGoExpression is exited.

func (*BaseClauseExpressionListener) ExitPrimaryExpression 

func (s *BaseClauseExpressionListener) ExitPrimaryExpression(ctx *PrimaryExpressionContext)

ExitPrimaryExpression is called when production primaryExpression is exited.

func (*BaseClauseExpressionListener) ExitQualifiedIdentifier 

func (s *BaseClauseExpressionListener) ExitQualifiedIdentifier(ctx *QualifiedIdentifierContext)

ExitQualifiedIdentifier is called when production qualifiedIdentifier is exited.

func (*BaseClauseExpressionListener) ExitRoot 

func (s *BaseClauseExpressionListener) ExitRoot(ctx *RootContext)

ExitRoot is called when production root is exited.

func (*BaseClauseExpressionListener) ExitSliceIndex 

func (s *BaseClauseExpressionListener) ExitSliceIndex(ctx *SliceIndexContext)

ExitSliceIndex is called when production sliceIndex is exited.

func (*BaseClauseExpressionListener) ExitString 

func (s *BaseClauseExpressionListener) ExitString(ctx *StringContext)

ExitString is called when production string is exited.

func (*BaseClauseExpressionListener) VisitErrorNode 

func (s *BaseClauseExpressionListener) VisitErrorNode(node antlr.ErrorNode)

VisitErrorNode is called when an error node is visited.

func (*BaseClauseExpressionListener) VisitTerminal 

func (s *BaseClauseExpressionListener) VisitTerminal(node antlr.TerminalNode)

VisitTerminal is called when a terminal node is visited.

type BaseClauseExpressionVisitor 

type BaseClauseExpressionVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseClauseExpressionVisitor) VisitCollection 

func (v *BaseClauseExpressionVisitor) VisitCollection(ctx *CollectionContext) interface{}

func (*BaseClauseExpressionVisitor) VisitCompleteGoExpression 

func (v *BaseClauseExpressionVisitor) VisitCompleteGoExpression(ctx *CompleteGoExpressionContext) interface{}

func (*BaseClauseExpressionVisitor) VisitExistsElement 

func (v *BaseClauseExpressionVisitor) VisitExistsElement(ctx *ExistsElementContext) interface{}

func (*BaseClauseExpressionVisitor) VisitExistsIndex 

func (v *BaseClauseExpressionVisitor) VisitExistsIndex(ctx *ExistsIndexContext) interface{}

func (*BaseClauseExpressionVisitor) VisitExistsIterator 

func (v *BaseClauseExpressionVisitor) VisitExistsIterator(ctx *ExistsIteratorContext) interface{}

func (*BaseClauseExpressionVisitor) VisitExprInParens 

func (v *BaseClauseExpressionVisitor) VisitExprInParens(ctx *ExprInParensContext) interface{}

func (*BaseClauseExpressionVisitor) VisitForallElement 

func (v *BaseClauseExpressionVisitor) VisitForallElement(ctx *ForallElementContext) interface{}

func (*BaseClauseExpressionVisitor) VisitForallIndex 

func (v *BaseClauseExpressionVisitor) VisitForallIndex(ctx *ForallIndexContext) interface{}

func (*BaseClauseExpressionVisitor) VisitForallIterator 

func (v *BaseClauseExpressionVisitor) VisitForallIterator(ctx *ForallIteratorContext) interface{}

func (*BaseClauseExpressionVisitor) VisitFunctionCallArguments 

func (v *BaseClauseExpressionVisitor) VisitFunctionCallArguments(ctx *FunctionCallArgumentsContext) interface{}

func (*BaseClauseExpressionVisitor) VisitGoExpression 

func (v *BaseClauseExpressionVisitor) VisitGoExpression(ctx *GoExpressionContext) interface{}

func (*BaseClauseExpressionVisitor) VisitIff 

func (v *BaseClauseExpressionVisitor) VisitIff(ctx *IffContext) interface{}

func (*BaseClauseExpressionVisitor) VisitImplies 

func (v *BaseClauseExpressionVisitor) VisitImplies(ctx *ImpliesContext) interface{}

func (*BaseClauseExpressionVisitor) VisitIterator 

func (v *BaseClauseExpressionVisitor) VisitIterator(ctx *IteratorContext) interface{}

func (*BaseClauseExpressionVisitor) VisitNumber 

func (v *BaseClauseExpressionVisitor) VisitNumber(ctx *NumberContext) interface{}

func (*BaseClauseExpressionVisitor) VisitPlainGoExpression 

func (v *BaseClauseExpressionVisitor) VisitPlainGoExpression(ctx *PlainGoExpressionContext) interface{}

func (*BaseClauseExpressionVisitor) VisitPrimaryExpression 

func (v *BaseClauseExpressionVisitor) VisitPrimaryExpression(ctx *PrimaryExpressionContext) interface{}

func (*BaseClauseExpressionVisitor) VisitQualifiedIdentifier 

func (v *BaseClauseExpressionVisitor) VisitQualifiedIdentifier(ctx *QualifiedIdentifierContext) interface{}

func (*BaseClauseExpressionVisitor) VisitRoot 

func (v *BaseClauseExpressionVisitor) VisitRoot(ctx *RootContext) interface{}

func (*BaseClauseExpressionVisitor) VisitSliceIndex 

func (v *BaseClauseExpressionVisitor) VisitSliceIndex(ctx *SliceIndexContext) interface{}

func (*BaseClauseExpressionVisitor) VisitString 

func (v *BaseClauseExpressionVisitor) VisitString(ctx *StringContext) interface{}

type ClauseExpressionContext 

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

func NewClauseExpressionContext 

func NewClauseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClauseExpressionContext

func NewEmptyClauseExpressionContext 

func NewEmptyClauseExpressionContext() *ClauseExpressionContext

func (*ClauseExpressionContext) CopyAll 

func (s *ClauseExpressionContext) CopyAll(ctx *ClauseExpressionContext)

func (*ClauseExpressionContext) GetParser 

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

func (*ClauseExpressionContext) GetRuleContext 

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

func (*ClauseExpressionContext) IsClauseExpressionContext 

func (*ClauseExpressionContext) IsClauseExpressionContext()

func (*ClauseExpressionContext) ToStringTree 

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

type ClauseExpressionLexer 

type ClauseExpressionLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewClauseExpressionLexer 

func NewClauseExpressionLexer(input antlr.CharStream) *ClauseExpressionLexer

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

type ClauseExpressionListener 

type ClauseExpressionListener interface {
	antlr.ParseTreeListener

	// EnterRoot is called when entering the root production.
	EnterRoot(c *RootContext)

	// EnterExprInParens is called when entering the ExprInParens production.
	EnterExprInParens(c *ExprInParensContext)

	// EnterImplies is called when entering the Implies production.
	EnterImplies(c *ImpliesContext)

	// EnterExistsIndex is called when entering the ExistsIndex production.
	EnterExistsIndex(c *ExistsIndexContext)

	// EnterExistsElement is called when entering the ExistsElement production.
	EnterExistsElement(c *ExistsElementContext)

	// EnterPlainGoExpression is called when entering the PlainGoExpression production.
	EnterPlainGoExpression(c *PlainGoExpressionContext)

	// EnterIff is called when entering the Iff production.
	EnterIff(c *IffContext)

	// EnterForallIndex is called when entering the ForallIndex production.
	EnterForallIndex(c *ForallIndexContext)

	// EnterForallElement is called when entering the ForallElement production.
	EnterForallElement(c *ForallElementContext)

	// EnterExistsIterator is called when entering the ExistsIterator production.
	EnterExistsIterator(c *ExistsIteratorContext)

	// EnterForallIterator is called when entering the ForallIterator production.
	EnterForallIterator(c *ForallIteratorContext)

	// EnterIterator is called when entering the iterator production.
	EnterIterator(c *IteratorContext)

	// EnterCollection is called when entering the collection production.
	EnterCollection(c *CollectionContext)

	// EnterCompleteGoExpression is called when entering the completeGoExpression production.
	EnterCompleteGoExpression(c *CompleteGoExpressionContext)

	// EnterGoExpression is called when entering the goExpression production.
	EnterGoExpression(c *GoExpressionContext)

	// EnterPrimaryExpression is called when entering the primaryExpression production.
	EnterPrimaryExpression(c *PrimaryExpressionContext)

	// EnterQualifiedIdentifier is called when entering the qualifiedIdentifier production.
	EnterQualifiedIdentifier(c *QualifiedIdentifierContext)

	// EnterFunctionCallArguments is called when entering the functionCallArguments production.
	EnterFunctionCallArguments(c *FunctionCallArgumentsContext)

	// EnterSliceIndex is called when entering the sliceIndex production.
	EnterSliceIndex(c *SliceIndexContext)

	// EnterNumber is called when entering the number production.
	EnterNumber(c *NumberContext)

	// EnterString is called when entering the string production.
	EnterString(c *StringContext)

	// ExitRoot is called when exiting the root production.
	ExitRoot(c *RootContext)

	// ExitExprInParens is called when exiting the ExprInParens production.
	ExitExprInParens(c *ExprInParensContext)

	// ExitImplies is called when exiting the Implies production.
	ExitImplies(c *ImpliesContext)

	// ExitExistsIndex is called when exiting the ExistsIndex production.
	ExitExistsIndex(c *ExistsIndexContext)

	// ExitExistsElement is called when exiting the ExistsElement production.
	ExitExistsElement(c *ExistsElementContext)

	// ExitPlainGoExpression is called when exiting the PlainGoExpression production.
	ExitPlainGoExpression(c *PlainGoExpressionContext)

	// ExitIff is called when exiting the Iff production.
	ExitIff(c *IffContext)

	// ExitForallIndex is called when exiting the ForallIndex production.
	ExitForallIndex(c *ForallIndexContext)

	// ExitForallElement is called when exiting the ForallElement production.
	ExitForallElement(c *ForallElementContext)

	// ExitExistsIterator is called when exiting the ExistsIterator production.
	ExitExistsIterator(c *ExistsIteratorContext)

	// ExitForallIterator is called when exiting the ForallIterator production.
	ExitForallIterator(c *ForallIteratorContext)

	// ExitIterator is called when exiting the iterator production.
	ExitIterator(c *IteratorContext)

	// ExitCollection is called when exiting the collection production.
	ExitCollection(c *CollectionContext)

	// ExitCompleteGoExpression is called when exiting the completeGoExpression production.
	ExitCompleteGoExpression(c *CompleteGoExpressionContext)

	// ExitGoExpression is called when exiting the goExpression production.
	ExitGoExpression(c *GoExpressionContext)

	// ExitPrimaryExpression is called when exiting the primaryExpression production.
	ExitPrimaryExpression(c *PrimaryExpressionContext)

	// ExitQualifiedIdentifier is called when exiting the qualifiedIdentifier production.
	ExitQualifiedIdentifier(c *QualifiedIdentifierContext)

	// ExitFunctionCallArguments is called when exiting the functionCallArguments production.
	ExitFunctionCallArguments(c *FunctionCallArgumentsContext)

	// ExitSliceIndex is called when exiting the sliceIndex production.
	ExitSliceIndex(c *SliceIndexContext)

	// ExitNumber is called when exiting the number production.
	ExitNumber(c *NumberContext)

	// ExitString is called when exiting the string production.
	ExitString(c *StringContext)
}

ClauseExpressionListener is a complete listener for a parse tree produced by ClauseExpressionParser.

type ClauseExpressionParser 

type ClauseExpressionParser struct {
	*antlr.BaseParser
}

func NewClauseExpressionParser 

func NewClauseExpressionParser(input antlr.TokenStream) *ClauseExpressionParser

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

func (*ClauseExpressionParser) ClauseExpression 

func (p *ClauseExpressionParser) ClauseExpression() (localctx IClauseExpressionContext)

func (*ClauseExpressionParser) ClauseExpression_Sempred 

func (p *ClauseExpressionParser) ClauseExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*ClauseExpressionParser) Collection 

func (p *ClauseExpressionParser) Collection() (localctx ICollectionContext)

func (*ClauseExpressionParser) CompleteGoExpression 

func (p *ClauseExpressionParser) CompleteGoExpression() (localctx ICompleteGoExpressionContext)

func (*ClauseExpressionParser) FunctionCallArguments 

func (p *ClauseExpressionParser) FunctionCallArguments() (localctx IFunctionCallArgumentsContext)

func (*ClauseExpressionParser) GoExpression 

func (p *ClauseExpressionParser) GoExpression() (localctx IGoExpressionContext)

func (*ClauseExpressionParser) Iterator 

func (p *ClauseExpressionParser) Iterator() (localctx IIteratorContext)

func (*ClauseExpressionParser) Number 

func (p *ClauseExpressionParser) Number() (localctx INumberContext)

func (*ClauseExpressionParser) PrimaryExpression 

func (p *ClauseExpressionParser) PrimaryExpression() (localctx IPrimaryExpressionContext)

func (*ClauseExpressionParser) QualifiedIdentifier 

func (p *ClauseExpressionParser) QualifiedIdentifier() (localctx IQualifiedIdentifierContext)

func (*ClauseExpressionParser) Root 

func (p *ClauseExpressionParser) Root() (localctx IRootContext)

func (*ClauseExpressionParser) Sempred 

func (p *ClauseExpressionParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

func (*ClauseExpressionParser) SliceIndex 

func (p *ClauseExpressionParser) SliceIndex() (localctx ISliceIndexContext)

func (*ClauseExpressionParser) String_ 

func (p *ClauseExpressionParser) String_() (localctx IStringContext)

type ClauseExpressionVisitor 

type ClauseExpressionVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by ClauseExpressionParser#root.
	VisitRoot(ctx *RootContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#ExprInParens.
	VisitExprInParens(ctx *ExprInParensContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#Implies.
	VisitImplies(ctx *ImpliesContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#ExistsIndex.
	VisitExistsIndex(ctx *ExistsIndexContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#ExistsElement.
	VisitExistsElement(ctx *ExistsElementContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#PlainGoExpression.
	VisitPlainGoExpression(ctx *PlainGoExpressionContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#Iff.
	VisitIff(ctx *IffContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#ForallIndex.
	VisitForallIndex(ctx *ForallIndexContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#ForallElement.
	VisitForallElement(ctx *ForallElementContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#ExistsIterator.
	VisitExistsIterator(ctx *ExistsIteratorContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#ForallIterator.
	VisitForallIterator(ctx *ForallIteratorContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#iterator.
	VisitIterator(ctx *IteratorContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#collection.
	VisitCollection(ctx *CollectionContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#completeGoExpression.
	VisitCompleteGoExpression(ctx *CompleteGoExpressionContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#goExpression.
	VisitGoExpression(ctx *GoExpressionContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#primaryExpression.
	VisitPrimaryExpression(ctx *PrimaryExpressionContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#qualifiedIdentifier.
	VisitQualifiedIdentifier(ctx *QualifiedIdentifierContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#functionCallArguments.
	VisitFunctionCallArguments(ctx *FunctionCallArgumentsContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#sliceIndex.
	VisitSliceIndex(ctx *SliceIndexContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#number.
	VisitNumber(ctx *NumberContext) interface{}

	// Visit a parse tree produced by ClauseExpressionParser#string.
	VisitString(ctx *StringContext) interface{}
}

A complete Visitor for a parse tree produced by ClauseExpressionParser.

type CollectionContext 

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

func NewCollectionContext 

func NewCollectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectionContext

func NewEmptyCollectionContext 

func NewEmptyCollectionContext() *CollectionContext

func (*CollectionContext) Accept 

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

func (*CollectionContext) EnterRule 

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

func (*CollectionContext) ExitRule 

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

func (*CollectionContext) FunctionCallArguments 

func (s *CollectionContext) FunctionCallArguments() IFunctionCallArgumentsContext

func (*CollectionContext) GetParser 

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

func (*CollectionContext) GetRuleContext 

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

func (*CollectionContext) IsCollectionContext 

func (*CollectionContext) IsCollectionContext()

func (*CollectionContext) QualifiedIdentifier 

func (s *CollectionContext) QualifiedIdentifier() IQualifiedIdentifierContext

func (*CollectionContext) SliceIndex 

func (s *CollectionContext) SliceIndex() ISliceIndexContext

func (*CollectionContext) ToStringTree 

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

type CompleteGoExpressionContext 

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

func NewCompleteGoExpressionContext 

func NewCompleteGoExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompleteGoExpressionContext

func NewEmptyCompleteGoExpressionContext 

func NewEmptyCompleteGoExpressionContext() *CompleteGoExpressionContext

func (*CompleteGoExpressionContext) Accept 

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

func (*CompleteGoExpressionContext) EnterRule 

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

func (*CompleteGoExpressionContext) ExitRule 

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

func (*CompleteGoExpressionContext) GetParser 

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

func (*CompleteGoExpressionContext) GetRuleContext 

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

func (*CompleteGoExpressionContext) GoExpression 

func (s *CompleteGoExpressionContext) GoExpression() IGoExpressionContext

func (*CompleteGoExpressionContext) IsCompleteGoExpressionContext 

func (*CompleteGoExpressionContext) IsCompleteGoExpressionContext()

func (*CompleteGoExpressionContext) ToStringTree 

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

type ExistsElementContext 

type ExistsElementContext struct {
	ClauseExpressionContext
}

func NewExistsElementContext 

func NewExistsElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsElementContext

func (*ExistsElementContext) Accept 

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

func (*ExistsElementContext) ClauseExpression 

func (s *ExistsElementContext) ClauseExpression() IClauseExpressionContext

func (*ExistsElementContext) Collection 

func (s *ExistsElementContext) Collection() ICollectionContext

func (*ExistsElementContext) EXISTS 

func (s *ExistsElementContext) EXISTS() antlr.TerminalNode

func (*ExistsElementContext) EnterRule 

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

func (*ExistsElementContext) ExitRule 

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

func (*ExistsElementContext) GetRuleContext 

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

func (*ExistsElementContext) IN 

func (s *ExistsElementContext) IN() antlr.TerminalNode

func (*ExistsElementContext) Iterator 

func (s *ExistsElementContext) Iterator() IIteratorContext

type ExistsIndexContext 

type ExistsIndexContext struct {
	ClauseExpressionContext
}

func NewExistsIndexContext 

func NewExistsIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsIndexContext

func (*ExistsIndexContext) Accept 

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

func (*ExistsIndexContext) ClauseExpression 

func (s *ExistsIndexContext) ClauseExpression() IClauseExpressionContext

func (*ExistsIndexContext) Collection 

func (s *ExistsIndexContext) Collection() ICollectionContext

func (*ExistsIndexContext) EXISTS 

func (s *ExistsIndexContext) EXISTS() antlr.TerminalNode

func (*ExistsIndexContext) EnterRule 

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

func (*ExistsIndexContext) ExitRule 

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

func (*ExistsIndexContext) GetRuleContext 

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

func (*ExistsIndexContext) INDEXOF 

func (s *ExistsIndexContext) INDEXOF() antlr.TerminalNode

func (*ExistsIndexContext) Iterator 

func (s *ExistsIndexContext) Iterator() IIteratorContext

type ExistsIteratorContext 

type ExistsIteratorContext struct {
	ClauseExpressionContext
}

func NewExistsIteratorContext 

func NewExistsIteratorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsIteratorContext

func (*ExistsIteratorContext) Accept 

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

func (*ExistsIteratorContext) ClauseExpression 

func (s *ExistsIteratorContext) ClauseExpression() IClauseExpressionContext

func (*ExistsIteratorContext) Collection 

func (s *ExistsIteratorContext) Collection() ICollectionContext

func (*ExistsIteratorContext) EXISTS 

func (s *ExistsIteratorContext) EXISTS() antlr.TerminalNode

func (*ExistsIteratorContext) EnterRule 

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

func (*ExistsIteratorContext) ExitRule 

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

func (*ExistsIteratorContext) GetRuleContext 

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

func (*ExistsIteratorContext) ITERATING 

func (s *ExistsIteratorContext) ITERATING() antlr.TerminalNode

func (*ExistsIteratorContext) Iterator 

func (s *ExistsIteratorContext) Iterator() IIteratorContext

type ExprInParensContext 

type ExprInParensContext struct {
	ClauseExpressionContext
}

func NewExprInParensContext 

func NewExprInParensContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExprInParensContext

func (*ExprInParensContext) Accept 

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

func (*ExprInParensContext) ClauseExpression 

func (s *ExprInParensContext) ClauseExpression() IClauseExpressionContext

func (*ExprInParensContext) EnterRule 

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

func (*ExprInParensContext) ExitRule 

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

func (*ExprInParensContext) GetRuleContext 

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

type ForallElementContext 

type ForallElementContext struct {
	ClauseExpressionContext
}

func NewForallElementContext 

func NewForallElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForallElementContext

func (*ForallElementContext) Accept 

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

func (*ForallElementContext) ClauseExpression 

func (s *ForallElementContext) ClauseExpression() IClauseExpressionContext

func (*ForallElementContext) Collection 

func (s *ForallElementContext) Collection() ICollectionContext

func (*ForallElementContext) EnterRule 

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

func (*ForallElementContext) ExitRule 

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

func (*ForallElementContext) FORALL 

func (s *ForallElementContext) FORALL() antlr.TerminalNode

func (*ForallElementContext) GetRuleContext 

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

func (*ForallElementContext) IN 

func (s *ForallElementContext) IN() antlr.TerminalNode

func (*ForallElementContext) Iterator 

func (s *ForallElementContext) Iterator() IIteratorContext

type ForallIndexContext 

type ForallIndexContext struct {
	ClauseExpressionContext
}

func NewForallIndexContext 

func NewForallIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForallIndexContext

func (*ForallIndexContext) Accept 

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

func (*ForallIndexContext) ClauseExpression 

func (s *ForallIndexContext) ClauseExpression() IClauseExpressionContext

func (*ForallIndexContext) Collection 

func (s *ForallIndexContext) Collection() ICollectionContext

func (*ForallIndexContext) EnterRule 

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

func (*ForallIndexContext) ExitRule 

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

func (*ForallIndexContext) FORALL 

func (s *ForallIndexContext) FORALL() antlr.TerminalNode

func (*ForallIndexContext) GetRuleContext 

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

func (*ForallIndexContext) INDEXOF 

func (s *ForallIndexContext) INDEXOF() antlr.TerminalNode

func (*ForallIndexContext) Iterator 

func (s *ForallIndexContext) Iterator() IIteratorContext

type ForallIteratorContext 

type ForallIteratorContext struct {
	ClauseExpressionContext
}

func NewForallIteratorContext 

func NewForallIteratorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForallIteratorContext

func (*ForallIteratorContext) Accept 

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

func (*ForallIteratorContext) ClauseExpression 

func (s *ForallIteratorContext) ClauseExpression() IClauseExpressionContext

func (*ForallIteratorContext) Collection 

func (s *ForallIteratorContext) Collection() ICollectionContext

func (*ForallIteratorContext) EnterRule 

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

func (*ForallIteratorContext) ExitRule 

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

func (*ForallIteratorContext) FORALL 

func (s *ForallIteratorContext) FORALL() antlr.TerminalNode

func (*ForallIteratorContext) GetRuleContext 

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

func (*ForallIteratorContext) ITERATING 

func (s *ForallIteratorContext) ITERATING() antlr.TerminalNode

func (*ForallIteratorContext) Iterator 

func (s *ForallIteratorContext) Iterator() IIteratorContext

type FunctionCallArgumentsContext 

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

func NewEmptyFunctionCallArgumentsContext 

func NewEmptyFunctionCallArgumentsContext() *FunctionCallArgumentsContext

func NewFunctionCallArgumentsContext 

func NewFunctionCallArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallArgumentsContext

func (*FunctionCallArgumentsContext) Accept 

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

func (*FunctionCallArgumentsContext) AllGoExpression 

func (s *FunctionCallArgumentsContext) AllGoExpression() []IGoExpressionContext

func (*FunctionCallArgumentsContext) EnterRule 

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

func (*FunctionCallArgumentsContext) ExitRule 

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

func (*FunctionCallArgumentsContext) GetParser 

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

func (*FunctionCallArgumentsContext) GetRuleContext 

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

func (*FunctionCallArgumentsContext) GoExpression 

func (s *FunctionCallArgumentsContext) GoExpression(i int) IGoExpressionContext

func (*FunctionCallArgumentsContext) IsFunctionCallArgumentsContext 

func (*FunctionCallArgumentsContext) IsFunctionCallArgumentsContext()

func (*FunctionCallArgumentsContext) ToStringTree 

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

type GoExpressionContext 

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

func NewEmptyGoExpressionContext 

func NewEmptyGoExpressionContext() *GoExpressionContext

func NewGoExpressionContext 

func NewGoExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GoExpressionContext

func (*GoExpressionContext) Accept 

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

func (*GoExpressionContext) AllPrimaryExpression 

func (s *GoExpressionContext) AllPrimaryExpression() []IPrimaryExpressionContext

func (*GoExpressionContext) EnterRule 

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

func (*GoExpressionContext) ExitRule 

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

func (*GoExpressionContext) GetParser 

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

func (*GoExpressionContext) GetRuleContext 

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

func (*GoExpressionContext) IsGoExpressionContext 

func (*GoExpressionContext) IsGoExpressionContext()

func (*GoExpressionContext) PrimaryExpression 

func (s *GoExpressionContext) PrimaryExpression(i int) IPrimaryExpressionContext

func (*GoExpressionContext) ToStringTree 

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

type IClauseExpressionContext 

type IClauseExpressionContext interface {
	antlr.ParserRuleContext

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

IClauseExpressionContext is an interface to support dynamic dispatch.

type ICollectionContext 

type ICollectionContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	QualifiedIdentifier() IQualifiedIdentifierContext
	FunctionCallArguments() IFunctionCallArgumentsContext
	SliceIndex() ISliceIndexContext

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

ICollectionContext is an interface to support dynamic dispatch.

type ICompleteGoExpressionContext 

type ICompleteGoExpressionContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	GoExpression() IGoExpressionContext

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

ICompleteGoExpressionContext is an interface to support dynamic dispatch.

type IFunctionCallArgumentsContext 

type IFunctionCallArgumentsContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllGoExpression() []IGoExpressionContext
	GoExpression(i int) IGoExpressionContext

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

IFunctionCallArgumentsContext is an interface to support dynamic dispatch.

type IGoExpressionContext 

type IGoExpressionContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllPrimaryExpression() []IPrimaryExpressionContext
	PrimaryExpression(i int) IPrimaryExpressionContext

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

IGoExpressionContext is an interface to support dynamic dispatch.

type IIteratorContext 

type IIteratorContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	ID() antlr.TerminalNode

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

IIteratorContext is an interface to support dynamic dispatch.

type INumberContext 

type INumberContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	DECIMAL_LIT() antlr.TerminalNode

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

INumberContext is an interface to support dynamic dispatch.

type IPrimaryExpressionContext 

type IPrimaryExpressionContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	PrimaryExpression() IPrimaryExpressionContext
	ClauseExpression() IClauseExpressionContext
	Number() INumberContext
	String_() IStringContext
	QualifiedIdentifier() IQualifiedIdentifierContext
	FunctionCallArguments() IFunctionCallArgumentsContext
	SliceIndex() ISliceIndexContext

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

IPrimaryExpressionContext is an interface to support dynamic dispatch.

type IQualifiedIdentifierContext 

type IQualifiedIdentifierContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	AllID() []antlr.TerminalNode
	ID(i int) antlr.TerminalNode
	AllDOT() []antlr.TerminalNode
	DOT(i int) antlr.TerminalNode

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

IQualifiedIdentifierContext is an interface to support dynamic dispatch.

type IRootContext 

type IRootContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	ClauseExpression() IClauseExpressionContext
	EOF() antlr.TerminalNode

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

IRootContext is an interface to support dynamic dispatch.

type ISliceIndexContext 

type ISliceIndexContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	GoExpression() IGoExpressionContext

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

ISliceIndexContext is an interface to support dynamic dispatch.

type IStringContext 

type IStringContext interface {
	antlr.ParserRuleContext

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

	// Getter signatures
	RAW_STRING_LIT() antlr.TerminalNode
	INTERPRETED_STRING_LIT() antlr.TerminalNode

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

IStringContext is an interface to support dynamic dispatch.

type IffContext 

type IffContext struct {
	ClauseExpressionContext
}

func NewIffContext 

func NewIffContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IffContext

func (*IffContext) Accept 

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

func (*IffContext) AllClauseExpression 

func (s *IffContext) AllClauseExpression() []IClauseExpressionContext

func (*IffContext) ClauseExpression 

func (s *IffContext) ClauseExpression(i int) IClauseExpressionContext

func (*IffContext) EnterRule 

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

func (*IffContext) ExitRule 

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

func (*IffContext) GetRuleContext 

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

func (*IffContext) IFF 

func (s *IffContext) IFF() antlr.TerminalNode

type ImpliesContext 

type ImpliesContext struct {
	ClauseExpressionContext
}

func NewImpliesContext 

func NewImpliesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImpliesContext

func (*ImpliesContext) Accept 

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

func (*ImpliesContext) AllClauseExpression 

func (s *ImpliesContext) AllClauseExpression() []IClauseExpressionContext

func (*ImpliesContext) ClauseExpression 

func (s *ImpliesContext) ClauseExpression(i int) IClauseExpressionContext

func (*ImpliesContext) EnterRule 

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

func (*ImpliesContext) ExitRule 

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

func (*ImpliesContext) GetRuleContext 

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

func (*ImpliesContext) IMPLIES 

func (s *ImpliesContext) IMPLIES() antlr.TerminalNode

type IteratorContext 

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

func NewEmptyIteratorContext 

func NewEmptyIteratorContext() *IteratorContext

func NewIteratorContext 

func NewIteratorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IteratorContext

func (*IteratorContext) Accept 

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

func (*IteratorContext) EnterRule 

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

func (*IteratorContext) ExitRule 

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

func (*IteratorContext) GetParser 

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

func (*IteratorContext) GetRuleContext 

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

func (*IteratorContext) ID 

func (s *IteratorContext) ID() antlr.TerminalNode

func (*IteratorContext) IsIteratorContext 

func (*IteratorContext) IsIteratorContext()

func (*IteratorContext) ToStringTree 

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

type NumberContext 

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

func NewEmptyNumberContext 

func NewEmptyNumberContext() *NumberContext

func NewNumberContext 

func NewNumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumberContext

func (*NumberContext) Accept 

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

func (*NumberContext) DECIMAL_LIT 

func (s *NumberContext) DECIMAL_LIT() antlr.TerminalNode

func (*NumberContext) EnterRule 

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

func (*NumberContext) ExitRule 

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

func (*NumberContext) GetParser 

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

func (*NumberContext) GetRuleContext 

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

func (*NumberContext) IsNumberContext 

func (*NumberContext) IsNumberContext()

func (*NumberContext) ToStringTree 

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

type PlainGoExpressionContext 

type PlainGoExpressionContext struct {
	ClauseExpressionContext
}

func NewPlainGoExpressionContext 

func NewPlainGoExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PlainGoExpressionContext

func (*PlainGoExpressionContext) Accept 

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

func (*PlainGoExpressionContext) CompleteGoExpression 

func (s *PlainGoExpressionContext) CompleteGoExpression() ICompleteGoExpressionContext

func (*PlainGoExpressionContext) EnterRule 

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

func (*PlainGoExpressionContext) ExitRule 

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

func (*PlainGoExpressionContext) GetRuleContext 

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

type PrimaryExpressionContext 

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

func NewEmptyPrimaryExpressionContext 

func NewEmptyPrimaryExpressionContext() *PrimaryExpressionContext

func NewPrimaryExpressionContext 

func NewPrimaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryExpressionContext

func (*PrimaryExpressionContext) Accept 

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

func (*PrimaryExpressionContext) ClauseExpression 

func (s *PrimaryExpressionContext) ClauseExpression() IClauseExpressionContext

func (*PrimaryExpressionContext) EnterRule 

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

func (*PrimaryExpressionContext) ExitRule 

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

func (*PrimaryExpressionContext) FunctionCallArguments 

func (s *PrimaryExpressionContext) FunctionCallArguments() IFunctionCallArgumentsContext

func (*PrimaryExpressionContext) GetParser 

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

func (*PrimaryExpressionContext) GetRuleContext 

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

func (*PrimaryExpressionContext) IsPrimaryExpressionContext 

func (*PrimaryExpressionContext) IsPrimaryExpressionContext()

func (*PrimaryExpressionContext) Number 

func (s *PrimaryExpressionContext) Number() INumberContext

func (*PrimaryExpressionContext) PrimaryExpression 

func (s *PrimaryExpressionContext) PrimaryExpression() IPrimaryExpressionContext

func (*PrimaryExpressionContext) QualifiedIdentifier 

func (s *PrimaryExpressionContext) QualifiedIdentifier() IQualifiedIdentifierContext

func (*PrimaryExpressionContext) SliceIndex 

func (s *PrimaryExpressionContext) SliceIndex() ISliceIndexContext

func (*PrimaryExpressionContext) String_ 

func (s *PrimaryExpressionContext) String_() IStringContext

func (*PrimaryExpressionContext) ToStringTree 

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

type QualifiedIdentifierContext 

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

func NewEmptyQualifiedIdentifierContext 

func NewEmptyQualifiedIdentifierContext() *QualifiedIdentifierContext

func NewQualifiedIdentifierContext 

func NewQualifiedIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QualifiedIdentifierContext

func (*QualifiedIdentifierContext) Accept 

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

func (*QualifiedIdentifierContext) AllDOT 

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

func (*QualifiedIdentifierContext) AllID 

func (s *QualifiedIdentifierContext) AllID() []antlr.TerminalNode

func (*QualifiedIdentifierContext) DOT 

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

func (*QualifiedIdentifierContext) EnterRule 

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

func (*QualifiedIdentifierContext) ExitRule 

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

func (*QualifiedIdentifierContext) GetParser 

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

func (*QualifiedIdentifierContext) GetRuleContext 

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

func (*QualifiedIdentifierContext) ID 

func (s *QualifiedIdentifierContext) ID(i int) antlr.TerminalNode

func (*QualifiedIdentifierContext) IsQualifiedIdentifierContext 

func (*QualifiedIdentifierContext) IsQualifiedIdentifierContext()

func (*QualifiedIdentifierContext) ToStringTree 

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

type RootContext 

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

func NewEmptyRootContext 

func NewEmptyRootContext() *RootContext

func NewRootContext 

func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext

func (*RootContext) Accept 

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

func (*RootContext) ClauseExpression 

func (s *RootContext) ClauseExpression() IClauseExpressionContext

func (*RootContext) EOF 

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

func (*RootContext) EnterRule 

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

func (*RootContext) ExitRule 

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

func (*RootContext) GetParser 

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

func (*RootContext) GetRuleContext 

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

func (*RootContext) IsRootContext 

func (*RootContext) IsRootContext()

func (*RootContext) ToStringTree 

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

type SliceIndexContext 

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

func NewEmptySliceIndexContext 

func NewEmptySliceIndexContext() *SliceIndexContext

func NewSliceIndexContext 

func NewSliceIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SliceIndexContext

func (*SliceIndexContext) Accept 

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

func (*SliceIndexContext) EnterRule 

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

func (*SliceIndexContext) ExitRule 

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

func (*SliceIndexContext) GetParser 

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

func (*SliceIndexContext) GetRuleContext 

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

func (*SliceIndexContext) GoExpression 

func (s *SliceIndexContext) GoExpression() IGoExpressionContext

func (*SliceIndexContext) IsSliceIndexContext 

func (*SliceIndexContext) IsSliceIndexContext()

func (*SliceIndexContext) ToStringTree 

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

type StringContext 

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

func NewEmptyStringContext 

func NewEmptyStringContext() *StringContext

func NewStringContext 

func NewStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringContext

func (*StringContext) Accept 

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

func (*StringContext) EnterRule 

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

func (*StringContext) ExitRule 

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

func (*StringContext) GetParser 

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

func (*StringContext) GetRuleContext 

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

func (*StringContext) INTERPRETED_STRING_LIT 

func (s *StringContext) INTERPRETED_STRING_LIT() antlr.TerminalNode

func (*StringContext) IsStringContext 

func (*StringContext) IsStringContext()

func (*StringContext) RAW_STRING_LIT 

func (s *StringContext) RAW_STRING_LIT() antlr.TerminalNode

func (*StringContext) ToStringTree 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

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