antlr

package
v0.0.0-...-464bcbc Latest Latest
Warning

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

 Go to latest Published: Jan 5, 2021 License: BSD-3-Clause, MIT Imports: 12 Imported by: 0

Documentation

Overview

Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. Use of this file is governed by the BSD 3-clause license that can be found in the LICENSE.txt file in the project root.

Index

Constants

View Source 
const (
	ATNStateInvalidType    = 0
	ATNStateBasic          = 1
	ATNStateRuleStart      = 2
	ATNStateBlockStart     = 3
	ATNStatePlusBlockStart = 4
	ATNStateStarBlockStart = 5
	ATNStateTokenStart     = 6
	ATNStateRuleStop       = 7
	ATNStateBlockEnd       = 8
	ATNStateStarLoopBack   = 9
	ATNStateStarLoopEntry  = 10
	ATNStatePlusLoopBack   = 11
	ATNStateLoopEnd        = 12

	ATNStateInvalidStateNumber = -1
)

Constants for serialization.

View Source 
const (
	ATNTypeLexer  = 0
	ATNTypeParser = 1
)

Represent the type of recognizer an ATN applies to.

View Source 
const (
	LexerDefaultMode = 0
	LexerMore        = -2
	LexerSkip        = -3
)
View Source 
const (
	LexerDefaultTokenChannel = TokenDefaultChannel
	LexerHidden              = TokenHiddenChannel
	LexerMinCharValue        = 0x0000
	LexerMaxCharValue        = 0x10FFFF
)
View Source 
const (
	LexerActionTypeChannel  = 0 //The type of a {@link LexerChannelAction} action.
	LexerActionTypeCustom   = 1 //The type of a {@link LexerCustomAction} action.
	LexerActionTypeMode     = 2 //The type of a {@link LexerModeAction} action.
	LexerActionTypeMore     = 3 //The type of a {@link LexerMoreAction} action.
	LexerActionTypePopMode  = 4 //The type of a {@link LexerPopModeAction} action.
	LexerActionTypePushMode = 5 //The type of a {@link LexerPushModeAction} action.
	LexerActionTypeSkip     = 6 //The type of a {@link LexerSkipAction} action.
	LexerActionTypeType     = 7 //The type of a {@link LexerTypeAction} action.
)
View Source 
const (
	//
	// The SLL(*) prediction mode. This prediction mode ignores the current
	// parser context when making predictions. This is the fastest prediction
	// mode, and provides correct results for many grammars. This prediction
	// mode is more powerful than the prediction mode provided by ANTLR 3, but
	// may result in syntax errors for grammar and input combinations which are
	// not SLL.
	//
	// <p>
	// When using this prediction mode, the parser will either return a correct
	// parse tree (i.e. the same parse tree that would be returned with the
	// {@link //LL} prediction mode), or it will Report a syntax error. If a
	// syntax error is encountered when using the {@link //SLL} prediction mode,
	// it may be due to either an actual syntax error in the input or indicate
	// that the particular combination of grammar and input requires the more
	// powerful {@link //LL} prediction abilities to complete successfully.</p>
	//
	// <p>
	// This prediction mode does not provide any guarantees for prediction
	// behavior for syntactically-incorrect inputs.</p>
	//
	PredictionModeSLL = 0
	//
	// The LL(*) prediction mode. This prediction mode allows the current parser
	// context to be used for resolving SLL conflicts that occur during
	// prediction. This is the fastest prediction mode that guarantees correct
	// parse results for all combinations of grammars with syntactically correct
	// inputs.
	//
	// <p>
	// When using this prediction mode, the parser will make correct decisions
	// for all syntactically-correct grammar and input combinations. However, in
	// cases where the grammar is truly ambiguous this prediction mode might not
	// Report a precise answer for <em>exactly which</em> alternatives are
	// ambiguous.</p>
	//
	// <p>
	// This prediction mode does not provide any guarantees for prediction
	// behavior for syntactically-incorrect inputs.</p>
	//
	PredictionModeLL = 1
	//
	// The LL(*) prediction mode with exact ambiguity detection. In addition to
	// the correctness guarantees provided by the {@link //LL} prediction mode,
	// this prediction mode instructs the prediction algorithm to determine the
	// complete and exact set of ambiguous alternatives for every ambiguous
	// decision encountered while parsing.
	//
	// <p>
	// This prediction mode may be used for diagnosing ambiguities during
	// grammar development. Due to the performance overhead of calculating sets
	// of ambiguous alternatives, this prediction mode should be avoided when
	// the exact results are not necessary.</p>
	//
	// <p>
	// This prediction mode does not provide any guarantees for prediction
	// behavior for syntactically-incorrect inputs.</p>
	//
	PredictionModeLLExactAmbigDetection = 2
)
View Source 
const (
	TokenInvalidType = 0

	// During lookahead operations, this "token" signifies we hit rule end ATN state
	// and did not follow it despite needing to.
	TokenEpsilon = -2

	TokenMinUserTokenType = 1

	TokenEOF = -1

	TokenDefaultChannel = 0

	TokenHiddenChannel = 1
)
View Source 
const (
	Default_Program_Name = "default"
	Program_Init_Size    = 100
	Min_Token_Index      = 0
)
View Source 
const (
	TransitionEPSILON    = 1
	TransitionRANGE      = 2
	TransitionRULE       = 3
	TransitionPREDICATE  = 4 // e.g., {isType(input.LT(1))}?
	TransitionATOM       = 5
	TransitionACTION     = 6
	TransitionSET        = 7 // ~(A|B) or ~atom, wildcard, which convert to next 2
	TransitionNOTSET     = 8
	TransitionWILDCARD   = 9
	TransitionPRECEDENCE = 10
)
View Source 
const (
	BasePredictionContextEmptyReturnState = 0x7FFFFFFF
)

Represents {@code $} in local context prediction, which means wildcard. {@code//+x =//}. /

View Source 
const (
	LL1AnalyzerHitPred = TokenInvalidType
)
  • Special value added to the lookahead sets to indicate that we hit a predicate during analysis if {@code seeThruPreds==false}.

/

Variables

View Source 
var (
	LexerATNSimulatorDebug    = false
	LexerATNSimulatorDFADebug = false

	LexerATNSimulatorMinDFAEdge = 0
	LexerATNSimulatorMaxDFAEdge = 127 // forces unicode to stay in ATN

	LexerATNSimulatorMatchCalls = 0
)
View Source 
var (
	ParserATNSimulatorDebug            = false
	ParserATNSimulatorListATNDecisions = false
	ParserATNSimulatorDFADebug         = false
	ParserATNSimulatorRetryDebug       = false
)
View Source 
var (
	BasePredictionContextglobalNodeCount = 1
	BasePredictionContextid              = BasePredictionContextglobalNodeCount
)
View Source 
var ATNDeserializationOptionsdefaultOptions = &ATNDeserializationOptions{true, false, false}
View Source 
var ATNInvalidAltNumber int
View Source 
var ATNSimulatorError = NewDFAState(0x7FFFFFFF, NewBaseATNConfigSet(false))
View Source 
var ATNStateInitialNumTransitions = 4
View Source 
var AddedUnicodeSMP = "59627784-3BE5-417A-B9EB-8131A7286089"
View Source 
var BasePredictionContextEMPTY = NewEmptyPredictionContext()
View Source 
var BaseSerializedUUID = "AADB8D7E-AEEF-4415-AD2B-8204D6CF042E"

This is the earliest supported serialized UUID. stick to serialized version for now, we don't need a UUID instance

View Source 
var CommonTokenFactoryDEFAULT = NewCommonTokenFactory(false)

CommonTokenFactoryDEFAULT is the default CommonTokenFactory. It does not explicitly copy token text when constructing tokens.

View Source 
var ConsoleErrorListenerINSTANCE = NewConsoleErrorListener()

Provides a default instance of {@link ConsoleErrorListener}.

View Source 
var ErrEmptyStack = errors.New("Stack is empty")
View Source 
var LexerMoreActionINSTANCE = NewLexerMoreAction()
View Source 
var LexerPopModeActionINSTANCE = NewLexerPopModeAction()
View Source 
var LexerSkipActionINSTANCE = NewLexerSkipAction()

Provides a singleton instance of l parameterless lexer action.

View Source 
var ParseTreeWalkerDefault = NewParseTreeWalker()
View Source 
var RuleContextEmpty = NewBaseParserRuleContext(nil, -1)
View Source 
var SerializedUUID = AddedUnicodeSMP

This is the current serialized UUID.

View Source 
var SerializedVersion = 3
View Source 
var SupportedUUIDs = []string{BaseSerializedUUID, AddedUnicodeSMP}

This list contains all of the currently supported UUIDs, ordered by when the feature first appeared in this branch.

View Source 
var TransitionserializationNames = []string{
	"INVALID",
	"EPSILON",
	"RANGE",
	"RULE",
	"PREDICATE",
	"ATOM",
	"ACTION",
	"SET",
	"NOT_SET",
	"WILDCARD",
	"PRECEDENCE",
}
View Source 
var TreeInvalidInterval = NewInterval(-1, -2)

Functions

func EscapeWhitespace 

func EscapeWhitespace(s string, escapeSpaces bool) string

func PredictionModeallConfigsInRuleStopStates 

func PredictionModeallConfigsInRuleStopStates(configs ATNConfigSet) bool

Checks if all configurations in {@code configs} are in a {@link RuleStopState}. Configurations meeting this condition have reached the end of the decision rule (local context) or end of start rule (full context).

@param configs the configuration set to test @return {@code true} if all configurations in {@code configs} are in a {@link RuleStopState}, otherwise {@code false}

func PredictionModeallSubsetsConflict 

func PredictionModeallSubsetsConflict(altsets []*BitSet) bool

Determines if every alternative subset in {@code altsets} contains more than one alternative.

@param altsets a collection of alternative subsets @return {@code true} if every {@link BitSet} in {@code altsets} has {@link BitSet//cardinality cardinality} &gt 1, otherwise {@code false}

func PredictionModeallSubsetsEqual 

func PredictionModeallSubsetsEqual(altsets []*BitSet) bool

Determines if every alternative subset in {@code altsets} is equivalent.

@param altsets a collection of alternative subsets @return {@code true} if every member of {@code altsets} is equal to the others, otherwise {@code false}

func PredictionModegetSingleViableAlt 

func PredictionModegetSingleViableAlt(altsets []*BitSet) int

func PredictionModegetUniqueAlt 

func PredictionModegetUniqueAlt(altsets []*BitSet) int

Returns the unique alternative predicted by all alternative subsets in {@code altsets}. If no such alternative exists, this method returns {@link ATN//INVALID_ALT_NUMBER}.

@param altsets a collection of alternative subsets

func PredictionModehasConfigInRuleStopState 

func PredictionModehasConfigInRuleStopState(configs ATNConfigSet) bool

Checks if any configuration in {@code configs} is in a {@link RuleStopState}. Configurations meeting this condition have reached the end of the decision rule (local context) or end of start rule (full context).

@param configs the configuration set to test @return {@code true} if any configuration in {@code configs} is in a {@link RuleStopState}, otherwise {@code false}

func PredictionModehasConflictingAltSet 

func PredictionModehasConflictingAltSet(altsets []*BitSet) bool

Determines if any single alternative subset in {@code altsets} contains more than one alternative.

@param altsets a collection of alternative subsets @return {@code true} if {@code altsets} contains a {@link BitSet} with {@link BitSet//cardinality cardinality} &gt 1, otherwise {@code false}

func PredictionModehasNonConflictingAltSet 

func PredictionModehasNonConflictingAltSet(altsets []*BitSet) bool

Determines if any single alternative subset in {@code altsets} contains exactly one alternative.

@param altsets a collection of alternative subsets @return {@code true} if {@code altsets} contains a {@link BitSet} with {@link BitSet//cardinality cardinality} 1, otherwise {@code false}

func PredictionModehasSLLConflictTerminatingPrediction 

func PredictionModehasSLLConflictTerminatingPrediction(mode int, configs ATNConfigSet) bool

Computes the SLL prediction termination condition.

<p> This method computes the SLL prediction termination condition for both of the following cases.</p>

<ul> <li>The usual SLL+LL fallback upon SLL conflict</li> <li>Pure SLL without LL fallback</li> </ul>

<p><strong>COMBINED SLL+LL PARSING</strong></p>

<p>When LL-fallback is enabled upon SLL conflict, correct predictions are ensured regardless of how the termination condition is computed by this method. Due to the substantially higher cost of LL prediction, the prediction should only fall back to LL when the additional lookahead cannot lead to a unique SLL prediction.</p>

<p>Assuming combined SLL+LL parsing, an SLL configuration set with only conflicting subsets should fall back to full LL, even if the configuration sets don't resolve to the same alternative (e.g. {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting configuration, SLL could continue with the hopes that more lookahead will resolve via one of those non-conflicting configurations.</p>

<p>Here's the prediction termination rule them: SLL (for SLL+LL parsing) stops when it sees only conflicting configuration subsets. In contrast, full LL keeps going when there is uncertainty.</p>

<p><strong>HEURISTIC</strong></p>

<p>As a heuristic, we stop prediction when we see any conflicting subset unless we see a state that only has one alternative associated with it. The single-alt-state thing lets prediction continue upon rules like (otherwise, it would admit defeat too soon):</p>

<p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ” }</p>

<p>When the ATN simulation reaches the state before {@code ”}, it has a DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop processing this node because alternative to has another way to continue, via {@code [6|2|[]]}.</p>

<p>It also let's us continue for this rule:</p>

<p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B }</p>

<p>After Matching input A, we reach the stop state for rule A, state 1. State 8 is the state right before B. Clearly alternatives 1 and 2 conflict and no amount of further lookahead will separate the two. However, alternative 3 will be able to continue and so we do not stop working on this state. In the previous example, we're concerned with states associated with the conflicting alternatives. Here alt 3 is not associated with the conflicting configs, but since we can continue looking for input reasonably, don't declare the state done.</p>

<p><strong>PURE SLL PARSING</strong></p>

<p>To handle pure SLL parsing, all we have to do is make sure that we combine stack contexts for configurations that differ only by semantic predicate. From there, we can do the usual SLL termination heuristic.</p>

<p><strong>PREDICATES IN SLL+LL PARSING</strong></p>

<p>SLL decisions don't evaluate predicates until after they reach DFA stop states because they need to create the DFA cache that works in all semantic situations. In contrast, full LL evaluates predicates collected during start state computation so it can ignore predicates thereafter. This means that SLL termination detection can totally ignore semantic predicates.</p>

<p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not semantic predicate contexts so we might see two configurations like the following.</p>

<p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>

<p>Before testing these configurations against others, we have to merge {@code x} and {@code x'} (without modifying the existing configurations). For example, we test {@code (x+x')==x”} when looking for conflicts in the following configurations.</p>

<p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x”, {})}</p>

<p>If the configuration set has predicates (as indicated by {@link ATNConfigSet//hasSemanticContext}), this algorithm makes a copy of the configurations to strip out all of the predicates so that a standard {@link ATNConfigSet} will merge everything ignoring predicates.</p>

func PredictionModehasStateAssociatedWithOneAlt 

func PredictionModehasStateAssociatedWithOneAlt(configs ATNConfigSet) bool

func PredictionModeresolvesToJustOneViableAlt 

func PredictionModeresolvesToJustOneViableAlt(altsets []*BitSet) int

Full LL prediction termination.

<p>Can we stop looking ahead during ATN simulation or is there some uncertainty as to which alternative we will ultimately pick, after consuming more input? Even if there are partial conflicts, we might know that everything is going to resolve to the same minimum alternative. That means we can stop since no more lookahead will change that fact. On the other hand, there might be multiple conflicts that resolve to different minimums. That means we need more look ahead to decide which of those alternatives we should predict.</p>

<p>The basic idea is to split the set of configurations {@code C}, into conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with non-conflicting configurations. Two configurations conflict if they have identical {@link ATNConfig//state} and {@link ATNConfig//context} values but different {@link ATNConfig//alt} value, e.g. {@code (s, i, ctx, _)} and {@code (s, j, ctx, _)} for {@code i!=j}.</p>

<p>Reduce these configuration subsets to the set of possible alternatives. You can compute the alternative subsets in one pass as follows:</p>

<p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in {@code C} holding {@code s} and {@code ctx} fixed.</p>

<p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>

<pre> map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not alt and not pred </pre>

<p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>

<p>If {@code |A_s,ctx|=1} then there is no conflict associated with {@code s} and {@code ctx}.</p>

<p>Reduce the subsets to singletons by choosing a minimum of each subset. If the union of these alternative subsets is a singleton, then no amount of more lookahead will help us. We will always pick that alternative. If, however, there is more than one alternative, then we are uncertain which alternative to predict and must continue looking for resolution. We may or may not discover an ambiguity in the future, even if there are no conflicting subsets this round.</p>

<p>The biggest sin is to terminate early because it means we've made a decision but were uncertain as to the eventual outcome. We haven't used enough lookahead. On the other hand, announcing a conflict too late is no big deal you will still have the conflict. It's just inefficient. It might even look until the end of file.</p>

<p>No special consideration for semantic predicates is required because predicates are evaluated on-the-fly for full LL prediction, ensuring that no configuration contains a semantic context during the termination check.</p>

<p><strong>CONFLICTING CONFIGS</strong></p>

<p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict when {@code i!=j} but {@code x=x'}. Because we merge all {@code (s, i, _)} configurations together, that means that there are at most {@code n} configurations associated with state {@code s} for {@code n} possible alternatives in the decision. The merged stacks complicate the comparison of configuration contexts {@code x} and {@code x'}. Sam checks to see if one is a subset of the other by calling merge and checking to see if the merged result is either {@code x} or {@code x'}. If the {@code x} associated with lowest alternative {@code i} is the superset, then {@code i} is the only possible prediction since the others resolve to {@code min(i)} as well. However, if {@code x} is associated with {@code j>i} then at least one stack configuration for {@code j} is not in conflict with alternative {@code i}. The algorithm should keep going, looking for more lookahead due to the uncertainty.</p>

<p>For simplicity, I'm doing a equality check between {@code x} and {@code x'} that lets the algorithm continue to consume lookahead longer than necessary. The reason I like the equality is of course the simplicity but also because that is the test you need to detect the alternatives that are actually in conflict.</p>

<p><strong>CONTINUE/STOP RULE</strong></p>

<p>Continue if union of resolved alternative sets from non-conflicting and conflicting alternative subsets has more than one alternative. We are uncertain about which alternative to predict.</p>

<p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which alternatives are still in the running for the amount of input we've consumed at this point. The conflicting sets let us to strip away configurations that won't lead to more states because we resolve conflicts to the configuration with a minimum alternate for the conflicting set.</p>

<p><strong>CASES</strong></p>

<ul>

<li>no conflicts and more than 1 alternative in set =&gt continue</li>

<li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)}, {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} = {@code {1,3}} =&gt continue </li>

<li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)}, {@code (s', 2, y)}, {@code (s”, 1, z)} yields non-conflicting set {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} = {@code {1}} =&gt stop and predict 1</li>

<li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)}, {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U {@code {1}} = {@code {1}} =&gt stop and predict 1, can announce ambiguity {@code {1,2}}</li>

<li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)}, {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U {@code {2}} = {@code {1,2}} =&gt continue</li>

<li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)}, {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U {@code {3}} = {@code {1,3}} =&gt continue</li>

</ul>

<p><strong>EXACT AMBIGUITY DETECTION</strong></p>

<p>If all states Report the same conflicting set of alternatives, then we know we have the exact ambiguity set.</p>

<p><code>|A_<em>i</em>|&gt1</code> and <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>

<p>In other words, we continue examining lookahead until all {@code A_i} have more than one alternative and all {@code A_i} are the same. If {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate because the resolved set is {@code {1}}. To determine what the real ambiguity is, we have to know whether the ambiguity is between one and two or one and three so we keep going. We can only stop prediction when we need exact ambiguity detection when the sets look like {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>

func PrintArrayJavaStyle 

func PrintArrayJavaStyle(sa []string) string

func TerminalNodeToStringArray 

func TerminalNodeToStringArray(sa []TerminalNode) []string

func TreesGetNodeText 

func TreesGetNodeText(t Tree, ruleNames []string, recog Parser) string

func TreesStringTree 

func TreesStringTree(tree Tree, ruleNames []string, recog Recognizer) string

Print out a whole tree in LISP form. {@link //getNodeText} is used on the 

node payloads to get the text for the nodes.  Detect
parse trees and extract data appropriately.

Types

type AND 

type AND struct {
	// contains filtered or unexported fields
}

func NewAND 

func NewAND(a, b SemanticContext) *AND

func (*AND) String 

func (a *AND) String() string

type ATN 

type ATN struct {
	// DecisionToState is the decision points for all rules, subrules, optional
	// blocks, ()+, ()*, etc. Used to build DFA predictors for them.
	DecisionToState []DecisionState
	// contains filtered or unexported fields
}

func NewATN 

func NewATN(grammarType int, maxTokenType int) *ATN

func (*ATN) NextTokens 

func (a *ATN) NextTokens(s ATNState, ctx RuleContext) *IntervalSet

func (*ATN) NextTokensInContext 

func (a *ATN) NextTokensInContext(s ATNState, ctx RuleContext) *IntervalSet

NextTokensInContext computes the set of valid tokens that can occur starting in state s. If ctx is nil, the set of tokens will not include what can follow the rule surrounding s. In other words, the set will be restricted to tokens reachable staying within the rule of s.

func (*ATN) NextTokensNoContext 

func (a *ATN) NextTokensNoContext(s ATNState) *IntervalSet

NextTokensNoContext computes the set of valid tokens that can occur starting in s and staying in same rule. Token.EPSILON is in set if we reach end of rule.

type ATNConfig 

type ATNConfig interface {
	GetState() ATNState
	GetAlt() int
	GetSemanticContext() SemanticContext

	GetContext() PredictionContext
	SetContext(PredictionContext)

	GetReachesIntoOuterContext() int
	SetReachesIntoOuterContext(int)

	String() string
	// contains filtered or unexported methods
}

ATNConfig is a tuple: (ATN state, predicted alt, syntactic, semantic context). The syntactic context is a graph-structured stack node whose path(s) to the root is the rule invocation(s) chain used to arrive at the state. The semantic context is the tree of semantic predicates encountered before reaching an ATN state.

type ATNConfigSet 

type ATNConfigSet interface {
	Add(ATNConfig, *DoubleDict) bool
	AddAll([]ATNConfig) bool

	GetStates() *Set
	GetPredicates() []SemanticContext
	GetItems() []ATNConfig

	OptimizeConfigs(interpreter *BaseATNSimulator)

	Equals(other interface{}) bool

	Length() int
	IsEmpty() bool
	Contains(ATNConfig) bool
	ContainsFast(ATNConfig) bool
	Clear()
	String() string

	HasSemanticContext() bool
	SetHasSemanticContext(v bool)

	ReadOnly() bool
	SetReadOnly(bool)

	GetConflictingAlts() *BitSet
	SetConflictingAlts(*BitSet)

	FullContext() bool

	GetUniqueAlt() int
	SetUniqueAlt(int)

	GetDipsIntoOuterContext() bool
	SetDipsIntoOuterContext(bool)
	// contains filtered or unexported methods
}

type ATNConfigSetPair 

type ATNConfigSetPair struct {
	// contains filtered or unexported fields
}

type ATNDeserializationOptions 

type ATNDeserializationOptions struct {
	// contains filtered or unexported fields
}

func NewATNDeserializationOptions 

func NewATNDeserializationOptions(CopyFrom *ATNDeserializationOptions) *ATNDeserializationOptions

type ATNDeserializer 

type ATNDeserializer struct {
	// contains filtered or unexported fields
}

func NewATNDeserializer 

func NewATNDeserializer(options *ATNDeserializationOptions) *ATNDeserializer

func (*ATNDeserializer) DeserializeFromUInt16 

func (a *ATNDeserializer) DeserializeFromUInt16(data []uint16) *ATN

type ATNState 

type ATNState interface {
	GetEpsilonOnlyTransitions() bool

	GetRuleIndex() int
	SetRuleIndex(int)

	GetNextTokenWithinRule() *IntervalSet
	SetNextTokenWithinRule(*IntervalSet)

	GetATN() *ATN
	SetATN(*ATN)

	GetStateType() int

	GetStateNumber() int
	SetStateNumber(int)

	GetTransitions() []Transition
	SetTransitions([]Transition)
	AddTransition(Transition, int)

	String() string
	// contains filtered or unexported methods
}

type AbstractPredicateTransition 

type AbstractPredicateTransition interface {
	Transition
	IAbstractPredicateTransitionFoo()
}

type ActionTransition 

type ActionTransition struct {
	*BaseTransition
	// contains filtered or unexported fields
}

func NewActionTransition 

func NewActionTransition(target ATNState, ruleIndex, actionIndex int, isCtxDependent bool) *ActionTransition

func (*ActionTransition) Matches 

func (t *ActionTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*ActionTransition) String 

func (t *ActionTransition) String() string

type AltDict 

type AltDict struct {
	// contains filtered or unexported fields
}

func NewAltDict 

func NewAltDict() *AltDict

func PredictionModeGetStateToAltMap 

func PredictionModeGetStateToAltMap(configs ATNConfigSet) *AltDict

Get a map from state to alt subset from a configuration set. For each configuration {@code c} in {@code configs}:

<pre> map[c.{@link ATNConfig//state state}] U= c.{@link ATNConfig//alt alt} </pre>

func (*AltDict) Get 

func (a *AltDict) Get(key string) interface{}

type ArrayPredictionContext 

type ArrayPredictionContext struct {
	*BasePredictionContext
	// contains filtered or unexported fields
}

func NewArrayPredictionContext 

func NewArrayPredictionContext(parents []PredictionContext, returnStates []int) *ArrayPredictionContext

func (*ArrayPredictionContext) GetParent 

func (a *ArrayPredictionContext) GetParent(index int) PredictionContext

func (*ArrayPredictionContext) GetReturnStates 

func (a *ArrayPredictionContext) GetReturnStates() []int

func (*ArrayPredictionContext) String 

func (a *ArrayPredictionContext) String() string

type AtomTransition 

type AtomTransition struct {
	*BaseTransition
}

TODO: make all transitions sets? no, should remove set edges

func NewAtomTransition 

func NewAtomTransition(target ATNState, intervalSet int) *AtomTransition

func (*AtomTransition) Matches 

func (t *AtomTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*AtomTransition) String 

func (t *AtomTransition) String() string

type BailErrorStrategy 

type BailErrorStrategy struct {
	*DefaultErrorStrategy
}

func NewBailErrorStrategy 

func NewBailErrorStrategy() *BailErrorStrategy

func (*BailErrorStrategy) Recover 

func (b *BailErrorStrategy) Recover(recognizer Parser, e RecognitionException)

Instead of recovering from exception {@code e}, re-panic it wrapped in a {@link ParseCancellationException} so it is not caught by the rule func catches. Use {@link Exception//getCause()} to get the original {@link RecognitionException}.

func (*BailErrorStrategy) RecoverInline 

func (b *BailErrorStrategy) RecoverInline(recognizer Parser) Token

Make sure we don't attempt to recover inline if the parser successfully recovers, it won't panic an exception.

func (*BailErrorStrategy) Sync 

func (b *BailErrorStrategy) Sync(recognizer Parser)

Make sure we don't attempt to recover from problems in subrules.//

type BaseATNConfig 

type BaseATNConfig struct {
	// contains filtered or unexported fields
}

func NewBaseATNConfig 

func NewBaseATNConfig(c ATNConfig, state ATNState, context PredictionContext, semanticContext SemanticContext) *BaseATNConfig

func NewBaseATNConfig1 

func NewBaseATNConfig1(c ATNConfig, state ATNState, context PredictionContext) *BaseATNConfig

func NewBaseATNConfig2 

func NewBaseATNConfig2(c ATNConfig, semanticContext SemanticContext) *BaseATNConfig

func NewBaseATNConfig3 

func NewBaseATNConfig3(c ATNConfig, state ATNState, semanticContext SemanticContext) *BaseATNConfig

func NewBaseATNConfig4 

func NewBaseATNConfig4(c ATNConfig, state ATNState) *BaseATNConfig

func NewBaseATNConfig5 

func NewBaseATNConfig5(state ATNState, alt int, context PredictionContext, semanticContext SemanticContext) *BaseATNConfig

func NewBaseATNConfig6 

func NewBaseATNConfig6(state ATNState, alt int, context PredictionContext) *BaseATNConfig

func NewBaseATNConfig7 

func NewBaseATNConfig7(old *BaseATNConfig) *BaseATNConfig

func (*BaseATNConfig) GetAlt 

func (b *BaseATNConfig) GetAlt() int

func (*BaseATNConfig) GetContext 

func (b *BaseATNConfig) GetContext() PredictionContext

func (*BaseATNConfig) GetReachesIntoOuterContext 

func (b *BaseATNConfig) GetReachesIntoOuterContext() int

func (*BaseATNConfig) GetSemanticContext 

func (b *BaseATNConfig) GetSemanticContext() SemanticContext

func (*BaseATNConfig) GetState 

func (b *BaseATNConfig) GetState() ATNState

func (*BaseATNConfig) SetContext 

func (b *BaseATNConfig) SetContext(v PredictionContext)

func (*BaseATNConfig) SetReachesIntoOuterContext 

func (b *BaseATNConfig) SetReachesIntoOuterContext(v int)

func (*BaseATNConfig) String 

func (b *BaseATNConfig) String() string

type BaseATNConfigSet 

type BaseATNConfigSet struct {
	// contains filtered or unexported fields
}

BaseATNConfigSet is a specialized set of ATNConfig that tracks information about its elements and can combine similar configurations using a graph-structured stack.

func NewBaseATNConfigSet 

func NewBaseATNConfigSet(fullCtx bool) *BaseATNConfigSet

func (*BaseATNConfigSet) Add 

func (b *BaseATNConfigSet) Add(config ATNConfig, mergeCache *DoubleDict) bool

Add merges contexts with existing configs for (s, i, pi, _), where s is the ATNConfig.state, i is the ATNConfig.alt, and pi is the ATNConfig.semanticContext. We use (s,i,pi) as the key. Updates dipsIntoOuterContext and hasSemanticContext when necessary.

func (*BaseATNConfigSet) AddAll 

func (b *BaseATNConfigSet) AddAll(coll []ATNConfig) bool

func (*BaseATNConfigSet) Clear 

func (b *BaseATNConfigSet) Clear()

func (*BaseATNConfigSet) Contains 

func (b *BaseATNConfigSet) Contains(item ATNConfig) bool

func (*BaseATNConfigSet) ContainsFast 

func (b *BaseATNConfigSet) ContainsFast(item ATNConfig) bool

func (*BaseATNConfigSet) Equals 

func (b *BaseATNConfigSet) Equals(other interface{}) bool

func (*BaseATNConfigSet) FullContext 

func (b *BaseATNConfigSet) FullContext() bool

func (*BaseATNConfigSet) GetConflictingAlts 

func (b *BaseATNConfigSet) GetConflictingAlts() *BitSet

func (*BaseATNConfigSet) GetDipsIntoOuterContext 

func (b *BaseATNConfigSet) GetDipsIntoOuterContext() bool

func (*BaseATNConfigSet) GetItems 

func (b *BaseATNConfigSet) GetItems() []ATNConfig

func (*BaseATNConfigSet) GetPredicates 

func (b *BaseATNConfigSet) GetPredicates() []SemanticContext

func (*BaseATNConfigSet) GetStates 

func (b *BaseATNConfigSet) GetStates() *Set

func (*BaseATNConfigSet) GetUniqueAlt 

func (b *BaseATNConfigSet) GetUniqueAlt() int

func (*BaseATNConfigSet) HasSemanticContext 

func (b *BaseATNConfigSet) HasSemanticContext() bool

func (*BaseATNConfigSet) IsEmpty 

func (b *BaseATNConfigSet) IsEmpty() bool

func (*BaseATNConfigSet) Length 

func (b *BaseATNConfigSet) Length() int

func (*BaseATNConfigSet) OptimizeConfigs 

func (b *BaseATNConfigSet) OptimizeConfigs(interpreter *BaseATNSimulator)

func (*BaseATNConfigSet) ReadOnly 

func (b *BaseATNConfigSet) ReadOnly() bool

func (*BaseATNConfigSet) SetConflictingAlts 

func (b *BaseATNConfigSet) SetConflictingAlts(v *BitSet)

func (*BaseATNConfigSet) SetDipsIntoOuterContext 

func (b *BaseATNConfigSet) SetDipsIntoOuterContext(v bool)

func (*BaseATNConfigSet) SetHasSemanticContext 

func (b *BaseATNConfigSet) SetHasSemanticContext(v bool)

func (*BaseATNConfigSet) SetReadOnly 

func (b *BaseATNConfigSet) SetReadOnly(readOnly bool)

func (*BaseATNConfigSet) SetUniqueAlt 

func (b *BaseATNConfigSet) SetUniqueAlt(v int)

func (*BaseATNConfigSet) String 

func (b *BaseATNConfigSet) String() string

type BaseATNSimulator 

type BaseATNSimulator struct {
	// contains filtered or unexported fields
}

func NewBaseATNSimulator 

func NewBaseATNSimulator(atn *ATN, sharedContextCache *PredictionContextCache) *BaseATNSimulator

func (*BaseATNSimulator) ATN 

func (b *BaseATNSimulator) ATN() *ATN

func (*BaseATNSimulator) DecisionToDFA 

func (b *BaseATNSimulator) DecisionToDFA() []*DFA

func (*BaseATNSimulator) SharedContextCache 

func (b *BaseATNSimulator) SharedContextCache() *PredictionContextCache

type BaseATNState 

type BaseATNState struct {
	// NextTokenWithinRule caches lookahead during parsing. Not used during construction.
	NextTokenWithinRule *IntervalSet
	// contains filtered or unexported fields
}

func NewBaseATNState 

func NewBaseATNState() *BaseATNState

func (*BaseATNState) AddTransition 

func (as *BaseATNState) AddTransition(trans Transition, index int)

func (*BaseATNState) GetATN 

func (as *BaseATNState) GetATN() *ATN

func (*BaseATNState) GetEpsilonOnlyTransitions 

func (as *BaseATNState) GetEpsilonOnlyTransitions() bool

func (*BaseATNState) GetNextTokenWithinRule 

func (as *BaseATNState) GetNextTokenWithinRule() *IntervalSet

func (*BaseATNState) GetRuleIndex 

func (as *BaseATNState) GetRuleIndex() int

func (*BaseATNState) GetStateNumber 

func (as *BaseATNState) GetStateNumber() int

func (*BaseATNState) GetStateType 

func (as *BaseATNState) GetStateType() int

func (*BaseATNState) GetTransitions 

func (as *BaseATNState) GetTransitions() []Transition

func (*BaseATNState) SetATN 

func (as *BaseATNState) SetATN(atn *ATN)

func (*BaseATNState) SetNextTokenWithinRule 

func (as *BaseATNState) SetNextTokenWithinRule(v *IntervalSet)

func (*BaseATNState) SetRuleIndex 

func (as *BaseATNState) SetRuleIndex(v int)

func (*BaseATNState) SetStateNumber 

func (as *BaseATNState) SetStateNumber(stateNumber int)

func (*BaseATNState) SetTransitions 

func (as *BaseATNState) SetTransitions(t []Transition)

func (*BaseATNState) String 

func (as *BaseATNState) String() string

type BaseAbstractPredicateTransition 

type BaseAbstractPredicateTransition struct {
	*BaseTransition
}

func NewBasePredicateTransition 

func NewBasePredicateTransition(target ATNState) *BaseAbstractPredicateTransition

func (*BaseAbstractPredicateTransition) IAbstractPredicateTransitionFoo 

func (a *BaseAbstractPredicateTransition) IAbstractPredicateTransitionFoo()

type BaseBlockStartState 

type BaseBlockStartState struct {
	*BaseDecisionState
	// contains filtered or unexported fields
}

BaseBlockStartState is the start of a regular (...) block.

func NewBlockStartState 

func NewBlockStartState() *BaseBlockStartState

type BaseDecisionState 

type BaseDecisionState struct {
	*BaseATNState
	// contains filtered or unexported fields
}

func NewBaseDecisionState 

func NewBaseDecisionState() *BaseDecisionState

type BaseInterpreterRuleContext 

type BaseInterpreterRuleContext struct {
	*BaseParserRuleContext
}

func NewBaseInterpreterRuleContext 

func NewBaseInterpreterRuleContext(parent BaseInterpreterRuleContext, invokingStateNumber, ruleIndex int) *BaseInterpreterRuleContext

type BaseLexer 

type BaseLexer struct {
	*BaseRecognizer

	Interpreter         ILexerATNSimulator
	TokenStartCharIndex int
	TokenStartLine      int
	TokenStartColumn    int
	ActionType          int
	Virt                Lexer // The most derived lexer implementation. Allows virtual method calls.
	// contains filtered or unexported fields
}

func NewBaseLexer 

func NewBaseLexer(input CharStream) *BaseLexer

func (*BaseLexer) Emit 

func (b *BaseLexer) Emit() Token

The standard method called to automatically emit a token at the outermost lexical rule. The token object should point into the char buffer start..stop. If there is a text override in 'text', use that to set the token's text. Override l method to emit custom Token objects or provide a Newfactory. /

func (*BaseLexer) EmitEOF 

func (b *BaseLexer) EmitEOF() Token

func (*BaseLexer) EmitToken 

func (b *BaseLexer) EmitToken(token Token)

By default does not support multiple emits per NextToken invocation for efficiency reasons. Subclass and override l method, NextToken, and GetToken (to push tokens into a list and pull from that list rather than a single variable as l implementation does). /

func (*BaseLexer) GetATN 

func (b *BaseLexer) GetATN() *ATN

func (*BaseLexer) GetAllTokens 

func (b *BaseLexer) GetAllTokens() []Token

Return a list of all Token objects in input char stream. Forces load of all tokens. Does not include EOF token. /

func (*BaseLexer) GetCharIndex 

func (b *BaseLexer) GetCharIndex() int

What is the index of the current character of lookahead?///

func (*BaseLexer) GetCharPositionInLine 

func (b *BaseLexer) GetCharPositionInLine() int

func (*BaseLexer) GetInputStream 

func (b *BaseLexer) GetInputStream() CharStream

func (*BaseLexer) GetInterpreter 

func (b *BaseLexer) GetInterpreter() ILexerATNSimulator

func (*BaseLexer) GetLine 

func (b *BaseLexer) GetLine() int

func (*BaseLexer) GetSourceName 

func (b *BaseLexer) GetSourceName() string

func (*BaseLexer) GetText 

func (b *BaseLexer) GetText() string

Return the text Matched so far for the current token or any text override. Set the complete text of l token it wipes any previous changes to the text.

func (*BaseLexer) GetTokenFactory 

func (b *BaseLexer) GetTokenFactory() TokenFactory

func (*BaseLexer) GetTokenSourceCharStreamPair 

func (b *BaseLexer) GetTokenSourceCharStreamPair() *TokenSourceCharStreamPair

func (*BaseLexer) GetType 

func (b *BaseLexer) GetType() int

func (*BaseLexer) More 

func (b *BaseLexer) More()

func (*BaseLexer) NextToken 

func (b *BaseLexer) NextToken() Token

Return a token from l source i.e., Match a token on the char stream.

func (*BaseLexer) PopMode 

func (b *BaseLexer) PopMode() int

func (*BaseLexer) PushMode 

func (b *BaseLexer) PushMode(m int)

func (*BaseLexer) Recover 

func (b *BaseLexer) Recover(re RecognitionException)

Lexers can normally Match any char in it's vocabulary after Matching a token, so do the easy thing and just kill a character and hope it all works out. You can instead use the rule invocation stack to do sophisticated error recovery if you are in a fragment rule. /

func (*BaseLexer) SetChannel 

func (b *BaseLexer) SetChannel(v int)

func (*BaseLexer) SetInputStream 

func (b *BaseLexer) SetInputStream(input CharStream)

SetInputStream resets the lexer input stream and associated lexer state.

func (*BaseLexer) SetMode 

func (b *BaseLexer) SetMode(m int)

func (*BaseLexer) SetText 

func (b *BaseLexer) SetText(text string)

func (*BaseLexer) SetType 

func (b *BaseLexer) SetType(t int)

func (*BaseLexer) Skip 

func (b *BaseLexer) Skip()

Instruct the lexer to Skip creating a token for current lexer rule and look for another token. NextToken() knows to keep looking when a lexer rule finishes with token set to SKIPTOKEN. Recall that if token==nil at end of any token rule, it creates one for you and emits it. /

type BaseLexerAction 

type BaseLexerAction struct {
	// contains filtered or unexported fields
}

func NewBaseLexerAction 

func NewBaseLexerAction(action int) *BaseLexerAction

type BaseParseTreeListener 

type BaseParseTreeListener struct{}

func (*BaseParseTreeListener) EnterEveryRule 

func (l *BaseParseTreeListener) EnterEveryRule(ctx ParserRuleContext)

func (*BaseParseTreeListener) ExitEveryRule 

func (l *BaseParseTreeListener) ExitEveryRule(ctx ParserRuleContext)

func (*BaseParseTreeListener) VisitErrorNode 

func (l *BaseParseTreeListener) VisitErrorNode(node ErrorNode)

func (*BaseParseTreeListener) VisitTerminal 

func (l *BaseParseTreeListener) VisitTerminal(node TerminalNode)

type BaseParseTreeVisitor 

type BaseParseTreeVisitor struct{}

func (*BaseParseTreeVisitor) Visit 

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

func (*BaseParseTreeVisitor) VisitChildren 

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

func (*BaseParseTreeVisitor) VisitErrorNode 

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

func (*BaseParseTreeVisitor) VisitTerminal 

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

type BaseParser 

type BaseParser struct {
	*BaseRecognizer

	Interpreter     *ParserATNSimulator
	BuildParseTrees bool
	// contains filtered or unexported fields
}

func NewBaseParser 

func NewBaseParser(input TokenStream) *BaseParser

p.is all the parsing support code essentially most of it is error recovery stuff.//

func (*BaseParser) AddParseListener 

func (p *BaseParser) AddParseListener(listener ParseTreeListener)

Registers {@code listener} to receive events during the parsing process.

<p>To support output-preserving grammar transformations (including but not limited to left-recursion removal, automated left-factoring, and optimized code generation), calls to listener methods during the parse may differ substantially from calls made by {@link ParseTreeWalker//DEFAULT} used after the parse is complete. In particular, rule entry and exit events may occur in a different order during the parse than after the parser. In addition, calls to certain rule entry methods may be omitted.</p>

<p>With the following specific exceptions, calls to listener events are <em>deterministic</em>, i.e. for identical input the calls to listener methods will be the same.</p>

<ul> <li>Alterations to the grammar used to generate code may change the behavior of the listener calls.</li> <li>Alterations to the command line options passed to ANTLR 4 when generating the parser may change the behavior of the listener calls.</li> <li>Changing the version of the ANTLR Tool used to generate the parser may change the behavior of the listener calls.</li> </ul>

@param listener the listener to add

@panics nilPointerException if {@code} listener is {@code nil}

func (*BaseParser) Consume 

func (p *BaseParser) Consume() Token

func (*BaseParser) DumpDFA 

func (p *BaseParser) DumpDFA()

For debugging and other purposes.//

func (*BaseParser) EnterOuterAlt 

func (p *BaseParser) EnterOuterAlt(localctx ParserRuleContext, altNum int)

func (*BaseParser) EnterRecursionRule 

func (p *BaseParser) EnterRecursionRule(localctx ParserRuleContext, state, ruleIndex, precedence int)

func (*BaseParser) EnterRule 

func (p *BaseParser) EnterRule(localctx ParserRuleContext, state, ruleIndex int)

func (*BaseParser) ExitRule 

func (p *BaseParser) ExitRule()

func (*BaseParser) GetATN 

func (p *BaseParser) GetATN() *ATN

func (*BaseParser) GetATNWithBypassAlts 

func (p *BaseParser) GetATNWithBypassAlts()

The ATN with bypass alternatives is expensive to create so we create it lazily.

@panics UnsupportedOperationException if the current parser does not implement the {@link //getSerializedATN()} method.

func (*BaseParser) GetCurrentToken 

func (p *BaseParser) GetCurrentToken() Token

Match needs to return the current input symbol, which gets put into the label for the associated token ref e.g., x=ID.

func (*BaseParser) GetDFAStrings 

func (p *BaseParser) GetDFAStrings() string

For debugging and other purposes.//

func (*BaseParser) GetErrorHandler 

func (p *BaseParser) GetErrorHandler() ErrorStrategy

func (*BaseParser) GetExpectedTokens 

func (p *BaseParser) GetExpectedTokens() *IntervalSet

Computes the set of input symbols which could follow the current parser state and context, as given by {@link //GetState} and {@link //GetContext}, respectively.

@see ATN//getExpectedTokens(int, RuleContext)

func (*BaseParser) GetExpectedTokensWithinCurrentRule 

func (p *BaseParser) GetExpectedTokensWithinCurrentRule() *IntervalSet

func (*BaseParser) GetInputStream 

func (p *BaseParser) GetInputStream() IntStream

func (*BaseParser) GetInterpreter 

func (p *BaseParser) GetInterpreter() *ParserATNSimulator

func (*BaseParser) GetInvokingContext 

func (p *BaseParser) GetInvokingContext(ruleIndex int) ParserRuleContext

func (*BaseParser) GetParseListeners 

func (p *BaseParser) GetParseListeners() []ParseTreeListener

func (*BaseParser) GetParserRuleContext 

func (p *BaseParser) GetParserRuleContext() ParserRuleContext

func (*BaseParser) GetPrecedence 

func (p *BaseParser) GetPrecedence() int

func (*BaseParser) GetRuleIndex 

func (p *BaseParser) GetRuleIndex(ruleName string) int

Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.//

func (*BaseParser) GetRuleInvocationStack 

func (p *BaseParser) GetRuleInvocationStack(c ParserRuleContext) []string

func (*BaseParser) GetSourceName 

func (p *BaseParser) GetSourceName() string

func (*BaseParser) GetTokenFactory 

func (p *BaseParser) GetTokenFactory() TokenFactory

func (*BaseParser) GetTokenStream 

func (p *BaseParser) GetTokenStream() TokenStream

func (*BaseParser) IsExpectedToken 

func (p *BaseParser) IsExpectedToken(symbol int) bool

func (*BaseParser) Match 

func (p *BaseParser) Match(ttype int) Token

func (*BaseParser) MatchWildcard 

func (p *BaseParser) MatchWildcard() Token

func (*BaseParser) NotifyErrorListeners 

func (p *BaseParser) NotifyErrorListeners(msg string, offendingToken Token, err RecognitionException)

func (*BaseParser) Precpred 

func (p *BaseParser) Precpred(localctx RuleContext, precedence int) bool

func (*BaseParser) PushNewRecursionContext 

func (p *BaseParser) PushNewRecursionContext(localctx ParserRuleContext, state, ruleIndex int)

func (*BaseParser) RemoveParseListener 

func (p *BaseParser) RemoveParseListener(listener ParseTreeListener)

Remove {@code listener} from the list of parse listeners.

<p>If {@code listener} is {@code nil} or has not been added as a parse listener, p.method does nothing.</p> @param listener the listener to remove

func (*BaseParser) SetErrorHandler 

func (p *BaseParser) SetErrorHandler(e ErrorStrategy)

func (*BaseParser) SetInputStream 

func (p *BaseParser) SetInputStream(input TokenStream)

func (*BaseParser) SetParserRuleContext 

func (p *BaseParser) SetParserRuleContext(v ParserRuleContext)

func (*BaseParser) SetTokenStream 

func (p *BaseParser) SetTokenStream(input TokenStream)

Set the token stream and reset the parser.//

func (*BaseParser) SetTrace 

func (p *BaseParser) SetTrace(trace *TraceListener)

During a parse is sometimes useful to listen in on the rule entry and exit events as well as token Matches. p.is for quick and dirty debugging.

func (*BaseParser) TriggerEnterRuleEvent 

func (p *BaseParser) TriggerEnterRuleEvent()

Notify any parse listeners of an enter rule event.

func (*BaseParser) TriggerExitRuleEvent 

func (p *BaseParser) TriggerExitRuleEvent()

Notify any parse listeners of an exit rule event.

@see //addParseListener

func (*BaseParser) UnrollRecursionContexts 

func (p *BaseParser) UnrollRecursionContexts(parentCtx ParserRuleContext)

type BaseParserRuleContext 

type BaseParserRuleContext struct {
	*BaseRuleContext
	// contains filtered or unexported fields
}

func NewBaseParserRuleContext 

func NewBaseParserRuleContext(parent ParserRuleContext, invokingStateNumber int) *BaseParserRuleContext

func (*BaseParserRuleContext) Accept 

func (prc *BaseParserRuleContext) Accept(visitor ParseTreeVisitor) interface{}

func (*BaseParserRuleContext) AddChild 

func (prc *BaseParserRuleContext) AddChild(child RuleContext) RuleContext

func (*BaseParserRuleContext) AddErrorNode 

func (prc *BaseParserRuleContext) AddErrorNode(badToken Token) *ErrorNodeImpl

func (*BaseParserRuleContext) AddTokenNode 

func (prc *BaseParserRuleContext) AddTokenNode(token Token) *TerminalNodeImpl

func (*BaseParserRuleContext) CopyFrom 

func (prc *BaseParserRuleContext) CopyFrom(ctx *BaseParserRuleContext)

func (*BaseParserRuleContext) EnterRule 

func (prc *BaseParserRuleContext) EnterRule(listener ParseTreeListener)

Double dispatch methods for listeners

func (*BaseParserRuleContext) ExitRule 

func (prc *BaseParserRuleContext) ExitRule(listener ParseTreeListener)

func (*BaseParserRuleContext) GetChild 

func (prc *BaseParserRuleContext) GetChild(i int) Tree

func (*BaseParserRuleContext) GetChildCount 

func (prc *BaseParserRuleContext) GetChildCount() int

func (*BaseParserRuleContext) GetChildOfType 

func (prc *BaseParserRuleContext) GetChildOfType(i int, childType reflect.Type) RuleContext

func (*BaseParserRuleContext) GetChildren 

func (prc *BaseParserRuleContext) GetChildren() []Tree

func (*BaseParserRuleContext) GetPayload 

func (prc *BaseParserRuleContext) GetPayload() interface{}

func (*BaseParserRuleContext) GetRuleContext 

func (prc *BaseParserRuleContext) GetRuleContext() RuleContext

func (*BaseParserRuleContext) GetSourceInterval 

func (prc *BaseParserRuleContext) GetSourceInterval() *Interval

func (*BaseParserRuleContext) GetStart 

func (prc *BaseParserRuleContext) GetStart() Token

func (*BaseParserRuleContext) GetStop 

func (prc *BaseParserRuleContext) GetStop() Token

func (*BaseParserRuleContext) GetText 

func (prc *BaseParserRuleContext) GetText() string

func (*BaseParserRuleContext) GetToken 

func (prc *BaseParserRuleContext) GetToken(ttype int, i int) TerminalNode

func (*BaseParserRuleContext) GetTokens 

func (prc *BaseParserRuleContext) GetTokens(ttype int) []TerminalNode

func (*BaseParserRuleContext) GetTypedRuleContext 

func (prc *BaseParserRuleContext) GetTypedRuleContext(ctxType reflect.Type, i int) RuleContext

func (*BaseParserRuleContext) GetTypedRuleContexts 

func (prc *BaseParserRuleContext) GetTypedRuleContexts(ctxType reflect.Type) []RuleContext

func (*BaseParserRuleContext) RemoveLastChild 

func (prc *BaseParserRuleContext) RemoveLastChild()

* Used by EnterOuterAlt to toss out a RuleContext previously added as we entered a rule. If we have // label, we will need to remove generic ruleContext object. /

func (*BaseParserRuleContext) SetException 

func (prc *BaseParserRuleContext) SetException(e RecognitionException)

func (*BaseParserRuleContext) SetStart 

func (prc *BaseParserRuleContext) SetStart(t Token)

func (*BaseParserRuleContext) SetStop 

func (prc *BaseParserRuleContext) SetStop(t Token)

func (*BaseParserRuleContext) String 

func (prc *BaseParserRuleContext) String(ruleNames []string, stop RuleContext) string

func (*BaseParserRuleContext) ToStringTree 

func (prc *BaseParserRuleContext) ToStringTree(ruleNames []string, recog Recognizer) string

type BasePredictionContext 

type BasePredictionContext struct {
	// contains filtered or unexported fields
}

func NewBasePredictionContext 

func NewBasePredictionContext(cachedHash int) *BasePredictionContext

type BaseRecognitionException 

type BaseRecognitionException struct {
	// contains filtered or unexported fields
}

func NewBaseRecognitionException 

func NewBaseRecognitionException(message string, recognizer Recognizer, input IntStream, ctx RuleContext) *BaseRecognitionException

func (*BaseRecognitionException) GetInputStream 

func (b *BaseRecognitionException) GetInputStream() IntStream

func (*BaseRecognitionException) GetMessage 

func (b *BaseRecognitionException) GetMessage() string

func (*BaseRecognitionException) GetOffendingToken 

func (b *BaseRecognitionException) GetOffendingToken() Token

func (*BaseRecognitionException) String 

func (b *BaseRecognitionException) String() string

type BaseRecognizer 

type BaseRecognizer struct {
	RuleNames       []string
	LiteralNames    []string
	SymbolicNames   []string
	GrammarFileName string
	// contains filtered or unexported fields
}

func NewBaseRecognizer 

func NewBaseRecognizer() *BaseRecognizer

func (*BaseRecognizer) Action 

func (b *BaseRecognizer) Action(context RuleContext, ruleIndex, actionIndex int)

func (*BaseRecognizer) AddErrorListener 

func (b *BaseRecognizer) AddErrorListener(listener ErrorListener)

func (*BaseRecognizer) GetErrorHeader 

func (b *BaseRecognizer) GetErrorHeader(e RecognitionException) string

What is the error header, normally line/character position information?//

func (*BaseRecognizer) GetErrorListenerDispatch 

func (b *BaseRecognizer) GetErrorListenerDispatch() ErrorListener

func (*BaseRecognizer) GetLiteralNames 

func (b *BaseRecognizer) GetLiteralNames() []string

func (*BaseRecognizer) GetRuleIndexMap 

func (b *BaseRecognizer) GetRuleIndexMap() map[string]int

Get a map from rule names to rule indexes.

<p>Used for XPath and tree pattern compilation.</p>

func (*BaseRecognizer) GetRuleNames 

func (b *BaseRecognizer) GetRuleNames() []string

func (*BaseRecognizer) GetState 

func (b *BaseRecognizer) GetState() int

func (*BaseRecognizer) GetSymbolicNames 

func (b *BaseRecognizer) GetSymbolicNames() []string

func (*BaseRecognizer) GetTokenErrorDisplay 

func (b *BaseRecognizer) GetTokenErrorDisplay(t Token) string

How should a token be displayed in an error message? The default 

is to display just the text, but during development you might
want to have a lot of information spit out.  Override in that case
to use t.String() (which, for CommonToken, dumps everything about
the token). This is better than forcing you to override a method in
your token objects because you don't have to go modify your lexer
so that it creates a NewJava type.

@deprecated This method is not called by the ANTLR 4 Runtime. Specific implementations of {@link ANTLRErrorStrategy} may provide a similar feature when necessary. For example, see {@link DefaultErrorStrategy//GetTokenErrorDisplay}.

func (*BaseRecognizer) GetTokenNames 

func (b *BaseRecognizer) GetTokenNames() []string

func (*BaseRecognizer) GetTokenType 

func (b *BaseRecognizer) GetTokenType(tokenName string) int

func (*BaseRecognizer) Precpred 

func (b *BaseRecognizer) Precpred(localctx RuleContext, precedence int) bool

func (*BaseRecognizer) RemoveErrorListeners 

func (b *BaseRecognizer) RemoveErrorListeners()

func (*BaseRecognizer) Sempred 

func (b *BaseRecognizer) Sempred(localctx RuleContext, ruleIndex int, actionIndex int) bool

subclass needs to override these if there are sempreds or actions that the ATN interp needs to execute

func (*BaseRecognizer) SetState 

func (b *BaseRecognizer) SetState(v int)

type BaseRewriteOperation 

type BaseRewriteOperation struct {
	// contains filtered or unexported fields
}

func (*BaseRewriteOperation) Execute 

func (op *BaseRewriteOperation) Execute(buffer *bytes.Buffer) int

func (*BaseRewriteOperation) GetIndex 

func (op *BaseRewriteOperation) GetIndex() int

func (*BaseRewriteOperation) GetInstructionIndex 

func (op *BaseRewriteOperation) GetInstructionIndex() int

func (*BaseRewriteOperation) GetOpName 

func (op *BaseRewriteOperation) GetOpName() string

func (*BaseRewriteOperation) GetText 

func (op *BaseRewriteOperation) GetText() string

func (*BaseRewriteOperation) GetTokens 

func (op *BaseRewriteOperation) GetTokens() TokenStream

func (*BaseRewriteOperation) SetIndex 

func (op *BaseRewriteOperation) SetIndex(val int)

func (*BaseRewriteOperation) SetInstructionIndex 

func (op *BaseRewriteOperation) SetInstructionIndex(val int)

func (*BaseRewriteOperation) SetOpName 

func (op *BaseRewriteOperation) SetOpName(val string)

func (*BaseRewriteOperation) SetText 

func (op *BaseRewriteOperation) SetText(val string)

func (*BaseRewriteOperation) SetTokens 

func (op *BaseRewriteOperation) SetTokens(val TokenStream)

func (*BaseRewriteOperation) String 

func (op *BaseRewriteOperation) String() string

type BaseRuleContext 

type BaseRuleContext struct {
	RuleIndex int
	// contains filtered or unexported fields
}

func NewBaseRuleContext 

func NewBaseRuleContext(parent RuleContext, invokingState int) *BaseRuleContext

func (*BaseRuleContext) GetAltNumber 

func (b *BaseRuleContext) GetAltNumber() int

func (*BaseRuleContext) GetBaseRuleContext 

func (b *BaseRuleContext) GetBaseRuleContext() *BaseRuleContext

func (*BaseRuleContext) GetInvokingState 

func (b *BaseRuleContext) GetInvokingState() int

func (*BaseRuleContext) GetParent 

func (b *BaseRuleContext) GetParent() Tree

func (*BaseRuleContext) GetRuleIndex 

func (b *BaseRuleContext) GetRuleIndex() int

func (*BaseRuleContext) IsEmpty 

func (b *BaseRuleContext) IsEmpty() bool

A context is empty if there is no invoking state meaning nobody call current context.

func (*BaseRuleContext) SetAltNumber 

func (b *BaseRuleContext) SetAltNumber(altNumber int)

func (*BaseRuleContext) SetInvokingState 

func (b *BaseRuleContext) SetInvokingState(t int)

func (*BaseRuleContext) SetParent 

func (b *BaseRuleContext) SetParent(v Tree)

type BaseSingletonPredictionContext 

type BaseSingletonPredictionContext struct {
	*BasePredictionContext
	// contains filtered or unexported fields
}

func NewBaseSingletonPredictionContext 

func NewBaseSingletonPredictionContext(parent PredictionContext, returnState int) *BaseSingletonPredictionContext

func (*BaseSingletonPredictionContext) GetParent 

func (b *BaseSingletonPredictionContext) GetParent(index int) PredictionContext

func (*BaseSingletonPredictionContext) String 

func (b *BaseSingletonPredictionContext) String() string

type BaseToken 

type BaseToken struct {
	// contains filtered or unexported fields
}

func (*BaseToken) GetChannel 

func (b *BaseToken) GetChannel() int

func (*BaseToken) GetColumn 

func (b *BaseToken) GetColumn() int

func (*BaseToken) GetInputStream 

func (b *BaseToken) GetInputStream() CharStream

func (*BaseToken) GetLine 

func (b *BaseToken) GetLine() int

func (*BaseToken) GetSource 

func (b *BaseToken) GetSource() *TokenSourceCharStreamPair

func (*BaseToken) GetStart 

func (b *BaseToken) GetStart() int

func (*BaseToken) GetStop 

func (b *BaseToken) GetStop() int

func (*BaseToken) GetTokenIndex 

func (b *BaseToken) GetTokenIndex() int

func (*BaseToken) GetTokenSource 

func (b *BaseToken) GetTokenSource() TokenSource

func (*BaseToken) GetTokenType 

func (b *BaseToken) GetTokenType() int

func (*BaseToken) SetTokenIndex 

func (b *BaseToken) SetTokenIndex(v int)

type BaseTransition 

type BaseTransition struct {
	// contains filtered or unexported fields
}

func NewBaseTransition 

func NewBaseTransition(target ATNState) *BaseTransition

func (*BaseTransition) Matches 

func (t *BaseTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

type BasicBlockStartState 

type BasicBlockStartState struct {
	*BaseBlockStartState
}

func NewBasicBlockStartState 

func NewBasicBlockStartState() *BasicBlockStartState

type BasicState 

type BasicState struct {
	*BaseATNState
}

func NewBasicState 

func NewBasicState() *BasicState

type BitSet 

type BitSet struct {
	// contains filtered or unexported fields
}

func NewBitSet 

func NewBitSet() *BitSet

func PredictionModeGetAlts 

func PredictionModeGetAlts(altsets []*BitSet) *BitSet

Gets the complete set of represented alternatives for a collection of alternative subsets. This method returns the union of each {@link BitSet} in {@code altsets}.

@param altsets a collection of alternative subsets @return the set of represented alternatives in {@code altsets}

func PredictionModegetConflictingAltSubsets 

func PredictionModegetConflictingAltSubsets(configs ATNConfigSet) []*BitSet

This func gets the conflicting alt subsets from a configuration set. For each configuration {@code c} in {@code configs}:

<pre> map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not alt and not pred </pre>

func (*BitSet) String 

func (b *BitSet) String() string

type BlockEndState 

type BlockEndState struct {
	*BaseATNState
	// contains filtered or unexported fields
}

BlockEndState is a terminal node of a simple (a|b|c) block.

func NewBlockEndState 

func NewBlockEndState() *BlockEndState

type BlockStartState 

type BlockStartState interface {
	DecisionState
	// contains filtered or unexported methods
}

type BlockStartStateIntPair 

type BlockStartStateIntPair struct {
	// contains filtered or unexported fields
}

type CharStream 

type CharStream interface {
	IntStream
	GetText(int, int) string
	GetTextFromTokens(start, end Token) string
	GetTextFromInterval(*Interval) string
}

type CommonToken 

type CommonToken struct {
	*BaseToken
}

func NewCommonToken 

func NewCommonToken(source *TokenSourceCharStreamPair, tokenType, channel, start, stop int) *CommonToken

func (*CommonToken) GetText 

func (c *CommonToken) GetText() string

func (*CommonToken) SetText 

func (c *CommonToken) SetText(text string)

func (*CommonToken) String 

func (c *CommonToken) String() string

type CommonTokenFactory 

type CommonTokenFactory struct {
	// contains filtered or unexported fields
}

CommonTokenFactory is the default TokenFactory implementation.

func NewCommonTokenFactory 

func NewCommonTokenFactory(copyText bool) *CommonTokenFactory

func (*CommonTokenFactory) Create 

func (c *CommonTokenFactory) Create(source *TokenSourceCharStreamPair, ttype int, text string, channel, start, stop, line, column int) Token

type CommonTokenStream 

type CommonTokenStream struct {
	// contains filtered or unexported fields
}

CommonTokenStream is an implementation of TokenStream that loads tokens from a TokenSource on-demand and places the tokens in a buffer to provide access to any previous token by index. This token stream ignores the value of Token.getChannel. If your parser requires the token stream filter tokens to only those on a particular channel, such as Token.DEFAULT_CHANNEL or Token.HIDDEN_CHANNEL, use a filtering token stream such a CommonTokenStream.

func NewCommonTokenStream 

func NewCommonTokenStream(lexer Lexer, channel int) *CommonTokenStream

func (*CommonTokenStream) Consume 

func (c *CommonTokenStream) Consume()

func (*CommonTokenStream) Fill 

func (c *CommonTokenStream) Fill()

Fill gets all tokens from the lexer until EOF.

func (*CommonTokenStream) Get 

func (c *CommonTokenStream) Get(index int) Token

func (*CommonTokenStream) GetAllText 

func (c *CommonTokenStream) GetAllText() string

func (*CommonTokenStream) GetAllTokens 

func (c *CommonTokenStream) GetAllTokens() []Token

func (*CommonTokenStream) GetHiddenTokensToLeft 

func (c *CommonTokenStream) GetHiddenTokensToLeft(tokenIndex, channel int) []Token

GetHiddenTokensToLeft collects all tokens on channel to the left of the current token until we see a token on DEFAULT_TOKEN_CHANNEL. If channel is -1, it finds any non default channel token.

func (*CommonTokenStream) GetHiddenTokensToRight 

func (c *CommonTokenStream) GetHiddenTokensToRight(tokenIndex, channel int) []Token

GetHiddenTokensToRight collects all tokens on a specified channel to the right of the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or EOF. If channel is -1, it finds any non-default channel token.

func (*CommonTokenStream) GetSourceName 

func (c *CommonTokenStream) GetSourceName() string

func (*CommonTokenStream) GetTextFromInterval 

func (c *CommonTokenStream) GetTextFromInterval(interval *Interval) string

func (*CommonTokenStream) GetTextFromRuleContext 

func (c *CommonTokenStream) GetTextFromRuleContext(interval RuleContext) string

func (*CommonTokenStream) GetTextFromTokens 

func (c *CommonTokenStream) GetTextFromTokens(start, end Token) string

func (*CommonTokenStream) GetTokenSource 

func (c *CommonTokenStream) GetTokenSource() TokenSource

func (*CommonTokenStream) GetTokens 

func (c *CommonTokenStream) GetTokens(start int, stop int, types *IntervalSet) []Token

GetTokens gets all tokens from start to stop inclusive.

func (*CommonTokenStream) Index 

func (c *CommonTokenStream) Index() int

func (*CommonTokenStream) LA 

func (c *CommonTokenStream) LA(i int) int

func (*CommonTokenStream) LB 

func (c *CommonTokenStream) LB(k int) Token

func (*CommonTokenStream) LT 

func (c *CommonTokenStream) LT(k int) Token

func (*CommonTokenStream) Mark 

func (c *CommonTokenStream) Mark() int

func (*CommonTokenStream) NextTokenOnChannel 

func (c *CommonTokenStream) NextTokenOnChannel(i, channel int) int

NextTokenOnChannel returns the index of the next token on channel given a starting index. Returns i if tokens[i] is on channel. Returns -1 if there are no tokens on channel between i and EOF.

func (*CommonTokenStream) Release 

func (c *CommonTokenStream) Release(marker int)

func (*CommonTokenStream) Seek 

func (c *CommonTokenStream) Seek(index int)

func (*CommonTokenStream) SetTokenSource 

func (c *CommonTokenStream) SetTokenSource(tokenSource TokenSource)

SetTokenSource resets the c token stream by setting its token source.

func (*CommonTokenStream) Size 

func (c *CommonTokenStream) Size() int

func (*CommonTokenStream) Sync 

func (c *CommonTokenStream) Sync(i int) bool

Sync makes sure index i in tokens has a token and returns true if a token is located at index i and otherwise false.

type ConsoleErrorListener 

type ConsoleErrorListener struct {
	*DefaultErrorListener
}

func NewConsoleErrorListener 

func NewConsoleErrorListener() *ConsoleErrorListener

func (*ConsoleErrorListener) SyntaxError 

func (c *ConsoleErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, msg string, e RecognitionException)

{@inheritDoc}

<p> This implementation prints messages to {@link System//err} containing the values of {@code line}, {@code charPositionInLine}, and {@code msg} using the following format.</p>

<pre> line <em>line</em>:<em>charPositionInLine</em> <em>msg</em> </pre>

type DFA 

type DFA struct {
	// contains filtered or unexported fields
}

func NewDFA 

func NewDFA(atnStartState DecisionState, decision int) *DFA

func (*DFA) String 

func (d *DFA) String(literalNames []string, symbolicNames []string) string

func (*DFA) ToLexerString 

func (d *DFA) ToLexerString() string

type DFASerializer 

type DFASerializer struct {
	// contains filtered or unexported fields
}

DFASerializer is a DFA walker that knows how to dump them to serialized strings.

func NewDFASerializer 

func NewDFASerializer(dfa *DFA, literalNames, symbolicNames []string) *DFASerializer

func (*DFASerializer) GetStateString 

func (d *DFASerializer) GetStateString(s *DFAState) string

func (*DFASerializer) String 

func (d *DFASerializer) String() string

type DFAState 

type DFAState struct {
	// contains filtered or unexported fields
}

DFAState represents a set of possible ATN configurations. As Aho, Sethi, Ullman p. 117 says: "The DFA uses its state to keep track of all possible states the ATN can be in after reading each input symbol. That is to say, after reading input a1a2..an, the DFA is in a state that represents the subset T of the states of the ATN that are reachable from the ATN's start state along some path labeled a1a2..an." In conventional NFA-to-DFA conversion, therefore, the subset T would be a bitset representing the set of states the ATN could be in. We need to track the alt predicted by each state as well, however. More importantly, we need to maintain a stack of states, tracking the closure operations as they jump from rule to rule, emulating rule invocations (method calls). I have to add a stack to simulate the proper lookahead sequences for the underlying LL grammar from which the ATN was derived.

I use a set of ATNConfig objects, not simple states. An ATNConfig is both a state (ala normal conversion) and a RuleContext describing the chain of rules (if any) followed to arrive at that state.

A DFAState may have multiple references to a particular state, but with different ATN contexts (with same or different alts) meaning that state was reached via a different set of rule invocations.

func NewDFAState 

func NewDFAState(stateNumber int, configs ATNConfigSet) *DFAState

func (*DFAState) GetAltSet 

func (d *DFAState) GetAltSet() *Set

GetAltSet gets the set of all alts mentioned by all ATN configurations in d.

func (*DFAState) String 

func (d *DFAState) String() string

type DecisionState 

type DecisionState interface {
	ATNState
	// contains filtered or unexported methods
}

type DefaultErrorListener 

type DefaultErrorListener struct {
}

func NewDefaultErrorListener 

func NewDefaultErrorListener() *DefaultErrorListener

func (*DefaultErrorListener) ReportAmbiguity 

func (d *DefaultErrorListener) ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ambigAlts *BitSet, configs ATNConfigSet)

func (*DefaultErrorListener) ReportAttemptingFullContext 

func (d *DefaultErrorListener) ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, conflictingAlts *BitSet, configs ATNConfigSet)

func (*DefaultErrorListener) ReportContextSensitivity 

func (d *DefaultErrorListener) ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, configs ATNConfigSet)

func (*DefaultErrorListener) SyntaxError 

func (d *DefaultErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, msg string, e RecognitionException)

type DefaultErrorStrategy 

type DefaultErrorStrategy struct {
	// contains filtered or unexported fields
}

This is the default implementation of {@link ANTLRErrorStrategy} used for error Reporting and recovery in ANTLR parsers.

func NewDefaultErrorStrategy 

func NewDefaultErrorStrategy() *DefaultErrorStrategy

func (*DefaultErrorStrategy) GetExpectedTokens 

func (d *DefaultErrorStrategy) GetExpectedTokens(recognizer Parser) *IntervalSet

func (*DefaultErrorStrategy) GetMissingSymbol 

func (d *DefaultErrorStrategy) GetMissingSymbol(recognizer Parser) Token

Conjure up a missing token during error recovery.

The recognizer attempts to recover from single missing symbols. But, actions might refer to that missing symbol. For example, x=ID {f($x)}. The action clearly assumes that there has been an identifier Matched previously and that $x points at that token. If that token is missing, but the next token in the stream is what we want we assume that d token is missing and we keep going. Because we have to return some token to replace the missing token, we have to conjure one up. This method gives the user control over the tokens returned for missing tokens. Mostly, you will want to create something special for identifier tokens. For literals such as '{' and ',', the default action in the parser or tree parser works. It simply creates a CommonToken of the appropriate type. The text will be the token. If you change what tokens must be created by the lexer, override d method to create the appropriate tokens.

func (*DefaultErrorStrategy) GetTokenErrorDisplay 

func (d *DefaultErrorStrategy) GetTokenErrorDisplay(t Token) string

How should a token be displayed in an error message? The default is to display just the text, but during development you might want to have a lot of information spit out. Override in that case to use t.String() (which, for CommonToken, dumps everything about the token). This is better than forcing you to override a method in your token objects because you don't have to go modify your lexer so that it creates a NewJava type.

func (*DefaultErrorStrategy) Recover 

func (d *DefaultErrorStrategy) Recover(recognizer Parser, e RecognitionException)

{@inheritDoc}

<p>The default implementation reSynchronizes the parser by consuming tokens until we find one in the reSynchronization set--loosely the set of tokens that can follow the current rule.</p>

func (*DefaultErrorStrategy) RecoverInline 

func (d *DefaultErrorStrategy) RecoverInline(recognizer Parser) Token

<p>The default implementation attempts to recover from the mismatched input by using single token insertion and deletion as described below. If the recovery attempt fails, d method panics an {@link InputMisMatchException}.</p>

<p><strong>EXTRA TOKEN</strong> (single token deletion)</p>

<p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the right token, however, then assume {@code LA(1)} is some extra spurious token and delete it. Then consume and return the next token (which was the {@code LA(2)} token) as the successful result of the Match operation.</p>

<p>This recovery strategy is implemented by {@link //singleTokenDeletion}.</p>

<p><strong>MISSING TOKEN</strong> (single token insertion)</p>

<p>If current token (at {@code LA(1)}) is consistent with what could come after the expected {@code LA(1)} token, then assume the token is missing and use the parser's {@link TokenFactory} to create it on the fly. The "insertion" is performed by returning the created token as the successful result of the Match operation.</p>

<p>This recovery strategy is implemented by {@link //singleTokenInsertion}.</p>

<p><strong>EXAMPLE</strong></p>

<p>For example, Input {@code i=(3} is clearly missing the {@code ')'}. When the parser returns from the nested call to {@code expr}, it will have call chain:</p>

<pre> stat &rarr expr &rarr atom </pre>

and it will be trying to Match the {@code ')'} at d point in the derivation:

<pre> =&gt ID '=' '(' INT ')' ('+' atom)* ” ^ </pre>

The attempt to Match {@code ')'} will fail when it sees {@code ”} and call {@link //recoverInline}. To recover, it sees that {@code LA(1)==”} is in the set of tokens that can follow the {@code ')'} token reference in rule {@code atom}. It can assume that you forgot the {@code ')'}.

func (*DefaultErrorStrategy) ReportError 

func (d *DefaultErrorStrategy) ReportError(recognizer Parser, e RecognitionException)

{@inheritDoc}

<p>The default implementation returns immediately if the handler is already in error recovery mode. Otherwise, it calls {@link //beginErrorCondition} and dispatches the Reporting task based on the runtime type of {@code e} according to the following table.</p>

<ul> <li>{@link NoViableAltException}: Dispatches the call to {@link //ReportNoViableAlternative}</li> <li>{@link InputMisMatchException}: Dispatches the call to {@link //ReportInputMisMatch}</li> <li>{@link FailedPredicateException}: Dispatches the call to {@link //ReportFailedPredicate}</li> <li>All other types: calls {@link Parser//NotifyErrorListeners} to Report the exception</li> </ul>

func (*DefaultErrorStrategy) ReportFailedPredicate 

func (d *DefaultErrorStrategy) ReportFailedPredicate(recognizer Parser, e *FailedPredicateException)

This is called by {@link //ReportError} when the exception is a {@link FailedPredicateException}.

@see //ReportError

@param recognizer the parser instance @param e the recognition exception

func (*DefaultErrorStrategy) ReportInputMisMatch 

func (this *DefaultErrorStrategy) ReportInputMisMatch(recognizer Parser, e *InputMisMatchException)

This is called by {@link //ReportError} when the exception is an {@link InputMisMatchException}.

@see //ReportError

@param recognizer the parser instance @param e the recognition exception

func (*DefaultErrorStrategy) ReportMatch 

func (d *DefaultErrorStrategy) ReportMatch(recognizer Parser)

{@inheritDoc}

<p>The default implementation simply calls {@link //endErrorCondition}.</p>

func (*DefaultErrorStrategy) ReportMissingToken 

func (d *DefaultErrorStrategy) ReportMissingToken(recognizer Parser)

This method is called to Report a syntax error which requires the insertion of a missing token into the input stream. At the time d method is called, the missing token has not yet been inserted. When d method returns, {@code recognizer} is in error recovery mode.

<p>This method is called when {@link //singleTokenInsertion} identifies single-token insertion as a viable recovery strategy for a mismatched input error.</p>

<p>The default implementation simply returns if the handler is already in error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to enter error recovery mode, followed by calling {@link Parser//NotifyErrorListeners}.</p>

@param recognizer the parser instance

func (*DefaultErrorStrategy) ReportNoViableAlternative 

func (d *DefaultErrorStrategy) ReportNoViableAlternative(recognizer Parser, e *NoViableAltException)

This is called by {@link //ReportError} when the exception is a {@link NoViableAltException}.

@see //ReportError

@param recognizer the parser instance @param e the recognition exception

func (*DefaultErrorStrategy) ReportUnwantedToken 

func (d *DefaultErrorStrategy) ReportUnwantedToken(recognizer Parser)

This method is called to Report a syntax error which requires the removal of a token from the input stream. At the time d method is called, the erroneous symbol is current {@code LT(1)} symbol and has not yet been removed from the input stream. When d method returns, {@code recognizer} is in error recovery mode.

<p>This method is called when {@link //singleTokenDeletion} identifies single-token deletion as a viable recovery strategy for a mismatched input error.</p>

<p>The default implementation simply returns if the handler is already in error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to enter error recovery mode, followed by calling {@link Parser//NotifyErrorListeners}.</p>

@param recognizer the parser instance

func (*DefaultErrorStrategy) SingleTokenDeletion 

func (d *DefaultErrorStrategy) SingleTokenDeletion(recognizer Parser) Token

This method implements the single-token deletion inline error recovery strategy. It is called by {@link //recoverInline} to attempt to recover from mismatched input. If this method returns nil, the parser and error handler state will not have changed. If this method returns non-nil, {@code recognizer} will <em>not</em> be in error recovery mode since the returned token was a successful Match.

<p>If the single-token deletion is successful, d method calls {@link //ReportUnwantedToken} to Report the error, followed by {@link Parser//consume} to actually "delete" the extraneous token. Then, before returning {@link //ReportMatch} is called to signal a successful Match.</p>

@param recognizer the parser instance @return the successfully Matched {@link Token} instance if single-token deletion successfully recovers from the mismatched input, otherwise {@code nil}

func (*DefaultErrorStrategy) SingleTokenInsertion 

func (d *DefaultErrorStrategy) SingleTokenInsertion(recognizer Parser) bool

This method implements the single-token insertion inline error recovery strategy. It is called by {@link //recoverInline} if the single-token deletion strategy fails to recover from the mismatched input. If this method returns {@code true}, {@code recognizer} will be in error recovery mode.

<p>This method determines whether or not single-token insertion is viable by checking if the {@code LA(1)} input symbol could be successfully Matched if it were instead the {@code LA(2)} symbol. If d method returns {@code true}, the caller is responsible for creating and inserting a token with the correct type to produce d behavior.</p>

@param recognizer the parser instance @return {@code true} if single-token insertion is a viable recovery strategy for the current mismatched input, otherwise {@code false}

func (*DefaultErrorStrategy) Sync 

func (d *DefaultErrorStrategy) Sync(recognizer Parser)

The default implementation of {@link ANTLRErrorStrategy//Sync} makes sure that the current lookahead symbol is consistent with what were expecting at d point in the ATN. You can call d anytime but ANTLR only generates code to check before subrules/loops and each iteration.

<p>Implements Jim Idle's magic Sync mechanism in closures and optional subrules. E.g.,</p>

<pre> a : Sync ( stuff Sync )* Sync : {consume to what can follow Sync} </pre>

At the start of a sub rule upon error, {@link //Sync} performs single token deletion, if possible. If it can't do that, it bails on the current rule and uses the default error recovery, which consumes until the reSynchronization set of the current rule.

<p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block with an empty alternative), then the expected set includes what follows the subrule.</p>

<p>During loop iteration, it consumes until it sees a token that can start a sub rule or what follows loop. Yes, that is pretty aggressive. We opt to stay in the loop as long as possible.</p>

<p><strong>ORIGINS</strong></p>

<p>Previous versions of ANTLR did a poor job of their recovery within loops. A single mismatch token or missing token would force the parser to bail out of the entire rules surrounding the loop. So, for rule</p>

<pre> classfunc : 'class' ID '{' member* '}' </pre>

input with an extra token between members would force the parser to consume until it found the next class definition rather than the next member definition of the current class.

<p>This functionality cost a little bit of effort because the parser has to compare token set at the start of the loop and at each iteration. If for some reason speed is suffering for you, you can turn off d functionality by simply overriding d method as a blank { }.</p>

type DiagnosticErrorListener 

type DiagnosticErrorListener struct {
	*DefaultErrorListener
	// contains filtered or unexported fields
}

func NewDiagnosticErrorListener 

func NewDiagnosticErrorListener(exactOnly bool) *DiagnosticErrorListener

func (*DiagnosticErrorListener) ReportAmbiguity 

func (d *DiagnosticErrorListener) ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ambigAlts *BitSet, configs ATNConfigSet)

func (*DiagnosticErrorListener) ReportAttemptingFullContext 

func (d *DiagnosticErrorListener) ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, conflictingAlts *BitSet, configs ATNConfigSet)

func (*DiagnosticErrorListener) ReportContextSensitivity 

func (d *DiagnosticErrorListener) ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, configs ATNConfigSet)

type DoubleDict 

type DoubleDict struct {
	// contains filtered or unexported fields
}

func NewDoubleDict 

func NewDoubleDict() *DoubleDict

func (*DoubleDict) Get 

func (d *DoubleDict) Get(a, b int) interface{}

type EmptyPredictionContext 

type EmptyPredictionContext struct {
	*BaseSingletonPredictionContext
}

func NewEmptyPredictionContext 

func NewEmptyPredictionContext() *EmptyPredictionContext

func (*EmptyPredictionContext) GetParent 

func (e *EmptyPredictionContext) GetParent(index int) PredictionContext

func (*EmptyPredictionContext) String 

func (e *EmptyPredictionContext) String() string

type EpsilonTransition 

type EpsilonTransition struct {
	*BaseTransition
	// contains filtered or unexported fields
}

func NewEpsilonTransition 

func NewEpsilonTransition(target ATNState, outermostPrecedenceReturn int) *EpsilonTransition

func (*EpsilonTransition) Matches 

func (t *EpsilonTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*EpsilonTransition) String 

func (t *EpsilonTransition) String() string

type ErrorListener 

type ErrorListener interface {
	SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, msg string, e RecognitionException)
	ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ambigAlts *BitSet, configs ATNConfigSet)
	ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, conflictingAlts *BitSet, configs ATNConfigSet)
	ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, configs ATNConfigSet)
}

type ErrorNode 

type ErrorNode interface {
	TerminalNode
	// contains filtered or unexported methods
}

type ErrorNodeImpl 

type ErrorNodeImpl struct {
	*TerminalNodeImpl
}

func NewErrorNodeImpl 

func NewErrorNodeImpl(token Token) *ErrorNodeImpl

func (*ErrorNodeImpl) Accept 

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

type ErrorStrategy 

type ErrorStrategy interface {
	RecoverInline(Parser) Token
	Recover(Parser, RecognitionException)
	Sync(Parser)

	ReportError(Parser, RecognitionException)
	ReportMatch(Parser)
	// contains filtered or unexported methods
}

type FailedPredicateException 

type FailedPredicateException struct {
	*BaseRecognitionException
	// contains filtered or unexported fields
}

func NewFailedPredicateException 

func NewFailedPredicateException(recognizer Parser, predicate string, message string) *FailedPredicateException

type FileStream 

type FileStream struct {
	*InputStream
	// contains filtered or unexported fields
}

func NewFileStream 

func NewFileStream(fileName string) (*FileStream, error)

func (*FileStream) GetSourceName 

func (f *FileStream) GetSourceName() string

type IATNSimulator 

type IATNSimulator interface {
	SharedContextCache() *PredictionContextCache
	ATN() *ATN
	DecisionToDFA() []*DFA
}

type ILexerATNSimulator 

type ILexerATNSimulator interface {
	IATNSimulator

	Match(input CharStream, mode int) int
	GetCharPositionInLine() int
	GetLine() int
	GetText(input CharStream) string
	Consume(input CharStream)
	// contains filtered or unexported methods
}

type InputMisMatchException 

type InputMisMatchException struct {
	*BaseRecognitionException
}

func NewInputMisMatchException 

func NewInputMisMatchException(recognizer Parser) *InputMisMatchException

This signifies any kind of mismatched input exceptions such as when the current input does not Match the expected token.

type InputStream 

type InputStream struct {
	// contains filtered or unexported fields
}

func NewInputStream 

func NewInputStream(data string) *InputStream

func (*InputStream) Consume 

func (is *InputStream) Consume()

func (*InputStream) GetSourceName 

func (*InputStream) GetSourceName() string

func (*InputStream) GetText 

func (is *InputStream) GetText(start int, stop int) string

func (*InputStream) GetTextFromInterval 

func (is *InputStream) GetTextFromInterval(i *Interval) string

func (*InputStream) GetTextFromTokens 

func (is *InputStream) GetTextFromTokens(start, stop Token) string

func (*InputStream) Index 

func (is *InputStream) Index() int

func (*InputStream) LA 

func (is *InputStream) LA(offset int) int

func (*InputStream) LT 

func (is *InputStream) LT(offset int) int

func (*InputStream) Mark 

func (is *InputStream) Mark() int

mark/release do nothing we have entire buffer

func (*InputStream) Release 

func (is *InputStream) Release(marker int)

func (*InputStream) Seek 

func (is *InputStream) Seek(index int)

func (*InputStream) Size 

func (is *InputStream) Size() int

func (*InputStream) String 

func (is *InputStream) String() string

type InsertAfterOp 

type InsertAfterOp struct {
	BaseRewriteOperation
}

func NewInsertAfterOp 

func NewInsertAfterOp(index int, text string, stream TokenStream) *InsertAfterOp

func (*InsertAfterOp) Execute 

func (op *InsertAfterOp) Execute(buffer *bytes.Buffer) int

func (*InsertAfterOp) String 

func (op *InsertAfterOp) String() string

type InsertBeforeOp 

type InsertBeforeOp struct {
	BaseRewriteOperation
}

func NewInsertBeforeOp 

func NewInsertBeforeOp(index int, text string, stream TokenStream) *InsertBeforeOp

func (*InsertBeforeOp) Execute 

func (op *InsertBeforeOp) Execute(buffer *bytes.Buffer) int

func (*InsertBeforeOp) String 

func (op *InsertBeforeOp) String() string

type IntStack 

type IntStack []int

func (*IntStack) Pop 

func (s *IntStack) Pop() (int, error)

func (*IntStack) Push 

func (s *IntStack) Push(e int)

type IntStream 

type IntStream interface {
	Consume()
	LA(int) int
	Mark() int
	Release(marker int)
	Index() int
	Seek(index int)
	Size() int
	GetSourceName() string
}

type InterpreterRuleContext 

type InterpreterRuleContext interface {
	ParserRuleContext
}

type Interval 

type Interval struct {
	Start int
	Stop  int
}

func NewInterval 

func NewInterval(start, stop int) *Interval

stop is not included!

func (*Interval) Contains 

func (i *Interval) Contains(item int) bool

func (*Interval) String 

func (i *Interval) String() string

type IntervalSet 

type IntervalSet struct {
	// contains filtered or unexported fields
}

func NewIntervalSet 

func NewIntervalSet() *IntervalSet

func (*IntervalSet) String 

func (i *IntervalSet) String() string

func (*IntervalSet) StringVerbose 

func (i *IntervalSet) StringVerbose(literalNames []string, symbolicNames []string, elemsAreChar bool) string

type LL1Analyzer 

type LL1Analyzer struct {
	// contains filtered or unexported fields
}

func NewLL1Analyzer 

func NewLL1Analyzer(atn *ATN) *LL1Analyzer

func (*LL1Analyzer) Look 

func (la *LL1Analyzer) Look(s, stopState ATNState, ctx RuleContext) *IntervalSet

* Compute set of tokens that can follow {@code s} in the ATN in the specified {@code ctx}.

<p>If {@code ctx} is {@code nil} and the end of the rule containing {@code s} is reached, {@link Token//EPSILON} is added to the result set. If {@code ctx} is not {@code nil} and the end of the outermost rule is reached, {@link Token//EOF} is added to the result set.</p>

@param s the ATN state @param stopState the ATN state to stop at. This can be a {@link BlockEndState} to detect epsilon paths through a closure. @param ctx the complete parser context, or {@code nil} if the context should be ignored

@return The set of tokens that can follow {@code s} in the ATN in the specified {@code ctx}. /

type Lexer 

type Lexer interface {
	TokenSource
	Recognizer

	Emit() Token

	SetChannel(int)
	PushMode(int)
	PopMode() int
	SetType(int)
	SetMode(int)
}

type LexerATNConfig 

type LexerATNConfig struct {
	*BaseATNConfig
	// contains filtered or unexported fields
}

func NewLexerATNConfig1 

func NewLexerATNConfig1(state ATNState, alt int, context PredictionContext) *LexerATNConfig

func NewLexerATNConfig2 

func NewLexerATNConfig2(c *LexerATNConfig, state ATNState, context PredictionContext) *LexerATNConfig

func NewLexerATNConfig3 

func NewLexerATNConfig3(c *LexerATNConfig, state ATNState, lexerActionExecutor *LexerActionExecutor) *LexerATNConfig

func NewLexerATNConfig4 

func NewLexerATNConfig4(c *LexerATNConfig, state ATNState) *LexerATNConfig

func NewLexerATNConfig5 

func NewLexerATNConfig5(state ATNState, alt int, context PredictionContext, lexerActionExecutor *LexerActionExecutor) *LexerATNConfig

func NewLexerATNConfig6 

func NewLexerATNConfig6(state ATNState, alt int, context PredictionContext) *LexerATNConfig

type LexerATNSimulator 

type LexerATNSimulator struct {
	*BaseATNSimulator

	Line               int
	CharPositionInLine int

	MatchCalls int
	// contains filtered or unexported fields
}

func NewLexerATNSimulator 

func NewLexerATNSimulator(recog Lexer, atn *ATN, decisionToDFA []*DFA, sharedContextCache *PredictionContextCache) *LexerATNSimulator

func (*LexerATNSimulator) Consume 

func (l *LexerATNSimulator) Consume(input CharStream)

func (*LexerATNSimulator) GetCharPositionInLine 

func (l *LexerATNSimulator) GetCharPositionInLine() int

func (*LexerATNSimulator) GetLine 

func (l *LexerATNSimulator) GetLine() int

func (*LexerATNSimulator) GetText 

func (l *LexerATNSimulator) GetText(input CharStream) string

Get the text Matched so far for the current token.

func (*LexerATNSimulator) GetTokenName 

func (l *LexerATNSimulator) GetTokenName(tt int) string

func (*LexerATNSimulator) Match 

func (l *LexerATNSimulator) Match(input CharStream, mode int) int

func (*LexerATNSimulator) MatchATN 

func (l *LexerATNSimulator) MatchATN(input CharStream) int

type LexerAction 

type LexerAction interface {
	// contains filtered or unexported methods
}

type LexerActionExecutor 

type LexerActionExecutor struct {
	// contains filtered or unexported fields
}

func LexerActionExecutorappend 

func LexerActionExecutorappend(lexerActionExecutor *LexerActionExecutor, lexerAction LexerAction) *LexerActionExecutor

Creates a {@link LexerActionExecutor} which executes the actions for the input {@code lexerActionExecutor} followed by a specified {@code lexerAction}.

@param lexerActionExecutor The executor for actions already traversed by the lexer while Matching a token within a particular {@link LexerATNConfig}. If this is {@code nil}, the method behaves as though it were an empty executor. @param lexerAction The lexer action to execute after the actions specified in {@code lexerActionExecutor}.

@return A {@link LexerActionExecutor} for executing the combine actions of {@code lexerActionExecutor} and {@code lexerAction}.

func NewLexerActionExecutor 

func NewLexerActionExecutor(lexerActions []LexerAction) *LexerActionExecutor

type LexerChannelAction 

type LexerChannelAction struct {
	*BaseLexerAction
	// contains filtered or unexported fields
}

Implements the {@code channel} lexer action by calling {@link Lexer//setChannel} with the assigned channel. Constructs a New{@code channel} action with the specified channel value. @param channel The channel value to pass to {@link Lexer//setChannel}.

func NewLexerChannelAction 

func NewLexerChannelAction(channel int) *LexerChannelAction

func (*LexerChannelAction) String 

func (l *LexerChannelAction) String() string

type LexerCustomAction 

type LexerCustomAction struct {
	*BaseLexerAction
	// contains filtered or unexported fields
}

func NewLexerCustomAction 

func NewLexerCustomAction(ruleIndex, actionIndex int) *LexerCustomAction

type LexerDFASerializer 

type LexerDFASerializer struct {
	*DFASerializer
}

func NewLexerDFASerializer 

func NewLexerDFASerializer(dfa *DFA) *LexerDFASerializer

func (*LexerDFASerializer) String 

func (l *LexerDFASerializer) String() string

type LexerIndexedCustomAction 

type LexerIndexedCustomAction struct {
	*BaseLexerAction
	// contains filtered or unexported fields
}

Constructs a Newindexed custom action by associating a character offset with a {@link LexerAction}.

<p>Note: This class is only required for lexer actions for which {@link LexerAction//isPositionDependent} returns {@code true}.</p>

@param offset The offset into the input {@link CharStream}, relative to the token start index, at which the specified lexer action should be executed. @param action The lexer action to execute at a particular offset in the input {@link CharStream}.

func NewLexerIndexedCustomAction 

func NewLexerIndexedCustomAction(offset int, lexerAction LexerAction) *LexerIndexedCustomAction

type LexerModeAction 

type LexerModeAction struct {
	*BaseLexerAction
	// contains filtered or unexported fields
}

Implements the {@code mode} lexer action by calling {@link Lexer//mode} with the assigned mode.

func NewLexerModeAction 

func NewLexerModeAction(mode int) *LexerModeAction

func (*LexerModeAction) String 

func (l *LexerModeAction) String() string

type LexerMoreAction 

type LexerMoreAction struct {
	*BaseLexerAction
}

func NewLexerMoreAction 

func NewLexerMoreAction() *LexerMoreAction

func (*LexerMoreAction) String 

func (l *LexerMoreAction) String() string

type LexerNoViableAltException 

type LexerNoViableAltException struct {
	*BaseRecognitionException
	// contains filtered or unexported fields
}

func NewLexerNoViableAltException 

func NewLexerNoViableAltException(lexer Lexer, input CharStream, startIndex int, deadEndConfigs ATNConfigSet) *LexerNoViableAltException

func (*LexerNoViableAltException) String 

func (l *LexerNoViableAltException) String() string

type LexerPopModeAction 

type LexerPopModeAction struct {
	*BaseLexerAction
}

Implements the {@code popMode} lexer action by calling {@link Lexer//popMode}.

<p>The {@code popMode} command does not have any parameters, so l action is implemented as a singleton instance exposed by {@link //INSTANCE}.</p>

func NewLexerPopModeAction 

func NewLexerPopModeAction() *LexerPopModeAction

func (*LexerPopModeAction) String 

func (l *LexerPopModeAction) String() string

type LexerPushModeAction 

type LexerPushModeAction struct {
	*BaseLexerAction
	// contains filtered or unexported fields
}

Implements the {@code pushMode} lexer action by calling {@link Lexer//pushMode} with the assigned mode.

func NewLexerPushModeAction 

func NewLexerPushModeAction(mode int) *LexerPushModeAction

func (*LexerPushModeAction) String 

func (l *LexerPushModeAction) String() string

type LexerSkipAction 

type LexerSkipAction struct {
	*BaseLexerAction
}

Implements the {@code Skip} lexer action by calling {@link Lexer//Skip}.

<p>The {@code Skip} command does not have any parameters, so l action is implemented as a singleton instance exposed by {@link //INSTANCE}.</p>

func NewLexerSkipAction 

func NewLexerSkipAction() *LexerSkipAction

func (*LexerSkipAction) String 

func (l *LexerSkipAction) String() string

type LexerTypeAction 

type LexerTypeAction struct {
	*BaseLexerAction
	// contains filtered or unexported fields
}
Implements the {@code type} lexer action by calling {@link Lexer//setType}

with the assigned type.

func NewLexerTypeAction 

func NewLexerTypeAction(thetype int) *LexerTypeAction

func (*LexerTypeAction) String 

func (l *LexerTypeAction) String() string

type LoopEndState 

type LoopEndState struct {
	*BaseATNState
	// contains filtered or unexported fields
}

LoopEndState marks the end of a * or + loop.

func NewLoopEndState 

func NewLoopEndState() *LoopEndState

type LoopEndStateIntPair 

type LoopEndStateIntPair struct {
	// contains filtered or unexported fields
}

type NoViableAltException 

type NoViableAltException struct {
	*BaseRecognitionException
	// contains filtered or unexported fields
}

func NewNoViableAltException 

func NewNoViableAltException(recognizer Parser, input TokenStream, startToken Token, offendingToken Token, deadEndConfigs ATNConfigSet, ctx ParserRuleContext) *NoViableAltException

Indicates that the parser could not decide which of two or more paths to take based upon the remaining input. It tracks the starting token of the offending input and also knows where the parser was in the various paths when the error. Reported by ReportNoViableAlternative()

type NotSetTransition 

type NotSetTransition struct {
	*SetTransition
}

func NewNotSetTransition 

func NewNotSetTransition(target ATNState, set *IntervalSet) *NotSetTransition

func (*NotSetTransition) Matches 

func (t *NotSetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*NotSetTransition) String 

func (t *NotSetTransition) String() string

type OR 

type OR struct {
	// contains filtered or unexported fields
}

func NewOR 

func NewOR(a, b SemanticContext) *OR

func (*OR) String 

func (o *OR) String() string

type OrderedATNConfigSet 

type OrderedATNConfigSet struct {
	*BaseATNConfigSet
}

func NewOrderedATNConfigSet 

func NewOrderedATNConfigSet() *OrderedATNConfigSet

type ParseCancellationException 

type ParseCancellationException struct {
}

func NewParseCancellationException 

func NewParseCancellationException() *ParseCancellationException

type ParseTree 

type ParseTree interface {
	SyntaxTree

	Accept(Visitor ParseTreeVisitor) interface{}
	GetText() string

	ToStringTree([]string, Recognizer) string
}

func TreesDescendants 

func TreesDescendants(t ParseTree) []ParseTree

func TreesFindAllTokenNodes 

func TreesFindAllTokenNodes(t ParseTree, ttype int) []ParseTree

func TreesfindAllNodes 

func TreesfindAllNodes(t ParseTree, index int, findTokens bool) []ParseTree

func TreesfindAllRuleNodes 

func TreesfindAllRuleNodes(t ParseTree, ruleIndex int) []ParseTree

type ParseTreeListener 

type ParseTreeListener interface {
	VisitTerminal(node TerminalNode)
	VisitErrorNode(node ErrorNode)
	EnterEveryRule(ctx ParserRuleContext)
	ExitEveryRule(ctx ParserRuleContext)
}

type ParseTreeVisitor 

type ParseTreeVisitor interface {
	Visit(tree ParseTree) interface{}
	VisitChildren(node RuleNode) interface{}
	VisitTerminal(node TerminalNode) interface{}
	VisitErrorNode(node ErrorNode) interface{}
}

type ParseTreeWalker 

type ParseTreeWalker struct {
}

func NewParseTreeWalker 

func NewParseTreeWalker() *ParseTreeWalker

func (*ParseTreeWalker) EnterRule 

func (p *ParseTreeWalker) EnterRule(listener ParseTreeListener, r RuleNode)

Enters a grammar rule by first triggering the generic event {@link ParseTreeListener//EnterEveryRule} then by triggering the event specific to the given parse tree node

func (*ParseTreeWalker) ExitRule 

func (p *ParseTreeWalker) ExitRule(listener ParseTreeListener, r RuleNode)

Exits a grammar rule by first triggering the event specific to the given parse tree node then by triggering the generic event {@link ParseTreeListener//ExitEveryRule}

func (*ParseTreeWalker) Walk 

func (p *ParseTreeWalker) Walk(listener ParseTreeListener, t Tree)

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.

type Parser 

type Parser interface {
	Recognizer

	GetInterpreter() *ParserATNSimulator

	GetTokenStream() TokenStream
	GetTokenFactory() TokenFactory
	GetParserRuleContext() ParserRuleContext
	SetParserRuleContext(ParserRuleContext)
	Consume() Token
	GetParseListeners() []ParseTreeListener

	GetErrorHandler() ErrorStrategy
	SetErrorHandler(ErrorStrategy)
	GetInputStream() IntStream
	GetCurrentToken() Token
	GetExpectedTokens() *IntervalSet
	NotifyErrorListeners(string, Token, RecognitionException)
	IsExpectedToken(int) bool
	GetPrecedence() int
	GetRuleInvocationStack(ParserRuleContext) []string
}

type ParserATNSimulator 

type ParserATNSimulator struct {
	*BaseATNSimulator
	// contains filtered or unexported fields
}

func NewParserATNSimulator 

func NewParserATNSimulator(parser Parser, atn *ATN, decisionToDFA []*DFA, sharedContextCache *PredictionContextCache) *ParserATNSimulator

func (*ParserATNSimulator) AdaptivePredict 

func (p *ParserATNSimulator) AdaptivePredict(input TokenStream, decision int, outerContext ParserRuleContext) int

func (*ParserATNSimulator) GetAltThatFinishedDecisionEntryRule 

func (p *ParserATNSimulator) GetAltThatFinishedDecisionEntryRule(configs ATNConfigSet) int

func (*ParserATNSimulator) GetPredictionMode 

func (p *ParserATNSimulator) GetPredictionMode() int

func (*ParserATNSimulator) GetTokenName 

func (p *ParserATNSimulator) GetTokenName(t int) string

func (*ParserATNSimulator) ReportAmbiguity 

func (p *ParserATNSimulator) ReportAmbiguity(dfa *DFA, D *DFAState, startIndex, stopIndex int,
	exact bool, ambigAlts *BitSet, configs ATNConfigSet)

If context sensitive parsing, we know it's ambiguity not conflict//

func (*ParserATNSimulator) ReportAttemptingFullContext 

func (p *ParserATNSimulator) ReportAttemptingFullContext(dfa *DFA, conflictingAlts *BitSet, configs ATNConfigSet, startIndex, stopIndex int)

func (*ParserATNSimulator) ReportContextSensitivity 

func (p *ParserATNSimulator) ReportContextSensitivity(dfa *DFA, prediction int, configs ATNConfigSet, startIndex, stopIndex int)

func (*ParserATNSimulator) SetPredictionMode 

func (p *ParserATNSimulator) SetPredictionMode(v int)

type ParserRuleContext 

type ParserRuleContext interface {
	RuleContext

	SetException(RecognitionException)

	AddTokenNode(token Token) *TerminalNodeImpl
	AddErrorNode(badToken Token) *ErrorNodeImpl

	EnterRule(listener ParseTreeListener)
	ExitRule(listener ParseTreeListener)

	SetStart(Token)
	GetStart() Token

	SetStop(Token)
	GetStop() Token

	AddChild(child RuleContext) RuleContext
	RemoveLastChild()
}

type PlusBlockStartState 

type PlusBlockStartState struct {
	*BaseBlockStartState
	// contains filtered or unexported fields
}

PlusBlockStartState is the start of a (A|B|...)+ loop. Technically it is a decision state; we don't use it for code generation. Somebody might need it, it is included for completeness. In reality, PlusLoopbackState is the real decision-making node for A+.

func NewPlusBlockStartState 

func NewPlusBlockStartState() *PlusBlockStartState

type PlusLoopbackState 

type PlusLoopbackState struct {
	*BaseDecisionState
}

PlusLoopbackState is a decision state for A+ and (A|B)+. It has two transitions: one to the loop back to start of the block, and one to exit.

func NewPlusLoopbackState 

func NewPlusLoopbackState() *PlusLoopbackState

type PrecedencePredicate 

type PrecedencePredicate struct {
	// contains filtered or unexported fields
}

func NewPrecedencePredicate 

func NewPrecedencePredicate(precedence int) *PrecedencePredicate

func PrecedencePredicatefilterPrecedencePredicates 

func PrecedencePredicatefilterPrecedencePredicates(set *Set) []*PrecedencePredicate

func (*PrecedencePredicate) String 

func (p *PrecedencePredicate) String() string

type PrecedencePredicateTransition 

type PrecedencePredicateTransition struct {
	*BaseAbstractPredicateTransition
	// contains filtered or unexported fields
}

func NewPrecedencePredicateTransition 

func NewPrecedencePredicateTransition(target ATNState, precedence int) *PrecedencePredicateTransition

func (*PrecedencePredicateTransition) Matches 

func (t *PrecedencePredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*PrecedencePredicateTransition) String 

func (t *PrecedencePredicateTransition) String() string

type PredPrediction 

type PredPrediction struct {
	// contains filtered or unexported fields
}

PredPrediction maps a predicate to a predicted alternative.

func NewPredPrediction 

func NewPredPrediction(pred SemanticContext, alt int) *PredPrediction

func (*PredPrediction) String 

func (p *PredPrediction) String() string

type Predicate 

type Predicate struct {
	// contains filtered or unexported fields
}

func NewPredicate 

func NewPredicate(ruleIndex, predIndex int, isCtxDependent bool) *Predicate

func (*Predicate) String 

func (p *Predicate) String() string

type PredicateTransition 

type PredicateTransition struct {
	*BaseAbstractPredicateTransition
	// contains filtered or unexported fields
}

func NewPredicateTransition 

func NewPredicateTransition(target ATNState, ruleIndex, predIndex int, isCtxDependent bool) *PredicateTransition

func (*PredicateTransition) Matches 

func (t *PredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*PredicateTransition) String 

func (t *PredicateTransition) String() string

type PredictionContext 

type PredictionContext interface {
	GetParent(int) PredictionContext

	String() string
	// contains filtered or unexported methods
}

func SingletonBasePredictionContextCreate 

func SingletonBasePredictionContextCreate(parent PredictionContext, returnState int) PredictionContext

type PredictionContextCache 

type PredictionContextCache struct {
	// contains filtered or unexported fields
}

func NewPredictionContextCache 

func NewPredictionContextCache() *PredictionContextCache

func (*PredictionContextCache) Get 

func (p *PredictionContextCache) Get(ctx PredictionContext) PredictionContext

type ProxyErrorListener 

type ProxyErrorListener struct {
	*DefaultErrorListener
	// contains filtered or unexported fields
}

func NewProxyErrorListener 

func NewProxyErrorListener(delegates []ErrorListener) *ProxyErrorListener

func (*ProxyErrorListener) ReportAmbiguity 

func (p *ProxyErrorListener) ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ambigAlts *BitSet, configs ATNConfigSet)

func (*ProxyErrorListener) ReportAttemptingFullContext 

func (p *ProxyErrorListener) ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, conflictingAlts *BitSet, configs ATNConfigSet)

func (*ProxyErrorListener) ReportContextSensitivity 

func (p *ProxyErrorListener) ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, configs ATNConfigSet)

func (*ProxyErrorListener) SyntaxError 

func (p *ProxyErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, msg string, e RecognitionException)

type RangeTransition 

type RangeTransition struct {
	*BaseTransition
	// contains filtered or unexported fields
}

func NewRangeTransition 

func NewRangeTransition(target ATNState, start, stop int) *RangeTransition

func (*RangeTransition) Matches 

func (t *RangeTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*RangeTransition) String 

func (t *RangeTransition) String() string

type RecognitionException 

type RecognitionException interface {
	GetOffendingToken() Token
	GetMessage() string
	GetInputStream() IntStream
}

type Recognizer 

type Recognizer interface {
	GetLiteralNames() []string
	GetSymbolicNames() []string
	GetRuleNames() []string

	Sempred(RuleContext, int, int) bool
	Precpred(RuleContext, int) bool

	GetState() int
	SetState(int)
	Action(RuleContext, int, int)
	AddErrorListener(ErrorListener)
	RemoveErrorListeners()
	GetATN() *ATN
	GetErrorListenerDispatch() ErrorListener
}

type ReplaceOp 

type ReplaceOp struct {
	BaseRewriteOperation
	LastIndex int
}

I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp instructions.

func NewReplaceOp 

func NewReplaceOp(from, to int, text string, stream TokenStream) *ReplaceOp

func (*ReplaceOp) Execute 

func (op *ReplaceOp) Execute(buffer *bytes.Buffer) int

func (*ReplaceOp) String 

func (op *ReplaceOp) String() string

type RewriteOperation 

type RewriteOperation interface {
	// Execute the rewrite operation by possibly adding to the buffer.
	// Return the index of the next token to operate on.
	Execute(buffer *bytes.Buffer) int
	String() string
	GetInstructionIndex() int
	GetIndex() int
	GetText() string
	GetOpName() string
	GetTokens() TokenStream
	SetInstructionIndex(val int)
	SetIndex(int)
	SetText(string)
	SetOpName(string)
	SetTokens(TokenStream)
}

type RuleContext 

type RuleContext interface {
	RuleNode

	GetInvokingState() int
	SetInvokingState(int)

	GetRuleIndex() int
	IsEmpty() bool

	GetAltNumber() int
	SetAltNumber(altNumber int)

	String([]string, RuleContext) string
}

type RuleNode 

type RuleNode interface {
	ParseTree

	GetRuleContext() RuleContext
	GetBaseRuleContext() *BaseRuleContext
}

type RuleStartState 

type RuleStartState struct {
	*BaseATNState
	// contains filtered or unexported fields
}

func NewRuleStartState 

func NewRuleStartState() *RuleStartState

type RuleStopState 

type RuleStopState struct {
	*BaseATNState
}

RuleStopState is the last node in the ATN for a rule, unless that rule is the start symbol. In that case, there is one transition to EOF. Later, we might encode references to all calls to this rule to compute FOLLOW sets for error handling.

func NewRuleStopState 

func NewRuleStopState() *RuleStopState

type RuleTransition 

type RuleTransition struct {
	*BaseTransition
	// contains filtered or unexported fields
}

func NewRuleTransition 

func NewRuleTransition(ruleStart ATNState, ruleIndex, precedence int, followState ATNState) *RuleTransition

func (*RuleTransition) Matches 

func (t *RuleTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

type SemanticContext 

type SemanticContext interface {
	String() string
	// contains filtered or unexported methods
}
var SemanticContextNone SemanticContext = NewPredicate(-1, -1, false)

func SemanticContextandContext 

func SemanticContextandContext(a, b SemanticContext) SemanticContext

func SemanticContextorContext 

func SemanticContextorContext(a, b SemanticContext) SemanticContext

type Set 

type Set struct {
	// contains filtered or unexported fields
}

func NewSet 

func NewSet(
	hashcodeFunction func(interface{}) int,
	equalsFunction func(interface{}, interface{}) bool) *Set

func (*Set) String 

func (s *Set) String() string

type SetTransition 

type SetTransition struct {
	*BaseTransition
}

func NewSetTransition 

func NewSetTransition(target ATNState, set *IntervalSet) *SetTransition

func (*SetTransition) Matches 

func (t *SetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*SetTransition) String 

func (t *SetTransition) String() string

type SimState 

type SimState struct {
	// contains filtered or unexported fields
}

func NewSimState 

func NewSimState() *SimState

type SingletonPredictionContext 

type SingletonPredictionContext interface {
	PredictionContext
}

type StarBlockStartState 

type StarBlockStartState struct {
	*BaseBlockStartState
}

StarBlockStartState is the block that begins a closure loop.

func NewStarBlockStartState 

func NewStarBlockStartState() *StarBlockStartState

type StarLoopEntryState 

type StarLoopEntryState struct {
	*BaseDecisionState
	// contains filtered or unexported fields
}

func NewStarLoopEntryState 

func NewStarLoopEntryState() *StarLoopEntryState

type StarLoopbackState 

type StarLoopbackState struct {
	*BaseATNState
}

func NewStarLoopbackState 

func NewStarLoopbackState() *StarLoopbackState

type SyntaxTree 

type SyntaxTree interface {
	Tree

	GetSourceInterval() *Interval
}

type TerminalNode 

type TerminalNode interface {
	ParseTree

	GetSymbol() Token
}

type TerminalNodeImpl 

type TerminalNodeImpl struct {
	// contains filtered or unexported fields
}

func NewTerminalNodeImpl 

func NewTerminalNodeImpl(symbol Token) *TerminalNodeImpl

func (*TerminalNodeImpl) Accept 

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

func (*TerminalNodeImpl) GetChild 

func (t *TerminalNodeImpl) GetChild(i int) Tree

func (*TerminalNodeImpl) GetChildCount 

func (t *TerminalNodeImpl) GetChildCount() int

func (*TerminalNodeImpl) GetChildren 

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

func (*TerminalNodeImpl) GetParent 

func (t *TerminalNodeImpl) GetParent() Tree

func (*TerminalNodeImpl) GetPayload 

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

func (*TerminalNodeImpl) GetSourceInterval 

func (t *TerminalNodeImpl) GetSourceInterval() *Interval

func (*TerminalNodeImpl) GetSymbol 

func (t *TerminalNodeImpl) GetSymbol() Token

func (*TerminalNodeImpl) GetText 

func (t *TerminalNodeImpl) GetText() string

func (*TerminalNodeImpl) SetChildren 

func (t *TerminalNodeImpl) SetChildren(tree []Tree)

func (*TerminalNodeImpl) SetParent 

func (t *TerminalNodeImpl) SetParent(tree Tree)

func (*TerminalNodeImpl) String 

func (t *TerminalNodeImpl) String() string

func (*TerminalNodeImpl) ToStringTree 

func (t *TerminalNodeImpl) ToStringTree(s []string, r Recognizer) string

type Token 

type Token interface {
	GetSource() *TokenSourceCharStreamPair
	GetTokenType() int
	GetChannel() int
	GetStart() int
	GetStop() int
	GetLine() int
	GetColumn() int

	GetText() string
	SetText(s string)

	GetTokenIndex() int
	SetTokenIndex(v int)

	GetTokenSource() TokenSource
	GetInputStream() CharStream
}

type TokenFactory 

type TokenFactory interface {
	Create(source *TokenSourceCharStreamPair, ttype int, text string, channel, start, stop, line, column int) Token
}

TokenFactory creates CommonToken objects.

type TokenSource 

type TokenSource interface {
	NextToken() Token
	Skip()
	More()
	GetLine() int
	GetCharPositionInLine() int
	GetInputStream() CharStream
	GetSourceName() string

	GetTokenFactory() TokenFactory
	// contains filtered or unexported methods
}

type TokenSourceCharStreamPair 

type TokenSourceCharStreamPair struct {
	// contains filtered or unexported fields
}

type TokenStream 

type TokenStream interface {
	IntStream

	LT(k int) Token

	Get(index int) Token
	GetTokenSource() TokenSource
	SetTokenSource(TokenSource)

	GetAllText() string
	GetTextFromInterval(*Interval) string
	GetTextFromRuleContext(RuleContext) string
	GetTextFromTokens(Token, Token) string
}

type TokenStreamRewriter 

type TokenStreamRewriter struct {
	// contains filtered or unexported fields
}

func NewTokenStreamRewriter 

func NewTokenStreamRewriter(tokens TokenStream) *TokenStreamRewriter

func (*TokenStreamRewriter) AddToProgram 

func (tsr *TokenStreamRewriter) AddToProgram(name string, op RewriteOperation)

func (*TokenStreamRewriter) Delete 

func (tsr *TokenStreamRewriter) Delete(program_name string, from, to int)

func (*TokenStreamRewriter) DeleteDefault 

func (tsr *TokenStreamRewriter) DeleteDefault(from, to int)

func (*TokenStreamRewriter) DeleteDefaultPos 

func (tsr *TokenStreamRewriter) DeleteDefaultPos(index int)

func (*TokenStreamRewriter) DeleteProgram 

func (tsr *TokenStreamRewriter) DeleteProgram(program_name string)

Reset the program so that no instructions exist

func (*TokenStreamRewriter) DeleteProgramDefault 

func (tsr *TokenStreamRewriter) DeleteProgramDefault()

func (*TokenStreamRewriter) DeleteToken 

func (tsr *TokenStreamRewriter) DeleteToken(program_name string, from, to Token)

func (*TokenStreamRewriter) DeleteTokenDefault 

func (tsr *TokenStreamRewriter) DeleteTokenDefault(from, to Token)

func (*TokenStreamRewriter) GetLastRewriteTokenIndex 

func (tsr *TokenStreamRewriter) GetLastRewriteTokenIndex(program_name string) int

func (*TokenStreamRewriter) GetLastRewriteTokenIndexDefault 

func (tsr *TokenStreamRewriter) GetLastRewriteTokenIndexDefault() int

func (*TokenStreamRewriter) GetProgram 

func (tsr *TokenStreamRewriter) GetProgram(name string) []RewriteOperation

func (*TokenStreamRewriter) GetText 

func (tsr *TokenStreamRewriter) GetText(program_name string, interval *Interval) string

Return the text from the original tokens altered per the instructions given to this rewriter.

func (*TokenStreamRewriter) GetTextDefault 

func (tsr *TokenStreamRewriter) GetTextDefault() string

Return the text from the original tokens altered per the instructions given to this rewriter.

func (*TokenStreamRewriter) GetTokenStream 

func (tsr *TokenStreamRewriter) GetTokenStream() TokenStream

func (*TokenStreamRewriter) InitializeProgram 

func (tsr *TokenStreamRewriter) InitializeProgram(name string) []RewriteOperation

func (*TokenStreamRewriter) InsertAfter 

func (tsr *TokenStreamRewriter) InsertAfter(program_name string, index int, text string)

func (*TokenStreamRewriter) InsertAfterDefault 

func (tsr *TokenStreamRewriter) InsertAfterDefault(index int, text string)

func (*TokenStreamRewriter) InsertAfterToken 

func (tsr *TokenStreamRewriter) InsertAfterToken(program_name string, token Token, text string)

func (*TokenStreamRewriter) InsertBefore 

func (tsr *TokenStreamRewriter) InsertBefore(program_name string, index int, text string)

func (*TokenStreamRewriter) InsertBeforeDefault 

func (tsr *TokenStreamRewriter) InsertBeforeDefault(index int, text string)

func (*TokenStreamRewriter) InsertBeforeToken 

func (tsr *TokenStreamRewriter) InsertBeforeToken(program_name string, token Token, text string)

func (*TokenStreamRewriter) Replace 

func (tsr *TokenStreamRewriter) Replace(program_name string, from, to int, text string)

func (*TokenStreamRewriter) ReplaceDefault 

func (tsr *TokenStreamRewriter) ReplaceDefault(from, to int, text string)

func (*TokenStreamRewriter) ReplaceDefaultPos 

func (tsr *TokenStreamRewriter) ReplaceDefaultPos(index int, text string)

func (*TokenStreamRewriter) ReplaceToken 

func (tsr *TokenStreamRewriter) ReplaceToken(program_name string, from, to Token, text string)

func (*TokenStreamRewriter) ReplaceTokenDefault 

func (tsr *TokenStreamRewriter) ReplaceTokenDefault(from, to Token, text string)

func (*TokenStreamRewriter) ReplaceTokenDefaultPos 

func (tsr *TokenStreamRewriter) ReplaceTokenDefaultPos(index Token, text string)

func (*TokenStreamRewriter) Rollback 

func (tsr *TokenStreamRewriter) Rollback(program_name string, instruction_index int)

Rollback the instruction stream for a program so that the indicated instruction (via instructionIndex) is no longer in the stream. UNTESTED!

func (*TokenStreamRewriter) RollbackDefault 

func (tsr *TokenStreamRewriter) RollbackDefault(instruction_index int)

func (*TokenStreamRewriter) SetLastRewriteTokenIndex 

func (tsr *TokenStreamRewriter) SetLastRewriteTokenIndex(program_name string, i int)

type TokensStartState 

type TokensStartState struct {
	*BaseDecisionState
}

TokensStartState is the Tokens rule start state linking to each lexer rule start state.

func NewTokensStartState 

func NewTokensStartState() *TokensStartState

type TraceListener 

type TraceListener struct {
	// contains filtered or unexported fields
}

func NewTraceListener 

func NewTraceListener(parser *BaseParser) *TraceListener

func (*TraceListener) EnterEveryRule 

func (t *TraceListener) EnterEveryRule(ctx ParserRuleContext)

func (*TraceListener) ExitEveryRule 

func (t *TraceListener) ExitEveryRule(ctx ParserRuleContext)

func (*TraceListener) VisitErrorNode 

func (t *TraceListener) VisitErrorNode(_ ErrorNode)

func (*TraceListener) VisitTerminal 

func (t *TraceListener) VisitTerminal(node TerminalNode)

type Transition 

type Transition interface {
	Matches(int, int, int) bool
	// contains filtered or unexported methods
}

type Tree 

type Tree interface {
	GetParent() Tree
	SetParent(Tree)
	GetPayload() interface{}
	GetChild(i int) Tree
	GetChildCount() int
	GetChildren() []Tree
}

func TreesGetChildren 

func TreesGetChildren(t Tree) []Tree

Return ordered list of all children of this node

func TreesgetAncestors 

func TreesgetAncestors(t Tree) []Tree

Return a list of all ancestors of this node. The first node of 

list is the root and the last is the parent of this node.

type WildcardTransition 

type WildcardTransition struct {
	*BaseTransition
}

func NewWildcardTransition 

func NewWildcardTransition(target ATNState) *WildcardTransition

func (*WildcardTransition) Matches 

func (t *WildcardTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool

func (*WildcardTransition) String 

func (t *WildcardTransition) String() 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.