// загрузить дерево в TreeView по дереву парсинга public void LoadNode(TreeNode node, IParseTree tree) { string s; if (node == null) {// если дерева в TreeView еще нет { s = tree.GetType().ToString(); if (s.Contains("+")) { s = tree.GetType().ToString().Split('+')[1]; } if (s.Contains(".")) { s = tree.GetType().ToString().Split('.')[3]; } if (s.Contains("Context")) { s = "Rule:" + s.Substring(0, s.IndexOf("Context")); } if (s.Contains("Terminal")) { s = s.Substring(0, 8); } node = tv.Nodes.Add(s + " # " + tree.GetText()); } } else { { s = tree.GetType().ToString(); if (s.Contains("+")) { s = tree.GetType().ToString().Split('+')[1]; } if (s.Contains(".")) { s = tree.GetType().ToString().Split('.')[3]; } if (s.Contains("Context")) { s = "Rule:" + s.Substring(0, s.IndexOf("Context")); } if (s.Contains("Terminal")) { s = s.Substring(0, 8); } node = node.Nodes.Add(s + " # " + tree.GetText()); } } // загрузить дочерние ноды for (int i = 0; i < tree.ChildCount; i++) { LoadNode(node, tree.GetChild(i)); } }
/// <summary> /// Parse the AST constant node and return Object value. /// </summary> /// <param name="node">parse node for which to parse the string value</param> /// <returns>value matching AST node type</returns> public static object Parse(IParseTree node) { if (node is ITerminalNode) { var terminal = (ITerminalNode) node; switch (terminal.Symbol.Type) { case EsperEPL2GrammarParser.BOOLEAN_TRUE: return BoolValue.ParseString(terminal.GetText()); case EsperEPL2GrammarParser.BOOLEAN_FALSE: return BoolValue.ParseString(terminal.GetText()); case EsperEPL2GrammarParser.VALUE_NULL: return null; default: throw ASTWalkException.From("Encountered unexpected constant type " + terminal.Symbol.Type, terminal.Symbol); } } var ruleNode = (IRuleNode) node; var ruleIndex = ruleNode.RuleContext.RuleIndex; if (ruleIndex == EsperEPL2GrammarParser.RULE_number) { return ParseNumber(ruleNode, 1); } if (ruleIndex == EsperEPL2GrammarParser.RULE_numberconstant) { var number = FindChildRuleByType(ruleNode, EsperEPL2GrammarParser.RULE_number); if (ruleNode.ChildCount > 1) { if (ASTUtil.IsTerminatedOfType(ruleNode.GetChild(0), EsperEPL2GrammarLexer.MINUS)) { return ParseNumber(number, -1); } return ParseNumber(number, 1); } return ParseNumber(number, 1); } if (ruleIndex == EsperEPL2GrammarParser.RULE_stringconstant) { return StringValue.ParseString(node.GetText()); } if (ruleIndex == EsperEPL2GrammarParser.RULE_constant) { return Parse(ruleNode.GetChild(0)); } throw ASTWalkException.From("Encountered unrecognized constant", node.GetText()); }
public static object CreateNumber(IParseTree context) { string rawText = context.GetText(); if (DecimalPointNumberRegex.Match(rawText).Success) { return(PyFloat.Create(Decimal.Parse(rawText))); } return(PyInteger.Create(BigInteger.Parse(context.GetText()))); }
public string GetContextName(IParseTree context) { if (context == null) { return(null); } if (context is CSharpParser.Member_nameContext) { return(context.GetText()); } if (context is CSharpParser.Method_member_nameContext) { return(context.GetText()); } if (context is CSharpParser.Field_declarationContext flCtx && flCtx.variable_declarators() != null) { return(flCtx.variable_declarators().GetText()); } if (context is CSharpParser.Class_definitionContext) { return(((CSharpParser.Class_definitionContext)context).identifier().GetText()); } if (context is CSharpParser.Delegate_definitionContext) { return(((CSharpParser.Delegate_definitionContext)context).identifier().GetText()); } if (context is CSharpParser.Enum_definitionContext) { return(((CSharpParser.Enum_definitionContext)context).identifier().GetText()); } if (context is CSharpParser.Interface_definitionContext) { return(((CSharpParser.Interface_definitionContext)context).identifier().GetText()); } if (context is CSharpParser.Struct_definitionContext) { return(((CSharpParser.Struct_definitionContext)context).identifier().GetText()); } if (context.ChildCount <= 0) { return(null); } for (var i = 0; i < context.ChildCount; i++) { var nm = GetContextName(context.GetChild(i)); if (!string.IsNullOrWhiteSpace(nm)) { return(nm); } } return(null); }
private void CheckContext(ParserRuleContext context, IParseTree subTreeToExamine) { if (subTreeToExamine?.GetText().Contains("_") ?? false) { _contexts.Add(new QualifiedContext <ParserRuleContext>(CurrentModuleName, context)); } }
public override bool VisitUnary_expression([NotNull] calculatorParser.Unary_expressionContext context) { if (context.children != null) { foreach (var c in context.children) { if (!Visit(c)) { Results[context] = false; return(false); } } } if (context.ChildCount == 1) { bool lhs = Results[context.GetChild(0)]; Results[context] = lhs; return(lhs); } if (context.ChildCount == 2) { bool rhs = Results[context.GetChild(1)]; bool res = rhs; IParseTree op_pt = context.GetChild(0); string op = op_pt.GetText(); Results[context] = res; return(res); } { bool res = false; Results[context] = res; return(res); } }
public override Expression VisitUnary_expression([NotNull] calculatorParser.Unary_expressionContext context) { if (context.children != null) { foreach (IParseTree c in context.children) { Visit(c); } } if (_completeness.Results[context]) { if (context.ChildCount == 1) { Expression lhs = Results[context.GetChild(0)]; Results[context] = lhs; return(lhs); } if (context.ChildCount == 2) { Expression rhs = Results[context.children[1]]; IParseTree op_pt = context.GetChild(0); string op = op_pt.GetText(); if (op == "+") { return(Expression.UnaryPlus(rhs)); } else if (op == "-") { return(Expression.Negate(rhs)); } } } Results[context] = null; return(null); }
public Tree Peek(int level) { IParseTree v = _current; if (level > 0) { while (v != null) { _parent_map.TryGetValue(v, out IParseTree par); if (par == null) { v = null; break; } if (v.GetText() != par.GetText()) { v = par; level--; if (level == 0) { break; } } v = par; } } Tree t = new Tree(_parent_map, _ast, v, _common_token_stream); return(t); }
private string getContextType(IParseTree context) { string switchString = context.GetType().ToString(); switch (switchString) { case "GiraphParser+VariableContext": IParseTree childString = context.GetChild(0).GetChild(context.GetChild(0).ChildCount - 1); if (childString == null) { return("void"); } switch (childString.GetText()) { case "Vertices": return("vertex"); case "Edges": return("edge"); default: return("void"); } } throw new WrongExpressionPartTypeFoundException("Spørg Mads"); }
public static void ParenthesizedAST(this IParseTree tree, StringBuilder sb, string file_name, CommonTokenStream stream, int level = 0) { // Antlr always names a non-terminal with first letter lowercase, // but renames it when creating the type in C#. So, remove the prefix, // lowercase the first letter, and remove the trailing "Context" part of // the name. Saves big time on output! if (tree as TerminalNodeImpl != null) { TerminalNodeImpl tok = tree as TerminalNodeImpl; Interval interval = tok.SourceInterval; System.Collections.Generic.IList <IToken> inter = tok.Symbol.TokenIndex >= 0 ? stream.GetHiddenTokensToLeft(tok.Symbol.TokenIndex) : null; if (inter != null) { foreach (IToken t in inter) { StartLine(sb, file_name, tree, stream, level); sb.AppendLine("( HIDDEN text=" + t.Text.PerformEscapes()); } } StartLine(sb, file_name, tree, stream, level); sb.AppendLine("( TOKEN i=" + tree.SourceInterval.a + " t=" + tree.GetText().PerformEscapes()); } else { string fixed_name = tree.GetType().ToString() .Replace("Antlr4.Runtime.Tree.", ""); fixed_name = Regex.Replace(fixed_name, "^.*[+]", ""); fixed_name = fixed_name.Substring(0, fixed_name.Length - "Context".Length); fixed_name = fixed_name[0].ToString().ToLower() + fixed_name.Substring(1); StartLine(sb, file_name, tree, stream, level); sb.Append("( " + fixed_name); if (level == 0) { sb.Append(" File=\"" + file_name + "\""); } sb.AppendLine(); } for (int i = 0; i < tree.ChildCount; ++i) { IParseTree c = tree.GetChild(i); c.ParenthesizedAST(sb, file_name, stream, level + 1); } if (level == 0) { for (int k = 0; k < 1 + changed - level; ++k) { sb.Append(") "); } sb.AppendLine(); changed = 0; } }
public static string GetText(IParseTree context) { if (context as TerminalNodeImpl != null) { return(context.GetText()); } var x = context as ParserRuleContext; if (x == null) { return("UNKNOWN TYPE!"); } var c = x; var startToken = c.Start; var stopToken = c.Stop; var cs = startToken.InputStream; var startIndex = startToken.StartIndex; var stopIndex = stopToken.StopIndex; if (startIndex > stopIndex) { startIndex = stopIndex; } return(cs.GetText(new Interval(startIndex, stopIndex))); }
private void ResolveReferences(DeclarationFinder finder, VBComponent component, IParseTree tree) { Debug.Assert(State.GetModuleState(component) == ParserState.ResolvingReferences); var qualifiedName = new QualifiedModuleName(component); Logger.Debug("Resolving identifier references in '{0}'... (thread {1})", qualifiedName.Name, Thread.CurrentThread.ManagedThreadId); var resolver = new IdentifierReferenceResolver(qualifiedName, finder); var listener = new IdentifierReferenceListener(resolver); if (!string.IsNullOrWhiteSpace(tree.GetText().Trim())) { var walker = new ParseTreeWalker(); try { var watch = Stopwatch.StartNew(); walker.Walk(listener, tree); watch.Stop(); Logger.Debug("Binding Resolution done for component '{0}' in {1}ms (thread {2})", component.Name, watch.ElapsedMilliseconds, Thread.CurrentThread.ManagedThreadId); State.RebuildSelectionCache(); State.SetModuleState(component, ParserState.Ready); } catch (Exception exception) { Logger.Error(exception, "Exception thrown resolving '{0}' (thread {1}).", component.Name, Thread.CurrentThread.ManagedThreadId); State.SetModuleState(component, ParserState.ResolverError); } } }
private static void ToStringTreeIndented(this IParseTree parseTree, Parser parser, StringBuilder builder, int level) { int currentLevelStringLength = level * IndentSize; builder.PadLeft(currentLevelStringLength); var ruleContext = parseTree as RuleContext; if (ruleContext != null) { builder.AppendLine("("); builder.PadLeft(currentLevelStringLength); builder.AppendLine(parser.RuleNames[ruleContext.RuleIndex]); for (int i = 0; i < ruleContext.ChildCount; i++) { ruleContext.GetChild(i).ToStringTreeIndented(parser, builder, level + 1); builder.AppendLine(); } builder.PadLeft(currentLevelStringLength); builder.Append(")"); } else { builder.Append('\'' + parseTree.GetText() + '\''); // TODO: replace with RenderToken. } }
protected void ResolveReferences(DeclarationFinder finder, QualifiedModuleName module, IParseTree tree, CancellationToken token) { token.ThrowIfCancellationRequested(); Logger.Debug("Resolving identifier references in '{0}'... (thread {1})", module.Name, Thread.CurrentThread.ManagedThreadId); var resolver = new IdentifierReferenceResolver(module, finder); var listener = new IdentifierReferenceListener(resolver); if (!string.IsNullOrWhiteSpace(tree.GetText().Trim())) { var walker = new ParseTreeWalker(); try { var watch = Stopwatch.StartNew(); walker.Walk(listener, tree); watch.Stop(); Logger.Debug("Binding resolution done for component '{0}' in {1}ms (thread {2})", module.Name, watch.ElapsedMilliseconds, Thread.CurrentThread.ManagedThreadId); //Evaluation of the overall status has to be defered to allow processing of undeclared variables before setting the ready state. _parserStateManager.SetModuleState(module, ParserState.Ready, token, false); } catch (OperationCanceledException) { throw; //We do not want to set an error state if the exception was just caused by some cancellation. } catch (Exception exception) { Logger.Error(exception, "Exception thrown resolving '{0}' (thread {1}).", module.Name, Thread.CurrentThread.ManagedThreadId); _parserStateManager.SetModuleState(module, ParserState.ResolverError, token); } } }
public static PyString CreateString(IParseTree context) { // TODO: Expand to include literals, unicode, f-strings... // For now, we just clip off the single/double quotes string rawText = context.GetText(); // Check for long string. var match = LongStringDoubleQuoteRegex.Match(rawText); if (match.Success) { return(PyString.Create(match.Groups[1].Value)); } match = LongStringSingleQuoteRegex.Match(rawText); if (match.Success) { return(PyString.Create(match.Groups[1].Value)); } // At this point, just assume quotes on each end and clip them off. string finalString = rawText.Substring(1, rawText.Length - 2); return(PyString.Create(finalString)); }
private static string FormatTree(IParseTree tree) { if (tree == null) return ""; return "@ " + tree.GetText(); }
public Path(Edge e, IParseTree input, Path r) { if (r == null) { throw new Exception(); } var p = r; while (p.Next != null) { p = p.Next; } p.Next = this; LastEdge = e; if (e.IsEmpty || e.IsCode || e.IsText) { Input = null; InputText = ""; } else { Input = input; InputText = input.GetText(); } }
private void ResolveReferences(DeclarationFinder finder, VBComponent component, IParseTree tree) { var state = _state.GetModuleState(component); if (_state.Status == ParserState.ResolverError || (state != ParserState.Parsed)) { return; } var qualifiedName = new QualifiedModuleName(component); Debug.WriteLine("Resolving identifier references in '{0}'... (thread {1})", qualifiedName.Name, Thread.CurrentThread.ManagedThreadId); var resolver = new IdentifierReferenceResolver(qualifiedName, finder); var listener = new IdentifierReferenceListener(resolver); if (!string.IsNullOrWhiteSpace(tree.GetText().Trim())) { var walker = new ParseTreeWalker(); try { walker.Walk(listener, tree); state = ParserState.Ready; } catch (Exception exception) { Debug.Print("Exception thrown resolving '{0}' (thread {2}): {1}", component.Name, exception, Thread.CurrentThread.ManagedThreadId); state = ParserState.ResolverError; } } _state.SetModuleState(component, state); Debug.Print("'{0}' is {1}. Resolver took {2}ms to complete (thread {3})", component.Name, _state.GetModuleState(component), /*_resolverTimer[component].ElapsedMilliseconds*/ 0, Thread.CurrentThread.ManagedThreadId); }
public IEnumerable <NewFolding> CreateNewFoldings(IParseTree tree) { List <NewFolding> res = new List <NewFolding>(); ParserRuleContext rc = tree as ParserRuleContext; if (rc == null) { return(res); } if (IsTreeElementToFolding(tree)) { IToken tokenStart = rc.Start; IToken tokenEnd = rc.Stop; if ((tokenStart != null) && (tokenEnd != null) && (tokenStart != tokenEnd) && (tokenEnd.StopIndex > tokenStart.StartIndex)) { NewFolding folding = new NewFolding(tokenStart.StartIndex, tokenEnd.StopIndex); folding.Name = tree.GetText(); res.Add(folding); } } for (int i = 0; i < rc.ChildCount; i++) { res.AddRange(CreateNewFoldings(rc.GetChild(i))); } return(res); }
private void CheckContext(ParserRuleContext context, IParseTree subTreeToExamine) { if (subTreeToExamine?.GetText().Contains("_") ?? false) { SaveContext(context); } }
private static string GetStringValueFromNode(IParseTree parseTree) { string text = parseTree.GetText(); string textWithoutQuotes = text.Substring(1, text.Length - 2); return(textWithoutQuotes); }
/// <summary> /// Make parse tree string representation. This method is recursive and not open to public. /// </summary> /// <param name="rules"></param> /// <param name="nRules"></param> /// <param name="leaves"></param> /// <param name="nLeaves"></param> /// <param name="tree"></param> /// <returns></returns> private StringBuilder makeParseTree(StringBuilder rules, ref int nRules, StringBuilder leaves, ref int nLeaves, IParseTree tree = null) { if (tree == null && this.cst == null) { return(new StringBuilder()); } else if (tree == null) { tree = this.cst; } StringBuilder builder = new StringBuilder(); for (int i = 0; i < tree.ChildCount; i++) { if (i == 0) { builder.Append("["); } IParseTree child = tree.GetChild(i); if (child is ITerminalNode) { string text = child.GetText(); text = SanitizeJsCode(text); int tokenType = ((CommonToken)child.Payload).Type; string varName = String.Format("tokens[{0}]", nLeaves++); leaves.AppendFormat("{0} = {{l:{1},t:\"{2}\"}};\n", varName, tokenType, text); builder.Append(varName); } else if (child is RuleContext) { StringBuilder childTree = makeParseTree(rules, ref nRules, leaves, ref nLeaves, child); if (childTree.Length < 1) { childTree.Append("[]"); } string varName = String.Format("rules[{0}]", nRules++); rules.AppendFormat("{0} = {{r:{1},c:{2}}};\n", varName, ((RuleContext)child).RuleIndex, childTree.ToString()); builder.Append(varName); } if (i == tree.ChildCount - 1) { builder.Append("]"); } else { builder.Append(","); } } return(builder); }
private static void ParenthesizedAST(IParseTree tree, StringBuilder sb, Lexer lexer, Parser parser, CommonTokenStream stream, int level = 0) { // Antlr always names a non-terminal with first letter lowercase, // but renames it when creating the type in C#. So, remove the prefix, // lowercase the first letter, and remove the trailing "Context" part of // the name. Saves big time on output! if (tree as TerminalNodeImpl != null) { TerminalNodeImpl tok = tree as TerminalNodeImpl; Interval interval = tok.SourceInterval; IList <IToken> inter = null; if (tok.Symbol.TokenIndex >= 0) { inter = stream?.GetHiddenTokensToLeft(tok.Symbol.TokenIndex); } if (inter != null) { foreach (var t in inter) { var ty = tok.Symbol.Type; var name = lexer.Vocabulary.GetSymbolicName(ty); StartLine(sb, level); sb.AppendLine("( " + name + " text=" + PerformEscapes(t.Text) + " " + lexer.ChannelNames[t.Channel]); } } { var ty = tok.Symbol.Type; var name = lexer.Vocabulary.GetSymbolicName(ty); StartLine(sb, level); sb.AppendLine("( " + name + " i=" + tree.SourceInterval.a + " txt=" + PerformEscapes(tree.GetText()) + " tt=" + tok.Symbol.Type + " " + lexer.ChannelNames[tok.Symbol.Channel]); } } else { var x = tree as RuleContext; var ri = x.RuleIndex; var name = parser.RuleNames[ri]; StartLine(sb, level); sb.Append("( " + name); sb.AppendLine(); } for (int i = 0; i < tree.ChildCount; ++i) { var c = tree.GetChild(i); ParenthesizedAST(c, sb, lexer, parser, stream, level + 1); } if (level == 0) { for (int k = 0; k < 1 + changed - level; ++k) { sb.Append(") "); } sb.AppendLine(); changed = 0; } }
protected PftAst ( IParseTree node ) : this() { Text = node.GetText(); }
private void ValidateToken(IParseTree node, string token) { ValidateType <TerminalNodeImpl>(node); if (token != node.GetText()) { throw new InterpreterException(node, string.Format("Wrong node text, expected: {0} actual: {1}", token, node.GetText())); } }
/// <summary> /// antlr runtime wil call this method when parse tree's context is <see cref="AdaptiveCardsTemplateParser.TemplateDataContext"/> /// <para>It is used in parsing a pair that has $data as key</para> /// <para>It creates new data context, and set it as current memory scope</para> /// </summary> /// <param name="context"></param> /// <returns></returns> public override AdaptiveCardsTemplateResult VisitTemplateData([NotNull] AdaptiveCardsTemplateParser.TemplateDataContext context) { // checks if parsing failed, if failed, return failed segment as string unchanged if (!ValidateParserRuleContext(context)) { return(new AdaptiveCardsTemplateResult(context.GetText())); } // get value node from pair node // i.e. $data : "value" IParseTree templateDataValueNode = context.value(); // refer to label, valueTemplateStringWithRoot in AdaptiveCardsTemplateParser.g4 for the grammar this branch is checking if (templateDataValueNode is AdaptiveCardsTemplateParser.ValueTemplateStringWithRootContext) { // call a visit method for further processing Visit(templateDataValueNode); } // refer to label, valueTemplateString in AdaptiveCardsTemplateParser.g4 for the grammar this branch is checking else if (templateDataValueNode is AdaptiveCardsTemplateParser.ValueTemplateStringContext) { // tempalteString() can be zero or more due to user error var templateStrings = (templateDataValueNode as AdaptiveCardsTemplateParser.ValueTemplateStringContext).templateString(); if (templateStrings?.Length == 1) { // retrieve template literal and create a data context var templateLiteral = (templateStrings[0] as AdaptiveCardsTemplateParser.TemplatedStringContext).TEMPLATELITERAL(); try { PushTemplatedDataContext(templateLiteral.GetText()); } catch (ArgumentNullException) { throw new ArgumentNullException($"Check if parent data context is set, or please enter a non-null value for '{templateLiteral.Symbol.Text}' at line, '{templateLiteral.Symbol.Line}'"); } catch (JsonException innerException) { throw new AdaptiveTemplateException($"'{templateLiteral.Symbol.Text}' at line, '{templateLiteral.Symbol.Line}' is malformed for '$data : ' pair", innerException); } } } else // else clause handles all of the ordinary json values { string childJson = templateDataValueNode.GetText(); try { PushDataContext(childJson, root); } catch (JsonException innerException) { throw new AdaptiveTemplateException($"parsing data failed at line, '{context.Start.Line}', '{childJson}' was given", innerException); } } return(new AdaptiveCardsTemplateResult()); }
private void CheckContext(ParserRuleContext context, IParseTree expression) { var target = expression?.GetText().Trim() ?? string.Empty; if (target.StartsWith("-") && int.TryParse(target.Substring(1), out _)) { SaveContext(context); } }
private void CheckContext(ParserRuleContext context, IParseTree expression) { var target = expression?.GetText().Trim() ?? string.Empty; if (target.StartsWith("-") && int.TryParse(target.Substring(1), out var result) && result == 1) { _contexts.Add(new QualifiedContext <ParserRuleContext>(CurrentModuleName, context)); } }
public static string GetString(IParseTree tree) { string s = tree.GetText(); s = s.Substring(1, s.Length - 2); s = s.Replace("\"", "\\\""); s = s.Replace("''", "'"); return($"\"{s}\""); }
static public string GetTextEX(this IParseTree item) { if (item != null) { return(item.GetText()); } return(""); }
/// <summary> /// Проверяет два синтаксических дерева на сходство, игнорируя вертикальные "цепочки" и скобки. /// </summary> public static bool Same(this IParseTree tree1, IParseTree tree2) { tree1 = tree1.Collapse(); tree2 = tree2.Collapse(); if (tree1.ChildCount == 0 || tree2.ChildCount == 0) return tree1.GetText() == tree2.GetText(); if (tree1.ChildCount != tree2.ChildCount) return false; for (int i = 0; i < tree1.ChildCount; i++) { if (!tree1.GetChild(i).Same(tree2.GetChild(i))) return false; } return true; }
// загрузить дерево в TreeView по дереву парсинга public void LoadNode(TreeNode node, IParseTree tree) { string s; if (node == null) {// если дерева в TreeView еще нет { s = tree.GetType().ToString(); if (s.Contains("+")) s = tree.GetType().ToString().Split('+')[1]; if (s.Contains(".")) s = tree.GetType().ToString().Split('.')[3]; if (s.Contains("Context")) s = "Rule:" + s.Substring(0, s.IndexOf("Context")); if (s.Contains("Terminal")) s = s.Substring(0, 8); node = tv.Nodes.Add(s + " # " + tree.GetText()); } } else { { s = tree.GetType().ToString(); if (s.Contains("+")) s = tree.GetType().ToString().Split('+')[1]; if (s.Contains(".")) s = tree.GetType().ToString().Split('.')[3]; if (s.Contains("Context")) s = "Rule:" + s.Substring(0, s.IndexOf("Context")); if (s.Contains("Terminal")) s = s.Substring(0, 8); node = node.Nodes.Add(s + " # " + tree.GetText()); } } // загрузить дочерние ноды for (int i = 0; i < tree.ChildCount; i++) { LoadNode(node, tree.GetChild(i)); } }
private bool CompareWrite(string key, IParseTree value) { if (!char.IsLetter(key[0])) return key == value.GetText(); //TODO: Use appropriate array of identifiers/operators if (_dict.ContainsKey(key)) return _dict[key].Same(value); _dict.Add(key, value); return true; }
private bool Match(IParseTree tree, IParseTree localTree) { tree = tree.Collapse(); localTree = localTree.Collapse(); if (localTree.ChildCount == 0) return CompareWrite(localTree.GetText(), tree); if (tree.ChildCount != localTree.ChildCount) return false; for (int i = 0; i < tree.ChildCount; i++) { if (!Match(tree.GetChild(i), localTree.GetChild(i))) return false; } return true; }
private void ResolveReferences(DeclarationFinder finder, VBComponent component, IParseTree tree) { var state = _state.GetModuleState(component); if (_state.Status == ParserState.ResolverError || (state != ParserState.Parsed)) { return; } Debug.WriteLine("Resolving '{0}'... (thread {1})", component.Name, Thread.CurrentThread.ManagedThreadId); var qualifiedName = new QualifiedModuleName(component); var resolver = new IdentifierReferenceResolver(qualifiedName, finder); var listener = new IdentifierReferenceListener(resolver); if (!string.IsNullOrWhiteSpace(tree.GetText().Trim())) { var walker = new ParseTreeWalker(); try { walker.Walk(listener, tree); state = ParserState.Ready; } catch (Exception exception) { Debug.Print("Exception thrown resolving '{0}' (thread {2}): {1}", component.Name, exception, Thread.CurrentThread.ManagedThreadId); state = ParserState.ResolverError; } } _state.SetModuleState(component, state); Debug.Print("'{0}' is {1}. Resolver took {2}ms to complete (thread {3})", component.Name, _state.GetModuleState(component), /*_resolverTimer[component].ElapsedMilliseconds*/0, Thread.CurrentThread.ManagedThreadId); }