public void ConvertEmittedElementsToRealTokenNodes(bool aRecurse)
{
int i = ChildCount;
//
while (i > 0)
{
SymNode child = this[--i];
//
if (child is SymTokenBalancerNodeEmittedElement)
{
SymTokenBalancerNodeEmittedElement emittedElement = (SymTokenBalancerNodeEmittedElement)child;
if (emittedElement.Emit)
{
SymNodeToken replacement = new SymNodeToken(emittedElement.Token);
InsertChild(replacement, child);
}
child.Remove();
}
else if (child is SymTokenBalancerMarkerLevelNode && aRecurse)
{
SymTokenBalancerMarkerLevelNode childLevel = (SymTokenBalancerMarkerLevelNode)child;
childLevel.ConvertEmittedElementsToRealTokenNodes(aRecurse);
}
}
}
public void ExtractTokens(IEnumerable aEnumerable, bool aIgnoreWhiteSpace, bool aRecurse, SymTokenContainer aContainer)
{
foreach (SymNode node in aEnumerable)
{
if (node.HasChildren)
{
if (aRecurse)
{
ExtractTokens(node, aIgnoreWhiteSpace, aRecurse, aContainer);
}
else
{
// Ignore - its just a placeholder for child nodes
}
}
else if (node is SymNodeToken)
{
SymNodeToken tokenNode = (SymNodeToken)node;
if (!(aIgnoreWhiteSpace && tokenNode.Token.Class == SymToken.TClass.EClassWhiteSpace) || aIgnoreWhiteSpace == false)
{
aContainer.Append(tokenNode.Token);
}
}
else if (NodeIsExtractable(node))
{
ExtractToContainer(node, aContainer);
}
}
}
public void ExtractTokens(IEnumerable aEnumerable, bool aIgnoreWhiteSpace, bool aRecurse, SymTokenDocument aDocument)
{
foreach (SymNode node in aEnumerable)
{
if (node.HasChildren)
{
if (aRecurse)
{
SymNode newLevelNode = new SymNodeAddAsChild();
aDocument.CurrentNode.Add(newLevelNode);
aDocument.CurrentNode = newLevelNode;
ExtractTokens(node, aIgnoreWhiteSpace, aRecurse, aDocument);
aDocument.MakeParentCurrent();
}
else
{
// Ignore - its just a placeholder for child nodes and we're not recursing
}
}
else if (node is SymNodeToken)
{
SymNodeToken tokenNode = (SymNodeToken)node;
if (!(aIgnoreWhiteSpace && tokenNode.Token.Class == SymToken.TClass.EClassWhiteSpace) || aIgnoreWhiteSpace == false)
{
SymNodeToken copy = new SymNodeToken(tokenNode.Token);
aDocument.CurrentNode.Add(copy);
}
}
else if (NodeIsExtractable(node))
{
ExtractToDocument(node, aDocument);
}
}
}
public string MakeFunctionName()
{
StringBuilder name = new StringBuilder();
// Pull out all the level one tokens from the balancer. These form
// the function/define name.
foreach (SymNode n in DocumentTree)
{
if (n is SymTokenBalancerMarkerNode)
{
// Not part of the name
break;
}
else if (n is SymTokenBalancerNodeEmittedElement)
{
// Not part of the name - also, this is indicator to stop iterating!
break;
}
else if (n is SymNodeToken)
{
SymNodeToken tokenNode = (SymNodeToken)n;
name.Append(tokenNode.Token.Value);
}
}
return(name.ToString());
}
public static void RemoveWhiteSpace(SymNode aNode, bool aRecurse)
{
int count = aNode.ChildCount;
for (int i = count - 1; i >= 0; i--)
{
SymNode basicNode = aNode[i];
// If the node is whitespace, then remove it
if (basicNode is SymNodeToken)
{
SymNodeToken tokenNode = (SymNodeToken)basicNode;
bool isWhiteSpace = (tokenNode.Token.Class == SymToken.TClass.EClassWhiteSpace);
//
if (isWhiteSpace)
{
System.Diagnostics.Debug.Assert(basicNode.HasChildren == false);
basicNode.Remove();
}
}
// Remove whitespace from this node's children
if (basicNode.HasChildren && aRecurse)
{
RemoveWhiteSpace(basicNode, aRecurse);
}
}
}
protected virtual void AddToCurrentLevel(SymToken aToken)
{
System.Diagnostics.Debug.Write(aToken.Value);
SymNodeToken node = new SymNodeToken(aToken);
iTree.CurrentNode.Add(node);
}
public void AddToDocumentIfEmittable(SymDocument aDocument)
{
if (Emit)
{
SymNodeToken node = new SymNodeToken(Token);
aDocument.CurrentNode.Add(node);
}
}
private void BuildRecursiveTokenValueString(SymNode aNode, ref StringBuilder aString)
{
if (aNode is SymNodeToken)
{
SymNodeToken tokenNode = (SymNodeToken)aNode;
aString.Append(tokenNode.Token);
}
//
foreach (SymNode child in aNode)
{
BuildRecursiveTokenValueString(child, ref aString);
}
}
private void EvaluateDefineNodes(SymNode aNode, SymTokenDocument aDocument, SymParserDocumentContext aContext)
{
foreach (SymNode n in aNode)
{
if (n is SymTokenBalancerMarkerLevelNode)
{
bool added = false;
//
SymTokenBalancerMarkerLevelNode levelNode = (SymTokenBalancerMarkerLevelNode)n;
if (levelNode.IsFunction)
{
SymNodeToken functionNameNode = levelNode.FunctionName;
//
if (functionNameNode.Token.Equals(iDefinedNodeToken))
{
SymTokenContainer defineName = levelNode.ChildTokens;
string flattened = defineName.CoalescedTokenValue;
// Get definition result
bool isDefined = aContext.DefineDirectory.IsDefined(flattened);
SymToken isDefinedToken = new SymToken(isDefined.ToString().ToLower(), SymToken.TClass.EClassAlphaNumeric, SymToken.TType.ETypeAlphaNumericNormal);
// Remove already added "defined" text node from output document
if (aDocument.CurrentNode.LastChild is SymNodeToken)
{
SymNodeToken last = (SymNodeToken)aDocument.CurrentNode.LastChild;
if (last.Token.Equals(iDefinedNodeToken))
{
last.Remove();
}
}
// Add result
aDocument.CurrentNode.Add(new SymNodeToken(isDefinedToken));
added = true;
}
}
if (added == false)
{
if (levelNode.HasPrevious && levelNode.Previous is SymTokenBalancerNodeEmittedElement)
{
levelNode.EmittedElementPrevious.AddToDocumentIfEmittable(aDocument);
}
SymNode newLevelNode = new SymNodeAddAsChild();
aDocument.CurrentNode.Add(newLevelNode);
aDocument.CurrentNode = newLevelNode;
EvaluateDefineNodes(n, aDocument, aContext);
aDocument.MakeParentCurrent();
if (levelNode.HasNext && levelNode.Next is SymTokenBalancerNodeEmittedElement)
{
levelNode.EmittedElementNext.AddToDocumentIfEmittable(aDocument);
}
}
}
else if (n is SymNodeToken)
{
SymNodeToken node = (SymNodeToken)n;
SymNodeToken copy = new SymNodeToken(node.Token);
aDocument.CurrentNode.Add(copy);
}
else if (n is SymTokenBalancerNodeEmittedElement)
{
// Handled when the level marker is reached
}
}
}
public static SymNode Trim(SymNode aNode, bool aRecurse)
{
// Forward pass
while (aNode.HasChildren)
{
SymNode n = aNode.FirstChild;
if (n is SymNodeToken)
{
SymNodeToken nodeToken = (SymNodeToken)n;
bool isWhiteSpace = (nodeToken.Token.Class == SymToken.TClass.EClassWhiteSpace);
//
if (isWhiteSpace)
{
System.Diagnostics.Debug.Assert(n.HasChildren == false);
nodeToken.Remove();
}
else
{
break;
}
}
else
{
break;
}
}
// Backward pass
while (aNode.HasChildren)
{
SymNode n = aNode.LastChild;
if (n is SymNodeToken)
{
SymNodeToken nodeToken = (SymNodeToken)n;
bool isWhiteSpace = (nodeToken.Token.Class == SymToken.TClass.EClassWhiteSpace);
//
if (isWhiteSpace)
{
System.Diagnostics.Debug.Assert(n.HasChildren == false);
nodeToken.Remove();
}
else
{
break;
}
}
else
{
break;
}
}
// Child pass
if (aRecurse)
{
foreach (SymNode n in aNode)
{
if (n.HasChildren)
{
Trim(n, aRecurse);
}
}
}
return(aNode);
}
