public PlusBlock(OutputModelFactory factory,
GrammarAST plusRoot,
IList <CodeBlockForAlt> alts)
: base(factory, plusRoot, alts)
{
BlockAST blkAST = (BlockAST)plusRoot.GetChild(0);
PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState;
PlusLoopbackState loop = blkStart.loopBackState;
stateNumber = blkStart.loopBackState.stateNumber;
blockStartStateNumber = blkStart.stateNumber;
loopBackStateNumber = loop.stateNumber;
this.error = GetThrowNoViableAlt(factory, plusRoot, null);
decision = loop.decision;
}
public LL1PlusBlockSingleAlt(OutputModelFactory factory, GrammarAST plusRoot, IList <CodeBlockForAlt> alts)
: base(factory, plusRoot, alts)
{
BlockAST blkAST = (BlockAST)plusRoot.GetChild(0);
PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState;
stateNumber = blkStart.loopBackState.stateNumber;
blockStartStateNumber = blkStart.stateNumber;
PlusBlockStartState plus = (PlusBlockStartState)blkAST.atnState;
this.decision = plus.loopBackState.decision;
IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision];
IntervalSet loopBackLook = altLookSets[0];
loopExpr = AddCodeForLoopLookaheadTempVar(loopBackLook);
}
public virtual Handle Block([NotNull] BlockAST blkAST, [NotNull] GrammarAST ebnfRoot, [NotNull] IList <Handle> alts)
{
if (ebnfRoot == null)
{
if (alts.Count == 1)
{
Handle h = alts[0];
blkAST.atnState = h.left;
return(h);
}
BlockStartState start = NewState <BasicBlockStartState>(blkAST);
if (alts.Count > 1)
{
atn.DefineDecisionState(start);
}
return(MakeBlock(start, blkAST, alts));
}
switch (ebnfRoot.Type)
{
case ANTLRParser.OPTIONAL:
BlockStartState start = NewState <BasicBlockStartState>(blkAST);
atn.DefineDecisionState(start);
Handle h = MakeBlock(start, blkAST, alts);
return(Optional(ebnfRoot, h));
case ANTLRParser.CLOSURE:
BlockStartState star = NewState <StarBlockStartState>(ebnfRoot);
if (alts.Count > 1)
{
atn.DefineDecisionState(star);
}
h = MakeBlock(star, blkAST, alts);
return(Star(ebnfRoot, h));
case ANTLRParser.POSITIVE_CLOSURE:
PlusBlockStartState plus = NewState <PlusBlockStartState>(ebnfRoot);
if (alts.Count > 1)
{
atn.DefineDecisionState(plus);
}
h = MakeBlock(plus, blkAST, alts);
return(Plus(ebnfRoot, h));
}
return(null);
}
public virtual Handle Plus([NotNull] GrammarAST plusAST, [NotNull] Handle blk)
{
PlusBlockStartState blkStart = (PlusBlockStartState)blk.left;
BlockEndState blkEnd = (BlockEndState)blk.right;
preventEpsilonClosureBlocks.Add(Tuple.Create <Rule, ATNState, ATNState>(currentRule, blkStart, blkEnd));
PlusLoopbackState loop = NewState <PlusLoopbackState>(plusAST);
loop.nonGreedy = !((QuantifierAST)plusAST).GetGreedy();
loop.sll = false; // no way to express SLL restriction
atn.DefineDecisionState(loop);
LoopEndState end = NewState <LoopEndState>(plusAST);
blkStart.loopBackState = loop;
end.loopBackState = loop;
plusAST.atnState = loop;
Epsilon(blkEnd, loop); // blk can see loop back
BlockAST blkAST = (BlockAST)plusAST.GetChild(0);
if (((QuantifierAST)plusAST).GetGreedy())
{
if (ExpectNonGreedy(blkAST))
{
g.tool.errMgr.GrammarError(ErrorType.EXPECTED_NON_GREEDY_WILDCARD_BLOCK, g.fileName, plusAST.Token, plusAST.Token.Text);
}
Epsilon(loop, blkStart); // loop back to start
Epsilon(loop, end); // or exit
}
else
{
// if not greedy, priority to exit branch; make it first
Epsilon(loop, end); // exit
Epsilon(loop, blkStart); // loop back to start
}
return(new Handle(blkStart, end));
}
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
}
}
