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); }