public IntellisenseIcon Resolve(IBooParseTreeNode node) { Type nodeType = node.GetType(); if (treeNodeIconMap.ContainsKey(nodeType)) return treeNodeIconMap[nodeType]; return 0; }
public BooParseTreeNodeList FlattenFrom(IBooParseTreeNode node) { BooParseTreeNodeList flattened = new IntellisenseNodeList(); // add anything "below" the scope (e.g. locals in a method, methods in a class) flattened.AddRange(FlattenDown(node.Children)); // add anything "above" the scope (e.g. classes in a method) // also walks sideways (e.g. other methods in same class if scope is a method) flattened.AddRange(FlattenUp(node)); return flattened; }
private IList<IBooParseTreeNode> FlattenUp(IBooParseTreeNode node) { IList<IBooParseTreeNode> flattened = new IntellisenseNodeList(); IBooParseTreeNode parent = node; while ((parent = parent.Parent) != null) { foreach (IBooParseTreeNode sibling in parent.Children) { flattened.Add(sibling); } flattened.Add(parent); } return flattened; }
private IBooParseTreeNode GetScopeByLine(IBooParseTreeNode node, int line) { foreach (IBooParseTreeNode child in node.Children) { IBooParseTreeNode foundNode = GetScopeByLine(child, line); if (foundNode != null) return foundNode; } bool isScopable = AttributeHelper.Has<ScopableAttribute>(node.GetType()); if (isScopable && node.ContainsLine(line)) return node; return null; }
private static string Output(IBooParseTreeNode node, int indentLevel) { string indent = ""; for (int i = 0; i < indentLevel; i++) { indent += " "; } string output = indent + node.GetType().Name + ": " + node.Name + "(" + node.StartLine + "," + node.EndLine + ")" + Environment.NewLine; foreach (IBooParseTreeNode child in node.Children) { output += Output(child, indentLevel + 1); } return output; }
public void InjectIntoScope(IBooParseTreeNode scope) { if (scope == null) return; TypeKeywordResolver keywords = new TypeKeywordResolver(); string[] words = keywords.GetForScope(scope); foreach (IBooParseTreeNode child in scope.Children) { keywords.GetForScope(child); } foreach (string word in words) { KeywordTreeNode treeNode = new KeywordTreeNode(); treeNode.Name = word; scope.Children.Add(treeNode); } }
private void Push(IBooParseTreeNode node, int line) { node.Parent = currentScope; node.StartLine = line; currentScope.Children.Add(node); currentScope = node; }
private void Pop(int endLine) { currentScope.EndLine = endLine; currentScope = currentScope.Parent; }
public override void Run() { currentScope = project; Visit(CompileUnit); VisitReferences(); }
public override void Add(IBooParseTreeNode member) { // allow only other namespaces to be displayed if (member is NamespaceTreeNode) base.Add(member); }
public static string Output(IBooParseTreeNode node) { return Output(node, 0); }
private DocumentTreeNode GetDocument(IBooParseTreeNode node) { var currentNode = node; while (!(currentNode is DocumentTreeNode)) { currentNode = currentNode.Parent; } return currentNode as DocumentTreeNode; }
/// <summary> /// Adds members from the current scope (flattened, so all containing scopes are included) to /// the declarations. /// </summary> private void AddMembersFromScopeTree(IntellisenseDeclarations declarations, IBooParseTreeNode scopedParseTree) { var parseTreeFlattener = new BooParseTreeNodeFlatterner(); declarations.AddRange(parseTreeFlattener.FlattenFrom(scopedParseTree)); }
/// <summary> /// Adds keywords based on the current scope to the declarations. /// </summary> private void AddKeywords(IntellisenseDeclarations declarations, IBooParseTreeNode scopedParseTree) { var keywords = new TypeKeywordResolver(); declarations.Add(keywords.GetForScope(scopedParseTree)); }
public override void Add(IBooParseTreeNode item) { if (item.IntellisenseVisible) base.Add(item); }
public CompiledDocument(IBooParseTreeNode root) { this.root = root; }