private static bool TestTailCall(ATN atn, RuleTransition transition, bool optimizedPath) { if (!optimizedPath && transition.tailCall) { return true; } if (optimizedPath && transition.optimizedTailCall) { return true; } BitSet reachable = new BitSet(atn.states.Count); Stack<ATNState> worklist = new Stack<ATNState>(); worklist.Push(transition.followState); while (worklist.Count > 0) { ATNState state = worklist.Pop(); if (reachable.Get(state.stateNumber)) { continue; } if (state is RuleStopState) { continue; } if (!state.OnlyHasEpsilonTransitions) { return false; } IList<Transition> transitions = optimizedPath ? state.optimizedTransitions : state.transitions; foreach (Transition t in transitions) { if (t.TransitionType != TransitionType.EPSILON) { return false; } worklist.Push(t.target); } } return true; }
protected internal virtual Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets) { ATNState target = atn.states[trg]; switch (type) { case TransitionType.EPSILON: { return new EpsilonTransition(target); } case TransitionType.RANGE: { if (arg3 != 0) { return new RangeTransition(target, TokenConstants.EOF, arg2); } else { return new RangeTransition(target, arg1, arg2); } } case TransitionType.RULE: { RuleTransition rt = new RuleTransition((RuleStartState)atn.states[arg1], arg2, arg3, target); return rt; } case TransitionType.PREDICATE: { PredicateTransition pt = new PredicateTransition(target, arg1, arg2, arg3 != 0); return pt; } case TransitionType.PRECEDENCE: { return new PrecedencePredicateTransition(target, arg1); } case TransitionType.ATOM: { if (arg3 != 0) { return new AtomTransition(target, TokenConstants.EOF); } else { return new AtomTransition(target, arg1); } } case TransitionType.ACTION: { ActionTransition a = new ActionTransition(target, arg1, arg2, arg3 != 0); return a; } case TransitionType.SET: { return new SetTransition(target, sets[arg1]); } case TransitionType.NOT_SET: { return new NotSetTransition(target, sets[arg1]); } case TransitionType.WILDCARD: { return new WildcardTransition(target); } } throw new ArgumentException("The specified transition type is not valid."); }
protected ATNConfig RuleTransition(ATNConfig config, RuleTransition t) { if (debug) { Console.WriteLine("CALL rule " + GetRuleName(t.target.ruleIndex) + ", ctx=" + config.context); } ATNState returnState = t.followState; PredictionContext newContext = SingletonPredictionContext.Create(config.context, returnState.stateNumber); return new ATNConfig(config, t.target, newContext); }
protected internal virtual Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets) { ATNState target = atn.states[trg]; switch (type) { case TransitionType.Epsilon: { return new EpsilonTransition(target); } case TransitionType.Range: { if (arg3 != 0) { return new RangeTransition(target, TokenConstants.Eof, arg2); } else { return new RangeTransition(target, arg1, arg2); } } case TransitionType.Rule: { RuleTransition rt = new RuleTransition((RuleStartState)atn.states[arg1], arg2, arg3, target); return rt; } case TransitionType.Predicate: { PredicateTransition pt = new PredicateTransition(target, arg1, arg2, arg3 != 0); return pt; } case TransitionType.Precedence: { return new PrecedencePredicateTransition(target, arg1); } case TransitionType.Atom: { if (arg3 != 0) { return new AtomTransition(target, TokenConstants.Eof); } else { return new AtomTransition(target, arg1); } } case TransitionType.Action: { ActionTransition a = new ActionTransition(target, arg1, arg2, arg3 != 0); return a; } case TransitionType.Set: { return new SetTransition(target, sets[arg1]); } case TransitionType.NotSet: { return new NotSetTransition(target, sets[arg1]); } case TransitionType.Wildcard: { return new WildcardTransition(target); } } throw new ArgumentException("The specified transition type is not valid."); }
protected internal virtual void ReadEdges(ATN atn, IList <IntervalSet> sets) { // // EDGES // int nedges = ReadInt(); for (int i_9 = 0; i_9 < nedges; i_9++) { int src = ReadInt(); int trg = ReadInt(); TransitionType ttype = (TransitionType)ReadInt(); int arg1 = ReadInt(); int arg2 = ReadInt(); int arg3 = ReadInt(); Transition trans = EdgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets); ATNState srcState = atn.states[src]; srcState.AddTransition(trans); } // edges for rule stop states can be derived, so they aren't serialized foreach (ATNState state_1 in atn.states) { for (int i_10 = 0; i_10 < state_1.NumberOfTransitions; i_10++) { Transition t = state_1.Transition(i_10); if (!(t is RuleTransition)) { continue; } RuleTransition ruleTransition = (RuleTransition)t; int outermostPrecedenceReturn = -1; if (atn.ruleToStartState[ruleTransition.target.ruleIndex].isPrecedenceRule) { if (ruleTransition.precedence == 0) { outermostPrecedenceReturn = ruleTransition.target.ruleIndex; } } EpsilonTransition returnTransition = new EpsilonTransition(ruleTransition.followState, outermostPrecedenceReturn); atn.ruleToStopState[ruleTransition.target.ruleIndex].AddTransition(returnTransition); } } foreach (ATNState state_2 in atn.states) { if (state_2 is BlockStartState) { // we need to know the end state to set its start state if (((BlockStartState)state_2).endState == null) { throw new InvalidOperationException(); } // block end states can only be associated to a single block start state if (((BlockStartState)state_2).endState.startState != null) { throw new InvalidOperationException(); } ((BlockStartState)state_2).endState.startState = (BlockStartState)state_2; } else if (state_2 is PlusLoopbackState) { PlusLoopbackState loopbackState = (PlusLoopbackState)state_2; for (int i_10 = 0; i_10 < loopbackState.NumberOfTransitions; i_10++) { ATNState target = loopbackState.Transition(i_10).target; if (target is PlusBlockStartState) { ((PlusBlockStartState)target).loopBackState = loopbackState; } } } else if (state_2 is StarLoopbackState) { StarLoopbackState loopbackState = (StarLoopbackState)state_2; for (int i_10 = 0; i_10 < loopbackState.NumberOfTransitions; i_10++) { ATNState target = loopbackState.Transition(i_10).target; if (target is StarLoopEntryState) { ((StarLoopEntryState)target).loopBackState = loopbackState; } } } } }
protected internal virtual Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList <IntervalSet> sets) { ATNState target = atn.states[trg]; switch (type) { case TransitionType.EPSILON: { return(new EpsilonTransition(target)); } case TransitionType.RANGE: { if (arg3 != 0) { return(new RangeTransition(target, TokenConstants.EOF, arg2)); } else { return(new RangeTransition(target, arg1, arg2)); } } case TransitionType.RULE: { RuleTransition rt = new RuleTransition((RuleStartState)atn.states[arg1], arg2, arg3, target); return(rt); } case TransitionType.PREDICATE: { PredicateTransition pt = new PredicateTransition(target, arg1, arg2, arg3 != 0); return(pt); } case TransitionType.PRECEDENCE: { return(new PrecedencePredicateTransition(target, arg1)); } case TransitionType.ATOM: { if (arg3 != 0) { return(new AtomTransition(target, TokenConstants.EOF)); } else { return(new AtomTransition(target, arg1)); } } case TransitionType.ACTION: { ActionTransition a = new ActionTransition(target, arg1, arg2, arg3 != 0); return(a); } case TransitionType.SET: { return(new SetTransition(target, sets[arg1])); } case TransitionType.NOT_SET: { return(new NotSetTransition(target, sets[arg1])); } case TransitionType.WILDCARD: { return(new WildcardTransition(target)); } } throw new ArgumentException("The specified transition type is not valid."); }
/// <summary> /// Compute set of tokens that can follow /// <paramref name="s"/> /// in the ATN in the /// specified /// <paramref name="ctx"/> /// . /// <p/> /// If /// <paramref name="ctx"/> /// is /// <see cref="PredictionContext.EmptyLocal"/> /// and /// <paramref name="stopState"/> /// or the end of the rule containing /// <paramref name="s"/> /// is reached, /// <see cref="TokenConstants.EPSILON"/> /// is added to the result set. If /// <paramref name="ctx"/> /// is not /// <see cref="PredictionContext.EmptyLocal"/> /// and /// <paramref name="addEOF"/> /// is /// <see langword="true"/> /// and /// <paramref name="stopState"/> /// or the end of the outermost rule is reached, /// <see cref="TokenConstants.EOF"/> /// is added to the result set. /// </summary> /// <param name="s">the ATN state.</param> /// <param name="stopState"> /// the ATN state to stop at. This can be a /// <see cref="BlockEndState"/> /// to detect epsilon paths through a closure. /// </param> /// <param name="ctx"> /// The outer context, or /// <see cref="PredictionContext.EmptyLocal"/> /// if /// the outer context should not be used. /// </param> /// <param name="look">The result lookahead set.</param> /// <param name="lookBusy"> /// A set used for preventing epsilon closures in the ATN /// from causing a stack overflow. Outside code should pass /// <c>new HashSet<ATNConfig></c> /// for this argument. /// </param> /// <param name="calledRuleStack"> /// A set used for preventing left recursion in the /// ATN from causing a stack overflow. Outside code should pass /// <c>new BitSet()</c> /// for this argument. /// </param> /// <param name="seeThruPreds"> /// /// <see langword="true"/> /// to true semantic predicates as /// implicitly /// <see langword="true"/> /// and "see through them", otherwise /// <see langword="false"/> /// to treat semantic predicates as opaque and add /// <see cref="HitPred"/> /// to the /// result if one is encountered. /// </param> /// <param name="addEOF"> /// Add /// <see cref="TokenConstants.EOF"/> /// to the result if the end of the /// outermost context is reached. This parameter has no effect if /// <paramref name="ctx"/> /// is /// <see cref="PredictionContext.EmptyLocal"/> /// . /// </param> protected internal virtual void Look(ATNState s, ATNState stopState, PredictionContext ctx, IntervalSet look, HashSet <ATNConfig> lookBusy, BitSet calledRuleStack, bool seeThruPreds, bool addEOF) { // System.out.println("_LOOK("+s.stateNumber+", ctx="+ctx); ATNConfig c = new ATNConfig(s, 0, ctx); if (!lookBusy.Add(c)) { return; } if (s == stopState) { if (ctx == null) { look.Add(TokenConstants.EPSILON); return; } else if (ctx.IsEmpty && addEOF) { look.Add(TokenConstants.EOF); return; } } if (s is RuleStopState) { if (ctx == null) { look.Add(TokenConstants.EPSILON); return; } else if (ctx.IsEmpty && addEOF) { look.Add(TokenConstants.EOF); return; } if (ctx != PredictionContext.EMPTY) { for (int i = 0; i < ctx.Size; i++) { ATNState returnState = atn.states[ctx.GetReturnState(i)]; bool removed = calledRuleStack.Get(returnState.ruleIndex); try { calledRuleStack.Clear(returnState.ruleIndex); Look(returnState, stopState, ctx.GetParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF); } finally { if (removed) { calledRuleStack.Set(returnState.ruleIndex); } } } return; } } int n = s.NumberOfTransitions; for (int i_1 = 0; i_1 < n; i_1++) { Transition t = s.Transition(i_1); if (t is RuleTransition) { RuleTransition ruleTransition = (RuleTransition)t; if (calledRuleStack.Get(ruleTransition.ruleIndex)) { continue; } PredictionContext newContext = SingletonPredictionContext.Create(ctx, ruleTransition.followState.stateNumber); try { calledRuleStack.Set(ruleTransition.target.ruleIndex); Look(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF); } finally { calledRuleStack.Clear(ruleTransition.target.ruleIndex); } } else { if (t is AbstractPredicateTransition) { if (seeThruPreds) { Look(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF); } else { look.Add(HitPred); } } else { if (t.IsEpsilon) { Look(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF); } else { if (t is WildcardTransition) { look.AddAll(IntervalSet.Of(TokenConstants.MinUserTokenType, atn.maxTokenType)); } else { IntervalSet set = t.Label; if (set != null) { if (t is NotSetTransition) { set = set.Complement(IntervalSet.Of(TokenConstants.MinUserTokenType, atn.maxTokenType)); } look.AddAll(set); } } } } } } }