From b4da149732b0e37ca54efcb20369c4df869e0690 Mon Sep 17 00:00:00 2001 From: Will Faught Date: Sat, 21 May 2016 01:02:49 -0700 Subject: [PATCH] Lint: Remove underscores from names --- runtime/Go/antlr/atn_deserializer.go | 2 +- runtime/Go/antlr/common_token_stream.go | 8 +- runtime/Go/antlr/dfa.go | 12 +- runtime/Go/antlr/lexer.go | 168 +++++++++-------- runtime/Go/antlr/lexer_action.go | 14 +- runtime/Go/antlr/lexer_atn_simulator.go | 40 ++--- runtime/Go/antlr/ll1_analyzer.go | 30 ++-- runtime/Go/antlr/parser.go | 220 +++++++++++------------ runtime/Go/antlr/parser_atn_simulator.go | 82 ++++----- runtime/Go/antlr/prediction_context.go | 44 ++--- runtime/Go/antlr/recognizer.go | 10 +- runtime/Go/antlr/token.go | 10 +- runtime/Go/antlr/trace_listener.go | 6 +- runtime/Go/antlr/transition.go | 42 ++--- runtime/Go/antlr/trees.go | 6 +- 15 files changed, 345 insertions(+), 349 deletions(-) diff --git a/runtime/Go/antlr/atn_deserializer.go b/runtime/Go/antlr/atn_deserializer.go index c2cbea032..242425acc 100644 --- a/runtime/Go/antlr/atn_deserializer.go +++ b/runtime/Go/antlr/atn_deserializer.go @@ -614,7 +614,7 @@ func (a *ATNDeserializer) edgeFactory(atn *ATN, typeIndex, src, trg, arg1, arg2, return NewActionTransition(target, arg1, arg2, arg3 != 0) case TransitionSET: return NewSetTransition(target, sets[arg1]) - case TransitionNOT_SET: + case TransitionNOTSET: return NewNotSetTransition(target, sets[arg1]) case TransitionWILDCARD: return NewWildcardTransition(target) diff --git a/runtime/Go/antlr/common_token_stream.go b/runtime/Go/antlr/common_token_stream.go index aa520dd39..8aed01b46 100644 --- a/runtime/Go/antlr/common_token_stream.go +++ b/runtime/Go/antlr/common_token_stream.go @@ -261,7 +261,7 @@ func (c *CommonTokenStream) getHiddenTokensToRight(tokenIndex, channel int) []To panic(strconv.Itoa(tokenIndex) + " not in 0.." + strconv.Itoa(len(c.tokens)-1)) } var nextOnChannel = c.NextTokenOnChannel(tokenIndex+1, LexerDefaultTokenChannel) - var from_ = tokenIndex + 1 + var from = tokenIndex + 1 // if none onchannel to right, nextOnChannel=-1 so set to = last token var to int if nextOnChannel == -1 { @@ -269,7 +269,7 @@ func (c *CommonTokenStream) getHiddenTokensToRight(tokenIndex, channel int) []To } else { to = nextOnChannel } - return c.filterForChannel(from_, to, channel) + return c.filterForChannel(from, to, channel) } // Collect all tokens on specified channel to the left of @@ -285,9 +285,9 @@ func (c *CommonTokenStream) getHiddenTokensToLeft(tokenIndex, channel int) []Tok return nil } // if none on channel to left, prevOnChannel=-1 then from=0 - var from_ = prevOnChannel + 1 + var from = prevOnChannel + 1 var to = tokenIndex - 1 - return c.filterForChannel(from_, to, channel) + return c.filterForChannel(from, to, channel) } func (c *CommonTokenStream) filterForChannel(left, right, channel int) []Token { diff --git a/runtime/Go/antlr/dfa.go b/runtime/Go/antlr/dfa.go index 2d70052c5..6efbf1392 100644 --- a/runtime/Go/antlr/dfa.go +++ b/runtime/Go/antlr/dfa.go @@ -5,7 +5,7 @@ import "sort" type DFA struct { atnStartState DecisionState decision int - _states map[string]*DFAState + states map[string]*DFAState s0 *DFAState precedenceDfa bool } @@ -19,7 +19,7 @@ func NewDFA(atnStartState DecisionState, decision int) *DFA { d.decision = decision // A set of all DFA states. Use {@link Map} so we can get old state back // ({@link Set} only allows you to see if it's there). - d._states = make(map[string]*DFAState) + d.states = make(map[string]*DFAState) d.s0 = nil // {@code true} if d DFA is for a precedence decision otherwise, // {@code false}. This is the backing field for {@link //isPrecedenceDfa}, @@ -98,7 +98,7 @@ func (d *DFA) setPrecedenceStartState(precedence int, startState *DFAState) { func (d *DFA) setPrecedenceDfa(precedenceDfa bool) { if d.precedenceDfa != precedenceDfa { - d._states = make(map[string]*DFAState) + d.states = make(map[string]*DFAState) if precedenceDfa { var precedenceState = NewDFAState(-1, NewBaseATNConfigSet(false)) precedenceState.edges = make([]*DFAState, 0) @@ -113,7 +113,7 @@ func (d *DFA) setPrecedenceDfa(precedenceDfa bool) { } func (d *DFA) GetStates() map[string]*DFAState { - return d._states + return d.states } type DFAStateList []*DFAState @@ -126,9 +126,9 @@ func (a DFAStateList) Less(i, j int) bool { return a[i].stateNumber < a[j].state func (d *DFA) sortedStates() []*DFAState { // extract the values - vs := make([]*DFAState, len(d._states)) + vs := make([]*DFAState, len(d.states)) i := 0 - for _, v := range d._states { + for _, v := range d.states { vs[i] = v i++ } diff --git a/runtime/Go/antlr/lexer.go b/runtime/Go/antlr/lexer.go index 4029268be..8e171d0f8 100644 --- a/runtime/Go/antlr/lexer.go +++ b/runtime/Go/antlr/lexer.go @@ -31,16 +31,16 @@ type BaseLexer struct { TokenStartColumn int ActionType int - _input CharStream - _factory TokenFactory - _tokenFactorySourcePair *TokenSourceCharStreamPair - _token Token - _hitEOF bool - _channel int - _type int - _modeStack IntStack - _mode int - _text string + input CharStream + factory TokenFactory + tokenFactorySourcePair *TokenSourceCharStreamPair + token Token + hitEOF bool + channel int + thetype int + modeStack IntStack + mode int + text string } func NewBaseLexer(input CharStream) *BaseLexer { @@ -49,9 +49,9 @@ func NewBaseLexer(input CharStream) *BaseLexer { lexer.BaseRecognizer = NewBaseRecognizer() - lexer._input = input - lexer._factory = CommonTokenFactoryDEFAULT - lexer._tokenFactorySourcePair = &TokenSourceCharStreamPair{lexer, input} + lexer.input = input + lexer.factory = CommonTokenFactoryDEFAULT + lexer.tokenFactorySourcePair = &TokenSourceCharStreamPair{lexer, input} lexer.Interpreter = nil // child classes must populate it @@ -62,7 +62,7 @@ func NewBaseLexer(input CharStream) *BaseLexer { // emissions, then set l to the last token to be Matched or // something nonnil so that the auto token emit mechanism will not // emit another token. - lexer._token = nil + lexer.token = nil // What character index in the stream did the current token start at? // Needed, for example, to get the text for current token. Set at @@ -77,21 +77,21 @@ func NewBaseLexer(input CharStream) *BaseLexer { // Once we see EOF on char stream, next token will be EOF. // If you have DONE : EOF then you see DONE EOF. - lexer._hitEOF = false + lexer.hitEOF = false // The channel number for the current token/// - lexer._channel = TokenDefaultChannel + lexer.channel = TokenDefaultChannel // The token type for the current token/// - lexer._type = TokenInvalidType + lexer.thetype = TokenInvalidType - lexer._modeStack = make([]int, 0) - lexer._mode = LexerDefaultMode + lexer.modeStack = make([]int, 0) + lexer.mode = LexerDefaultMode // You can set the text for the current token to override what is in // the input char buffer. Use setText() or can set l instance var. // / - lexer._text = "" + lexer.text = "" return lexer } @@ -111,20 +111,20 @@ const ( func (b *BaseLexer) reset() { // wack Lexer state variables - if b._input != nil { - b._input.Seek(0) // rewind the input + if b.input != nil { + b.input.Seek(0) // rewind the input } - b._token = nil - b._type = TokenInvalidType - b._channel = TokenDefaultChannel + b.token = nil + b.thetype = TokenInvalidType + b.channel = TokenDefaultChannel b.TokenStartCharIndex = -1 b.TokenStartColumn = -1 b.TokenStartLine = -1 - b._text = "" + b.text = "" - b._hitEOF = false - b._mode = LexerDefaultMode - b._modeStack = make([]int, 0) + b.hitEOF = false + b.mode = LexerDefaultMode + b.modeStack = make([]int, 0) b.Interpreter.reset() } @@ -134,7 +134,7 @@ func (b *BaseLexer) GetInterpreter() *LexerATNSimulator { } func (b *BaseLexer) GetInputStream() CharStream { - return b._input + return b.input } func (b *BaseLexer) GetSourceName() string { @@ -142,15 +142,15 @@ func (b *BaseLexer) GetSourceName() string { } func (b *BaseLexer) setChannel(v int) { - b._channel = v + b.channel = v } func (b *BaseLexer) GetTokenFactory() TokenFactory { - return b._factory + return b.factory } func (b *BaseLexer) setTokenFactory(f TokenFactory) { - b._factory = f + b.factory = f } func (b *BaseLexer) safeMatch() (ret int) { @@ -166,53 +166,53 @@ func (b *BaseLexer) safeMatch() (ret int) { } }() - return b.Interpreter.Match(b._input, b._mode) + return b.Interpreter.Match(b.input, b.mode) } // Return a token from l source i.e., Match a token on the char stream. func (b *BaseLexer) NextToken() Token { - if b._input == nil { + if b.input == nil { panic("NextToken requires a non-nil input stream.") } - var tokenStartMarker = b._input.Mark() + var tokenStartMarker = b.input.Mark() // previously in finally block defer func() { // make sure we release marker after Match or // unbuffered char stream will keep buffering - b._input.Release(tokenStartMarker) + b.input.Release(tokenStartMarker) }() for true { - if b._hitEOF { + if b.hitEOF { b.emitEOF() - return b._token + return b.token } - b._token = nil - b._channel = TokenDefaultChannel - b.TokenStartCharIndex = b._input.Index() + b.token = nil + b.channel = TokenDefaultChannel + b.TokenStartCharIndex = b.input.Index() b.TokenStartColumn = b.Interpreter.column b.TokenStartLine = b.Interpreter.line - b._text = "" + b.text = "" var continueOuter = false for true { - b._type = TokenInvalidType + b.thetype = TokenInvalidType var ttype = LexerSkip ttype = b.safeMatch() - if b._input.LA(1) == TokenEOF { - b._hitEOF = true + if b.input.LA(1) == TokenEOF { + b.hitEOF = true } - if b._type == TokenInvalidType { - b._type = ttype + if b.thetype == TokenInvalidType { + b.thetype = ttype } - if b._type == LexerSkip { + if b.thetype == LexerSkip { continueOuter = true break } - if b._type != LexerMore { + if b.thetype != LexerMore { break } if PortDebug { @@ -226,10 +226,10 @@ func (b *BaseLexer) NextToken() Token { if continueOuter { continue } - if b._token == nil { + if b.token == nil { b.emit() } - return b._token + return b.token } return nil @@ -237,52 +237,48 @@ func (b *BaseLexer) NextToken() Token { // 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 SKIP_TOKEN. Recall that +// 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. // / func (b *BaseLexer) Skip() { - b._type = LexerSkip + b.thetype = LexerSkip } func (b *BaseLexer) More() { - b._type = LexerMore -} - -func (b *BaseLexer) mode(m int) { - b._mode = m + b.thetype = LexerMore } func (b *BaseLexer) pushMode(m int) { if LexerATNSimulatorDebug { fmt.Println("pushMode " + strconv.Itoa(m)) } - b._modeStack.Push(b._mode) - b.mode(m) + b.modeStack.Push(b.mode) + b.mode = m } func (b *BaseLexer) popMode() int { - if len(b._modeStack) == 0 { + if len(b.modeStack) == 0 { panic("Empty Stack") } if LexerATNSimulatorDebug { - fmt.Println("popMode back to " + fmt.Sprint(b._modeStack[0:len(b._modeStack)-1])) + fmt.Println("popMode back to " + fmt.Sprint(b.modeStack[0:len(b.modeStack)-1])) } - i, _ := b._modeStack.Pop() - b.mode(i) - return b._mode + i, _ := b.modeStack.Pop() + b.mode = i + return b.mode } func (b *BaseLexer) inputStream() CharStream { - return b._input + return b.input } func (b *BaseLexer) setInputStream(input CharStream) { - b._input = nil - b._tokenFactorySourcePair = &TokenSourceCharStreamPair{b, b._input} + b.input = nil + b.tokenFactorySourcePair = &TokenSourceCharStreamPair{b, b.input} b.reset() - b._input = input - b._tokenFactorySourcePair = &TokenSourceCharStreamPair{b, b._input} + b.input = input + b.tokenFactorySourcePair = &TokenSourceCharStreamPair{b, b.input} } // By default does not support multiple emits per NextToken invocation @@ -291,7 +287,7 @@ func (b *BaseLexer) setInputStream(input CharStream) { // rather than a single variable as l implementation does). // / func (b *BaseLexer) emitToken(token Token) { - b._token = token + b.token = token } // The standard method called to automatically emit a token at the @@ -304,7 +300,7 @@ func (b *BaseLexer) emit() Token { if PortDebug { fmt.Println("emit") } - var t = b._factory.Create(b._tokenFactorySourcePair, b._type, b._text, b._channel, b.TokenStartCharIndex, b.getCharIndex()-1, b.TokenStartLine, b.TokenStartColumn) + var t = b.factory.Create(b.tokenFactorySourcePair, b.thetype, b.text, b.channel, b.TokenStartCharIndex, b.getCharIndex()-1, b.TokenStartLine, b.TokenStartColumn) b.emitToken(t) return t } @@ -315,7 +311,7 @@ func (b *BaseLexer) emitEOF() Token { if PortDebug { fmt.Println("emitEOF") } - var eof = b._factory.Create(b._tokenFactorySourcePair, TokenEOF, "", TokenDefaultChannel, b._input.Index(), b._input.Index()-1, lpos, cpos) + var eof = b.factory.Create(b.tokenFactorySourcePair, TokenEOF, "", TokenDefaultChannel, b.input.Index(), b.input.Index()-1, lpos, cpos) b.emitToken(eof) return eof } @@ -329,30 +325,30 @@ func (b *BaseLexer) GetLine() int { } func (b *BaseLexer) getType() int { - return b._type + return b.thetype } func (b *BaseLexer) setType(t int) { - b._type = t + b.thetype = t } // What is the index of the current character of lookahead?/// func (b *BaseLexer) getCharIndex() int { - return b._input.Index() + return b.input.Index() } // 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 (b *BaseLexer) GetText() string { - if b._text != "" { - return b._text + if b.text != "" { + return b.text } - return b.Interpreter.GetText(b._input) + return b.Interpreter.GetText(b.input) } func (b *BaseLexer) SetText(text string) { - b._text = text + b.text = text } func (b *BaseLexer) GetATN() *ATN { @@ -380,8 +376,8 @@ func (b *BaseLexer) getAllTokens() []Token { func (b *BaseLexer) notifyListeners(e RecognitionException) { var start = b.TokenStartCharIndex - var stop = b._input.Index() - var text = b._input.GetTextFromInterval(NewInterval(start, stop)) + var stop = b.input.Index() + var text = b.input.GetTextFromInterval(NewInterval(start, stop)) var msg = "token recognition error at: '" + text + "'" var listener = b.GetErrorListenerDispatch() listener.SyntaxError(b, nil, b.TokenStartLine, b.TokenStartColumn, msg, e) @@ -411,13 +407,13 @@ func (b *BaseLexer) getCharErrorDisplay(c rune) string { // to do sophisticated error recovery if you are in a fragment rule. // / func (b *BaseLexer) Recover(re RecognitionException) { - if b._input.LA(1) != TokenEOF { + if b.input.LA(1) != TokenEOF { if _, ok := re.(*LexerNoViableAltException); ok { // Skip a char and try again - b.Interpreter.consume(b._input) + b.Interpreter.consume(b.input) } else { // TODO: Do we lose character or line position information? - b._input.Consume() + b.input.Consume() } } } diff --git a/runtime/Go/antlr/lexer_action.go b/runtime/Go/antlr/lexer_action.go index 63d205c80..d5f7ca509 100644 --- a/runtime/Go/antlr/lexer_action.go +++ b/runtime/Go/antlr/lexer_action.go @@ -86,22 +86,22 @@ func (l *LexerSkipAction) String() string { type LexerTypeAction struct { *BaseLexerAction - _type int + thetype int } -func NewLexerTypeAction(_type int) *LexerTypeAction { +func NewLexerTypeAction(thetype int) *LexerTypeAction { l := new(LexerTypeAction) l.BaseLexerAction = NewBaseLexerAction(LexerActionTypeType) - l._type = _type + l.thetype = thetype return l } func (l *LexerTypeAction) execute(lexer Lexer) { - lexer.setType(l._type) + lexer.setType(l.thetype) } func (l *LexerTypeAction) Hash() string { - return strconv.Itoa(l.actionType) + strconv.Itoa(l._type) + return strconv.Itoa(l.actionType) + strconv.Itoa(l.thetype) } func (l *LexerTypeAction) equals(other LexerAction) bool { @@ -110,12 +110,12 @@ func (l *LexerTypeAction) equals(other LexerAction) bool { } else if _, ok := other.(*LexerTypeAction); !ok { return false } else { - return l._type == other.(*LexerTypeAction)._type + return l.thetype == other.(*LexerTypeAction).thetype } } func (l *LexerTypeAction) String() string { - return "actionType(" + strconv.Itoa(l._type) + ")" + return "actionType(" + strconv.Itoa(l.thetype) + ")" } // Implements the {@code pushMode} lexer action by calling diff --git a/runtime/Go/antlr/lexer_atn_simulator.go b/runtime/Go/antlr/lexer_atn_simulator.go index a121467a2..3d0ebda8c 100644 --- a/runtime/Go/antlr/lexer_atn_simulator.go +++ b/runtime/Go/antlr/lexer_atn_simulator.go @@ -59,7 +59,7 @@ type LexerATNSimulator struct { column int mode int prevAccept *SimState - Match_calls int + MatchCalls int } func NewLexerATNSimulator(recog Lexer, atn *ATN, decisionToDFA []*DFA, sharedContextCache *PredictionContextCache) *LexerATNSimulator { @@ -91,10 +91,10 @@ func NewLexerATNSimulator(recog Lexer, atn *ATN, decisionToDFA []*DFA, sharedCon var LexerATNSimulatorDebug = false var LexerATNSimulatorDFADebug = false -var LexerATNSimulatorMIN_DFA_EDGE = 0 -var LexerATNSimulatorMAX_DFA_EDGE = 127 // forces unicode to stay in ATN +var LexerATNSimulatorMinDFAEdge = 0 +var LexerATNSimulatorMaxDFAEdge = 127 // forces unicode to stay in ATN -var LexerATNSimulatorMatch_calls = 0 +var LexerATNSimulatorMatchCalls = 0 func (l *LexerATNSimulator) copyState(simulator *LexerATNSimulator) { l.column = simulator.column @@ -109,7 +109,7 @@ func (l *LexerATNSimulator) Match(input CharStream, mode int) int { fmt.Println("Match") } - l.Match_calls++ + l.MatchCalls++ l.mode = mode var mark = input.Mark() @@ -153,12 +153,12 @@ func (l *LexerATNSimulator) MatchATN(input CharStream) int { if LexerATNSimulatorDebug { fmt.Println("MatchATN mode " + strconv.Itoa(l.mode) + " start: " + startState.String()) } - var old_mode = l.mode - var s0_closure = l.computeStartState(input, startState) - var suppressEdge = s0_closure.hasSemanticContext - s0_closure.hasSemanticContext = false + var oldMode = l.mode + var s0Closure = l.computeStartState(input, startState) + var suppressEdge = s0Closure.hasSemanticContext + s0Closure.hasSemanticContext = false - var next = l.addDFAState(s0_closure) + var next = l.addDFAState(s0Closure) if !suppressEdge { l.DecisionToDFA[l.mode].s0 = next @@ -167,7 +167,7 @@ func (l *LexerATNSimulator) MatchATN(input CharStream) int { var predict = l.execATN(input, next) if LexerATNSimulatorDebug { - fmt.Println("DFA after MatchATN: " + l.DecisionToDFA[old_mode].ToLexerString()) + fmt.Println("DFA after MatchATN: " + l.DecisionToDFA[oldMode].ToLexerString()) } return predict } @@ -251,11 +251,11 @@ func (l *LexerATNSimulator) execATN(input CharStream, ds0 *DFAState) int { // {@code t}, or {@code nil} if the target state for l edge is not // already cached func (l *LexerATNSimulator) getExistingTargetState(s *DFAState, t int) *DFAState { - if s.edges == nil || t < LexerATNSimulatorMIN_DFA_EDGE || t > LexerATNSimulatorMAX_DFA_EDGE { + if s.edges == nil || t < LexerATNSimulatorMinDFAEdge || t > LexerATNSimulatorMaxDFAEdge { return nil } - var target = s.edges[t-LexerATNSimulatorMIN_DFA_EDGE] + var target = s.edges[t-LexerATNSimulatorMinDFAEdge] if target == nil { target = nil } @@ -431,7 +431,7 @@ func (l *LexerATNSimulator) closure(input CharStream, config *LexerATNConfig, co } if config.context != nil && !config.context.isEmpty() { for i := 0; i < config.context.length(); i++ { - if config.context.getReturnState(i) != BasePredictionContextEMPTY_RETURN_STATE { + if config.context.getReturnState(i) != BasePredictionContextEmptyReturnState { var newContext = config.context.GetParent(i) // "pop" return state var returnState = l.atn.states[config.context.getReturnState(i)] cfg := NewLexerATNConfig2(config, returnState, newContext) @@ -585,7 +585,7 @@ func (l *LexerATNSimulator) captureSimState(settings *SimState, input CharStream settings.dfaState = dfaState } -func (l *LexerATNSimulator) addDFAEdge(from_ *DFAState, tk int, to *DFAState, cfgs ATNConfigSet) *DFAState { +func (l *LexerATNSimulator) addDFAEdge(from *DFAState, tk int, to *DFAState, cfgs ATNConfigSet) *DFAState { if to == nil && cfgs != nil { // leading to l call, ATNConfigSet.hasSemanticContext is used as a // marker indicating dynamic predicate evaluation makes l edge @@ -608,18 +608,18 @@ func (l *LexerATNSimulator) addDFAEdge(from_ *DFAState, tk int, to *DFAState, cf } } // add the edge - if tk < LexerATNSimulatorMIN_DFA_EDGE || tk > LexerATNSimulatorMAX_DFA_EDGE { + if tk < LexerATNSimulatorMinDFAEdge || tk > LexerATNSimulatorMaxDFAEdge { // Only track edges within the DFA bounds return to } if LexerATNSimulatorDebug { - fmt.Println("EDGE " + from_.String() + " -> " + to.String() + " upon " + strconv.Itoa(tk)) + fmt.Println("EDGE " + from.String() + " -> " + to.String() + " upon " + strconv.Itoa(tk)) } - if from_.edges == nil { + if from.edges == nil { // make room for tokens 1..n and -1 masquerading as index 0 - from_.edges = make([]*DFAState, LexerATNSimulatorMAX_DFA_EDGE-LexerATNSimulatorMIN_DFA_EDGE+1) + from.edges = make([]*DFAState, LexerATNSimulatorMaxDFAEdge-LexerATNSimulatorMinDFAEdge+1) } - from_.edges[tk-LexerATNSimulatorMIN_DFA_EDGE] = to // connect + from.edges[tk-LexerATNSimulatorMinDFAEdge] = to // connect return to } diff --git a/runtime/Go/antlr/ll1_analyzer.go b/runtime/Go/antlr/ll1_analyzer.go index 4b67f3816..2079c6227 100644 --- a/runtime/Go/antlr/ll1_analyzer.go +++ b/runtime/Go/antlr/ll1_analyzer.go @@ -18,7 +18,7 @@ func NewLL1Analyzer(atn *ATN) *LL1Analyzer { // a predicate during analysis if {@code seeThruPreds==false}. /// const ( - LL1AnalyzerHIT_PRED = TokenInvalidType + LL1AnalyzerHitPred = TokenInvalidType ) //* @@ -40,10 +40,10 @@ func (la *LL1Analyzer) getDecisionLookahead(s ATNState) []*IntervalSet { look[alt] = NewIntervalSet() var lookBusy = NewSet(nil, nil) var seeThruPreds = false // fail to get lookahead upon pred - la._look(s.GetTransitions()[alt].getTarget(), nil, BasePredictionContextEMPTY, look[alt], lookBusy, NewBitSet(), seeThruPreds, false) + la.look1(s.GetTransitions()[alt].getTarget(), nil, BasePredictionContextEMPTY, look[alt], lookBusy, NewBitSet(), seeThruPreds, false) // Wipe out lookahead for la alternative if we found nothing // or we had a predicate when we !seeThruPreds - if look[alt].length() == 0 || look[alt].contains(LL1AnalyzerHIT_PRED) { + if look[alt].length() == 0 || look[alt].contains(LL1AnalyzerHitPred) { look[alt] = nil } } @@ -85,7 +85,7 @@ func (la *LL1Analyzer) look(s, stopState ATNState, ctx RuleContext) *IntervalSet fmt.Println(seeThruPreds) fmt.Println("=====") } - la._look(s, stopState, lookContext, r, NewSet(nil, nil), NewBitSet(), seeThruPreds, true) + la.look1(s, stopState, lookContext, r, NewSet(nil, nil), NewBitSet(), seeThruPreds, true) if PortDebug { fmt.Println(r) } @@ -116,13 +116,13 @@ func (la *LL1Analyzer) look(s, stopState ATNState, ctx RuleContext) *IntervalSet // {@code NewBitSet()} for la argument. // @param seeThruPreds {@code true} to true semantic predicates as // implicitly {@code true} and "see through them", otherwise {@code false} -// to treat semantic predicates as opaque and add {@link //HIT_PRED} to the +// to treat semantic predicates as opaque and add {@link //HitPred} to the // result if one is encountered. // @param addEOF Add {@link Token//EOF} to the result if the end of the // outermost context is reached. This parameter has no effect if {@code ctx} // is {@code nil}. -func (la *LL1Analyzer) __look(s, stopState ATNState, ctx PredictionContext, look *IntervalSet, lookBusy *Set, calledRuleStack *BitSet, seeThruPreds, addEOF bool, i int) { +func (la *LL1Analyzer) look2(s, stopState ATNState, ctx PredictionContext, look *IntervalSet, lookBusy *Set, calledRuleStack *BitSet, seeThruPreds, addEOF bool, i int) { returnState := la.atn.states[ctx.getReturnState(i)] @@ -135,11 +135,11 @@ func (la *LL1Analyzer) __look(s, stopState ATNState, ctx PredictionContext, look }() calledRuleStack.remove(returnState.GetRuleIndex()) - la._look(returnState, stopState, ctx.GetParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF) + la.look1(returnState, stopState, ctx.GetParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF) } -func (la *LL1Analyzer) _look(s, stopState ATNState, ctx PredictionContext, look *IntervalSet, lookBusy *Set, calledRuleStack *BitSet, seeThruPreds, addEOF bool) { +func (la *LL1Analyzer) look1(s, stopState ATNState, ctx PredictionContext, look *IntervalSet, lookBusy *Set, calledRuleStack *BitSet, seeThruPreds, addEOF bool) { c := NewBaseATNConfig6(s, 0, ctx) @@ -182,7 +182,7 @@ func (la *LL1Analyzer) _look(s, stopState ATNState, ctx PredictionContext, look for i := 0; i < ctx.length(); i++ { returnState := la.atn.states[ctx.getReturnState(i)] - la.__look(returnState, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF, i) + la.look2(returnState, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF, i) } return @@ -205,7 +205,7 @@ func (la *LL1Analyzer) _look(s, stopState ATNState, ctx PredictionContext, look newContext := SingletonBasePredictionContextCreate(ctx, t1.followState.GetStateNumber()) - la.___look(stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF, t1) + la.look3(stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF, t1) if PortDebug { fmt.Println(look) @@ -216,15 +216,15 @@ func (la *LL1Analyzer) _look(s, stopState ATNState, ctx PredictionContext, look fmt.Println("DEBUG 9") } if seeThruPreds { - la._look(t2.getTarget(), stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) + la.look1(t2.getTarget(), stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) } else { - look.addOne(LL1AnalyzerHIT_PRED) + look.addOne(LL1AnalyzerHitPred) } } else if t.getIsEpsilon() { if PortDebug { fmt.Println("DEBUG 10") } - la._look(t.getTarget(), stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) + la.look1(t.getTarget(), stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) } else if _, ok := t.(*WildcardTransition); ok { if PortDebug { fmt.Println("DEBUG 11") @@ -248,7 +248,7 @@ func (la *LL1Analyzer) _look(s, stopState ATNState, ctx PredictionContext, look } } -func (la *LL1Analyzer) ___look(stopState ATNState, ctx PredictionContext, look *IntervalSet, lookBusy *Set, calledRuleStack *BitSet, seeThruPreds, addEOF bool, t1 *RuleTransition) { +func (la *LL1Analyzer) look3(stopState ATNState, ctx PredictionContext, look *IntervalSet, lookBusy *Set, calledRuleStack *BitSet, seeThruPreds, addEOF bool, t1 *RuleTransition) { newContext := SingletonBasePredictionContextCreate(ctx, t1.followState.GetStateNumber()) @@ -257,6 +257,6 @@ func (la *LL1Analyzer) ___look(stopState ATNState, ctx PredictionContext, look * }() calledRuleStack.add(t1.getTarget().GetRuleIndex()) - la._look(t1.getTarget(), stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) + la.look1(t1.getTarget(), stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) } diff --git a/runtime/Go/antlr/parser.go b/runtime/Go/antlr/parser.go index 4e556b0b7..1d6f29dc8 100644 --- a/runtime/Go/antlr/parser.go +++ b/runtime/Go/antlr/parser.go @@ -34,13 +34,13 @@ type BaseParser struct { Interpreter *ParserATNSimulator BuildParseTrees bool - _input TokenStream - _errHandler ErrorStrategy - _precedenceStack IntStack - _ctx ParserRuleContext + input TokenStream + errHandler ErrorStrategy + precedenceStack IntStack + ctx ParserRuleContext - _tracer *TraceListener - _parseListeners []ParseTreeListener + tracer *TraceListener + parseListeners []ParseTreeListener _SyntaxErrors int } @@ -53,15 +53,15 @@ func NewBaseParser(input TokenStream) *BaseParser { p.BaseRecognizer = NewBaseRecognizer() // The input stream. - p._input = nil + p.input = nil // The error handling strategy for the parser. The default value is a new // instance of {@link DefaultErrorStrategy}. - p._errHandler = NewDefaultErrorStrategy() - p._precedenceStack = make([]int, 0) - p._precedenceStack.Push(0) + p.errHandler = NewDefaultErrorStrategy() + p.precedenceStack = make([]int, 0) + p.precedenceStack.Push(0) // The {@link ParserRuleContext} object for the currently executing rule. // p.is always non-nil during the parsing process. - p._ctx = nil + p.ctx = nil // Specifies whether or not the parser should construct a parse tree during // the parsing process. The default value is {@code true}. p.BuildParseTrees = true @@ -70,10 +70,10 @@ func NewBaseParser(input TokenStream) *BaseParser { // later call to {@link //setTrace}{@code (false)}. The listener itself is // implemented as a parser listener so p.field is not directly used by // other parser methods. - p._tracer = nil + p.tracer = nil // The list of {@link ParseTreeListener} listeners registered to receive // events during the parse. - p._parseListeners = nil + p.parseListeners = nil // The number of syntax errors Reported during parsing. p.value is // incremented each time {@link //NotifyErrorListeners} is called. p._SyntaxErrors = 0 @@ -92,26 +92,26 @@ var bypassAltsAtnCache = make(map[string]int) // reset the parser's state// func (p *BaseParser) reset() { - if p._input != nil { - p._input.Seek(0) + if p.input != nil { + p.input.Seek(0) } - p._errHandler.reset(p) - p._ctx = nil + p.errHandler.reset(p) + p.ctx = nil p._SyntaxErrors = 0 p.SetTrace(nil) - p._precedenceStack = make([]int, 0) - p._precedenceStack.Push(0) + p.precedenceStack = make([]int, 0) + p.precedenceStack.Push(0) if p.Interpreter != nil { p.Interpreter.reset() } } func (p *BaseParser) GetErrorHandler() ErrorStrategy { - return p._errHandler + return p.errHandler } func (p *BaseParser) SetErrorHandler(e ErrorStrategy) { - p._errHandler = e + p.errHandler = e } // Match current input symbol against {@code ttype}. If the symbol type @@ -143,15 +143,15 @@ func (p *BaseParser) Match(ttype int) Token { } if t.GetTokenType() == ttype { - p._errHandler.ReportMatch(p) + p.errHandler.ReportMatch(p) p.Consume() } else { - t = p._errHandler.RecoverInline(p) + t = p.errHandler.RecoverInline(p) if p.BuildParseTrees && t.GetTokenIndex() == -1 { // we must have conjured up a Newtoken during single token // insertion // if it's not the current symbol - p._ctx.AddErrorNode(t) + p.ctx.AddErrorNode(t) } } @@ -181,33 +181,33 @@ func (p *BaseParser) Match(ttype int) Token { func (p *BaseParser) MatchWildcard() Token { var t = p.GetCurrentToken() if t.GetTokenType() > 0 { - p._errHandler.ReportMatch(p) + p.errHandler.ReportMatch(p) p.Consume() } else { - t = p._errHandler.RecoverInline(p) + t = p.errHandler.RecoverInline(p) if p.BuildParseTrees && t.GetTokenIndex() == -1 { // we must have conjured up a Newtoken during single token // insertion // if it's not the current symbol - p._ctx.AddErrorNode(t) + p.ctx.AddErrorNode(t) } } return t } func (p *BaseParser) GetParserRuleContext() ParserRuleContext { - return p._ctx + return p.ctx } func (p *BaseParser) SetParserRuleContext(v ParserRuleContext) { - p._ctx = v + p.ctx = v } func (p *BaseParser) GetParseListeners() []ParseTreeListener { - if p._parseListeners == nil { + if p.parseListeners == nil { return make([]ParseTreeListener, 0) } - return p._parseListeners + return p.parseListeners } // Registers {@code listener} to receive events during the parsing process. @@ -242,10 +242,10 @@ func (p *BaseParser) AddParseListener(listener ParseTreeListener) { if listener == nil { panic("listener") } - if p._parseListeners == nil { - p._parseListeners = make([]ParseTreeListener, 0) + if p.parseListeners == nil { + p.parseListeners = make([]ParseTreeListener, 0) } - p._parseListeners = append(p._parseListeners, listener) + p.parseListeners = append(p.parseListeners, listener) } // @@ -257,10 +257,10 @@ func (p *BaseParser) AddParseListener(listener ParseTreeListener) { // func (p *BaseParser) RemoveParseListener(listener ParseTreeListener) { - if p._parseListeners != nil { + if p.parseListeners != nil { idx := -1 - for i, v := range p._parseListeners { + for i, v := range p.parseListeners { if v == listener { idx = i break @@ -272,24 +272,24 @@ func (p *BaseParser) RemoveParseListener(listener ParseTreeListener) { } // remove the listener from the slice - p._parseListeners = append(p._parseListeners[0:idx], p._parseListeners[idx+1:]...) + p.parseListeners = append(p.parseListeners[0:idx], p.parseListeners[idx+1:]...) - if len(p._parseListeners) == 0 { - p._parseListeners = nil + if len(p.parseListeners) == 0 { + p.parseListeners = nil } } } // Remove all parse listeners. func (p *BaseParser) removeParseListeners() { - p._parseListeners = nil + p.parseListeners = nil } // Notify any parse listeners of an enter rule event. func (p *BaseParser) TriggerEnterRuleEvent() { - if p._parseListeners != nil { - var ctx = p._ctx - for _, listener := range p._parseListeners { + if p.parseListeners != nil { + var ctx = p.ctx + for _, listener := range p.parseListeners { listener.EnterEveryRule(ctx) ctx.EnterRule(listener) } @@ -302,13 +302,13 @@ func (p *BaseParser) TriggerEnterRuleEvent() { // @see //addParseListener // func (p *BaseParser) TriggerExitRuleEvent() { - if p._parseListeners != nil { + if p.parseListeners != nil { // reverse order walk of listeners - ctx := p._ctx - l := len(p._parseListeners) - 1 + ctx := p.ctx + l := len(p.parseListeners) - 1 - for i := range p._parseListeners { - listener := p._parseListeners[l-i] + for i := range p.parseListeners { + listener := p.parseListeners[l-i] ctx.ExitRule(listener) listener.ExitEveryRule(ctx) } @@ -324,12 +324,12 @@ func (p *BaseParser) GetATN() *ATN { } func (p *BaseParser) GetTokenFactory() TokenFactory { - return p._input.GetTokenSource().GetTokenFactory() + return p.input.GetTokenSource().GetTokenFactory() } // Tell our token source and error strategy about a Newway to create tokens.// func (p *BaseParser) setTokenFactory(factory TokenFactory) { - p._input.GetTokenSource().setTokenFactory(factory) + p.input.GetTokenSource().setTokenFactory(factory) } // The ATN with bypass alternatives is expensive to create so we create it @@ -397,21 +397,21 @@ func (p *BaseParser) SetInputStream(input TokenStream) { } func (p *BaseParser) GetTokenStream() TokenStream { - return p._input + return p.input } // Set the token stream and reset the parser.// func (p *BaseParser) SetTokenStream(input TokenStream) { - p._input = nil + p.input = nil p.reset() - p._input = input + p.input = input } // Match needs to return the current input symbol, which gets put // into the label for the associated token ref e.g., x=ID. // func (p *BaseParser) GetCurrentToken() Token { - return p._input.LT(1) + return p.input.LT(1) } func (p *BaseParser) NotifyErrorListeners(msg string, offendingToken Token, err RecognitionException) { @@ -436,20 +436,20 @@ func (p *BaseParser) Consume() Token { fmt.Println("Done consuming") } } - var hasListener = p._parseListeners != nil && len(p._parseListeners) > 0 + var hasListener = p.parseListeners != nil && len(p.parseListeners) > 0 if p.BuildParseTrees || hasListener { - if p._errHandler.inErrorRecoveryMode(p) { - var node = p._ctx.AddErrorNode(o) - if p._parseListeners != nil { - for _, l := range p._parseListeners { + if p.errHandler.inErrorRecoveryMode(p) { + var node = p.ctx.AddErrorNode(o) + if p.parseListeners != nil { + for _, l := range p.parseListeners { l.VisitErrorNode(node) } } } else { - node := p._ctx.AddTokenNode(o) - if p._parseListeners != nil { - for _, l := range p._parseListeners { + node := p.ctx.AddTokenNode(o) + if p.parseListeners != nil { + for _, l := range p.parseListeners { l.VisitTerminal(node) } } @@ -462,47 +462,47 @@ func (p *BaseParser) Consume() Token { func (p *BaseParser) addContextToParseTree() { // add current context to parent if we have a parent - if p._ctx.GetParent() != nil { - p._ctx.GetParent().(ParserRuleContext).AddChild(p._ctx) + if p.ctx.GetParent() != nil { + p.ctx.GetParent().(ParserRuleContext).AddChild(p.ctx) } } func (p *BaseParser) EnterRule(localctx ParserRuleContext, state, ruleIndex int) { p.SetState(state) - p._ctx = localctx - p._ctx.SetStart(p._input.LT(1)) + p.ctx = localctx + p.ctx.SetStart(p.input.LT(1)) if p.BuildParseTrees { p.addContextToParseTree() } - if p._parseListeners != nil { + if p.parseListeners != nil { p.TriggerEnterRuleEvent() } } func (p *BaseParser) ExitRule() { - p._ctx.SetStop(p._input.LT(-1)) - // trigger event on _ctx, before it reverts to parent - if p._parseListeners != nil { + p.ctx.SetStop(p.input.LT(-1)) + // trigger event on ctx, before it reverts to parent + if p.parseListeners != nil { p.TriggerExitRuleEvent() } - p.SetState(p._ctx.GetInvokingState()) - if p._ctx.GetParent() != nil { - p._ctx = p._ctx.GetParent().(ParserRuleContext) + p.SetState(p.ctx.GetInvokingState()) + if p.ctx.GetParent() != nil { + p.ctx = p.ctx.GetParent().(ParserRuleContext) } else { - p._ctx = nil + p.ctx = nil } } func (p *BaseParser) EnterOuterAlt(localctx ParserRuleContext, altNum int) { // if we have Newlocalctx, make sure we replace existing ctx // that is previous child of parse tree - if p.BuildParseTrees && p._ctx != localctx { - if p._ctx.GetParent() != nil { - p._ctx.GetParent().(ParserRuleContext).RemoveLastChild() - p._ctx.GetParent().(ParserRuleContext).AddChild(localctx) + if p.BuildParseTrees && p.ctx != localctx { + if p.ctx.GetParent() != nil { + p.ctx.GetParent().(ParserRuleContext).RemoveLastChild() + p.ctx.GetParent().(ParserRuleContext).AddChild(localctx) } } - p._ctx = localctx + p.ctx = localctx } // Get the precedence level for the top-most precedence rule. @@ -511,19 +511,19 @@ func (p *BaseParser) EnterOuterAlt(localctx ParserRuleContext, altNum int) { // the parser context is not nested within a precedence rule. func (p *BaseParser) GetPrecedence() int { - if len(p._precedenceStack) == 0 { + if len(p.precedenceStack) == 0 { return -1 } - return p._precedenceStack[len(p._precedenceStack)-1] + return p.precedenceStack[len(p.precedenceStack)-1] } func (p *BaseParser) EnterRecursionRule(localctx ParserRuleContext, state, ruleIndex, precedence int) { p.SetState(state) - p._precedenceStack.Push(precedence) - p._ctx = localctx - p._ctx.SetStart(p._input.LT(1)) - if p._parseListeners != nil { + p.precedenceStack.Push(precedence) + p.ctx = localctx + p.ctx.SetStart(p.input.LT(1)) + if p.parseListeners != nil { p.TriggerEnterRuleEvent() // simulates rule entry for // left-recursive rules } @@ -533,34 +533,34 @@ func (p *BaseParser) EnterRecursionRule(localctx ParserRuleContext, state, ruleI // Like {@link //EnterRule} but for recursive rules. func (p *BaseParser) PushNewRecursionContext(localctx ParserRuleContext, state, ruleIndex int) { - var previous = p._ctx + var previous = p.ctx previous.SetParent(localctx) previous.SetInvokingState(state) - previous.SetStop(p._input.LT(-1)) + previous.SetStop(p.input.LT(-1)) - p._ctx = localctx - p._ctx.SetStart(previous.GetStart()) + p.ctx = localctx + p.ctx.SetStart(previous.GetStart()) if p.BuildParseTrees { - p._ctx.AddChild(previous) + p.ctx.AddChild(previous) } - if p._parseListeners != nil { + if p.parseListeners != nil { p.TriggerEnterRuleEvent() // simulates rule entry for // left-recursive rules } } func (p *BaseParser) UnrollRecursionContexts(parentCtx ParserRuleContext) { - p._precedenceStack.Pop() - p._ctx.SetStop(p._input.LT(-1)) - var retCtx = p._ctx // save current ctx (return value) - // unroll so _ctx is as it was before call to recursive method - if p._parseListeners != nil { - for p._ctx != parentCtx { + p.precedenceStack.Pop() + p.ctx.SetStop(p.input.LT(-1)) + var retCtx = p.ctx // save current ctx (return value) + // unroll so ctx is as it was before call to recursive method + if p.parseListeners != nil { + for p.ctx != parentCtx { p.TriggerExitRuleEvent() - p._ctx = p._ctx.GetParent().(ParserRuleContext) + p.ctx = p.ctx.GetParent().(ParserRuleContext) } } else { - p._ctx = parentCtx + p.ctx = parentCtx } // hook into tree retCtx.SetParent(parentCtx) @@ -571,7 +571,7 @@ func (p *BaseParser) UnrollRecursionContexts(parentCtx ParserRuleContext) { } func (p *BaseParser) GetInvokingContext(ruleIndex int) ParserRuleContext { - var ctx = p._ctx + var ctx = p.ctx for ctx != nil { if ctx.GetRuleIndex() == ruleIndex { return ctx @@ -582,7 +582,7 @@ func (p *BaseParser) GetInvokingContext(ruleIndex int) ParserRuleContext { } func (p *BaseParser) Precpred(localctx RuleContext, precedence int) bool { - return precedence >= p._precedenceStack[len(p._precedenceStack)-1] + return precedence >= p.precedenceStack[len(p.precedenceStack)-1] } func (p *BaseParser) inContext(context ParserRuleContext) bool { @@ -606,7 +606,7 @@ func (p *BaseParser) inContext(context ParserRuleContext) bool { func (p *BaseParser) IsExpectedToken(symbol int) bool { var atn = p.Interpreter.atn - var ctx = p._ctx + var ctx = p.ctx var s = atn.states[p.state] var following = atn.NextTokens(s, nil) if following.contains(symbol) { @@ -638,7 +638,7 @@ func (p *BaseParser) IsExpectedToken(symbol int) bool { // @see ATN//getExpectedTokens(int, RuleContext) // func (p *BaseParser) GetExpectedTokens() *IntervalSet { - return p.Interpreter.atn.getExpectedTokens(p.state, p._ctx) + return p.Interpreter.atn.getExpectedTokens(p.state, p.ctx) } func (p *BaseParser) GetExpectedTokensWithinCurrentRule() *IntervalSet { @@ -666,7 +666,7 @@ func (p *BaseParser) GetRuleIndex(ruleName string) int { func (p *BaseParser) GetRuleInvocationStack(c ParserRuleContext) []string { if c == nil { - c = p._ctx + c = p.ctx } var stack = make([]string, 0) for c != nil { @@ -718,13 +718,13 @@ func (p *BaseParser) GetSourceName() string { // func (p *BaseParser) SetTrace(trace *TraceListener) { if trace == nil { - p.RemoveParseListener(p._tracer) - p._tracer = nil + p.RemoveParseListener(p.tracer) + p.tracer = nil } else { - if p._tracer != nil { - p.RemoveParseListener(p._tracer) + if p.tracer != nil { + p.RemoveParseListener(p.tracer) } - p._tracer = NewTraceListener(p) - p.AddParseListener(p._tracer) + p.tracer = NewTraceListener(p) + p.AddParseListener(p.tracer) } } diff --git a/runtime/Go/antlr/parser_atn_simulator.go b/runtime/Go/antlr/parser_atn_simulator.go index 32357b1d3..f7762f55f 100644 --- a/runtime/Go/antlr/parser_atn_simulator.go +++ b/runtime/Go/antlr/parser_atn_simulator.go @@ -11,12 +11,12 @@ type ParserATNSimulator struct { parser Parser predictionMode int - _input TokenStream - _startIndex int - _dfa *DFA + input TokenStream + startIndex int + dfa *DFA DecisionToDFA []*DFA mergeCache *DoubleDict - _outerContext ParserRuleContext + outerContext ParserRuleContext } func NewParserATNSimulator(parser Parser, atn *ATN, decisionToDFA []*DFA, sharedContextCache *PredictionContextCache) *ParserATNSimulator { @@ -30,10 +30,10 @@ func NewParserATNSimulator(parser Parser, atn *ATN, decisionToDFA []*DFA, shared // SLL, LL, or LL + exact ambig detection?// p.predictionMode = PredictionModeLL // LAME globals to avoid parameters!!!!! I need these down deep in predTransition - p._input = nil - p._startIndex = 0 - p._outerContext = nil - p._dfa = nil + p.input = nil + p.startIndex = 0 + p.outerContext = nil + p.dfa = nil // Each prediction operation uses a cache for merge of prediction contexts. // Don't keep around as it wastes huge amounts of memory. DoubleKeyMap // isn't Synchronized but we're ok since two threads shouldn't reuse same @@ -77,17 +77,17 @@ func (p *ParserATNSimulator) AdaptivePredict(input TokenStream, decision int, ou strconv.Itoa(input.LT(1).GetColumn())) } - p._input = input - p._startIndex = input.Index() - p._outerContext = outerContext + p.input = input + p.startIndex = input.Index() + p.outerContext = outerContext var dfa = p.DecisionToDFA[decision] - p._dfa = dfa + p.dfa = dfa var m = input.Mark() var index = input.Index() defer func() { - p._dfa = nil + p.dfa = nil p.mergeCache = nil // wack cache after each prediction input.Seek(index) input.Release(m) @@ -127,7 +127,7 @@ func (p *ParserATNSimulator) AdaptivePredict(input TokenStream, decision int, ou } } var fullCtx = false - var s0_closure = p.computeStartState(dfa.atnStartState, RuleContextEmpty, fullCtx) + var s0Closure = p.computeStartState(dfa.atnStartState, RuleContextEmpty, fullCtx) if dfa.precedenceDfa { // If p is a precedence DFA, we use applyPrecedenceFilter @@ -136,11 +136,11 @@ func (p *ParserATNSimulator) AdaptivePredict(input TokenStream, decision int, ou // appropriate start state for the precedence level rather // than simply setting DFA.s0. // - s0_closure = p.applyPrecedenceFilter(s0_closure) - s0 = p.addDFAState(dfa, NewDFAState(-1, s0_closure)) + s0Closure = p.applyPrecedenceFilter(s0Closure) + s0 = p.addDFAState(dfa, NewDFAState(-1, s0Closure)) dfa.setPrecedenceStartState(p.parser.GetPrecedence(), s0) } else { - s0 = p.addDFAState(dfa, NewDFAState(-1, s0_closure)) + s0 = p.addDFAState(dfa, NewDFAState(-1, s0Closure)) dfa.s0 = s0 } } @@ -248,9 +248,9 @@ func (p *ParserATNSimulator) execATN(dfa *DFA, s0 *DFAState, input TokenStream, fmt.Println("ctx sensitive state " + outerContext.String(nil, nil) + " in " + D.String()) } var fullCtx = true - var s0_closure = p.computeStartState(dfa.atnStartState, outerContext, fullCtx) + var s0Closure = p.computeStartState(dfa.atnStartState, outerContext, fullCtx) p.ReportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.Index()) - alt := p.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext) + alt := p.execATNWithFullContext(dfa, D, s0Closure, input, startIndex, outerContext) return alt } if D.isAcceptState { @@ -742,7 +742,7 @@ func (p *ParserATNSimulator) applyPrecedenceFilter(configs ATNConfigSet) ATNConf if config.GetAlt() != 1 { continue } - var updatedContext = config.GetSemanticContext().evalPrecedence(p.parser, p._outerContext) + var updatedContext = config.GetSemanticContext().evalPrecedence(p.parser, p.outerContext) if updatedContext == nil { // the configuration was eliminated continue @@ -998,7 +998,7 @@ func (p *ParserATNSimulator) closureCheckingStopState(config ATNConfig, configs // run thru all possible stack tops in ctx if !config.GetContext().isEmpty() { for i := 0; i < config.GetContext().length(); i++ { - if config.GetContext().getReturnState(i) == BasePredictionContextEMPTY_RETURN_STATE { + if config.GetContext().getReturnState(i) == BasePredictionContextEmptyReturnState { if fullCtx { configs.Add(NewBaseATNConfig1(config, config.GetState(), BasePredictionContextEMPTY), p.mergeCache) continue @@ -1010,7 +1010,7 @@ func (p *ParserATNSimulator) closureCheckingStopState(config ATNConfig, configs } fmt.Println("FALLING off rule " + p.getRuleName(config.GetState().GetRuleIndex())) } - p.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEOFAsEpsilon) + p.closureWork(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEOFAsEpsilon) } continue } @@ -1039,13 +1039,13 @@ func (p *ParserATNSimulator) closureCheckingStopState(config ATNConfig, configs } } } - p.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEOFAsEpsilon) + p.closureWork(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEOFAsEpsilon) } // Do the actual work of walking epsilon edges// -func (p *ParserATNSimulator) closure_(config ATNConfig, configs ATNConfigSet, closureBusy *Set, collectPredicates, fullCtx bool, depth int, treatEOFAsEpsilon bool) { +func (p *ParserATNSimulator) closureWork(config ATNConfig, configs ATNConfigSet, closureBusy *Set, collectPredicates, fullCtx bool, depth int, treatEOFAsEpsilon bool) { if PortDebug { - fmt.Println("closure_") + fmt.Println("closureWork") } var state = config.GetState() // optimization @@ -1094,11 +1094,11 @@ func (p *ParserATNSimulator) closure_(config ATNConfig, configs ATNConfigSet, cl } } - if p._dfa != nil && p._dfa.precedenceDfa { + if p.dfa != nil && p.dfa.precedenceDfa { if PortDebug { fmt.Println("DEBUG 4") } - if t.(*EpsilonTransition).outermostPrecedenceReturn == p._dfa.atnStartState.GetRuleIndex() { + if t.(*EpsilonTransition).outermostPrecedenceReturn == p.dfa.atnStartState.GetRuleIndex() { c.setPrecedenceFilterSuppressed(true) } } @@ -1197,10 +1197,10 @@ func (p *ParserATNSimulator) precedenceTransition(config ATNConfig, // during closure, which dramatically reduces the size of // the config sets. It also obviates the need to test predicates // later during conflict resolution. - var currentPosition = p._input.Index() - p._input.Seek(p._startIndex) - var predSucceeds = pt.getPredicate().evaluate(p.parser, p._outerContext) - p._input.Seek(currentPosition) + var currentPosition = p.input.Index() + p.input.Seek(p.startIndex) + var predSucceeds = pt.getPredicate().evaluate(p.parser, p.outerContext) + p.input.Seek(currentPosition) if predSucceeds { c = NewBaseATNConfig4(config, pt.getTarget()) // no pred context } @@ -1233,10 +1233,10 @@ func (p *ParserATNSimulator) predTransition(config ATNConfig, pt *PredicateTrans // during closure, which dramatically reduces the size of // the config sets. It also obviates the need to test predicates // later during conflict resolution. - var currentPosition = p._input.Index() - p._input.Seek(p._startIndex) - var predSucceeds = pt.getPredicate().evaluate(p.parser, p._outerContext) - p._input.Seek(currentPosition) + var currentPosition = p.input.Index() + p.input.Seek(p.startIndex) + var predSucceeds = pt.getPredicate().evaluate(p.parser, p.outerContext) + p.input.Seek(currentPosition) if predSucceeds { c = NewBaseATNConfig4(config, pt.getTarget()) // no pred context } @@ -1410,21 +1410,21 @@ func (p *ParserATNSimulator) getUniqueAlt(configs ATNConfigSet) int { // otherwise p method returns the result of calling {@link //addDFAState} // on {@code to} // -func (p *ParserATNSimulator) addDFAEdge(dfa *DFA, from_ *DFAState, t int, to *DFAState) *DFAState { +func (p *ParserATNSimulator) addDFAEdge(dfa *DFA, from *DFAState, t int, to *DFAState) *DFAState { if ParserATNSimulatorDebug { - fmt.Println("EDGE " + from_.String() + " -> " + to.String() + " upon " + p.GetTokenName(t)) + fmt.Println("EDGE " + from.String() + " -> " + to.String() + " upon " + p.GetTokenName(t)) } if to == nil { return nil } to = p.addDFAState(dfa, to) // used existing if possible not incoming - if from_ == nil || t < -1 || t > p.atn.maxTokenType { + if from == nil || t < -1 || t > p.atn.maxTokenType { return to } - if from_.edges == nil { - from_.edges = make([]*DFAState, p.atn.maxTokenType+1+1) + if from.edges == nil { + from.edges = make([]*DFAState, p.atn.maxTokenType+1+1) } - from_.edges[t+1] = to // connect + from.edges[t+1] = to // connect if ParserATNSimulatorDebug { var names []string diff --git a/runtime/Go/antlr/prediction_context.go b/runtime/Go/antlr/prediction_context.go index db7b437e8..6ec5047f3 100644 --- a/runtime/Go/antlr/prediction_context.go +++ b/runtime/Go/antlr/prediction_context.go @@ -32,12 +32,12 @@ func NewBasePredictionContext(cachedHashString string) *BasePredictionContext { // {@code//+x =//}. // / const ( - BasePredictionContextEMPTY_RETURN_STATE = 0x7FFFFFFF + BasePredictionContextEmptyReturnState = 0x7FFFFFFF ) // Represents {@code $} in an array in full context mode, when {@code $} // doesn't mean wildcard: {@code $ + x = [$,x]}. Here, -// {@code $} = {@link //EMPTY_RETURN_STATE}. +// {@code $} = {@link //EmptyReturnState}. // / var BasePredictionContextglobalNodeCount = 1 @@ -151,7 +151,7 @@ func NewBaseSingletonPredictionContext(parent PredictionContext, returnState int } func SingletonBasePredictionContextCreate(parent PredictionContext, returnState int) PredictionContext { - if returnState == BasePredictionContextEMPTY_RETURN_STATE && parent == nil { + if returnState == BasePredictionContextEmptyReturnState && parent == nil { // someone can pass in the bits of an array ctx that mean $ return BasePredictionContextEMPTY } @@ -172,7 +172,7 @@ func (b *BaseSingletonPredictionContext) getReturnState(index int) int { } func (b *BaseSingletonPredictionContext) hasEmptyPath() bool { - return b.returnState == BasePredictionContextEMPTY_RETURN_STATE + return b.returnState == BasePredictionContextEmptyReturnState } func (b *BaseSingletonPredictionContext) equals(other PredictionContext) bool { @@ -209,7 +209,7 @@ func (b *BaseSingletonPredictionContext) String() string { } if len(up) == 0 { - if b.returnState == BasePredictionContextEMPTY_RETURN_STATE { + if b.returnState == BasePredictionContextEmptyReturnState { return "$" } @@ -229,7 +229,7 @@ func NewEmptyPredictionContext() *EmptyPredictionContext { p := new(EmptyPredictionContext) - p.BaseSingletonPredictionContext = NewBaseSingletonPredictionContext(nil, BasePredictionContextEMPTY_RETURN_STATE) + p.BaseSingletonPredictionContext = NewBaseSingletonPredictionContext(nil, BasePredictionContextEmptyReturnState) return p } @@ -265,7 +265,7 @@ func NewArrayPredictionContext(parents []PredictionContext, returnStates []int) // Parent can be nil only if full ctx mode and we make an array // from {@link //EMPTY} and non-empty. We merge {@link //EMPTY} by using // nil parent and - // returnState == {@link //EMPTY_RETURN_STATE}. + // returnState == {@link //EmptyReturnState}. c := new(ArrayPredictionContext) c.BasePredictionContext = NewBasePredictionContext("") @@ -285,13 +285,13 @@ func (a *ArrayPredictionContext) GetReturnStates() []int { } func (a *ArrayPredictionContext) hasEmptyPath() bool { - return a.getReturnState(a.length()-1) == BasePredictionContextEMPTY_RETURN_STATE + return a.getReturnState(a.length()-1) == BasePredictionContextEmptyReturnState } func (a *ArrayPredictionContext) isEmpty() bool { - // since EMPTY_RETURN_STATE can only appear in the last position, we + // since EmptyReturnState can only appear in the last position, we // don't need to verify that size==1 - return a.returnStates[0] == BasePredictionContextEMPTY_RETURN_STATE + return a.returnStates[0] == BasePredictionContextEmptyReturnState } func (a *ArrayPredictionContext) length() int { @@ -327,7 +327,7 @@ func (a *ArrayPredictionContext) String() string { if i > 0 { s = s + ", " } - if a.returnStates[i] == BasePredictionContextEMPTY_RETURN_STATE { + if a.returnStates[i] == BasePredictionContextEmptyReturnState { s = s + "$" continue } @@ -567,11 +567,11 @@ func mergeRoot(a, b SingletonPredictionContext, rootIsWildcard bool) PredictionC if a == BasePredictionContextEMPTY && b == BasePredictionContextEMPTY { return BasePredictionContextEMPTY // $ + $ = $ } else if a == BasePredictionContextEMPTY { // $ + x = [$,x] - var payloads = []int{b.getReturnState(-1), BasePredictionContextEMPTY_RETURN_STATE} + var payloads = []int{b.getReturnState(-1), BasePredictionContextEmptyReturnState} var parents = []PredictionContext{b.GetParent(-1), nil} return NewArrayPredictionContext(parents, payloads) } else if b == BasePredictionContextEMPTY { // x + $ = [$,x] ($ is always first if present) - var payloads = []int{a.getReturnState(-1), BasePredictionContextEMPTY_RETURN_STATE} + var payloads = []int{a.getReturnState(-1), BasePredictionContextEmptyReturnState} var parents = []PredictionContext{a.GetParent(-1), nil} return NewArrayPredictionContext(parents, payloads) } @@ -619,32 +619,32 @@ func mergeArrays(a, b *ArrayPredictionContext, rootIsWildcard bool, mergeCache * var mergedParents = make([]PredictionContext, 0) // walk and merge to yield mergedParents, mergedReturnStates for i < len(a.returnStates) && j < len(b.returnStates) { - var a_parent = a.parents[i] - var b_parent = b.parents[j] + var aParent = a.parents[i] + var bParent = b.parents[j] if a.returnStates[i] == b.returnStates[j] { // same payload (stack tops are equal), must yield merged singleton var payload = a.returnStates[i] // $+$ = $ - var bothDollars = payload == BasePredictionContextEMPTY_RETURN_STATE && a_parent == nil && b_parent == nil - var ax_ax = (a_parent != nil && b_parent != nil && a_parent == b_parent) // ax+ax + var bothDollars = payload == BasePredictionContextEmptyReturnState && aParent == nil && bParent == nil + var axAX = (aParent != nil && bParent != nil && aParent == bParent) // ax+ax // -> // ax - if bothDollars || ax_ax { - mergedParents[k] = a_parent // choose left + if bothDollars || axAX { + mergedParents[k] = aParent // choose left mergedReturnStates[k] = payload } else { // ax+ay -> a'[x,y] - var mergedParent = merge(a_parent, b_parent, rootIsWildcard, mergeCache) + var mergedParent = merge(aParent, bParent, rootIsWildcard, mergeCache) mergedParents[k] = mergedParent mergedReturnStates[k] = payload } i++ // hop over left one as usual j++ // but also Skip one in right side since we merge } else if a.returnStates[i] < b.returnStates[j] { // copy a[i] to M - mergedParents[k] = a_parent + mergedParents[k] = aParent mergedReturnStates[k] = a.returnStates[i] i++ } else { // b > a, copy b[j] to M - mergedParents[k] = b_parent + mergedParents[k] = bParent mergedReturnStates[k] = b.returnStates[j] j++ } diff --git a/runtime/Go/antlr/recognizer.go b/runtime/Go/antlr/recognizer.go index fd6cc2b3e..fd49de7e0 100644 --- a/runtime/Go/antlr/recognizer.go +++ b/runtime/Go/antlr/recognizer.go @@ -25,7 +25,7 @@ type Recognizer interface { } type BaseRecognizer struct { - _listeners []ErrorListener + listeners []ErrorListener state int RuleNames []string @@ -36,7 +36,7 @@ type BaseRecognizer struct { func NewBaseRecognizer() *BaseRecognizer { rec := new(BaseRecognizer) - rec._listeners = []ErrorListener{ConsoleErrorListenerINSTANCE} + rec.listeners = []ErrorListener{ConsoleErrorListenerINSTANCE} rec.state = -1 return rec } @@ -56,11 +56,11 @@ func (b *BaseRecognizer) Action(context RuleContext, ruleIndex, actionIndex int) } func (b *BaseRecognizer) AddErrorListener(listener ErrorListener) { - b._listeners = append(b._listeners, listener) + b.listeners = append(b.listeners, listener) } func (b *BaseRecognizer) RemoveErrorListeners() { - b._listeners = make([]ErrorListener, 0) + b.listeners = make([]ErrorListener, 0) } func (b *BaseRecognizer) GetRuleNames() []string { @@ -203,7 +203,7 @@ func (b *BaseRecognizer) GetTokenErrorDisplay(t Token) string { } func (b *BaseRecognizer) GetErrorListenerDispatch() ErrorListener { - return NewProxyErrorListener(b._listeners) + return NewProxyErrorListener(b.listeners) } // subclass needs to override these if there are sempreds or actions diff --git a/runtime/Go/antlr/token.go b/runtime/Go/antlr/token.go index dbeec212b..02c51e909 100644 --- a/runtime/Go/antlr/token.go +++ b/runtime/Go/antlr/token.go @@ -42,7 +42,7 @@ type BaseToken struct { tokenIndex int // from 0..n-1 of the token object in the input stream line int // line=1..n of the 1st character column int // beginning of the line at which it occurs, 0..n-1 - _text string // text of the token. + text string // text of the token. readOnly bool } @@ -160,13 +160,13 @@ func (c *CommonToken) clone() *CommonToken { t.tokenIndex = c.GetTokenIndex() t.line = c.GetLine() t.column = c.GetColumn() - t._text = c.GetText() + t.text = c.GetText() return t } func (c *CommonToken) GetText() string { - if c._text != "" { - return c._text + if c.text != "" { + return c.text } var input = c.GetInputStream() if input == nil { @@ -180,7 +180,7 @@ func (c *CommonToken) GetText() string { } func (c *CommonToken) SetText(text string) { - c._text = text + c.text = text } func (c *CommonToken) String() string { diff --git a/runtime/Go/antlr/trace_listener.go b/runtime/Go/antlr/trace_listener.go index 8921d64d1..ed6d4fecd 100644 --- a/runtime/Go/antlr/trace_listener.go +++ b/runtime/Go/antlr/trace_listener.go @@ -16,13 +16,13 @@ func (t *TraceListener) VisitErrorNode(_ ErrorNode) { } func (t *TraceListener) EnterEveryRule(ctx ParserRuleContext) { - fmt.Println("enter " + t.parser.GetRuleNames()[ctx.GetRuleIndex()] + ", LT(1)=" + t.parser._input.LT(1).GetText()) + fmt.Println("enter " + t.parser.GetRuleNames()[ctx.GetRuleIndex()] + ", LT(1)=" + t.parser.input.LT(1).GetText()) } func (t *TraceListener) VisitTerminal(node TerminalNode) { - fmt.Println("consume " + fmt.Sprint(node.GetSymbol()) + " rule " + t.parser.GetRuleNames()[t.parser._ctx.GetRuleIndex()]) + fmt.Println("consume " + fmt.Sprint(node.GetSymbol()) + " rule " + t.parser.GetRuleNames()[t.parser.ctx.GetRuleIndex()]) } func (t *TraceListener) ExitEveryRule(ctx ParserRuleContext) { - fmt.Println("exit " + t.parser.GetRuleNames()[ctx.GetRuleIndex()] + ", LT(1)=" + t.parser._input.LT(1).GetText()) + fmt.Println("exit " + t.parser.GetRuleNames()[ctx.GetRuleIndex()] + ", LT(1)=" + t.parser.input.LT(1).GetText()) } diff --git a/runtime/Go/antlr/transition.go b/runtime/Go/antlr/transition.go index f9b0fe003..90f64288b 100644 --- a/runtime/Go/antlr/transition.go +++ b/runtime/Go/antlr/transition.go @@ -26,8 +26,8 @@ type Transition interface { type BaseTransition struct { target ATNState isEpsilon bool - label_ int - label *IntervalSet + label int + intervalSet *IntervalSet serializationType int } @@ -42,7 +42,7 @@ func NewBaseTransition(target ATNState) *BaseTransition { t.target = target // Are we epsilon, action, sempred? t.isEpsilon = false - t.label = nil + t.intervalSet = nil return t } @@ -60,7 +60,7 @@ func (t *BaseTransition) getIsEpsilon() bool { } func (t *BaseTransition) getLabel() *IntervalSet { - return t.label + return t.intervalSet } func (t *BaseTransition) getSerializationType() int { @@ -79,7 +79,7 @@ const ( TransitionATOM = 5 TransitionACTION = 6 TransitionSET = 7 // ~(A|B) or ~atom, wildcard, which convert to next 2 - TransitionNOT_SET = 8 + TransitionNOTSET = 8 TransitionWILDCARD = 9 TransitionPRECEDENCE = 10 ) @@ -117,7 +117,7 @@ var TransitionserializationNames = []string{ // TransitionATOM, // TransitionACTION, // TransitionSET, -// TransitionNOT_SET, +// TransitionNOTSET, // TransitionWILDCARD, // TransitionPRECEDENCE //} @@ -127,13 +127,13 @@ type AtomTransition struct { *BaseTransition } -func NewAtomTransition(target ATNState, label int) *AtomTransition { +func NewAtomTransition(target ATNState, intervalSet int) *AtomTransition { t := new(AtomTransition) t.BaseTransition = NewBaseTransition(target) - t.label_ = label // The token type or character value or, signifies special label. - t.label = t.makeLabel() + t.label = intervalSet // The token type or character value or, signifies special intervalSet. + t.intervalSet = t.makeLabel() t.serializationType = TransitionATOM return t @@ -141,16 +141,16 @@ func NewAtomTransition(target ATNState, label int) *AtomTransition { func (t *AtomTransition) makeLabel() *IntervalSet { var s = NewIntervalSet() - s.addOne(t.label_) + s.addOne(t.label) return s } func (t *AtomTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { - return t.label_ == symbol + return t.label == symbol } func (t *AtomTransition) String() string { - return strconv.Itoa(t.label_) + return strconv.Itoa(t.label) } type RuleTransition struct { @@ -217,7 +217,7 @@ func NewRangeTransition(target ATNState, start, stop int) *RangeTransition { t.serializationType = TransitionRANGE t.start = start t.stop = stop - t.label = t.makeLabel() + t.intervalSet = t.makeLabel() return t } @@ -325,21 +325,21 @@ func NewSetTransition(target ATNState, set *IntervalSet) *SetTransition { t.serializationType = TransitionSET if set != nil { - t.label = set + t.intervalSet = set } else { - t.label = NewIntervalSet() - t.label.addOne(TokenInvalidType) + t.intervalSet = NewIntervalSet() + t.intervalSet.addOne(TokenInvalidType) } return t } func (t *SetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { - return t.label.contains(symbol) + return t.intervalSet.contains(symbol) } func (t *SetTransition) String() string { - return t.label.String() + return t.intervalSet.String() } type NotSetTransition struct { @@ -352,17 +352,17 @@ func NewNotSetTransition(target ATNState, set *IntervalSet) *NotSetTransition { t.SetTransition = NewSetTransition(target, set) - t.serializationType = TransitionNOT_SET + t.serializationType = TransitionNOTSET return t } func (t *NotSetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { - return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !t.label.contains(symbol) + return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !t.intervalSet.contains(symbol) } func (t *NotSetTransition) String() string { - return "~" + t.label.String() + return "~" + t.intervalSet.String() } type WildcardTransition struct { diff --git a/runtime/Go/antlr/trees.go b/runtime/Go/antlr/trees.go index 2cfb27ffc..8a69e6440 100644 --- a/runtime/Go/antlr/trees.go +++ b/runtime/Go/antlr/trees.go @@ -93,11 +93,11 @@ func TreesfindAllRuleNodes(t ParseTree, ruleIndex int) []ParseTree { func TreesfindAllNodes(t ParseTree, index int, findTokens bool) []ParseTree { var nodes = make([]ParseTree, 0) - Trees_findAllNodes(t, index, findTokens, nodes) + TreesFindAllNodes(t, index, findTokens, nodes) return nodes } -func Trees_findAllNodes(t ParseTree, index int, findTokens bool, nodes []ParseTree) { +func TreesFindAllNodes(t ParseTree, index int, findTokens bool, nodes []ParseTree) { // check this node (the root) first t2, ok := t.(TerminalNode) @@ -114,7 +114,7 @@ func Trees_findAllNodes(t ParseTree, index int, findTokens bool, nodes []ParseTr } // check children for i := 0; i < t.GetChildCount(); i++ { - Trees_findAllNodes(t.GetChild(i).(ParseTree), index, findTokens, nodes) + TreesFindAllNodes(t.GetChild(i).(ParseTree), index, findTokens, nodes) } }