public NFAToDFAConverter(DFA dfa) { this.dfa = dfa; int nAlts = dfa.getNumberOfAlts(); initContextTrees(nAlts); }
/** Resolve state d by choosing exit alt, which is same value as the * number of alternatives. Return that exit alt. */ protected int resolveByPickingExitAlt(DFAState d, Set<Integer> nondeterministicAlts) { int exitAlt = dfa.getNumberOfAlts(); turnOffOtherAlts(d, exitAlt, nondeterministicAlts); return exitAlt; }
public NFAToDFAConverter(DFA dfa) { this.dfa = dfa; int nAlts = dfa.getNumberOfAlts(); initContextTrees(nAlts); }
/** Resolve state d by choosing exit alt, which is same value as the * number of alternatives. Return that exit alt. */ protected int resolveByPickingExitAlt(DFAState d, Set<Integer> nondeterministicAlts) { int exitAlt = dfa.getNumberOfAlts(); turnOffOtherAlts(d, exitAlt, nondeterministicAlts); return exitAlt; }
public NFAToDFAConverter(DFA dfa) { this.dfa = dfa; int nAlts = dfa.getNumberOfAlts(); initContextTrees(nAlts); }
public NFAToDFAConverter(DFA dfa) { this.dfa = dfa; int nAlts = dfa.getNumberOfAlts(); initContextTrees(nAlts); }
/** Resolve state d by choosing exit alt, which is same value as the * number of alternatives. Return that exit alt. */ protected int resolveByPickingExitAlt(DFAState d, Set nondeterministicAlts) { int exitAlt = dfa.getNumberOfAlts(); turnOffOtherAlts(d, exitAlt, nondeterministicAlts); return exitAlt; }
/** Resolve state d by choosing exit alt, which is same value as the * number of alternatives. Return that exit alt. */ protected int resolveByPickingExitAlt(DFAState d, Set nondeterministicAlts) { int exitAlt = dfa.getNumberOfAlts(); turnOffOtherAlts(d, exitAlt, nondeterministicAlts); return exitAlt; }
/** Walk all accept states and find the manually-specified synpreds. * Gated preds are not always hoisted * I used to do this in the code generator, but that is too late. * This converter tries to avoid computing DFA for decisions in * syntactic predicates that are not ever used such as those * created by autobacktrack mode. */ public void findAllGatedSynPredsUsedInDFAAcceptStates() { int nAlts = getNumberOfAlts(); for (int i=1; i<=nAlts; i++) { DFAState a = getAcceptState(i); //System.out.println("alt "+i+": "+a); if ( a!=null ) { Set synpreds = a.getGatedSyntacticPredicatesInNFAConfigurations(); if ( synpreds!=null ) { // add all the predicates we find (should be just one, right?) for (Iterator it = synpreds.iterator(); it.hasNext();) { SemanticContext semctx = (SemanticContext) it.next(); // System.out.println("synpreds: "+semctx); nfa.grammar.synPredUsedInDFA(this, semctx); } } } } }
/** Walk all accept states and find the manually-specified synpreds. * Gated preds are not always hoisted * I used to do this in the code generator, but that is too late. * This converter tries to avoid computing DFA for decisions in * syntactic predicates that are not ever used such as those * created by autobacktrack mode. */ public void findAllGatedSynPredsUsedInDFAAcceptStates() { int nAlts = getNumberOfAlts(); for (int i=1; i<=nAlts; i++) { DFAState a = getAcceptState(i); //System.out.println("alt "+i+": "+a); if ( a!=null ) { Set synpreds = a.getGatedSyntacticPredicatesInNFAConfigurations(); if ( synpreds!=null ) { // add all the predicates we find (should be just one, right?) for (Iterator it = synpreds.iterator(); it.hasNext();) { SemanticContext semctx = (SemanticContext) it.next(); // System.out.println("synpreds: "+semctx); nfa.grammar.synPredUsedInDFA(this, semctx); } } } } }
/** Walk all accept states and find the manually-specified synpreds. * Gated preds are not always hoisted * I used to do this in the code generator, but that is too late. * This converter tries to avoid computing DFA for decisions in * syntactic predicates that are not ever used such as those * created by autobacktrack mode. */ public void findAllGatedSynPredsUsedInDFAAcceptStates() { int nAlts = getNumberOfAlts(); for (int i=1; i<=nAlts; i++) { DFAState a = getAcceptState(i); //System.out.println("alt "+i+": "+a); if ( a!=null ) { Set<? extends SemanticContext> synpreds = a.getGatedSyntacticPredicatesInNFAConfigurations(); if ( synpreds!=null ) { // add all the predicates we find (should be just one, right?) for (SemanticContext semctx : synpreds) { // System.out.println("synpreds: "+semctx); nfa.grammar.synPredUsedInDFA(this, semctx); } } } } }
/** Walk all accept states and find the manually-specified synpreds. * Gated preds are not always hoisted * I used to do this in the code generator, but that is too late. * This converter tries to avoid computing DFA for decisions in * syntactic predicates that are not ever used such as those * created by autobacktrack mode. */ public void findAllGatedSynPredsUsedInDFAAcceptStates() { int nAlts = getNumberOfAlts(); for (int i=1; i<=nAlts; i++) { DFAState a = getAcceptState(i); //System.out.println("alt "+i+": "+a); if ( a!=null ) { Set<? extends SemanticContext> synpreds = a.getGatedSyntacticPredicatesInNFAConfigurations(); if ( synpreds!=null ) { // add all the predicates we find (should be just one, right?) for (SemanticContext semctx : synpreds) { // System.out.println("synpreds: "+semctx); nfa.grammar.synPredUsedInDFA(this, semctx); } } } } }
protected int resolveByChoosingFirstAlt(DFAState d, Set nondeterministicAlts) { int winningAlt = 0; if ( dfa.isGreedy() ) { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } else { // If nongreedy, the exit alt shout win, but only if it's // involved in the nondeterminism! /* System.out.println("resolving exit alt for decision="+ dfa.decisionNumber+" state="+d); System.out.println("nondet="+nondeterministicAlts); System.out.println("exit alt "+exitAlt); */ int exitAlt = dfa.getNumberOfAlts(); if ( nondeterministicAlts.contains(Utils.integer(exitAlt)) ) { // if nongreedy and exit alt is one of those nondeterministic alts // predicted, resolve in favor of what follows block winningAlt = resolveByPickingExitAlt(d,nondeterministicAlts); } else { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } } return winningAlt; }
protected int resolveByChoosingFirstAlt(DFAState d, Set<Integer> nondeterministicAlts) { int winningAlt; if ( dfa.isGreedy() ) { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } else { // If nongreedy, the exit alt shout win, but only if it's // involved in the nondeterminism! /* System.out.println("resolving exit alt for decision="+ dfa.decisionNumber+" state="+d); System.out.println("nondet="+nondeterministicAlts); System.out.println("exit alt "+exitAlt); */ int exitAlt = dfa.getNumberOfAlts(); if ( nondeterministicAlts.contains(Utils.integer(exitAlt)) ) { // if nongreedy and exit alt is one of those nondeterministic alts // predicted, resolve in favor of what follows block winningAlt = resolveByPickingExitAlt(d,nondeterministicAlts); } else { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } } return winningAlt; }
protected int resolveByChoosingFirstAlt(DFAState d, Set nondeterministicAlts) { int winningAlt = 0; if ( dfa.isGreedy() ) { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } else { // If nongreedy, the exit alt shout win, but only if it's // involved in the nondeterminism! /* System.out.println("resolving exit alt for decision="+ dfa.decisionNumber+" state="+d); System.out.println("nondet="+nondeterministicAlts); System.out.println("exit alt "+exitAlt); */ int exitAlt = dfa.getNumberOfAlts(); if ( nondeterministicAlts.contains(Utils.integer(exitAlt)) ) { // if nongreedy and exit alt is one of those nondeterministic alts // predicted, resolve in favor of what follows block winningAlt = resolveByPickingExitAlt(d,nondeterministicAlts); } else { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } } return winningAlt; }
protected int resolveByChoosingFirstAlt(DFAState d, Set<Integer> nondeterministicAlts) { int winningAlt; if ( dfa.isGreedy() ) { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } else { // If nongreedy, the exit alt shout win, but only if it's // involved in the nondeterminism! /* System.out.println("resolving exit alt for decision="+ dfa.decisionNumber+" state="+d); System.out.println("nondet="+nondeterministicAlts); System.out.println("exit alt "+exitAlt); */ int exitAlt = dfa.getNumberOfAlts(); if ( nondeterministicAlts.contains(Utils.integer(exitAlt)) ) { // if nongreedy and exit alt is one of those nondeterministic alts // predicted, resolve in favor of what follows block winningAlt = resolveByPickingExitAlt(d,nondeterministicAlts); } else { winningAlt = resolveByPickingMinAlt(d,nondeterministicAlts); } } return winningAlt; }
protected void optimizeExitBranches(DFAState d) { Integer sI = Utils.integer(d.stateNumber); if ( visited.contains(sI) ) { return; // already visited } visited.add(sI); int nAlts = d.dfa.getNumberOfAlts(); for (int i = 0; i < d.getNumberOfTransitions(); i++) { Transition edge = d.transition(i); DFAState edgeTarget = ((DFAState)edge.target); /* System.out.println(d.stateNumber+"-"+ edge.label.toString(d.dfa.nfa.grammar)+"->"+ edgeTarget.stateNumber); */ // if target is an accept state and that alt is the exit alt if ( edgeTarget.isAcceptState() && edgeTarget.getUniquelyPredictedAlt()==nAlts) { /* System.out.println("ignoring transition "+i+" to max alt "+ d.dfa.getNumberOfAlts()); */ d.removeTransition(i); i--; // back up one so that i++ of loop iteration stays within bounds } optimizeExitBranches(edgeTarget); } }
protected void optimizeExitBranches(DFAState d) { Integer sI = Utils.integer(d.stateNumber); if ( visited.contains(sI) ) { return; // already visited } visited.add(sI); int nAlts = d.dfa.getNumberOfAlts(); for (int i = 0; i < d.getNumberOfTransitions(); i++) { Transition edge = d.transition(i); DFAState edgeTarget = ((DFAState)edge.target); /* System.out.println(d.stateNumber+"-"+ edge.label.toString(d.dfa.nfa.grammar)+"->"+ edgeTarget.stateNumber); */ // if target is an accept state and that alt is the exit alt if ( edgeTarget.isAcceptState() && edgeTarget.getUniquelyPredictedAlt()==nAlts) { /* System.out.println("ignoring transition "+i+" to max alt "+ d.dfa.getNumberOfAlts()); */ d.removeTransition(i); i--; // back up one so that i++ of loop iteration stays within bounds } optimizeExitBranches(edgeTarget); } }
protected void optimizeExitBranches(DFAState d) { Integer sI = Utils.integer(d.stateNumber); if ( visited.contains(sI) ) { return; // already visited } visited.add(sI); int nAlts = d.dfa.getNumberOfAlts(); for (int i = 0; i < d.getNumberOfTransitions(); i++) { Transition edge = (Transition) d.transition(i); DFAState edgeTarget = ((DFAState)edge.target); /* System.out.println(d.stateNumber+"-"+ edge.label.toString(d.dfa.nfa.grammar)+"->"+ edgeTarget.stateNumber); */ // if target is an accept state and that alt is the exit alt if ( edgeTarget.isAcceptState() && edgeTarget.getUniquelyPredictedAlt()==nAlts) { /* System.out.println("ignoring transition "+i+" to max alt "+ d.dfa.getNumberOfAlts()); */ d.removeTransition(i); i--; // back up one so that i++ of loop iteration stays within bounds } optimizeExitBranches(edgeTarget); } }
protected void optimizeExitBranches(DFAState d) { Integer sI = Utils.integer(d.stateNumber); if ( visited.contains(sI) ) { return; // already visited } visited.add(sI); int nAlts = d.dfa.getNumberOfAlts(); for (int i = 0; i < d.getNumberOfTransitions(); i++) { Transition edge = (Transition) d.transition(i); DFAState edgeTarget = ((DFAState)edge.target); /* System.out.println(d.stateNumber+"-"+ edge.label.toString(d.dfa.nfa.grammar)+"->"+ edgeTarget.stateNumber); */ // if target is an accept state and that alt is the exit alt if ( edgeTarget.isAcceptState() && edgeTarget.getUniquelyPredictedAlt()==nAlts) { /* System.out.println("ignoring transition "+i+" to max alt "+ d.dfa.getNumberOfAlts()); */ d.removeTransition(i); i--; // back up one so that i++ of loop iteration stays within bounds } optimizeExitBranches(edgeTarget); } }