/// <summary> /// Creates a copy of this transition but with another target /// state. /// </summary> /// <param name="state">The new target state</param> /// <returns>An identical copy of this transition</returns> public override NFATransition Copy(NFAState state) { return(new NFADotTransition(state)); }
/** Fill a list of all NFA states visited during the parse */ protected virtual void ParseEngine(string startRule, NFAState start, NFAState stop, IIntStream input, Stack <object> ruleInvocationStack, IDebugEventListener actions, IList <NFAState> visitedStates) { NFAState s = start; if (actions != null) { actions.EnterRule(s.nfa.grammar.FileName, start.enclosingRule.Name); } int t = input.LA(1); while (s != stop) { if (visitedStates != null) { visitedStates.Add(s); } //Console.Out.WriteLine( "parse state " + s.stateNumber + " input=" + s.nfa.grammar.getTokenDisplayName( t ) ); // CASE 1: decision state if (s.DecisionNumber > 0 && s.nfa.grammar.GetNumberOfAltsForDecisionNFA(s) > 1) { // decision point, must predict and jump to alt DFA dfa = s.nfa.grammar.GetLookaheadDFA(s.DecisionNumber); //if ( s.nfa.grammar.type != GrammarType.Lexer ) //{ // Console.Out.WriteLine( "decision: " + // dfa.getNFADecisionStartState().Description + // " input=" + s.nfa.grammar.getTokenDisplayName( t ) ); //} int m = input.Mark(); int predictedAlt = Predict(dfa); if (predictedAlt == NFA.INVALID_ALT_NUMBER) { string description = dfa.NFADecisionStartState.Description; NoViableAltException nvae = new NoViableAltException(description, dfa.DecisionNumber, s.stateNumber, input); if (actions != null) { actions.RecognitionException(nvae); } input.Consume(); // recover throw nvae; } input.Rewind(m); int parseAlt = s.TranslateDisplayAltToWalkAlt(predictedAlt); //if ( s.nfa.grammar.type != GrammarType.Lexer ) //{ // Console.Out.WriteLine( "predicted alt " + predictedAlt + ", parseAlt " + parseAlt ); //} NFAState alt; if (parseAlt > s.nfa.grammar.GetNumberOfAltsForDecisionNFA(s)) { // implied branch of loop etc... alt = s.nfa.grammar.nfa.GetState(s.endOfBlockStateNumber); } else { alt = s.nfa.grammar.GetNFAStateForAltOfDecision(s, parseAlt); } s = (NFAState)alt.transition[0].target; continue; } // CASE 2: finished matching a rule if (s.IsAcceptState) { // end of rule node if (actions != null) { actions.ExitRule(s.nfa.grammar.FileName, s.enclosingRule.Name); } if (ruleInvocationStack.Count == 0) { // done parsing. Hit the start state. //Console.Out.WriteLine( "stack empty in stop state for " + s.enclosingRule ); break; } // pop invoking state off the stack to know where to return to NFAState invokingState = (NFAState)ruleInvocationStack.Pop(); RuleClosureTransition invokingTransition = (RuleClosureTransition)invokingState.transition[0]; // move to node after state that invoked this rule s = invokingTransition.followState; continue; } Transition trans = s.transition[0]; Label label = trans.label; if (label.IsSemanticPredicate) { FailedPredicateException fpe = new FailedPredicateException(input, s.enclosingRule.Name, "can't deal with predicates yet"); if (actions != null) { actions.RecognitionException(fpe); } } // CASE 3: epsilon transition if (label.IsEpsilon) { // CASE 3a: rule invocation state if (trans is RuleClosureTransition) { ruleInvocationStack.Push(s); s = (NFAState)trans.target; //Console.Out.WriteLine( "call " + s.enclosingRule.name + " from " + s.nfa.grammar.getFileName() ); if (actions != null) { actions.EnterRule(s.nfa.grammar.FileName, s.enclosingRule.Name); } // could be jumping to new grammar, make sure DFA created if (!s.nfa.grammar.AllDecisionDFAHaveBeenCreated) { s.nfa.grammar.CreateLookaheadDFAs(); } } // CASE 3b: plain old epsilon transition, just move else { s = (NFAState)trans.target; } } // CASE 4: match label on transition else if (label.Matches(t)) { if (actions != null) { if (s.nfa.grammar.type == GrammarType.Parser || s.nfa.grammar.type == GrammarType.Combined) { actions.ConsumeToken(((ITokenStream)input).LT(1)); } } s = (NFAState)s.transition[0].target; input.Consume(); t = input.LA(1); } // CASE 5: error condition; label is inconsistent with input else { if (label.IsAtom) { MismatchedTokenException mte = new MismatchedTokenException(label.Atom, input); if (actions != null) { actions.RecognitionException(mte); } input.Consume(); // recover throw mte; } else if (label.IsSet) { MismatchedSetException mse = new MismatchedSetException(((IntervalSet)label.Set).ToRuntimeBitSet(), input); if (actions != null) { actions.RecognitionException(mse); } input.Consume(); // recover throw mse; } else if (label.IsSemanticPredicate) { FailedPredicateException fpe = new FailedPredicateException(input, s.enclosingRule.Name, label.SemanticContext.ToString()); if (actions != null) { actions.RecognitionException(fpe); } input.Consume(); // recover throw fpe; } else { throw new RecognitionException(input); // unknown error } } } //Console.Out.WriteLine( "hit stop state for " + stop.enclosingRule ); if (actions != null) { actions.ExitRule(s.nfa.grammar.FileName, stop.enclosingRule.Name); } }
/// <summary> /// Initializes a new instance of the <see cref="NFADotTransition"/> class. /// </summary> /// <param name="state">The target state</param> public NFADotTransition(NFAState state) : base(state) { }
/// <summary> /// Adds a unicode character span to an existing NFA automaton /// </summary> /// <param name="automata">The target NFA</param> /// <param name="span">The unicode span to add</param> private static void AddUnicodeSpanToNFA(NFA automata, UnicodeSpan span) { char[] b = span.Begin.GetUTF16(); char[] e = span.End.GetUTF16(); if (span.IsPlane0) { // this span is entirely in plane 0 automata.StateEntry.AddTransition(new CharSpan(b[0], e[0]), automata.StateExit); } else if (span.Begin.IsPlane0) { // this span has only a part in plane 0 if (b[0] < 0xD800) { automata.StateEntry.AddTransition(new CharSpan(b[0], (char)0xD7FF), automata.StateExit); automata.StateEntry.AddTransition(new CharSpan((char)0xE000, (char)0xFFFF), automata.StateExit); } else { automata.StateEntry.AddTransition(new CharSpan(b[0], (char)0xFFFF), automata.StateExit); } NFAState intermediate = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan((char)0xD800, e[0]), intermediate); intermediate.AddTransition(new CharSpan((char)0xDC00, e[1]), automata.StateExit); } else { // this span has no part in plane 0 if (b[0] == e[0]) { // same first surrogate NFAState intermediate = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan(b[0], b[0]), intermediate); intermediate.AddTransition(new CharSpan(b[1], e[1]), automata.StateExit); } else if (e[0] == b[0] + 1) { // the first surrogates are consecutive encodings // build lower half NFAState i1 = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan(b[0], b[0]), i1); i1.AddTransition(new CharSpan(b[1], (char)0xDFFF), automata.StateExit); // build upper half NFAState i2 = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan(e[0], e[0]), i2); i2.AddTransition(new CharSpan((char)0xDC00, e[1]), automata.StateExit); } else { // there is at least one surrogate value between the first surrogates of begin and end // build lower part NFAState ia = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan(b[0], b[0]), ia); ia.AddTransition(new CharSpan(b[1], (char)0xDFFF), automata.StateExit); // build intermediate part NFAState im = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan((char)(b[0] + 1), (char)(e[0] - 1)), im); im.AddTransition(new CharSpan((char)0xDC00, (char)0xDFFF), automata.StateExit); // build upper part NFAState iz = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan(e[0], e[0]), iz); iz.AddTransition(new CharSpan((char)0xDC00, e[1]), automata.StateExit); } } }
/// <summary> /// Initializes a new instance of the <see cref="NFANonWordTransition"/> class /// </summary> /// <param name="state">The target state</param> public NFANonWordTransition(NFAState state) : base(state) { }
private string GetStateLabel(State state) { if (state == null) { return("null"); } string stateLabel = state.StateNumber.ToString(); DFAState dfaState = state as DFAState; NFAState nfaState = state as NFAState; if (dfaState != null) { StringBuilder builder = new StringBuilder(250); builder.Append('s'); builder.Append(state.StateNumber); if (AntlrTool.internalOption_ShowNFAConfigsInDFA) { if (dfaState.AbortedDueToRecursionOverflow) { builder.AppendLine(); builder.AppendLine("AbortedDueToRecursionOverflow"); } var alts = dfaState.AltSet; if (alts != null) { builder.AppendLine(); List <int> altList = alts.OrderBy(i => i).ToList(); ICollection <NFAConfiguration> configurations = dfaState.NfaConfigurations; for (int i = 0; i < altList.Count; i++) { int alt = altList[i]; if (i > 0) { builder.AppendLine(); } builder.AppendFormat("alt{0}:", alt); // get a list of configs for just this alt // it will help us print better later List <NFAConfiguration> configsInAlt = new List <NFAConfiguration>(); foreach (NFAConfiguration c in configurations) { if (c.Alt != alt) { continue; } configsInAlt.Add(c); } int n = 0; for (int cIndex = 0; cIndex < configsInAlt.Count; cIndex++) { NFAConfiguration c = configsInAlt[cIndex]; n++; builder.Append(c.ToString(false)); if ((cIndex + 1) < configsInAlt.Count) { builder.Append(", "); } if (n % 5 == 0 && (configsInAlt.Count - cIndex) > 3) { builder.Append("\\n"); } } } } } if (dfaState.IsAcceptState) { builder.Append("⇒" + dfaState.GetUniquelyPredictedAlt()); } stateLabel = builder.ToString(); } else if (nfaState != null) { if (nfaState.IsDecisionState) { stateLabel += ",d=" + nfaState.DecisionNumber; } if (nfaState.endOfBlockStateNumber != State.INVALID_STATE_NUMBER) { stateLabel += ",eob=" + nfaState.endOfBlockStateNumber; } } return(stateLabel); }
public NFAEdge(NFAState targetState) : this() { TargetState = targetState; }
/// <summary> /// Creates a copy of this transition but with another target /// state. /// </summary> /// <param name="state">The new target state</param> /// <returns>An identical copy of this transition</returns> public override NFATransition Copy(NFAState state) { return(new NFANonWhitespaceTransition(state)); }
/** Do a depth-first walk of the state machine graph and * fill a DOT description template. Keep filling the * states and edges attributes. We know this is an NFA * for a rule so don't traverse edges to other rules and * don't go past rule end state. */ protected virtual void WalkRuleNFACreatingDOT(StringTemplate dot, State s) { if (markedStates.Contains(s.stateNumber)) { return; // already visited this node } markedStates.Add(s.stateNumber); // mark this node as completed. // first add this node StringTemplate stateST; if (s.IsAcceptState) { stateST = stlib.GetInstanceOf(Path.Combine(dfaTemplateDirectoryName, "stopstate")); } else { stateST = stlib.GetInstanceOf(Path.Combine(dfaTemplateDirectoryName, "state")); } stateST.SetAttribute("name", GetStateLabel(s)); dot.SetAttribute("states", stateST); if (s.IsAcceptState) { return; // don't go past end of rule node to the follow states } // special case: if decision point, then line up the alt start states // unless it's an end of block if (((NFAState)s).IsDecisionState) { GrammarAST n = ((NFAState)s).associatedASTNode; if (n != null && n.Type != ANTLRParser.EOB) { StringTemplate rankST = stlib.GetInstanceOf(Path.Combine(dfaTemplateDirectoryName, "decision-rank")); NFAState alt = (NFAState)s; while (alt != null) { rankST.SetAttribute("states", GetStateLabel(alt)); if (alt.transition[1] != null) { alt = (NFAState)alt.transition[1].target; } else { alt = null; } } dot.SetAttribute("decisionRanks", rankST); } } // make a DOT edge for each transition StringTemplate edgeST = null; for (int i = 0; i < s.NumberOfTransitions; i++) { Transition edge = (Transition)s.GetTransition(i); if (edge is RuleClosureTransition) { RuleClosureTransition rr = ((RuleClosureTransition)edge); // don't jump to other rules, but display edge to follow node edgeST = stlib.GetInstanceOf(Path.Combine(dfaTemplateDirectoryName, "edge")); if (rr.rule.grammar != grammar) { edgeST.SetAttribute("label", "<" + rr.rule.grammar.name + "." + rr.rule.Name + ">"); } else { edgeST.SetAttribute("label", "<" + rr.rule.Name + ">"); } edgeST.SetAttribute("src", GetStateLabel(s)); edgeST.SetAttribute("target", GetStateLabel(rr.followState)); edgeST.SetAttribute("arrowhead", arrowhead); dot.SetAttribute("edges", edgeST); WalkRuleNFACreatingDOT(dot, rr.followState); continue; } if (edge.IsAction) { edgeST = stlib.GetInstanceOf(Path.Combine(dfaTemplateDirectoryName, "action-edge")); } else if (edge.IsEpsilon) { edgeST = stlib.GetInstanceOf(Path.Combine(dfaTemplateDirectoryName, "epsilon-edge")); } else { edgeST = stlib.GetInstanceOf(Path.Combine(dfaTemplateDirectoryName, "edge")); } edgeST.SetAttribute("label", GetEdgeLabel(edge)); edgeST.SetAttribute("src", GetStateLabel(s)); edgeST.SetAttribute("target", GetStateLabel(edge.target)); edgeST.SetAttribute("arrowhead", arrowhead); dot.SetAttribute("edges", edgeST); WalkRuleNFACreatingDOT(dot, edge.target); // keep walkin' } }
private void TransitionBetweenStates(NFAState a, NFAState b, int label) { Transition e = new Transition(label, b); a.AddTransition(e); }
/// <summary> /// Initializes a new instance of the <see cref="NFANonWhitespaceTransition"/> class /// </summary> /// <param name="state">The target state</param> /// @param state the target state public NFANonWhitespaceTransition(NFAState state) : base(state) { }
/** From A|B|..|Z alternative block build * * o->o-A->o->o (last NFAState is blockEndNFAState pointed to by all alts) * | ^ * o->o-B->o--| * | | * ... | * | | * o->o-Z->o--| * * So every alternative gets begin NFAState connected by epsilon * and every alt right side points at a block end NFAState. There is a * new NFAState in the NFAState in the StateCluster for each alt plus one for the * end NFAState. * * Special case: only one alternative: don't make a block with alt * begin/end. * * Special case: if just a list of tokens/chars/sets, then collapse * to a single edge'd o-set->o graph. * * Set alt number (1..n) in the left-Transition NFAState. */ public virtual StateCluster BuildAlternativeBlock(ICollection <StateCluster> alternativeStateClusters) { StateCluster result = null; if (alternativeStateClusters == null || alternativeStateClusters.Count == 0) { return(null); } // single alt case if (alternativeStateClusters.Count == 1) { // single alt, no decision, just return only alt state cluster StateCluster g = alternativeStateClusters.First(); NFAState startOfAlt = NewState(); // must have this no matter what TransitionBetweenStates(startOfAlt, g.Left, Label.EPSILON); //System.Console.Out.WriteLine( "### opt saved start/stop end in (...)" ); return(new StateCluster(startOfAlt, g.Right)); } // even if we can collapse for lookahead purposes, we will still // need to predict the alts of this subrule in case there are actions // etc... This is the decision that is pointed to from the AST node // (always) NFAState prevAlternative = null; // tracks prev so we can link to next alt NFAState firstAlt = null; NFAState blockEndNFAState = NewState(); blockEndNFAState.Description = "end block"; int altNum = 1; foreach (StateCluster g in alternativeStateClusters) { // add begin NFAState for this alt connected by epsilon NFAState left = NewState(); left.Description = "alt " + altNum + " of ()"; TransitionBetweenStates(left, g.Left, Label.EPSILON); TransitionBetweenStates(g.Right, blockEndNFAState, Label.EPSILON); // Are we the first alternative? if (firstAlt == null) { firstAlt = left; // track extreme left node of StateCluster } else { // if not first alternative, must link to this alt from previous TransitionBetweenStates(prevAlternative, left, Label.EPSILON); } prevAlternative = left; altNum++; } // return StateCluster pointing representing entire block // Points to first alt NFAState on left, block end on right result = new StateCluster(firstAlt, blockEndNFAState); firstAlt.decisionStateType = NFAState.BLOCK_START; // set EOB markers for Jean firstAlt.endOfBlockStateNumber = blockEndNFAState.StateNumber; return(result); }
/// <summary> /// Initializes a new instance of the <see cref="NFAEpsilonTransition"/> class. /// </summary> /// <param name="state">The target state</param> public NFAEpsilonTransition(NFAState state) : base(state) { }
/// <summary> /// Builds a NFA from a character class /// </summary> /// <param name="node">An AST node representing a NFA</param> /// <returns>The equivalent NFA</returns> private NFA BuildNFAFromClass(ASTNode node) { // extract the value string value = node.Value; value = value.Substring(1, value.Length - 2); bool positive = true; if (value.Length > 0 && value[0] == '^') { value = value.Substring(1); positive = false; } // build the character spans List <CharSpan> spans = new List <CharSpan>(); for (int i = 0; i != value.Length;) { // read the first full unicode character CharValue b = GetCharValue(value, i); i += b.length; if (b.chars[0] >= 0xD800 && b.chars[0] <= 0xDFFF) { OnError(node.Position, "Unsupported non-plane 0 Unicode character ({0}) in character class", new String(b.chars)); return(BuildEpsilonNFA()); } if ((i <= value.Length - 2) && (value[i] == '-')) { // this is a range, match the '-' i++; CharValue e = GetCharValue(value, i); i += e.length; if (e.chars[0] >= 0xD800 && e.chars[0] <= 0xDFFF) { OnError(node.Position, "Unsupported non-plane 0 Unicode character ({0}) in character class", new String(e.chars)); return(BuildEpsilonNFA()); } char begin = b.chars.Length == 1 ? b.chars[0] : b.chars[1]; char end = e.chars.Length == 1 ? e.chars[0] : e.chars[1]; if (begin < 0xD800 && end > 0xDFFF) { // oooh you ... spans.Add(new CharSpan(begin, (char)0xD7FF)); spans.Add(new CharSpan((char)0xE000, end)); } else { spans.Add(new CharSpan(begin, end)); } } else { // this is a normal character char begin = b.chars.Length == 1 ? b.chars[0] : b.chars[1]; spans.Add(new CharSpan(begin, begin)); } } // build the result NFA automata = NFA.NewMinimal(); if (positive) { foreach (CharSpan span in spans) { automata.StateEntry.AddTransition(span, automata.StateExit); } } else { spans.Sort(new System.Comparison <CharSpan>(CharSpan.Compare)); // TODO: Check for span intersections and overflow of b (when a span ends on 0xFFFF) char b = (char)0; for (int i = 0; i != spans.Count; i++) { if (spans[i].Begin > b) { automata.StateEntry.AddTransition(new CharSpan(b, (char)(spans[i].Begin - 1)), automata.StateExit); } b = (char)(spans[i].End + 1); // skip the surrogate encoding points if (b >= 0xD800 && b <= 0xDFFF) { b = (char)0xE000; } } if (b <= 0xD7FF) { automata.StateEntry.AddTransition(new CharSpan(b, (char)0xD7FF), automata.StateExit); automata.StateEntry.AddTransition(new CharSpan((char)0xE000, (char)0xFFFF), automata.StateExit); } else if (b != 0xFFFF) { // here b >= 0xE000 automata.StateEntry.AddTransition(new CharSpan(b, (char)0xFFFF), automata.StateExit); } // surrogate pairs NFAState intermediate = automata.AddNewState(); automata.StateEntry.AddTransition(new CharSpan((char)0xD800, (char)0xDBFF), intermediate); intermediate.AddTransition(new CharSpan((char)0xDC00, (char)0xDFFF), automata.StateExit); } return(automata); }
private void WalkRuleNfaCreatingDgml(State state) { if (!_markedStates.Add(state.StateNumber)) { return; } NFAState nfaState = state as NFAState; // create the node string nodeCategory; if (state.IsAcceptState) { nodeCategory = Categories.StopState; } else if (nfaState != null && nfaState.IsDecisionState) { nodeCategory = Categories.DecisionState; } else { nodeCategory = Categories.State; } XElement node = new XElement(Elements.Node, new XAttribute(Attributes.Id, "state_" + state.StateNumber), new XAttribute(Attributes.Label, GetStateLabel(state)), new XAttribute(Attributes.Category, nodeCategory)); if (nfaState != null && nfaState.IsDecisionState) { string baseFileName = _grammar.name; if (_grammar.implicitLexer) { baseFileName += Grammar.grammarTypeToFileNameSuffix[(int)_grammar.type]; } string decisionPath = string.Format("{0}.dec-{1}.dgml", baseFileName, nfaState.DecisionNumber); node.Add(new XAttribute(Attributes.Reference, decisionPath)); } _nodes.Add(state, node); if (GroupNodes) { _extraLinks.Add(CreateContainmentLink(_groupId, "state_" + state.StateNumber)); } // don't go past end of rule if (state.IsAcceptState) { return; } // create links for each transition for (int i = 0; i < state.NumberOfTransitions; i++) { Transition edge = state.GetTransition(i); RuleClosureTransition rr = edge as RuleClosureTransition; if (rr != null) { string label; if (rr.Rule.Grammar != _grammar) { label = string.Format("<{0}.{1}>", rr.Rule.Grammar.name, rr.Rule.Name); } else { label = string.Format("<{0}>", rr.Rule.Name); } XElement link = new XElement(Elements.Link, new XAttribute(Attributes.Source, "state_" + state.StateNumber), new XAttribute(Attributes.Target, "state_" + rr.FollowState), new XAttribute(Attributes.Category, Categories.RuleClosureEdge), new XAttribute(Attributes.Label, label)); _links.Add(new KeyValuePair <State, Transition>(state, edge), link); WalkRuleNfaCreatingDgml(rr.FollowState); } else { string edgeCategory; if (edge.IsAction) { edgeCategory = Categories.ActionEdge; } else if (edge.IsEpsilon) { edgeCategory = Categories.EpsilonEdge; } else if (edge.Label.IsSet || edge.Label.IsAtom) { edgeCategory = Categories.AtomEdge; } else { edgeCategory = Categories.Edge; } XElement link = new XElement(Elements.Link, new XAttribute(Attributes.Source, "state_" + state.StateNumber), new XAttribute(Attributes.Target, "state_" + edge.Target.StateNumber), new XAttribute(Attributes.Category, edgeCategory), new XAttribute(Attributes.Label, GetEdgeLabel(edge))); _links.Add(new KeyValuePair <State, Transition>(state, edge), link); WalkRuleNfaCreatingDgml(edge.Target); } } }
protected virtual string GetStateLabel(State s) { if (s == null) { return("null"); } string stateLabel = s.stateNumber.ToString(); if (s is DFAState) { StringBuffer buf = new StringBuffer(250); buf.Append('s'); buf.Append(s.stateNumber); if (AntlrTool.internalOption_ShowNFAConfigsInDFA) { if (s is DFAState) { if (((DFAState)s).abortedDueToRecursionOverflow) { buf.Append("\\n"); buf.Append("abortedDueToRecursionOverflow"); } } var alts = ((DFAState)s).AltSet; if (alts != null) { buf.Append("\\n"); // separate alts //List altList = new ArrayList(); //altList.addAll( alts ); //Collections.sort( altList ); List <int> altList = alts.OrderBy(i => i).ToList(); ICollection <NFAConfiguration> configurations = ((DFAState)s).nfaConfigurations; for (int altIndex = 0; altIndex < altList.Count; altIndex++) { object altI = altList[altIndex]; int alt = (int)altI; if (altIndex > 0) { buf.Append("\\n"); } buf.Append("alt"); buf.Append(alt); buf.Append(':'); // get a list of configs for just this alt // it will help us print better later IList configsInAlt = new List <object>(); foreach (NFAConfiguration c in configurations) { if (c.alt != alt) { continue; } configsInAlt.Add(c); } int n = 0; for (int cIndex = 0; cIndex < configsInAlt.Count; cIndex++) { NFAConfiguration c = (NFAConfiguration)configsInAlt[cIndex]; n++; buf.Append(c.ToString(false)); if ((cIndex + 1) < configsInAlt.Count) { buf.Append(", "); } if (n % 5 == 0 && (configsInAlt.Count - cIndex) > 3) { buf.Append("\\n"); } } } } } stateLabel = buf.ToString(); } if ((s is NFAState) && ((NFAState)s).IsDecisionState) { stateLabel = stateLabel + ",d=" + ((NFAState)s).DecisionNumber; if (((NFAState)s).endOfBlockStateNumber != State.INVALID_STATE_NUMBER) { stateLabel += ",eob=" + ((NFAState)s).endOfBlockStateNumber; } } else if ((s is NFAState) && ((NFAState)s).endOfBlockStateNumber != State.INVALID_STATE_NUMBER) { NFAState n = ((NFAState)s); stateLabel = stateLabel + ",eob=" + n.endOfBlockStateNumber; } else if (s is DFAState && ((DFAState)s).IsAcceptState) { stateLabel = stateLabel + "=>" + ((DFAState)s).GetUniquelyPredictedAlt(); } return('"' + stateLabel + '"'); }
private int NumberOfIncomingTransition(NFAState state) { return(_links.Count(i => i.Key.Value.Target == state)); }
/// <summary> /// Initializes a new instance of the <see cref="NFACharTransition"/> class. /// </summary> /// <param name="match">The character to match</param> /// <param name="state">The target state</param> public NFACharTransition(char match, NFAState state) : base(state) { this.match = match; }
public NFAEdge(int symbol, NFAState targetState) : this() { Symbol = symbol; TargetState = targetState; }
/// <summary> /// Creates a copy of this transition but with another target /// state. /// </summary> /// <param name="state">The new target state</param> /// <returns>An identical copy of this transition</returns> public override NFATransition Copy(NFAState state) { return(new NFACharTransition(this.match, state)); }
public StateCluster( NFAState left, NFAState right ) { this._left = left; this._right = right; }
public StartOfStringNFAState(NFAState exit) : base(RegExType.StartOfString) { this.exit = exit; }