public bool EquivalentTo(SppfNode alt)
{
if (this.Id != alt.Id)
{
return(false);
}
if (this == (object)alt)
{
return(true);
}
if (Children == null)
{
return(alt.Children == null);
}
int len = Children.Length;
if (alt.Children == null || len != alt.Children.Length)
{
return(false);
}
for (int i = 0; i != len; ++i)
{
if (Children[i] != (object)alt.Children[i])
{
return(false);
}
}
return(true);
}
private void BuildCache()
{
int tokenCount = grammar.SymbolCount;
tokenCache = new SppfNode[tokenCount];
for (int token = 0; token != tokenCount; ++token)
{
if (grammar.IsNullable(token))
{
tokenCache[token] = new SppfNode(token, null, Loc.Unknown, HLoc.Unknown);
}
}
ruleOffsetInCache = new int[grammar.Productions.Count];
ruleEndOffsetInCache = new int[grammar.Productions.Count];
int nullableCount = 0;
foreach (var rule in grammar.Productions)
{
int i = rule.PatternTokens.Length;
while (i != 0)
{
int token = rule.PatternTokens[--i];
if (tokenCache[token] == null)
{
break;
}
++nullableCount;
}
ruleEndOffsetInCache[rule.Index] = nullableCount;
ruleOffsetInCache[rule.Index] = nullableCount - rule.PatternTokens.Length;
}
this.ruleCache = new SppfNode[nullableCount];
foreach (var rule in grammar.Productions)
{
int endOffset = ruleOffsetInCache[rule.Index] + rule.PatternTokens.Length;
int i = rule.PatternTokens.Length;
while (i != 0)
{
int token = rule.PatternTokens[--i];
if (tokenCache[token] == null)
{
break;
}
ruleCache[--endOffset] = tokenCache[token];
}
}
}
private bool EnqueueNode(SppfNode node)
{
bool result = !visited.Contains(node);
if (result)
{
visited.Add(node);
front.Push(node);
}
return(result);
}
public void WriteGraph(SppfNode rootNode)
{
front.Push(rootNode);
graph.BeginDigraph("SPPF");
graph.SetGraphProperties(ordering: Ordering.Out);
while (front.Count != 0)
{
var node = front.Pop();
WriteNode(node);
}
graph.EndDigraph();
}
internal SppfNode AddAlternative(SppfNode other)
{
#if DEBUG
Debug.Assert(!other.isChild);
#endif
if (other == (object)this)
{
return(this);
}
#if DEBUG
other.isAlternative = true;
#endif
other.NextAlternative = NextAlternative;
NextAlternative = other;
return(this);
}
private string GetLabel(SppfNode node)
{
if (node.Id > 0)
{
return(grammar.Symbols[node.Id].Name + " pos: " + node.Location.Position);
}
if (node.NextAlternative != null)
{
return(grammar.Symbols[node.GetTokenId(grammar)].Name);
}
var production = grammar.Productions[-node.Id];
if (showRules)
{
return(string.Format(
"{0} -> {1}",
production.Outcome.Name,
string.Join(" ", from s in production.Pattern select s.Name)));
}
return(production.Outcome.Name);
}
void ISppfNodeVisitor.VisitAlternatives(SppfNode alternatives)
{
var token = alternatives.GetTokenId(grammar);
var symbol = grammar.Symbols[token];
string label = symbol.Name + " pos: " + alternatives.Location.Position
#if DEBUG
+ " t: " + currentNode.timestamp
#endif
;
object parentIdentity = currentNodeIdentity;
graph.AddNode(parentIdentity, label: label, shape: Shape.Rect);
var familyNode = alternatives;
var altIdentity = alternatives.Children ?? new object();
int altIndex = 0;
do
{
graph.AddEdge(
parentIdentity,
altIdentity,
style: Style.Dotted,
label: "alt#" + ++altIndex);
this.currentNodeIdentity = altIdentity;
this.currentNode = familyNode;
visited.Add(familyNode);
familyNode.Accept(this, ignoreAlternatives: true);
familyNode = familyNode.NextAlternative;
altIdentity = familyNode;
}while (familyNode != null);
}
private void WriteNode(SppfNode node)
{
this.currentNodeIdentity = node;
this.currentNode = node;
node.Accept(this, false);
}
