public virtual IntervalSet GetExpectedTokens(int stateNumber, RuleContext context)
{
if (stateNumber < 0 || stateNumber >= states.Count)
{
throw new ArgumentException("Invalid state number.");
}
RuleContext ctx = context;
ATNState s = states[stateNumber];
IntervalSet following = NextTokens(s);
if (!following.Contains(TokenConstants.EPSILON))
{
return(following);
}
IntervalSet expected = new IntervalSet();
expected.AddAll(following);
expected.Remove(TokenConstants.EPSILON);
while (ctx != null && ctx.invokingState >= 0 && following.Contains(TokenConstants.EPSILON))
{
ATNState invokingState = states[ctx.invokingState];
RuleTransition rt = (RuleTransition)invokingState.Transition(0);
following = NextTokens(rt.followState);
expected.AddAll(following);
expected.Remove(TokenConstants.EPSILON);
ctx = ctx.Parent;
}
if (following.Contains(TokenConstants.EPSILON))
{
expected.Add(TokenConstants.EOF);
}
return(expected);
}
private static IEnumerable <TextFragment> SplitFragment(TextFragment fragment, List <ITextFragment> processedFragments)
{
if (processedFragments.Count == 0)
{
return(new List <TextFragment> {
fragment
});
}
var fragmentSet =
new IntervalSet(
new List <Interval>()
{
new Interval()
{
Start = fragment.Start, End = fragment.End + 1
}
});
var processedFragmentsSet = new IntervalSet(processedFragments.Select(fr => new Interval()
{
Start = fr.Start, End = fr.End + 1
}).ToList());
var outputIntervals = IntervalSet.Remove(fragmentSet, processedFragmentsSet);
return(outputIntervals.Set.Select(
i => new TextFragment(i.Start, fragment.Text.Substring(i.Start - fragment.Start, i.End - i.Start))).ToList());
}
public void TestRmMiddleRange()
{
IntervalSet s = IntervalSet.Of(1, 10);
s.Add(-3, -3);
s.Remove(5);
String expecting = "{-3, 1..4, 6..10}";
String result = s.ToString();
Assert.AreEqual(expecting, result);
}
public void TestRmRightSide()
{
IntervalSet s = IntervalSet.Of(1, 10);
s.Add(-3, -3);
s.Remove(10);
String expecting = "{-3, 1..9}";
String result = s.ToString();
Assert.AreEqual(expecting, result);
}
public void TestRmSingleElement()
{
IntervalSet s = IntervalSet.Of(1, 10);
s.Add(-3, -3);
s.Remove(-3);
String expecting = "{1..10}";
String result = s.ToString();
Assert.AreEqual(expecting, result);
}
protected internal virtual IntervalSet GetErrorRecoverySet(Parser recognizer)
{
ATN atn = recognizer.Interpreter.atn;
RuleContext ctx = recognizer.RuleContext;
IntervalSet recoverSet = new IntervalSet();
while (ctx != null && ctx.invokingState >= 0)
{
// compute what follows who invoked us
ATNState invokingState = atn.states[ctx.invokingState];
RuleTransition rt = (RuleTransition)invokingState.Transition(0);
IntervalSet follow = atn.NextTokens(rt.followState);
recoverSet.AddAll(follow);
ctx = ctx.Parent;
}
recoverSet.Remove(TokenConstants.Epsilon);
// System.out.println("recover set "+recoverSet.toString(recognizer.getTokenNames()));
return(recoverSet);
}
private static Transition updateTransition(Transition t, char openDelimiter, char closeDelimiter)
{
Transition updated = null;
if (t is RuleTransition)
{
return(null);
}
else if (t is AtomTransition)
{
AtomTransition atomTransition = (AtomTransition)t;
int newLabel;
if (atomTransition.label == OpenDelimiterPlaceholder)
{
newLabel = openDelimiter;
}
else if (atomTransition.label == CloseDelimiterPlaceholder)
{
newLabel = closeDelimiter;
}
else
{
return(null);
}
updated = new AtomTransition(t.target, newLabel);
}
else if (t is NotSetTransition)
{
NotSetTransition notSetTransition = (NotSetTransition)t;
int removeLabel;
int addLabel;
if (notSetTransition.set.Contains(OpenDelimiterPlaceholder))
{
removeLabel = OpenDelimiterPlaceholder;
addLabel = openDelimiter;
}
else if (notSetTransition.set.Contains(CloseDelimiterPlaceholder))
{
removeLabel = CloseDelimiterPlaceholder;
addLabel = closeDelimiter;
}
else
{
return(null);
}
IntervalSet set = new IntervalSet(notSetTransition.set);
set.Remove(removeLabel);
set.Add(addLabel);
set.SetReadonly(true);
updated = new NotSetTransition(t.target, set);
}
else if (t is SetTransition)
{
SetTransition setTransition = (SetTransition)t;
int removeLabel;
int addLabel;
if (setTransition.set.Contains(OpenDelimiterPlaceholder))
{
removeLabel = OpenDelimiterPlaceholder;
addLabel = openDelimiter;
}
else if (setTransition.set.Contains(CloseDelimiterPlaceholder))
{
removeLabel = CloseDelimiterPlaceholder;
addLabel = closeDelimiter;
}
else
{
return(null);
}
IntervalSet set = new IntervalSet(setTransition.set);
set.Remove(removeLabel);
set.Add(addLabel);
set.SetReadonly(true);
updated = createSetTransition(t.target, set);
}
else if (t is RangeTransition)
{
RangeTransition rangeTransition = (RangeTransition)t;
int removeLabel;
int addLabel;
if (rangeTransition.from <= OpenDelimiterPlaceholder && rangeTransition.to >= OpenDelimiterPlaceholder)
{
removeLabel = OpenDelimiterPlaceholder;
addLabel = openDelimiter;
}
else if (rangeTransition.from <= CloseDelimiterPlaceholder && rangeTransition.to >= CloseDelimiterPlaceholder)
{
removeLabel = CloseDelimiterPlaceholder;
addLabel = closeDelimiter;
}
else
{
return(null);
}
IntervalSet set = IntervalSet.Of(rangeTransition.from, rangeTransition.to);
set.Remove(removeLabel);
set.Add(addLabel);
set.SetReadonly(true);
updated = createSetTransition(t.target, set);
}
return(updated);
}