From 2df791a2661e0b4e0ba8e247d7e9680ee7119854 Mon Sep 17 00:00:00 2001 From: Peter Boyer Date: Sat, 19 Dec 2015 18:28:22 -0500 Subject: [PATCH] LexerATNSimulator --- runtime/Go/src/antlr4/ATNConfig.go | 138 +++++++++--------- runtime/Go/src/antlr4/LexerATNSimulator.go | 62 ++++---- runtime/Go/src/antlr4/SemanticContext.go | 7 +- runtime/Go/src/antlr4/Transition.go | 8 +- .../src/antlr4/atn/SemanticContext.js | 2 +- 5 files changed, 105 insertions(+), 112 deletions(-) diff --git a/runtime/Go/src/antlr4/ATNConfig.go b/runtime/Go/src/antlr4/ATNConfig.go index c49a359cf..33bee08de 100644 --- a/runtime/Go/src/antlr4/ATNConfig.go +++ b/runtime/Go/src/antlr4/ATNConfig.go @@ -78,73 +78,6 @@ func (a *ATNConfig) InitATNConfig(c *ATNConfig, state *ATNState, context *Predic } -// -// -//func checkParams(params *ATNConfig, isCfg bool) *ATNConfigParams { -// if(params == nil) { -// var result = { state:nil, alt:nil, context:nil, semanticContext:nil } -// if(isCfg) { -// result.reachesIntoOuterContext = 0 -// } -// return result -// } else { -// var props = {} -// props.state = params.state || nil -// props.alt = params.alt || nil -// props.context = params.context || nil -// props.semanticContext = params.semanticContext || nil -// if(isCfg) { -// props.reachesIntoOuterContext = params.reachesIntoOuterContext || 0 -// props.precedenceFilterSuppressed = params.precedenceFilterSuppressed || false -// } -// return props -// } -//} -// -// -//func NewATNConfig(params *ATNConfig, config *ATNConfig) *ATNConfig { -// -// this := new(ATNConfig) -// -// this.checkContext(params, config) -// -// params = checkParams(params, false) -// config = checkParams(config, true) -// -// if params.state != nil { -// this.state = params.state -// } else { -// this.state = config.state -// } -// -// if params.alt != nil { -// this.alt = params.alt -// } else { -// this.alt = config.alt -// } -// -// this.context = params.context!=nil ? params.context : config.context -// -// this.semanticContext = params.semanticContext!=nil ? params.semanticContext : -// (config.semanticContext!=nil ? config.semanticContext : SemanticContext.NONE) -// -// this.reachesIntoOuterContext = config.reachesIntoOuterContext -// this.precedenceFilterSuppressed = config.precedenceFilterSuppressed -// -// return this -//} -// -// -// -// -// -//func (this *ATNConfig) checkContext(params, config) { -// if((params.context==nil || params.context==nil) && -// (config==nil || config.context==nil || config.context==nil)) { -// this.context = nil -// } -//} - // An ATN configuration is equal to another if both have // the same state, they predict the same alternative, and // syntactic/semantic contexts are the same. @@ -203,11 +136,74 @@ type LexerATNConfig struct { passedThroughNonGreedyDecision bool } -func NewLexerATNConfig( state *ATNState, alt int, context *PredictionContext) *LexerATNConfig { + + + + + + +func checkNonGreedyDecision(source *LexerATNConfig, target *ATNState) bool { + ds, ok := target.(*DecisionState) + return source.passedThroughNonGreedyDecision || (ok && ds.nonGreedy) +} + +func NewLexerATNConfig6(state *ATNState, alt int, context *PredictionContext) *LexerATNConfig { this := new(LexerATNConfig) this.InitATNConfig(state, alt, context, SemanticContextNONE) + this.passedThroughNonGreedyDecision = false + this.lexerActionExecutor = nil + return this +} + +func NewLexerATNConfig5(state *ATNState, alt int, context *PredictionContext, lexerActionExecutor *LexerActionExecutor) *LexerATNConfig { + + this := new(LexerATNConfig) + + this.InitATNConfig(state, alt, context, SemanticContextNONE) + this.lexerActionExecutor = lexerActionExecutor + this.passedThroughNonGreedyDecision = false + return this +} + +func NewLexerATNConfig4(c *LexerATNConfig, state *ATNState) *LexerATNConfig { + + this := new(LexerATNConfig) + + this.InitATNConfig(c, state, c.context, c.semanticContext) + this.lexerActionExecutor = c.lexerActionExecutor + this.passedThroughNonGreedyDecision = checkNonGreedyDecision(c, state) + return this +} + +func NewLexerATNConfig3(c *LexerATNConfig, state *ATNState, lexerActionExecutor *LexerActionExecutor) *LexerATNConfig { + + this := new(LexerATNConfig) + + this.InitATNConfig(c, state, c.context, c.semanticContext) + this.lexerActionExecutor = lexerActionExecutor + this.passedThroughNonGreedyDecision = checkNonGreedyDecision(c, state) + return this +} + +func NewLexerATNConfig2(c *LexerATNConfig, state *ATNState, context *PredictionContext) *LexerATNConfig { + + this := new(LexerATNConfig) + + this.InitATNConfig(c, state, context, c.semanticContext) + this.lexerActionExecutor = c.lexerActionExecutor + this.passedThroughNonGreedyDecision = checkNonGreedyDecision(c, state) + return this +} + + +func NewLexerATNConfig1( state *ATNState, alt int, context *PredictionContext) *LexerATNConfig { + + this := new(LexerATNConfig) + + // c *ATNConfig, state *ATNState, context *PredictionContext, semanticContext *SemanticContext + this.InitATNConfig(state, alt, context, SemanticContextNONE) this.lexerActionExecutor = nil this.passedThroughNonGreedyDecision = false @@ -215,6 +211,7 @@ func NewLexerATNConfig( state *ATNState, alt int, context *PredictionContext) *L return this } + func (this *LexerATNConfig) hashString() { var f string @@ -255,9 +252,4 @@ func (this *LexerATNConfig) equals(other *ATNConfig) bool { } } -//func (this *LexerATNConfig) checkNonGreedyDecision(source, target) { -// return source.passedThroughNonGreedyDecision || -// _, ok := target.(DecisionState); ok && target.nonGreedy -//} - diff --git a/runtime/Go/src/antlr4/LexerATNSimulator.go b/runtime/Go/src/antlr4/LexerATNSimulator.go index 8026da097..f83c8694a 100644 --- a/runtime/Go/src/antlr4/LexerATNSimulator.go +++ b/runtime/Go/src/antlr4/LexerATNSimulator.go @@ -261,7 +261,7 @@ func (this *LexerATNSimulator) computeTargetState(input *InputStream, s *DFAStat if (!reach.hasSemanticContext) { // we got nowhere on t, don't panic out this knowledge it'd // cause a failover from DFA later. - this.addDFAEdge(s, t, ATNSimulatorERROR) + this.addDFAEdge(s, t, ATNSimulatorERROR, nil) } // stop when we can't match any more char return ATNSimulatorERROR @@ -281,7 +281,7 @@ func (this *LexerATNSimulator) failOrAccept(prevAccept *SimState, input *InputSt if (t == TokenEOF && input.index == this.startIndex) { return TokenEOF } - panic NewLexerNoViableAltException(this.recog, input, this.startIndex, reach) + panic(NewLexerNoViableAltException(this.recog, input, this.startIndex, reach)) } } @@ -295,23 +295,22 @@ func (this *LexerATNSimulator) getReachableConfigSet(input *InputStream, closure for i := 0; i < len(closure.configs); i++ { var cfg = closure.configs[i] var currentAltReachedAcceptState = (cfg.alt == skipAlt) - if (currentAltReachedAcceptState && cfg.passedThroughNonGreedyDecision) { + if (currentAltReachedAcceptState && cfg.(*LexerATNConfig).passedThroughNonGreedyDecision) { continue } if (LexerATNSimulatordebug) { - fmt.Println("testing %s at %s\n", this.getTokenName(t), cfg - .toString(this.recog, true)) + fmt.Println("testing %s at %s\n", this.getTokenName(t), cfg.toString(this.recog, true)) } for j := 0; j < len(cfg.state.transitions); j++ { var trans = cfg.state.transitions[j] // for each transition var target = this.getReachableTarget(trans, t) if (target != nil) { - var lexerActionExecutor = cfg.lexerActionExecutor + var lexerActionExecutor = cfg.(*LexerATNConfig).lexerActionExecutor if (lexerActionExecutor != nil) { lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - this.startIndex) } var treatEofAsEpsilon = (t == TokenEOF) - var config = NewLexerATNConfig({state:target, lexerActionExecutor:lexerActionExecutor}, cfg) + var config = NewLexerATNConfig3(cfg, target, lexerActionExecutor) if (this.closure(input, config, reach, currentAltReachedAcceptState, true, treatEofAsEpsilon)) { // any remaining configs for this alt have a lower priority @@ -344,12 +343,12 @@ func (this *LexerATNSimulator) getReachableTarget(trans *Transition, t int) *ATN } } -func (this *LexerATNSimulator) computeStartState(input *InputStream, p *ATNState ) { - var initialContext = PredictionContextEMPTY +func (this *LexerATNSimulator) computeStartState(input *InputStream, p *ATNState ) *OrderedATNConfigSet { + var configs = NewOrderedATNConfigSet() for i := 0; i < len(p.transitions); i++ { var target = p.transitions[i].target - var cfg = NewLexerATNConfig({state:target, alt:i+1, context:initialContext}, nil) + var cfg = NewLexerATNConfig6(target, i+1, PredictionContextEMPTY) this.closure(input, cfg, configs, false, false, false) } return configs @@ -369,7 +368,9 @@ func (this *LexerATNSimulator) closure(input *InputStream, config *LexerATNConfi if (LexerATNSimulatordebug) { fmt.Println("closure(" + config.toString(this.recog, true) + ")") } - if (config.state instanceof RuleStopState) { + + _, ok :=config.state.(*RuleStopState) + if (ok) { if (LexerATNSimulatordebug) { if (this.recog != nil) { fmt.Println("closure at %s rule stop %s\n", this.recog.getRuleNames()[config.state.ruleIndex], config) @@ -379,10 +380,10 @@ func (this *LexerATNSimulator) closure(input *InputStream, config *LexerATNConfi } if (config.context == nil || config.context.hasEmptyPath()) { if (config.context == nil || config.context.isEmpty()) { - configs.add(config) + configs.add(config, nil) return true } else { - configs.add(NewLexerATNConfig({ state:config.state, context:PredictionContextEMPTY}, config)) + configs.add(NewLexerATNConfig2(config, config.state, PredictionContextEMPTY), nil) currentAltReachedAcceptState = true } } @@ -391,10 +392,8 @@ func (this *LexerATNSimulator) closure(input *InputStream, config *LexerATNConfi if (config.context.getReturnState(i) != PredictionContextEMPTY_RETURN_STATE) { var newContext = config.context.getParent(i) // "pop" return state var returnState = this.atn.states[config.context.getReturnState(i)] - cfg = NewLexerATNConfig({ state:returnState, context:newContext }, config) - currentAltReachedAcceptState = this.closure(input, cfg, - configs, currentAltReachedAcceptState, speculative, - treatEofAsEpsilon) + cfg := NewLexerATNConfig2(config, returnState, newContext) + currentAltReachedAcceptState = this.closure(input, cfg, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon) } } } @@ -403,12 +402,12 @@ func (this *LexerATNSimulator) closure(input *InputStream, config *LexerATNConfi // optimization if (!config.state.epsilonOnlyTransitions) { if (!currentAltReachedAcceptState || !config.passedThroughNonGreedyDecision) { - configs.add(config) + configs.add(config, nil) } } for j := 0; j < len(config.state.transitions); j++ { var trans = config.state.transitions[j] - cfg = this.getEpsilonTarget(input, config, trans, configs, speculative, treatEofAsEpsilon) + cfg := this.getEpsilonTarget(input, config, trans, configs, speculative, treatEofAsEpsilon) if (cfg != nil) { currentAltReachedAcceptState = this.closure(input, cfg, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon) @@ -424,10 +423,13 @@ func (this *LexerATNSimulator) getEpsilonTarget(input *InputStream, config *Lexe var cfg *LexerATNConfig if (trans.serializationType == TransitionRULE) { - var newContext = SingletonPredictionContext.create(config.context, trans.followState.stateNumber) - cfg = NewLexerATNConfig( { state:trans.target, context:newContext}, config) + + rt := trans.(*RuleTransition) + var newContext = SingletonPredictionContextcreate(config.context, rt.followState.stateNumber) + cfg = NewLexerATNConfig2(config, trans.target, newContext ) + } else if (trans.serializationType == TransitionPRECEDENCE) { - panic "Precedence predicates are not supported in lexers." + panic("Precedence predicates are not supported in lexers.") } else if (trans.serializationType == TransitionPREDICATE) { // Track traversing semantic predicates. If we traverse, // we cannot add a DFA state for this "reach" computation @@ -447,12 +449,14 @@ func (this *LexerATNSimulator) getEpsilonTarget(input *InputStream, config *Lexe // states reached by traversing predicates. Since this is when we // test them, we cannot cash the DFA state target of ID. + pt := trans.(*PredicateTransition) + if (LexerATNSimulatordebug) { - fmt.Println("EVAL rule " + trans.ruleIndex + ":" + trans.predIndex) + fmt.Println("EVAL rule " + trans.(*PredicateTransition).ruleIndex + ":" + pt.predIndex) } configs.hasSemanticContext = true - if (this.evaluatePredicate(input, trans.ruleIndex, trans.predIndex, speculative)) { - cfg = NewLexerATNConfig({ state:trans.target}, config) + if (this.evaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative)) { + cfg = NewLexerATNConfig4(config, trans.target) } } else if (trans.serializationType == TransitionACTION) { if (config.context == nil || config.context.hasEmptyPath()) { @@ -469,19 +473,19 @@ func (this *LexerATNSimulator) getEpsilonTarget(input *InputStream, config *Lexe // additional modifications are needed before we can support // the split operation. var lexerActionExecutor = LexerActionExecutorappend(config.lexerActionExecutor, this.atn.lexerActions[trans.actionIndex]) - cfg = NewLexerATNConfig({ state:trans.target, lexerActionExecutor:lexerActionExecutor }, config) + cfg = NewLexerATNConfig3(config, trans.target, lexerActionExecutor) } else { // ignore actions in referenced rules - cfg = NewLexerATNConfig( { state:trans.target}, config) + cfg = NewLexerATNConfig4(config, trans.target) } } else if (trans.serializationType == TransitionEPSILON) { - cfg = NewLexerATNConfig({ state:trans.target}, config) + cfg = NewLexerATNConfig4(config, trans.target) } else if (trans.serializationType == TransitionATOM || trans.serializationType == TransitionRANGE || trans.serializationType == TransitionSET) { if (treatEofAsEpsilon) { if (trans.matches(TokenEOF, 0, 0xFFFF)) { - cfg = NewLexerATNConfig( { state:trans.target }, config) + cfg = NewLexerATNConfig4(config, trans.target) } } } diff --git a/runtime/Go/src/antlr4/SemanticContext.go b/runtime/Go/src/antlr4/SemanticContext.go index e7ac05cbc..5a241d2e1 100644 --- a/runtime/Go/src/antlr4/SemanticContext.go +++ b/runtime/Go/src/antlr4/SemanticContext.go @@ -107,7 +107,7 @@ type PrecedencePredicate struct { precedence int } -func PrecedencePredicate(precedence int) *PrecedencePredicate { +func NewPrecedencePredicate(precedence int) *PrecedencePredicate { this := new(PrecedencePredicate) this.precedence = precedence @@ -115,9 +115,6 @@ func PrecedencePredicate(precedence int) *PrecedencePredicate { return this } -//PrecedencePredicate.prototype = Object.create(SemanticContext.prototype) -//PrecedencePredicate.prototype.constructor = PrecedencePredicate - func (this *PrecedencePredicate) evaluate(parser *Recognizer, outerContext *RuleContext) *SemanticContext { return parser.precpred(outerContext, this.precedence) } @@ -272,7 +269,7 @@ func (this *AND) evalPrecedence(parser *Recognizer, outerContext *RuleContext) * if (result == nil){ result = 0 } else { - result = SemanticPredicateandContext(result, o) + result = SemanticContextandContext(result, o) } } diff --git a/runtime/Go/src/antlr4/Transition.go b/runtime/Go/src/antlr4/Transition.go index a900ea236..81144b5c1 100644 --- a/runtime/Go/src/antlr4/Transition.go +++ b/runtime/Go/src/antlr4/Transition.go @@ -235,7 +235,7 @@ type PredicateTransition struct { ruleIndex, predIndex int } -func PredicateTransition ( target *ATNState, ruleIndex, predIndex int, isCtxDependent bool ) *PredicateTransition { +func NewPredicateTransition ( target *ATNState, ruleIndex, predIndex int, isCtxDependent bool ) *PredicateTransition { t := new(PredicateTransition) t.InitTransition(target) @@ -332,7 +332,7 @@ type NotSetTransition struct { SetTransition } -func NotSetTransition ( target *ATNState, set *IntervalSet) *NotSetTransition { +func NewNotSetTransition ( target *ATNState, set *IntervalSet) *NotSetTransition { t := new(NotSetTransition) t.InitTransition( target ) @@ -379,7 +379,7 @@ type PrecedencePredicateTransition struct { precedence int } -func PrecedencePredicateTransition ( target *ATNState, precedence int ) *PrecedencePredicateTransition { +func NewPrecedencePredicateTransition ( target *ATNState, precedence int ) *PrecedencePredicateTransition { t := new(PrecedencePredicateTransition) t.InitTransition( target ) @@ -396,7 +396,7 @@ func (t *PrecedencePredicateTransition) matches(symbol, minVocabSymbol, maxVoca return false } -func (t *PrecedencePredicateTransition) getPredicate() *NewPrecedencePredicate { +func (t *PrecedencePredicateTransition) getPredicate() *PrecedencePredicate { return NewPrecedencePredicate(t.precedence) } diff --git a/runtime/JavaScript/src/antlr4/atn/SemanticContext.js b/runtime/JavaScript/src/antlr4/atn/SemanticContext.js index 269034f28..256288a2b 100644 --- a/runtime/JavaScript/src/antlr4/atn/SemanticContext.js +++ b/runtime/JavaScript/src/antlr4/atn/SemanticContext.js @@ -301,7 +301,7 @@ AND.prototype.evalPrecedence = function(parser, outerContext) { } var result = null; operands.map(function(o) { - result = result === null ? o : SemanticPredicate.andContext(result, o); + result = result === null ? o : SemanticContext.andContext(result, o); }); return result; };