// загрузить дерево в 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);
}
