private static void GetDirectives(GreenNode node, List <DirectiveTriviaSyntax> directives) { if (node != null && node.ContainsDirectives) { var d = node as DirectiveTriviaSyntax; if (d != null) { directives.Add(d); } else { var t = node as SyntaxToken; if (t != null) { GetDirectives(t.GetLeadingTrivia(), directives); GetDirectives(t.GetTrailingTrivia(), directives); } else { for (int i = 0, n = node.SlotCount; i < n; i++) { GetDirectives(node.GetSlot(i), directives); } } } } }
public void Add(GreenNode item) { if (item == null) { return; } if (item.IsList) { int slotCount = item.SlotCount; // Necessary, but not sufficient (e.g. for nested lists). EnsureAdditionalCapacity(slotCount); for (int i = 0; i < slotCount; i++) { this.Add(item.GetSlot(i)); } } else { EnsureAdditionalCapacity(1); _nodes[Count++] = item; } }
private static bool EquivalentToInternal(GreenNode node1, GreenNode node2) { if (node1.RawKind != node2.RawKind) { // A single-element list is usually represented as just a single node, // but can be represented as a List node with one child. Move to that // child if necessary. if (node1.IsList && node1.SlotCount == 1) { node1 = node1.GetSlot(0); } if (node2.IsList && node2.SlotCount == 1) { node2 = node2.GetSlot(0); } if (node1.RawKind != node2.RawKind) { return(false); } } if (node1._fullWidth != node2._fullWidth) { return(false); } var n = node1.SlotCount; if (n != node2.SlotCount) { return(false); } for (int i = 0; i < n; i++) { var node1Child = node1.GetSlot(i); var node2Child = node2.GetSlot(i); if (node1Child != null && node2Child != null && !node1Child.IsEquivalentTo(node2Child)) { return(false); } } return(true); }
public bool MoveNext() { if (_node != null) { if (_list != null) { if (--_listIndex >= 0) { _currentChild = _list.GetSlot(_listIndex); return(true); } _list = null; _listIndex = -1; } while (--_childIndex >= 0) { var child = _node.GetSlot(_childIndex); if (child == null) { continue; } if (child.IsList) { _list = child; _listIndex = _list.SlotCount; if (--_listIndex >= 0) { _currentChild = _list.GetSlot(_listIndex); return(true); } else { _list = null; _listIndex = -1; continue; } } else { _currentChild = child; } return(true); } } _currentChild = null; return(false); }
public static DirectiveStack ApplyDirectives(GreenNode node, DirectiveStack stack) { if (node.ContainsDirectives) { for (int i = 0, n = node.SlotCount; i < n; i++) { var child = node.GetSlot(i); if (child != null) { stack = ApplyDirectivesToListOrNode(child, stack); } } } return(stack); }
private static int GetLastNonNullChildIndex(GreenNode node) { int n = node.SlotCount; int lastIndex = n - 1; for (; lastIndex >= 0; lastIndex--) { var child = node.GetSlot(lastIndex); if (child != null) { break; } } return(lastIndex); }
private static int GetFirstNonNullChildIndex(GreenNode node) { int n = node.SlotCount; int firstIndex = 0; for (; firstIndex < n; firstIndex++) { var child = node.GetSlot(firstIndex); if (child != null) { break; } } return(firstIndex); }
/// <summary> /// This function searches for the given location node within the subtree rooted at root node. /// If it finds it, the function computes the offset span of that child node within the root and returns true, /// otherwise it returns false. /// </summary> /// <param name="root">Root node</param> /// <param name="location">Node to search in the subtree rooted at root node</param> /// <param name="offset">Offset of the location node within the subtree rooted at child</param> /// <returns></returns> private bool FindOffset(GreenNode root, LeeSyntaxNode location, out int offset) { int currentOffset = 0; offset = 0; if (root != null) { for (int i = 0, n = root.SlotCount; i < n; i++) { var child = root.GetSlot(i); if (child == null) { // ignore null slots continue; } // check if the child node is the location node if (child == location) { // Found the location node in the subtree // Initialize offset with the offset of the location node within its parent // and walk up the stack of recursive calls adding the offset of each node // within its parent offset = currentOffset; return(true); } // search for the location node in the subtree rooted at child node if (this.FindOffset(child, location, out offset)) { // Found the location node in child's subtree // Add the offset of child node within its parent to offset // and continue walking up the stack offset += child.GetLeadingTriviaWidth() + currentOffset; return(true); } // We didn't find the location node in the subtree rooted at child // Move on to the next child currentOffset += child.FullWidth; } } // We didn't find the location node within the subtree rooted at root node return(false); }
public GreenNode GetLastNonmissingTerminal() { GreenNode node = this; do { GreenNode nonmissingChild = null; for (int i = node.SlotCount - 1; i >= 0; i--) { var child = node.GetSlot(i); if (child != null && !child.IsMissing) { nonmissingChild = child; break; } } node = nonmissingChild; }while (node?._slotCount > 0); return(node); }
public GreenNode GetLastTerminal() { GreenNode node = this; do { GreenNode lastChild = null; for (int i = node.SlotCount - 1; i >= 0; i--) { var child = node.GetSlot(i); if (child != null) { lastChild = child; break; } } node = lastChild; } while (node?._slotCount > 0); return(node); }
public GreenNode GetFirstTerminal() { GreenNode node = this; do { GreenNode firstChild = null; for (int i = 0, n = node.SlotCount; i < n; i++) { var child = node.GetSlot(i); if (child != null) { firstChild = child; break; } } node = firstChild; } while (node?._slotCount > 0); return(node); }
public bool MoveNext() { if (_node != null) { if (_list != null) { _listIndex++; if (_listIndex < _list.SlotCount) { _currentChild = _list.GetSlot(_listIndex); return(true); } _list = null; _listIndex = -1; } while (true) { _childIndex++; if (_childIndex == _node.SlotCount) { break; } var child = _node.GetSlot(_childIndex); if (child == null) { continue; } if (child.RawKind == GreenNode.ListKind) { _list = child; _listIndex++; if (_listIndex < _list.SlotCount) { _currentChild = _list.GetSlot(_listIndex); return(true); } else { _list = null; _listIndex = -1; continue; } } else { _currentChild = child; } return(true); } } _currentChild = null; return(false); }
private static GreenNode GetGreenNodeAt(GreenNode node, int i) { Debug.Assert(node.IsList || (i == 0 && !node.IsList)); return(node.IsList ? node.GetSlot(i) : node); }