public void SyntaxError(IRecognizer recognizer, IToken offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e)
{
AnyErrors = true;
CrawlParser parser = (CrawlParser)recognizer;
IntervalSet set = parser.GetExpectedTokens();
string help =
$"Symbolet {CrawlLexer.ruleNames[offendingSymbol.Type]} er ikke tilladt på dette punkt. En af de følgende var forventet:\n\t" +
string.Join("\n\t", set.ToArray().Select(x => parser.Vocabulary.GetDisplayName(x)));
int intrestinglocation = offendingSymbol.TokenIndex;
//for (int i = intrestinglocation; i < offendingSymbol.TokenIndex + 20; i++)
//{
// if (parser.TokenStream.Get(i).Channel == Lexer.DefaultTokenChannel)
// {
// intrestinglocation = i;
// break;
// }
//}
Errors.Add(CompilationMessage.Create(
parser.TokenStream,
Interval.Of(intrestinglocation, intrestinglocation),
MessageCode.UnexpectedSymbol,
$"{_file}:{line},{charPositionInLine}",
help,
MessageSeverity.Error));
}
protected virtual void TryParse(T parser, List <MultipleDecisionData> potentialAlternatives, List <int> currentPath, IDictionary <RuleContext, CaretReachedException> results)
{
RuleContext parseTree;
try
{
parser.Interpreter.SetFixedDecisions(potentialAlternatives, currentPath);
parseTree = ParseImpl(parser);
results[parseTree] = null;
}
catch (CaretReachedException ex)
{
if (ex.Transitions == null)
{
return;
}
if (ex.InnerException is FailedPredicateException)
{
return;
}
for (parseTree = ex.FinalContext; parseTree.Parent != null; parseTree = parseTree.Parent)
{
// intentionally blank
}
if (ex.InnerException != null)
{
IntervalSet alts = new IntervalSet();
IntervalSet semanticAlts = new IntervalSet();
foreach (ATNConfig c in ex.Transitions.Keys)
{
if (semanticAlts.Contains(c.Alt))
{
continue;
}
alts.Add(c.Alt);
var recognizer = parser as Recognizer <IToken, ParserATNSimulator>;
if (recognizer == null || c.SemanticContext.Eval(recognizer, ex.FinalContext))
{
semanticAlts.Add(c.Alt);
}
}
if (alts.Count != semanticAlts.Count)
{
Console.WriteLine("Forest decision {0} reduced to {1} by predicate evaluation.", alts, semanticAlts);
}
int inputIndex = parser.InputStream.Index;
int decision = 0;
int stateNumber = ex.InnerException.OffendingState;
ATNState state = parser.Atn.states[stateNumber];
if (state is StarLoopbackState)
{
Debug.Assert(state.NumberOfTransitions == 1 && state.OnlyHasEpsilonTransitions);
Debug.Assert(state.Transition(0).target is StarLoopEntryState);
state = state.Transition(0).target;
}
else
{
PlusBlockStartState plusBlockStartState = state as PlusBlockStartState;
if (plusBlockStartState != null && plusBlockStartState.decision == -1)
{
state = plusBlockStartState.loopBackState;
Debug.Assert(state != null);
}
}
DecisionState decisionState = state as DecisionState;
if (decisionState != null)
{
decision = decisionState.decision;
if (decision < 0)
{
Debug.WriteLine(string.Format("No decision number found for state {0}.", state.stateNumber));
}
}
else
{
if (state != null)
{
Debug.WriteLine(string.Format("No decision number found for state {0}.", state.stateNumber));
}
else
{
Debug.WriteLine("No decision number found for state <null>.");
}
// continuing is likely to terminate
return;
}
Debug.Assert(semanticAlts.MinElement >= 1);
Debug.Assert(semanticAlts.MaxElement <= parser.Atn.decisionToState[decision].NumberOfTransitions);
int[] alternatives = semanticAlts.ToArray();
MultipleDecisionData decisionData = new MultipleDecisionData(inputIndex, decision, alternatives);
potentialAlternatives.Add(decisionData);
currentPath.Add(-1);
}
else
{
results[parseTree] = ex;
}
}
catch (RecognitionException ex)
{
// not a viable path
}
}
