private static Transition createSetTransition(ATNState target, IntervalSet set)
{
if (set.GetIntervals().Count == 1)
{
Interval interval = set.GetIntervals()[0];
if (interval.a == interval.b)
{
return(new AtomTransition(target, interval.a));
}
else
{
return(new RangeTransition(target, interval.a, interval.b));
}
}
else
{
return(new SetTransition(target, set));
}
}
private IntervalSet Filter(IntervalSet original)
{
IntervalSet result = new IntervalSet();
foreach (Interval i in original.GetIntervals())
{
for (int j = i.a; j <= i.b; ++j)
{
if (!_not_used.Contains(j))
{
result.Add(j);
}
}
}
return(result);
}
private static int OptimizeSets(ATN atn, bool preserveOrder)
{
if (preserveOrder)
{
// this optimization currently doesn't preserve edge order.
return(0);
}
int removedPaths = 0;
IList <DecisionState> decisions = atn.decisionToState;
foreach (DecisionState decision in decisions)
{
IntervalSet setTransitions = new IntervalSet();
for (int i = 0; i < decision.NumberOfOptimizedTransitions; i++)
{
Transition epsTransition = decision.GetOptimizedTransition(i);
if (!(epsTransition is EpsilonTransition))
{
continue;
}
if (epsTransition.target.NumberOfOptimizedTransitions != 1)
{
continue;
}
Transition transition = epsTransition.target.GetOptimizedTransition(0);
if (!(transition.target is BlockEndState))
{
continue;
}
if (transition is NotSetTransition)
{
// TODO: not yet implemented
continue;
}
if (transition is AtomTransition || transition is RangeTransition || transition is SetTransition)
{
setTransitions.Add(i);
}
}
if (setTransitions.Count <= 1)
{
continue;
}
IList <Transition> optimizedTransitions = new List <Transition>();
for (int i_1 = 0; i_1 < decision.NumberOfOptimizedTransitions; i_1++)
{
if (!setTransitions.Contains(i_1))
{
optimizedTransitions.Add(decision.GetOptimizedTransition(i_1));
}
}
ATNState blockEndState = decision.GetOptimizedTransition(setTransitions.MinElement).target.GetOptimizedTransition(0).target;
IntervalSet matchSet = new IntervalSet();
for (int i_2 = 0; i_2 < setTransitions.GetIntervals().Count; i_2++)
{
Interval interval = setTransitions.GetIntervals()[i_2];
for (int j = interval.a; j <= interval.b; j++)
{
Transition matchTransition = decision.GetOptimizedTransition(j).target.GetOptimizedTransition(0);
if (matchTransition is NotSetTransition)
{
throw new NotSupportedException("Not yet implemented.");
}
else
{
matchSet.AddAll(matchTransition.Label);
}
}
}
Transition newTransition;
if (matchSet.GetIntervals().Count == 1)
{
if (matchSet.Count == 1)
{
newTransition = new AtomTransition(blockEndState, matchSet.MinElement);
}
else
{
Interval matchInterval = matchSet.GetIntervals()[0];
newTransition = new RangeTransition(blockEndState, matchInterval.a, matchInterval.b);
}
}
else
{
newTransition = new SetTransition(blockEndState, matchSet);
}
ATNState setOptimizedState = new BasicState();
setOptimizedState.SetRuleIndex(decision.ruleIndex);
atn.AddState(setOptimizedState);
setOptimizedState.AddTransition(newTransition);
optimizedTransitions.Add(new EpsilonTransition(setOptimizedState));
removedPaths += decision.NumberOfOptimizedTransitions - optimizedTransitions.Count;
if (decision.IsOptimized)
{
while (decision.NumberOfOptimizedTransitions > 0)
{
decision.RemoveOptimizedTransition(decision.NumberOfOptimizedTransitions - 1);
}
}
foreach (Transition transition_1 in optimizedTransitions)
{
decision.AddOptimizedTransition(transition_1);
}
}
return(removedPaths);
}
protected string GetListOfExpectedTokens(IntervalSet intervalSet, IVocabulary vocabulary)
{
StringBuilder buf = new StringBuilder();
if (intervalSet == null || intervalSet.Count == 0)
{
return("{}");
}
if (intervalSet.Count > 1)
{
buf.Append("{");
}
bool first = true;
// Never display more than 10 expected tokens
if (intervalSet.Count <= 10)
{
foreach (Interval I in intervalSet.GetIntervals())
{
if (!first)
{
buf.Append(", ");
}
first = false;
int a = I.a;
int b = I.b;
if (a == b)
{
buf.Append(TokenUtils.GetDisplayNameForTokenType((TokenType)a));
}
else
{
for (int i = a; i <= b; i++)
{
if (i > a)
{
buf.Append(", ");
}
buf.Append(TokenUtils.GetDisplayNameForTokenType((TokenType)i));
}
}
}
}
// If more than 10 expected tokens, display list of token families
else
{
HashSet <TokenFamily> familySet = new HashSet <TokenFamily>();
foreach (Interval I in intervalSet.GetIntervals())
{
for (int i = I.a; i <= I.b; i++)
{
TokenFamily tokenFamily = TokenUtils.GetTokenFamilyFromTokenType((TokenType)i);
if (familySet.Add(tokenFamily))
{
if (!first)
{
buf.Append(", ");
}
first = false;
buf.Append(TokenUtils.GetDisplayNameForTokenFamily(tokenFamily));
}
}
}
}
if (intervalSet.Count > 1)
{
buf.Append("}");
}
return(buf.ToString());
}