/** Given an input stream, return the unique alternative predicted by * matching the input. Upon error, return NFA.INVALID_ALT_NUMBER * The first symbol of lookahead is presumed to be primed; that is, * input.lookahead(1) must point at the input symbol you want to start * predicting with. */ public int Predict(DFA dfa) { DFAState s = dfa.StartState; int c = input.LA(1); Transition eotTransition = null; dfaLoop: while (!s.IsAcceptState) { //Console.Out.WriteLine( "DFA.predict(" + s.stateNumber + ", " + dfa.nfa.Grammar.getTokenDisplayName( c ) + ")" ); // for each edge of s, look for intersection with current char for (int i = 0; i < s.NumberOfTransitions; i++) { Transition t = s.GetTransition(i); // special case: EOT matches any char if (t.Label.Matches(c)) { // take transition i s = (DFAState)t.Target; input.Consume(); c = input.LA(1); goto dfaLoop; } if (t.Label.Atom == Label.EOT) { eotTransition = t; } } if (eotTransition != null) { s = (DFAState)eotTransition.Target; goto dfaLoop; } /* * ErrorManager.error(ErrorManager.MSG_NO_VIABLE_DFA_ALT, * s, * dfa.nfa.Grammar.getTokenName(c)); */ return(NFA.INVALID_ALT_NUMBER); } // woohoo! We know which alt to predict // nothing emanates from a stop state; must terminate anyway //Console.Out.WriteLine( "DFA stop state " + s.stateNumber + " predicts " + s.getUniquelyPredictedAlt() ); return(s.GetUniquelyPredictedAlt()); }
public virtual StringTemplate GenFixedLookaheadDecision( TemplateGroup templates, DFA dfa ) { return WalkFixedDFAGeneratingStateMachine( templates, dfa, dfa.StartState, 1 ); }
public DFAState( DFA dfa ) { if (dfa == null) throw new ArgumentNullException("dfa"); this.dfa = dfa; }
/** Report that at least 2 alts have recursive constructs. There is * no way to build a DFA so we terminated. */ public virtual void ReportNonLLStarDecision( DFA dfa ) { /* [email protected]("non-LL(*) DFA "+dfa.decisionNumber+", alts: "+ dfa.recursiveAltSet.toList()); */ _nonLLStarDecision = true; _altsWithProblem.addAll( dfa.recursiveAltSet.ToList() ); }
public DFAState( DFA dfa ) { this.dfa = dfa; }
/** 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.NfaStartStateDecisionNumber, 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); } }
public virtual void SynPredUsedInDFA( DFA dfa, SemanticContext semCtx ) { decisionsWhoseDFAsUsesSynPreds.Add( dfa ); semCtx.TrackUseOfSyntacticPredicates( this ); // walk ctx looking for preds }
protected virtual void Optimize( DFA dfa ) { if ( dfa == null ) { return; // nothing to do } /* [email protected]("Optimize DFA "+dfa.decisionNFAStartState.decisionNumber+ " num states="+dfa.getNumberOfStates()); */ //long start = JSystem.currentTimeMillis(); if ( PRUNE_EBNF_EXIT_BRANCHES && dfa.CanInlineDecision ) { _visited.Clear(); int decisionType = dfa.NFADecisionStartState.decisionStateType; if ( dfa.IsGreedy && ( decisionType == NFAState.OPTIONAL_BLOCK_START || decisionType == NFAState.LOOPBACK ) ) { OptimizeExitBranches( dfa.startState ); } } // If the Tokens rule has syntactically ambiguous rules, try to prune if ( PRUNE_TOKENS_RULE_SUPERFLUOUS_EOT_EDGES && dfa.IsTokensRuleDecision && dfa.probe.stateToSyntacticallyAmbiguousTokensRuleAltsMap.Count > 0 ) { _visited.Clear(); OptimizeEOTBranches( dfa.startState ); } /* ack...code gen needs this, cannot optimize visited.clear(); unlinkUnneededStateData(dfa.startState); */ //long stop = JSystem.currentTimeMillis(); //[email protected]("minimized in "+(int)(stop-start)+" ms"); }
public StringTemplate GenExpr( CodeGenerator generator, StringTemplateGroup templates, DFA dfa ) { if ( templates != null ) { return templates.GetInstanceOf( "false" ); } return new StringTemplate( "false" ); }
public override StringTemplate GenExpr( CodeGenerator generator, StringTemplateGroup templates, DFA dfa ) { StringTemplate eST = null; if ( templates != null ) { if ( _synpred ) { eST = templates.GetInstanceOf( "evalSynPredicate" ); } else { eST = templates.GetInstanceOf( "evalPredicate" ); generator.grammar.decisionsWhoseDFAsUsesSemPreds.Add( dfa ); } string predEnclosingRuleName = predicateAST.enclosingRuleName; /* String decisionEnclosingRuleName = dfa.getNFADecisionStartState().getEnclosingRule(); // if these rulenames are diff, then pred was hoisted out of rule // Currently I don't warn you about this as it could be annoying. // I do the translation anyway. */ //eST.setAttribute("pred", this.toString()); if ( generator != null ) { eST.SetAttribute( "pred", generator.TranslateAction( predEnclosingRuleName, predicateAST ) ); } } else { eST = new StringTemplate( "$pred$" ); eST.SetAttribute( "pred", this.ToString() ); return eST; } if ( generator != null ) { string description = generator.target.GetTargetStringLiteralFromString( this.ToString() ); eST.SetAttribute( "description", description ); } return eST; }
public override StringTemplate GenExpr( CodeGenerator generator, StringTemplateGroup templates, DFA dfa ) { StringTemplate eST = null; if ( templates != null ) { eST = templates.GetInstanceOf( "orPredicates" ); } else { eST = new StringTemplate( "($first(operands)$$rest(operands):{o | ||$o$}$)" ); } foreach ( SemanticContext semctx in _operands ) { eST.SetAttribute( "operands", semctx.GenExpr( generator, templates, dfa ) ); } return eST; }
public override StringTemplate GenExpr( CodeGenerator generator, StringTemplateGroup templates, DFA dfa ) { StringTemplate eST = null; if ( templates != null ) { eST = templates.GetInstanceOf( "notPredicate" ); } else { eST = new StringTemplate( "?!($pred$)" ); } eST.SetAttribute( "pred", ctx.GenExpr( generator, templates, dfa ) ); return eST; }
public override StringTemplate GenExpr( CodeGenerator generator, StringTemplateGroup templates, DFA dfa ) { StringTemplate eST = null; if ( templates != null ) { eST = templates.GetInstanceOf( "andPredicates" ); } else { eST = new StringTemplate( "($left$&&$right$)" ); } eST.SetAttribute( "left", _left.GenExpr( generator, templates, dfa ) ); eST.SetAttribute( "right", _right.GenExpr( generator, templates, dfa ) ); return eST; }
/** Generate an expression that will evaluate the semantic context, * given a set of output templates. */ public abstract StringTemplate GenExpr( CodeGenerator generator, StringTemplateGroup templates, DFA dfa );
protected virtual StringTemplate WalkFixedDFAGeneratingStateMachine( TemplateGroup templates, DFA dfa, DFAState s, int k ) { //System.Console.Out.WriteLine( "walk " + s.stateNumber + " in dfa for decision " + dfa.decisionNumber ); if ( s.IsAcceptState ) { StringTemplate dfaST2 = templates.GetInstanceOf( "dfaAcceptState" ); dfaST2.SetAttribute( "alt", s.GetUniquelyPredictedAlt() ); return dfaST2; } // the default templates for generating a state and its edges // can be an if-then-else structure or a switch string dfaStateName = "dfaState"; string dfaLoopbackStateName = "dfaLoopbackState"; string dfaOptionalBlockStateName = "dfaOptionalBlockState"; string dfaEdgeName = "dfaEdge"; if ( _parentGenerator.CanGenerateSwitch( s ) ) { dfaStateName = "dfaStateSwitch"; dfaLoopbackStateName = "dfaLoopbackStateSwitch"; dfaOptionalBlockStateName = "dfaOptionalBlockStateSwitch"; dfaEdgeName = "dfaEdgeSwitch"; } StringTemplate dfaST = templates.GetInstanceOf( dfaStateName ); if ( dfa.NFADecisionStartState.decisionStateType == NFAState.LOOPBACK ) { dfaST = templates.GetInstanceOf( dfaLoopbackStateName ); } else if ( dfa.NFADecisionStartState.decisionStateType == NFAState.OPTIONAL_BLOCK_START ) { dfaST = templates.GetInstanceOf( dfaOptionalBlockStateName ); } dfaST.SetAttribute( "k", k ); dfaST.SetAttribute( "stateNumber", s.StateNumber ); dfaST.SetAttribute( "semPredState", s.IsResolvedWithPredicates ); /* string description = dfa.getNFADecisionStartState().Description; description = parentGenerator.target.getTargetStringLiteralFromString( description ); //System.Console.Out.WriteLine( "DFA: " + description + " associated with AST " + dfa.getNFADecisionStartState() ); if ( description != null ) { dfaST.SetAttribute( "description", description ); } */ int EOTPredicts = NFA.INVALID_ALT_NUMBER; DFAState EOTTarget = null; //System.Console.Out.WriteLine( "DFA state " + s.stateNumber ); for ( int i = 0; i < s.NumberOfTransitions; i++ ) { Transition edge = (Transition)s.GetTransition( i ); //System.Console.Out.WriteLine( "edge " + s.stateNumber + "-" + edge.label.ToString() + "->" + edge.target.stateNumber ); if ( edge.Label.Atom == Label.EOT ) { // don't generate a real edge for EOT; track alt EOT predicts // generate that prediction in the else clause as default case EOTTarget = (DFAState)edge.Target; EOTPredicts = EOTTarget.GetUniquelyPredictedAlt(); /* System.Console.Out.WriteLine("DFA s"+s.stateNumber+" EOT goes to s"+ edge.target.stateNumber+" predicates alt "+ EOTPredicts); */ continue; } StringTemplate edgeST = templates.GetInstanceOf( dfaEdgeName ); // If the template wants all the label values delineated, do that if ( edgeST.impl.TryGetFormalArgument( "labels" ) != null ) { List<string> labels = edge.Label.Set.Select( value => _parentGenerator.GetTokenTypeAsTargetLabel( value ) ).ToList(); edgeST.SetAttribute( "labels", labels ); } else { // else create an expression to evaluate (the general case) edgeST.SetAttribute( "labelExpr", _parentGenerator.GenLabelExpr( templates, edge, k ) ); } // stick in any gated predicates for any edge if not already a pred if ( !edge.Label.IsSemanticPredicate ) { DFAState target = (DFAState)edge.Target; SemanticContext preds = target.GetGatedPredicatesInNFAConfigurations(); if ( preds != null ) { //System.Console.Out.WriteLine( "preds=" + target.getGatedPredicatesInNFAConfigurations() ); StringTemplate predST = preds.GenExpr( _parentGenerator, _parentGenerator.Templates, dfa ); edgeST.SetAttribute( "predicates", predST ); } } StringTemplate targetST = WalkFixedDFAGeneratingStateMachine( templates, dfa, (DFAState)edge.Target, k + 1 ); edgeST.SetAttribute( "targetState", targetST ); dfaST.SetAttribute( "edges", edgeST ); //System.Console.Out.WriteLine( "back to DFA " + dfa.decisionNumber + "." + s.stateNumber ); } // HANDLE EOT EDGE if ( EOTPredicts != NFA.INVALID_ALT_NUMBER ) { // EOT unique predicts an alt dfaST.SetAttribute( "eotPredictsAlt", EOTPredicts ); } else if ( EOTTarget != null && EOTTarget.NumberOfTransitions > 0 ) { // EOT state has transitions so must split on predicates. // Generate predicate else-if clauses and then generate // NoViableAlt exception as else clause. // Note: these predicates emanate from the EOT target state // rather than the current DFAState s so the error message // might be slightly misleading if you are looking at the // state number. Predicates emanating from EOT targets are // hoisted up to the state that has the EOT edge. for ( int i = 0; i < EOTTarget.NumberOfTransitions; i++ ) { Transition predEdge = (Transition)EOTTarget.GetTransition( i ); StringTemplate edgeST = templates.GetInstanceOf( dfaEdgeName ); edgeST.SetAttribute( "labelExpr", _parentGenerator.GenSemanticPredicateExpr( templates, predEdge ) ); // the target must be an accept state //System.Console.Out.WriteLine( "EOT edge" ); StringTemplate targetST = WalkFixedDFAGeneratingStateMachine( templates, dfa, (DFAState)predEdge.Target, k + 1 ); edgeST.SetAttribute( "targetState", targetST ); dfaST.SetAttribute( "edges", edgeST ); } } return dfaST; }
// L O O K A H E A D D E C I S I O N G E N E R A T I O N /** Generate code that computes the predicted alt given a DFA. The * recognizerST can be either the main generated recognizerTemplate * for storage in the main parser file or a separate file. It's up to * the code that ultimately invokes the codegen.g grammar rule. * * Regardless, the output file and header file get a copy of the DFAs. */ public virtual StringTemplate GenLookaheadDecision( StringTemplate recognizerST, DFA dfa ) { StringTemplate decisionST; // If we are doing inline DFA and this one is acyclic and LL(*) // I have to check for is-non-LL(*) because if non-LL(*) the cyclic // check is not done by DFA.verify(); that is, verify() avoids // doesStateReachAcceptState() if non-LL(*) if ( dfa.CanInlineDecision ) { decisionST = acyclicDFAGenerator.GenFixedLookaheadDecision( Templates, dfa ); } else { // generate any kind of DFA here (cyclic or acyclic) dfa.CreateStateTables( this ); outputFileST.SetAttribute( "cyclicDFAs", dfa ); headerFileST.SetAttribute( "cyclicDFAs", dfa ); decisionST = templates.GetInstanceOf( "dfaDecision" ); string description = dfa.NFADecisionStartState.Description; description = target.GetTargetStringLiteralFromString( description ); if ( description != null ) { decisionST.SetAttribute( "description", description ); } decisionST.SetAttribute( "decisionNumber", dfa.DecisionNumber ); } return decisionST; }
public AnalysisTimeoutException(DFA abortedDFA) { _abortedDFA = abortedDFA; }
/** Set the lookahead DFA for a particular decision. This means * that the appropriate AST node must updated to have the new lookahead * DFA. This method could be used to properly set the DFAs without * using the createLookaheadDFAs() method. You could do this * * Grammar g = new Grammar("..."); * g.setLookahead(1, dfa1); * g.setLookahead(2, dfa2); * ... */ public virtual void SetLookaheadDFA( int decision, DFA lookaheadDFA ) { Decision d = CreateDecision( decision ); d.dfa = lookaheadDFA; GrammarAST ast = d.startState.associatedASTNode; ast.LookaheadDFA = lookaheadDFA; }
/** Given an input stream, return the unique alternative predicted by * matching the input. Upon error, return NFA.INVALID_ALT_NUMBER * The first symbol of lookahead is presumed to be primed; that is, * input.lookahead(1) must point at the input symbol you want to start * predicting with. */ public int Predict( DFA dfa ) { DFAState s = dfa.startState; int c = input.LA( 1 ); Transition eotTransition = null; dfaLoop: while ( !s.IsAcceptState ) { //Console.Out.WriteLine( "DFA.predict(" + s.stateNumber + ", " + dfa.nfa.grammar.getTokenDisplayName( c ) + ")" ); // for each edge of s, look for intersection with current char for ( int i = 0; i < s.NumberOfTransitions; i++ ) { Transition t = s.Transition( i ); // special case: EOT matches any char if ( t.label.Matches( c ) ) { // take transition i s = (DFAState)t.target; input.Consume(); c = input.LA( 1 ); goto dfaLoop; } if ( t.label.Atom == Label.EOT ) { eotTransition = t; } } if ( eotTransition != null ) { s = (DFAState)eotTransition.target; goto dfaLoop; } /* ErrorManager.error(ErrorManager.MSG_NO_VIABLE_DFA_ALT, s, dfa.nfa.grammar.getTokenName(c)); */ return NFA.INVALID_ALT_NUMBER; } // woohoo! We know which alt to predict // nothing emanates from a stop state; must terminate anyway //Console.Out.WriteLine( "DFA stop state " + s.stateNumber + " predicts " + s.getUniquelyPredictedAlt() ); return s.GetUniquelyPredictedAlt(); }
private void UpdateLineColumnToLookaheadDFAMap( DFA lookaheadDFA ) { GrammarAST decisionAST = nfa.Grammar.GetDecisionBlockAST( lookaheadDFA.DecisionNumber ); int line = decisionAST.Line; int col = decisionAST.CharPositionInLine; lineColumnToLookaheadDFAMap[line + ":" + col] = lookaheadDFA; }
public DecisionProbe( DFA dfa ) { if (dfa == null) throw new ArgumentNullException("dfa"); this._dfa = dfa; }
/** Report that at least 2 alts have recursive constructs. There is * no way to build a DFA so we terminated. */ public virtual void ReportNonLLStarDecision( DFA dfa ) { /* [email protected]("non-LL(*) DFA "+dfa.decisionNumber+", alts: "+ dfa.recursiveAltSet.toList()); */ _nonLLStarDecision = true; dfa.Nfa.Grammar.numNonLLStar++; _altsWithProblem.UnionWith( dfa.RecursiveAltSet.ToList() ); }
public virtual DFA CreateLookaheadDFA( int decision, bool wackTempStructures ) { Decision d = GetDecision( decision ); string enclosingRule = d.startState.enclosingRule.Name; Rule r = d.startState.enclosingRule; //[email protected]("createLookaheadDFA(): "+enclosingRule+" dec "+decision+"; synprednames prev used "+synPredNamesUsedInDFA); NFAState decisionStartState = GetDecisionNFAStartState( decision ); DateTime startDFA = DateTime.MinValue; DateTime stopDFA = DateTime.MinValue; if ( composite.watchNFAConversion ) { Console.Out.WriteLine( "--------------------\nbuilding lookahead DFA (d=" + decisionStartState.DecisionNumber + ") for " + decisionStartState.Description ); startDFA = DateTime.Now; } DFA lookaheadDFA = new DFA( decision, decisionStartState ); // Retry to create a simpler DFA if analysis failed (non-LL(*), // recursion overflow, or time out). bool failed = lookaheadDFA.AnalysisTimedOut || lookaheadDFA.probe.IsNonLLStarDecision || lookaheadDFA.probe.AnalysisOverflowed; if ( failed && lookaheadDFA.OkToRetryWithK1 ) { // set k=1 option and try again. // First, clean up tracking stuff decisionsWhoseDFAsUsesSynPreds.Remove( lookaheadDFA ); // TODO: clean up synPredNamesUsedInDFA also (harder) d.blockAST.SetBlockOption( this, "k", 1 ); if ( composite.watchNFAConversion ) { Console.Out.Write( "trying decision " + decision + " again with k=1; reason: " + lookaheadDFA.ReasonForFailure ); } lookaheadDFA = null; // make sure other memory is "free" before redoing lookaheadDFA = new DFA( decision, decisionStartState ); } if ( lookaheadDFA.AnalysisTimedOut ) { // did analysis bug out? ErrorManager.InternalError( "could not even do k=1 for decision " + decision + "; reason: " + lookaheadDFA.ReasonForFailure ); } SetLookaheadDFA( decision, lookaheadDFA ); if ( wackTempStructures ) { foreach ( DFAState s in lookaheadDFA.UniqueStates.Values ) { s.Reset(); } } // create map from line:col to decision DFA (for ANTLRWorks) UpdateLineColumnToLookaheadDFAMap( lookaheadDFA ); if ( composite.watchNFAConversion ) { stopDFA = DateTime.Now; Console.Out.WriteLine( "cost: " + lookaheadDFA.NumberOfStates + " states, " + (int)( stopDFA - startDFA ).TotalMilliseconds + " ms" ); } //[email protected]("after create DFA; synPredNamesUsedInDFA="+synPredNamesUsedInDFA); return lookaheadDFA; }
public static DFA CreateFromNfa(int decisionNumber, NFAState decisionStartState) { DFA dfa = new DFA(decisionNumber, decisionStartState); //long start = JSystem.currentTimeMillis(); NFAToDFAConverter nfaConverter = new NFAToDFAConverter( dfa ); try { nfaConverter.Convert(); // figure out if there are problems with decision dfa.Verify(); if ( !dfa.Probe.IsDeterministic || dfa.Probe.AnalysisOverflowed ) { dfa.Probe.IssueWarnings(); } // must be after verify as it computes cyclic, needed by this routine // should be after warnings because early termination or something // will not allow the reset to operate properly in some cases. dfa.ResetStateNumbersToBeContiguous(); //long stop = JSystem.currentTimeMillis(); //[email protected]("verify cost: "+(int)(stop-start)+" ms"); } catch ( NonLLStarDecisionException /*nonLL*/ ) { dfa.Probe.ReportNonLLStarDecision( dfa ); // >1 alt recurses, k=* and no auto backtrack nor manual sem/syn if ( !dfa.OkToRetryWithK1 ) { dfa.Probe.IssueWarnings(); } } return dfa; }
public DecisionProbe( DFA dfa ) { this.dfa = dfa; }