public virtual void AddFollowLink(int ruleIndex, ATNState right)
{
// add follow edge from end of invoked rule
RuleStopState stop = atn.ruleToStopState[ruleIndex];
// System.out.println("add follow link from "+ruleIndex+" to "+right);
Epsilon(stop, right);
}
/** Define all the rule begin/end ATNStates to solve forward reference
* issues.
*/
internal virtual void CreateRuleStartAndStopATNStates()
{
atn.ruleToStartState = new RuleStartState[g.rules.Count];
atn.ruleToStopState = new RuleStopState[g.rules.Count];
foreach (Rule r in g.rules.Values)
{
RuleStartState start = NewState <RuleStartState>(r.ast);
RuleStopState stop = NewState <RuleStopState>(r.ast);
start.stopState = stop;
start.isPrecedenceRule = r is LeftRecursiveRule;
start.SetRuleIndex(r.index);
stop.SetRuleIndex(r.index);
atn.ruleToStartState[r.index] = start;
atn.ruleToStopState[r.index] = stop;
}
}
public virtual Handle Rule([NotNull] GrammarAST ruleAST, [NotNull] string name, [NotNull] Handle blk)
{
Rule r = g.GetRule(name);
RuleStartState start = atn.ruleToStartState[r.index];
Epsilon(start, blk.left);
RuleStopState stop = atn.ruleToStopState[r.index];
Epsilon(blk.right, stop);
Handle h = new Handle(start, stop);
//ATNPrinter ser = new ATNPrinter(g, h.left);
//System.Console.WriteLine(ruleAST.ToStringTree() + ":\n" + ser.AsString());
ruleAST.atnState = start;
return(h);
}
private HashSet <ATNState> ComputeSingle(List <Edge> parse)
{
List <Edge> copy = parse.ToList();
HashSet <ATNState> result = new HashSet <ATNState>();
if (_log_closure)
{
System.Console.Error.WriteLine("Computing closure for the following parse:");
System.Console.Error.Write(PrintSingle(parse));
System.Console.Error.WriteLine();
}
if (!copy.Any())
{
return(result);
}
Edge last_transaction = copy.First();
if (last_transaction == null)
{
return(result);
}
ATNState current_state = last_transaction._to;
if (current_state == null)
{
throw new Exception();
}
for (; ;)
{
if (_log_closure)
{
System.Console.Error.WriteLine("Getting closure of " + current_state.stateNumber);
}
HashSet <ATNState> c = closure(current_state);
if (_log_closure)
{
System.Console.Error.WriteLine("closure " + string.Join(" ", c.Select(s => s.stateNumber)));
}
bool do_continue = false;
ATN atn = current_state.atn;
int rule = current_state.ruleIndex;
RuleStartState start_state = atn.ruleToStartState[rule];
RuleStopState stop_state = atn.ruleToStopState[rule];
bool changed = false;
foreach (ATNState s in c)
{
if (result.Contains(s))
{
continue;
}
changed = true;
result.Add(s);
if (s == stop_state)
{
do_continue = true;
}
}
if (!changed)
{
break;
}
if (!do_continue)
{
break;
}
for (; ;)
{
if (!copy.Any())
{
break;
}
copy.RemoveAt(0);
if (!copy.Any())
{
break;
}
last_transaction = copy.First();
if (start_state == last_transaction._from)
{
copy.RemoveAt(0);
if (!copy.Any())
{
break;
}
last_transaction = copy.First();
// Get follow state of rule-type transition.
ATNState from_state = last_transaction._from;
if (from_state == null)
{
break;
}
ATNState follow_state = last_transaction._follow;
current_state = follow_state;
if (current_state == null)
{
throw new Exception();
}
break;
}
}
}
return(result);
}
