public void Visit(ISymbolForestNode node)
{
if (!_visited.Add(node))
{
return;
}
for (var a = 0; a < node.Children.Count; a++)
{
PrintNode(node);
_writer.Write(" ->");
var andNode = node.Children[a];
for (var c = 0; c < andNode.Children.Count; c++)
{
var child = andNode.Children[c];
PrintNode(child);
}
_writer.WriteLine();
}
for (var i = 0; i < node.Children.Count; i++)
{
var child = node.Children[i];
Visit(child);
}
}
public void Visit(ISymbolForestNode node)
{
if (!this.visited.Add(node))
{
return;
}
foreach (var child in node.Children)
{
PrintNode(node);
this.writer.Write(" ->");
var andNode = child;
foreach (var andChild in andNode.Children)
{
PrintNode(andChild);
}
this.writer.WriteLine();
}
foreach (var child in node.Children)
{
Visit(child);
}
}
private static void AssertNodeProperties(ISymbolForestNode node, string nodeName, int origin, int location)
{
var actualNodeName = (node.Symbol as INonTerminal).Value;
Assert.AreEqual(nodeName, actualNodeName, "Node Name Match Failed.");
Assert.AreEqual(origin, node.Origin, "Origin Match Failed.");
Assert.AreEqual(location, node.Location, "Location Match Failed.");
}
public override void Visit(ISymbolForestNode symbolNode)
{
VisitLog.Add(symbolNode.ToString());
foreach (var child in symbolNode.Children)
{
Visit(child);
}
}
bool AreSymbolNodesEqual(ISymbolForestNode firstSymbolForestNode, ISymbolForestNode secondSymbolForestNode)
{
if (!firstSymbolForestNode.Symbol.Equals(secondSymbolForestNode.Symbol))
{
return(false);
}
return(AreChildNodesEqual(firstSymbolForestNode, secondSymbolForestNode));
}
public InternalTreeNode(
ISymbolForestNode internalNode,
IForestDisambiguationAlgorithm stateManager)
{
this.disambiguationAlgorithm = stateManager;
this.internalNode = internalNode;
this.children = null;
SetSymbol(this.internalNode);
}
private static ISymbolForestNode CountChildren(ISymbolForestNode node, int childCount)
{
Assert.IsNotNull(node);
Assert.AreEqual(1, node.Children.Count);
var firstAndNode = node.Children[0];
Assert.IsNotNull(firstAndNode);
Assert.AreEqual(childCount, firstAndNode.Children.Count);
return(node);
}
public ISymbolForestNode AddOrGetExistingSymbolNode(ISymbol symbol, int origin, int location)
{
var hash = ComputeHashCode(symbol, origin, location);
ISymbolForestNode symbolNode = null;
if (_symbolNodes.TryGetValue(hash, out symbolNode))
{
return(symbolNode);
}
symbolNode = new SymbolForestNode(symbol, origin, location);
_symbolNodes.Add(hash, symbolNode);
return(symbolNode);
}
public override void Visit(ISymbolForestNode symbolNode)
{
if (!this.visited.Add(symbolNode))
{
return;
}
var childIndex = GetOrSetChildIndex(symbolNode);
var path = symbolNode.Children[childIndex];
var internalTreeNode = new InternalTreeNodeImpl(
symbolNode.Origin,
symbolNode.Location,
symbolNode.Symbol as NonTerminal);
var isRoot = this.nodeStack.Count == 0;
if (!isRoot)
{
this.nodeStack
.Peek()
.ReadWriteChildren
.Add(internalTreeNode);
}
this.nodeStack.Push(internalTreeNode);
Visit(path);
var top = this.nodeStack.Pop();
if (isRoot)
{
if (this.count > 0 && this._lock == null)
{
Root = null;
}
else
{
Root = top;
}
this.count++;
this.visited.Clear();
}
}
public abstract void Visit(ISymbolForestNode symbolNode);
private static string GetSymbolNodeString(ISymbolForestNode node)
{
return $"({node.Symbol}, {node.Origin}, {node.Location})";
}
public ParseTreeEnumerable(ISymbolForestNode internalForestNode)
{
this._internalForestNode = internalForestNode;
}
public InternalTreeNode(
ISymbolForestNode internalNode)
: this(internalNode, new SelectFirstChildDisambiguationAlgorithm())
{
}
public ParseTreeEnumerator(ISymbolForestNode forestRoot)
{
this._forestRoot = forestRoot;
this._status = ParseTreeEnumeratorState.New;
this._visitor = new ForestNodeVisitorImpl();
}
public override void Visit(ISymbolForestNode symbolNode)
{
VisitLog.Add(symbolNode.ToString());
foreach (var child in symbolNode.Children)
Visit(child);
}
public override void Visit(ISymbolForestNode symbolNode)
{
if (!_visited.Add(symbolNode))
return;
int childIndex = GetOrSetChildIndex(symbolNode);
var path = symbolNode.Children[childIndex];
var internalTreeNode = new InternalTreeNodeImpl(
symbolNode.Origin,
symbolNode.Location,
symbolNode.Symbol as INonTerminal);
var isRoot = _nodeStack.Count == 0;
if (!isRoot)
{
_nodeStack
.Peek()
.ReadWriteChildren
.Add(internalTreeNode);
}
_nodeStack.Push(internalTreeNode);
Visit(path);
var top = _nodeStack.Pop();
if (isRoot)
{
if (_count > 0 && _lock == null)
Root = null;
else
Root = top;
_count++;
_visited.Clear();
}
}
public abstract void Visit(ISymbolForestNode symbolNode);
public override void Visit(ISymbolForestNode symbolNode)
{
var currentAndNode = ForestDisambiguationAlgorithm.GetCurrentAndNode(symbolNode);
Visit(currentAndNode);
}
public override void Visit(ISymbolForestNode symbolNode)
{
var currentAndNode = ForestDisambiguationAlgorithm.GetCurrentAndNode(symbolNode);
Visit(currentAndNode);
}
