public virtual void trackNFAStatesThatHaveLabeledEdge(Label label, NFAState stateWithLabeledEdge)
{
HashSet <NFAState> states = typeToNFAStatesWithEdgeOfTypeMap.get(label);
if (states == null)
{
states = new HashSet <NFAState>();
typeToNFAStatesWithEdgeOfTypeMap[label] = states;
}
states.Add(stateWithLabeledEdge);
}
public override String ToString()
{
GrammarAST decisionASTNode = probe.Dfa.DecisionASTNode;
line = decisionASTNode.Line;
charPositionInLine = decisionASTNode.CharPositionInLine;
String fileName = probe.Dfa.Nfa.Grammar.FileName;
if (fileName != null)
{
file = fileName;
}
StringTemplate st = GetMessageTemplate();
if (probe.Dfa.IsTokensRuleDecision)
{
// alts are token rules, convert to the names instead of numbers
for (int i = 0; i < alts.Length; i++)
{
int altI = alts[i];
String tokenName = probe.GetTokenNameForTokensRuleAlt(altI);
// reset the line/col to the token definition
NFAState ruleStart = probe.Dfa.Nfa.Grammar.GetRuleStartState(tokenName);
line = ruleStart.associatedASTNode.Line;
charPositionInLine = ruleStart.associatedASTNode.CharPositionInLine;
st.SetAttribute("tokens", tokenName);
}
}
else
{
// regular alt numbers, show the alts
st.SetAttribute("alts", alts);
}
return(base.ToString(st));
}
public virtual void trackNFAStatesThatHaveLabeledEdge( Label label, NFAState stateWithLabeledEdge )
{
HashSet<NFAState> states = typeToNFAStatesWithEdgeOfTypeMap.get( label );
if ( states == null )
{
states = new HashSet<NFAState>();
typeToNFAStatesWithEdgeOfTypeMap[label] = states;
}
states.Add( stateWithLabeledEdge );
}
public virtual void AddState( NFAState state )
{
numberToStateList.Resize( state.StateNumber + 1 ); // make sure we have room
numberToStateList[state.StateNumber] = state;
}
public virtual void AddState(NFAState state)
{
numberToStateList.setSize(state.stateNumber + 1); // make sure we have room
numberToStateList[state.stateNumber] = state;
}
public override string ToString()
{
GrammarAST decisionASTNode = probe.dfa.DecisionASTNode;
line = decisionASTNode.Line;
charPositionInLine = decisionASTNode.CharPositionInLine;
string fileName = probe.dfa.nfa.grammar.FileName;
if (fileName != null)
{
file = fileName;
}
StringTemplate st = GetMessageTemplate();
// Now fill template with information about problemState
var labels = probe.GetSampleNonDeterministicInputSequence(problemState);
string input = probe.GetInputSequenceDisplay(labels);
st.SetAttribute("input", input);
if (probe.dfa.IsTokensRuleDecision)
{
var disabledAlts = probe.GetDisabledAlternatives(problemState);
foreach (int altI in disabledAlts)
{
string tokenName =
probe.GetTokenNameForTokensRuleAlt((int)altI);
// reset the line/col to the token definition (pick last one)
NFAState ruleStart =
probe.dfa.nfa.grammar.GetRuleStartState(tokenName);
line = ruleStart.associatedASTNode.Line;
charPositionInLine = ruleStart.associatedASTNode.CharPositionInLine;
st.SetAttribute("disabled", tokenName);
}
}
else
{
st.SetAttribute("disabled", probe.GetDisabledAlternatives(problemState));
}
var nondetAlts = probe.GetNonDeterministicAltsForState(problemState);
NFAState nfaStart = probe.dfa.NFADecisionStartState;
// all state paths have to begin with same NFA state
int firstAlt = 0;
if (nondetAlts != null)
{
foreach (int displayAltI in nondetAlts)
{
if (DecisionProbe.verbose)
{
int tracePathAlt =
nfaStart.TranslateDisplayAltToWalkAlt((int)displayAltI);
if (firstAlt == 0)
{
firstAlt = tracePathAlt;
}
IList path =
probe.GetNFAPathStatesForAlt(firstAlt,
tracePathAlt,
labels);
st.SetAttribute("paths.{alt,states}",
displayAltI, path);
}
else
{
if (probe.dfa.IsTokensRuleDecision)
{
// alts are token rules, convert to the names instead of numbers
string tokenName =
probe.GetTokenNameForTokensRuleAlt((int)displayAltI);
st.SetAttribute("conflictingTokens", tokenName);
}
else
{
st.SetAttribute("conflictingAlts", displayAltI);
}
}
}
}
st.SetAttribute("hasPredicateBlockedByAction", problemState.dfa.hasPredicateBlockedByAction);
return(base.ToString(st));
}
/** From state s, look for any transition to a rule that is currently
* being traced. When tracing r, visitedDuringRecursionCheck has r
* initially. If you reach an accept state, return but notify the
* invoking rule that it is nullable, which implies that invoking
* rule must look at follow transition for that invoking state.
* The visitedStates tracks visited states within a single rule so
* we can avoid epsilon-loop-induced infinite recursion here. Keep
* filling the cycles in listOfRecursiveCycles and also, as a
* side-effect, set leftRecursiveRules.
*/
protected virtual bool TraceStatesLookingForLeftRecursion(NFAState s,
HashSet <object> visitedStates,
IList <HashSet <Rule> > listOfRecursiveCycles)
{
if (s.IsAcceptState)
{
// this rule must be nullable!
// At least one epsilon edge reached accept state
return(true);
}
if (visitedStates.Contains(s))
{
// within same rule, we've hit same state; quit looping
return(false);
}
visitedStates.Add(s);
bool stateReachesAcceptState = false;
Transition t0 = s.transition[0];
if (t0 is RuleClosureTransition)
{
RuleClosureTransition refTrans = (RuleClosureTransition)t0;
Rule refRuleDef = refTrans.Rule;
//String targetRuleName = ((NFAState)t0.target).getEnclosingRule();
if (visitedDuringRecursionCheck.Contains(refRuleDef))
{
// record left-recursive rule, but don't go back in
grammar.leftRecursiveRules.Add(refRuleDef);
//System.Console.Out.WriteLine( "already visited " + refRuleDef + ", calling from " + s.enclosingRule );
AddRulesToCycle(refRuleDef,
s.enclosingRule,
listOfRecursiveCycles);
}
else
{
// must visit if not already visited; send new visitedStates set
visitedDuringRecursionCheck.Add(refRuleDef);
bool callReachedAcceptState =
TraceStatesLookingForLeftRecursion((NFAState)t0.Target,
new HashSet <object>(),
listOfRecursiveCycles);
// we're back from visiting that rule
visitedDuringRecursionCheck.Remove(refRuleDef);
// must keep going in this rule then
if (callReachedAcceptState)
{
NFAState followingState =
((RuleClosureTransition)t0).FollowState;
stateReachesAcceptState |=
TraceStatesLookingForLeftRecursion(followingState,
visitedStates,
listOfRecursiveCycles);
}
}
}
else if (t0.Label.IsEpsilon || t0.Label.IsSemanticPredicate)
{
stateReachesAcceptState |=
TraceStatesLookingForLeftRecursion((NFAState)t0.Target, visitedStates, listOfRecursiveCycles);
}
// else it has a labeled edge
// now do the other transition if it exists
Transition t1 = s.transition[1];
if (t1 != null)
{
stateReachesAcceptState |=
TraceStatesLookingForLeftRecursion((NFAState)t1.Target,
visitedStates,
listOfRecursiveCycles);
}
return(stateReachesAcceptState);
}
/** From state s, look for any transition to a rule that is currently
* being traced. When tracing r, visitedDuringRecursionCheck has r
* initially. If you reach an accept state, return but notify the
* invoking rule that it is nullable, which implies that invoking
* rule must look at follow transition for that invoking state.
* The visitedStates tracks visited states within a single rule so
* we can avoid epsilon-loop-induced infinite recursion here. Keep
* filling the cycles in listOfRecursiveCycles and also, as a
* side-effect, set leftRecursiveRules.
*/
protected virtual bool TraceStatesLookingForLeftRecursion( NFAState s,
HashSet<object> visitedStates,
IList<HashSet<Rule>> listOfRecursiveCycles )
{
if ( s.IsAcceptState )
{
// this rule must be nullable!
// At least one epsilon edge reached accept state
return true;
}
if ( visitedStates.Contains( s ) )
{
// within same rule, we've hit same state; quit looping
return false;
}
visitedStates.Add( s );
bool stateReachesAcceptState = false;
Transition t0 = s.transition[0];
if ( t0 is RuleClosureTransition )
{
RuleClosureTransition refTrans = (RuleClosureTransition)t0;
Rule refRuleDef = refTrans.rule;
//String targetRuleName = ((NFAState)t0.target).getEnclosingRule();
if ( visitedDuringRecursionCheck.Contains( refRuleDef ) )
{
// record left-recursive rule, but don't go back in
grammar.leftRecursiveRules.Add( refRuleDef );
//System.Console.Out.WriteLine( "already visited " + refRuleDef + ", calling from " + s.enclosingRule );
AddRulesToCycle( refRuleDef,
s.enclosingRule,
listOfRecursiveCycles );
}
else
{
// must visit if not already visited; send new visitedStates set
visitedDuringRecursionCheck.Add( refRuleDef );
bool callReachedAcceptState =
TraceStatesLookingForLeftRecursion( (NFAState)t0.target,
new HashSet<object>(),
listOfRecursiveCycles );
// we're back from visiting that rule
visitedDuringRecursionCheck.Remove( refRuleDef );
// must keep going in this rule then
if ( callReachedAcceptState )
{
NFAState followingState =
( (RuleClosureTransition)t0 ).followState;
stateReachesAcceptState |=
TraceStatesLookingForLeftRecursion( followingState,
visitedStates,
listOfRecursiveCycles );
}
}
}
else if ( t0.label.IsEpsilon || t0.label.IsSemanticPredicate )
{
stateReachesAcceptState |=
TraceStatesLookingForLeftRecursion( (NFAState)t0.target, visitedStates, listOfRecursiveCycles );
}
// else it has a labeled edge
// now do the other transition if it exists
Transition t1 = s.transition[1];
if ( t1 != null )
{
stateReachesAcceptState |=
TraceStatesLookingForLeftRecursion( (NFAState)t1.target,
visitedStates,
listOfRecursiveCycles );
}
return stateReachesAcceptState;
}
