public Directive(IZ80AsmVisitorContext visitorContext, IParseTree context) : base(context)
{
if (context.ChildCount > 1)
{
Identifier = context.GetChild(1).NormalizeToken();
}
if (context.GetChild(1) is Z80AsmParser.ExprContext)
{
Expr = visitorContext.GetExpression(context.GetChild(1));
}
}
public static IParseTree GetValue(IParseTree tree, string key)
{
for (int i = 0; i < tree.ChildCount; i++)
{
if (tree.GetChild(i).GetChild(0).GetText() == key)
{
return(tree.GetChild(i).GetChild(2));
}
}
return(null);
}
public FillbPragma(IZ80AsmVisitorContext visitorContext, IParseTree context)
{
if (context.ChildCount > 1)
{
Count = visitorContext.GetExpression(context.GetChild(1));
}
if (context.ChildCount > 3)
{
Expression = visitorContext.GetExpression(context.GetChild(3));
}
}
public OperatorExpression(IParseTree tree, ScriptLoadingContext lcontext)
: base(tree, lcontext)
{
var child0 = tree.GetChild(0);
if (s_OperatorTypes.Contains(child0.GetType()))
{
// unary op
SyntaxAssert(tree.ChildCount == 2, "Unexpected node found");
m_Operator = ParseUnaryOperator(child0);
m_Exp1 = NodeFactory.CreateExpression(tree.GetChild(1), lcontext);
m_IsUnary = true;
}
else if (s_LeftAssocOperatorTypes.Contains(tree.GetType()))
{
// binary right associative op or simple left associative
IParseTree child2 = tree.GetChild(2);
if (child2.GetType() == tree.GetType())
{
m_Exps = new List <Expression>();
m_Ops = new List <Operator>();
m_Operator = ParseBinaryOperator(tree.GetChild(1));
while (child2.GetType() == tree.GetType())
{
m_Exps.Add(NodeFactory.CreateExpression(child2.GetChild(0), lcontext));
m_Ops.Add(m_Operator);
m_Operator = ParseBinaryOperator(child2.GetChild(1));
child2 = child2.GetChild(2);
}
m_Exp1 = NodeFactory.CreateExpression(child0, lcontext);
m_Exp2 = NodeFactory.CreateExpression(child2, lcontext);
}
else
{
SyntaxAssert(tree.ChildCount == 3, "Unexpected node found");
m_Operator = ParseBinaryOperator(tree.GetChild(1));
m_Exp1 = NodeFactory.CreateExpression(child0, lcontext);
m_Exp2 = NodeFactory.CreateExpression(child2, lcontext);
}
}
else
{
// binary right associative op or simple left associative
SyntaxAssert(tree.ChildCount == 3, "Unexpected node found");
m_Operator = ParseBinaryOperator(tree.GetChild(1));
m_Exp1 = NodeFactory.CreateExpression(child0, lcontext);
m_Exp2 = NodeFactory.CreateExpression(tree.GetChild(2), lcontext);
}
}
public override ParsedProcedure Visit(IParseTree tree)
{
var methodTypeName = (tree.GetChild(0) as TerminalNodeImpl).Symbol.Text;
var identifierContext = tree.GetChild(1);
if (!(identifierContext is PlSqlParser.IdentifierContext))
{
throw new NotImplementedException("Ожидалось имя процедуры");
}
if (methodTypeName == "PROCEDURE")
{
_Result = new ParsedProcedure(identifierContext.GetText());
}
else
{
_Result = new ParsedFunction(identifierContext.GetText());
}
var codePosition = new PieceOfCode();
codePosition.SetPosition(identifierContext as ParserRuleContext);
_Result.NameIdentifierPart = codePosition;
int chCnt = tree.ChildCount;
for (int i = 2; i < chCnt; i++)
{
if (tree.GetChild(i) is TerminalNodeImpl terminalNoeImpl)
{
if (terminalNoeImpl.Symbol.Text == "IS" || terminalNoeImpl.Symbol.Text == "AS")
{
codePosition = new PieceOfCode();
codePosition.SetPosition(tree as ParserRuleContext);
var PrevChild = tree.GetChild(i - 1);
if (PrevChild is ParserRuleContext PrevContext)
{
codePosition.SetPosition(PrevContext);
}
else if (PrevChild is TerminalNodeImpl PrevTerminalNodeImpl)
{
codePosition.SetPosition(PrevTerminalNodeImpl);
}
_Result.DeclarationPart = codePosition;
break;
}
}
}
return(base.Visit(tree));
}
private Node[] VisitChilds(IParseTree context, string sep)
{
var list = new List <Node>();
for (int i = 0; i < context.ChildCount; i++)
{
if (context.GetChild(i).GetText() != sep)
{
list.Add(Visit(context.GetChild(i)));
}
}
return(list.ToArray());
}
public static IEnumerable <IParseTree> Descendants(this IParseTree node)
{
for (int i = 0; i < node.ChildCount; i++)
{
yield return(node.GetChild(i));
var descendants = node.GetChild(i).Descendants();
foreach (var descendant in descendants)
{
yield return(descendant);
}
}
}
private object InterpretForeachContext(IParseTree node)
{
string alias = null;
if (node.GetChild(0) is ITerminalNode term && term.Symbol.Type == TAG)
{
ValidateChildCount(node, 4);
alias = term.GetText();
if (jsonAliases.ContainsKey(alias))
{
throw new InterpreterException(node, "alias " + alias + " already used");
}
//jsonAliases.Add(alias, jsonCurrent);
}
ValidateChildCountMin(node, 3);
object result = null;
if (jsonCurrent is JArray array)
{
List <object> resultArray = new List <object>();
var oldJsonCurrent = jsonCurrent;
for (int i = 0; i < array.Count; i++)
{
jsonCurrent = array[i];
if (alias != null)
{
jsonAliases[alias] = jsonCurrent;
}
resultArray.Add(Interpret(node.GetChild(node.ChildCount - 2)));
}
jsonCurrent = oldJsonCurrent;
result = resultArray;
}
else
{
if (alias != null)
{
jsonAliases[alias] = jsonCurrent;
}
result = Interpret(node.GetChild(node.ChildCount - 2));
//result.Add(Interpret(node.GetChild(node.ChildCount - 2)));
}
//object result = Interpret(node.GetChild(node.ChildCount - 2));
if (alias != null)
{
jsonAliases.Remove(alias);
}
return(result);
}
public static IEnumerable <IParseTree> Children(this IParseTree tree)
{
for (int i = 0; i < tree.ChildCount; i++)
{
yield return(tree.GetChild(i));
}
}
public Tuple <int, int> GetBodyStart(IParseTree context)
{
if (context is CSharpParser.BodyContext ||
context is CSharpParser.Method_bodyContext ||
context is CSharpParser.Namespace_bodyContext ||
context is CSharpParser.Class_bodyContext ||
context is CSharpParser.Interface_bodyContext ||
context is CSharpParser.Enum_bodyContext ||
context is CSharpParser.Struct_bodyContext)
{
var plCtx = (ParserRuleContext)context;
return(new Tuple <int, int>(plCtx.Start.Line, plCtx.Start.Column));
}
if (context.ChildCount <= 0)
{
return(null);
}
for (var i = 0; i < context.ChildCount; i++)
{
var bodyStart = GetBodyStart(context.GetChild(i));
if (bodyStart != null)
{
return(bodyStart);
}
}
return(null);
}
public static IParseTree ReconstructTree(Parser grammar, Lexer lexer, string ast_string)
{
///////////////////////////////////////////////////////////////////
// Parse as a parenthesized expression tree.
///////////////////////////////////////////////////////////////////
var ast_stream = CharStreams.fromstring(ast_string);
ITokenSource ast_lexer = new AstLexer(ast_stream);
var ast_tokens = new CommonTokenStream(ast_lexer);
var ast_parser = new AstParserParser(ast_tokens);
ast_parser.BuildParseTree = true;
var listener = new ErrorListener <IToken>();
ast_parser.AddErrorListener(listener);
IParseTree ast_tree = ast_parser.ast();
ast_tree = ast_tree.GetChild(0);
if (listener.had_error)
{
throw new Exception();
}
///////////////////////////////////////////////////////////////////
// Convert parenthesized expression tree back into parse tree
// of original grammar.
///////////////////////////////////////////////////////////////////
var reconstructed_tree = ReconstructTreeAux(grammar, lexer, ast_tree, null);
return(reconstructed_tree);
}
/// <summary>
/// It finds a substring from the actual value between a frirs word and a last word range.
/// Then it will walk into the tree and recurse through all the remaining steps or reutn null if no range.
/// </summary>
/// <param name="tree">The tree to walk into.</param>
/// <param name="value">The actual value of the node or null to get the root.</param>
/// <returns>Either null or the actual value that was found.</returns>
public override WalkList.WalkResult Walk(IParseTree tree, string value)
{
var actualValue = this.GetActualValue(tree, value);
string filteredValue;
if (tree.ChildCount == 1)
{
var child = tree.GetChild(0);
if (child is UserAgentParser.SingleVersionContext || child is UserAgentParser.SingleVersionWithCommasContext)
{
filteredValue = VersionSplitter.Instance.GetSplitRange(actualValue, this.firstWord, this.lastWord);
}
else
{
filteredValue = WordSplitter.GetInstance().GetSplitRange(actualValue, this.firstWord, this.lastWord);
}
}
else
{
filteredValue = WordSplitter.GetInstance().GetSplitRange(actualValue, this.firstWord, this.lastWord);
}
if (filteredValue is null)
{
return(null);
}
else
{
return(this.WalkNextStep(tree, filteredValue));
}
}
protected ExpressionPragmaBase(IZ80AsmVisitorContext visitorContext, IParseTree context)
{
if (context.ChildCount > 1)
{
Expression = visitorContext.GetExpression(context.GetChild(1));
}
}
public static void Reconstruct(IParseTree tree, CommonTokenStream stream)
{
if (tree as TerminalNodeImpl != null)
{
TerminalNodeImpl tok = tree as TerminalNodeImpl;
Interval interval = tok.SourceInterval;
var inter = stream.GetHiddenTokensToLeft(tok.Symbol.TokenIndex);
if (inter != null)
{
foreach (var t in inter)
{
System.Console.Write(t.Text);
}
}
var s = stream.GetText(interval);
System.Console.Write(s);
}
else
{
for (int i = 0; i < tree.ChildCount; ++i)
{
var c = tree.GetChild(i);
Reconstruct(c, stream);
}
}
}
public static ParserRuleContext GetRootOfSubtreeEnclosingRegion([NotNull] IParseTree t, int startTokenIndex, int stopTokenIndex)
{
// inclusive
// inclusive
int n = t.ChildCount;
for (int i = 0; i < n; i++)
{
IParseTree child = t.GetChild(i);
ParserRuleContext r = GetRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex);
if (r != null)
{
return(r);
}
}
if (t is ParserRuleContext)
{
ParserRuleContext r = (ParserRuleContext)t;
if (startTokenIndex >= r.Start.TokenIndex && (r.Stop == null || stopTokenIndex <= r.Stop.TokenIndex))
{
// is range fully contained in t?
// note: r.getStop()==null likely implies that we bailed out of parser and there's nothing to the right
return(r);
}
}
return(null);
}
public override void ExitAliasAssignment(AdvplParser.AliasAssignmentContext ctx)
{
if (ctx.expression().Length > 0)
{
if (ctx.expression(0).children.Count > 0)
{
IParseTree it = ctx.expression(0).children[0];
IdentifierContext lastCxt = null;
for (int nx = 0; nx < it.ChildCount; nx++)
{
IParseTree tree = it.GetChild(nx);
if (tree is IdentifierContext)
{
lastCxt = (IdentifierContext)tree;
}
}
if (lastCxt != null)
{
String varName = lastCxt.GetText().ToUpper();
if (!currentScope.existLocalScope(varName))
{
defineVar(Symbol.Type.tALIAS, lastCxt.Start, ctx);
}
}
}
}
}
public static IEnumerable <IParseTree> EnumerateChildContexts(this IParseTree parseTree)
{
for (int i = 0; i < parseTree.ChildCount; i++)
{
yield return(parseTree.GetChild(i));
}
}
protected OperationBase(IParseTree context = null)
{
if (context != null)
{
Mnemonic = context.GetChild(0).NormalizeToken();
}
}
public static IEnumerable AsEdgeTrimmedIEnumerable(this IParseTree tree)
{
for (int i = 1; i < tree.ChildCount - 1; i++)
{
yield return(tree.GetChild(i));
}
}
/// <summary>
/// Returns the right most token.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public static IToken RightMostToken(this IParseTree context)
{
if (context == null)
{
return(null);
}
else if (context is TerminalNodeImpl)
{
var terminalNode = (TerminalNodeImpl)context;
return(terminalNode.Symbol);
}
else
{
for (int ii = context.ChildCount - 1; ii >= 0; ii--)
{
var token = RightMostToken(context.GetChild(ii));
if (token != null)
{
return(token);
}
}
return(null);
}
}
private Tuple <List <RecycleParser.CstorageContext>, List <RecycleParser.VarContext> > FindGameInfo(IParseTree game)
{
List <IParseTree> nodes = new List <IParseTree>();
nodes.Add(game);
List <RecycleParser.CstorageContext> cstorages = new List <RecycleParser.CstorageContext>();
List <RecycleParser.VarContext> vars = new List <RecycleParser.VarContext>();
while (nodes.Count > 0)
{
IParseTree current = nodes[0];
nodes.RemoveAt(0);
for (int i = 0; i < current.ChildCount; i++)
{
var child = current.GetChild(i);
if (!((child is TerminalNodeImpl) || (child is RecycleParser.NamegrContext)))
{
if (child is RecycleParser.CstorageContext)
{
cstorages.Add(child as RecycleParser.CstorageContext);
}
nodes.Add(child);
}
}
}
return(new Tuple <List <RecycleParser.CstorageContext>, List <RecycleParser.VarContext> >(cstorages, vars));
}
public static ITerminalNode GetStopNode(IParseTree context)
{
if (context == null)
{
return(null);
}
ITerminalNode terminalNode = context as ITerminalNode;
if (terminalNode != null)
{
return(terminalNode);
}
for (int i = context.ChildCount - 1;
i >= context.ChildCount;
i--)
{
terminalNode = GetStopNode(context.GetChild(i));
if (terminalNode != null)
{
return(terminalNode);
}
}
return(null);
}
static private void PrintSyntaxTree(IParseTree p, int level)
{
string s = p.GetType().ToString();
if (p is ErrorNodeImpl)
{
errCount++;
}
else if (p is TerminalNodeImpl)
{
Console.WriteLine("<Terminal type=\"" + SVLexer.DefaultVocabulary.GetSymbolicName(((TerminalNodeImpl)p).Payload.Type) + "\">" + SecurityElement.Escape(p.GetText()) + "</Terminal>");
}
else
{
if (p.ChildCount > 0)
{
string tag = s.Substring(s.IndexOf('+') + 1).Replace("Context", "");
Console.Write("<" + tag + ">");
for (int i = 0; i < p.ChildCount; i++)
{
PrintSyntaxTree(p.GetChild(i), level + 1);
}
Console.Write("</" + tag + ">");
}
}
}
public static IEnumerable <IParseTree> DFS(ParserRuleContext root)
{
var toVisit = new Stack <IParseTree>();
var visitedAncestors = new Stack <IParseTree>();
toVisit.Push(root);
while (toVisit.Count > 0)
{
IParseTree node = toVisit.Peek();
if (node.ChildCount > 0)
{
if (visitedAncestors.PeekOrDefault() != node)
{
visitedAncestors.Push(node);
for (int i = node.ChildCount - 1; i >= 0; --i)
{
IParseTree o = node.GetChild(i);
Type t = o.GetType();
toVisit.Push(o);
}
continue;
}
visitedAncestors.Pop();
}
yield return(node);
//Console.Write(node.Id);
toVisit.Pop();
}
}
private static void _findAllNodes(IParseTree t, int index, bool findTokens, IList <IParseTree> nodes)
{
// check this node (the root) first
if (findTokens && t is ITerminalNode)
{
ITerminalNode tnode = (ITerminalNode)t;
if (tnode.Symbol.Type == index)
{
nodes.Add(t);
}
}
else
{
if (!findTokens && t is ParserRuleContext)
{
ParserRuleContext ctx = (ParserRuleContext)t;
if (ctx.RuleIndex == index)
{
nodes.Add(t);
}
}
}
// check children
for (int i = 0; i < t.ChildCount; i++)
{
_findAllNodes(t.GetChild(i), index, findTokens, nodes);
}
}
private void Fun(string pat, string ast_string)
{
var ast_stream = CharStreams.fromstring(ast_string);
var ast_lexer = new AstLexer(ast_stream);
var ast_tokens = new CommonTokenStream(ast_lexer);
var ast_parser = new AstParserParser(ast_tokens);
ast_parser.BuildParseTree = true;
var listener = new ErrorListener <IToken>();
ast_parser.AddErrorListener(listener);
IParseTree ast_tree = ast_parser.ast();
if (listener.had_error)
{
throw new Exception();
}
_ast = ast_tree;
var lexer = new AstLexer(null);
var parser = new AstParserParser(new CommonTokenStream(lexer));
ParseTreePatternMatcher ptpm = new ParseTreePatternMatcher(lexer, parser);
var re = ptpm.Compile(pat, AstParserParser.RULE_node);
var c = ast_tree.GetChild(0);
var b = re.Matches(c);
System.Console.WriteLine(b);
}
private static AstNodeBase Create(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
if (IsRoot(node, args))
{
return(CreateRoot(node, args));
}
if (IsConcat(node, args))
{
return(CreateConcat(node, args));
}
if (IsAtom(node, args))
{
return(CreateAtom(node, args));
}
if (IsGroup(node, args))
{
return(CreateGroup(node, args));
}
if (IsUnOper(node, args))
{
return(CreateUnOper(node, args));
}
if (IsBinOper(node, args))
{
return(CreateBinOper(node, args));
}
return(Create(node.GetChild(0), args)); //fictive node, skip him
}
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 ParserRuleContext GetRootOfSubtreeEnclosingRegion(IParseTree t, int startTokenIndex, int stopTokenIndex)
{
// inclusive
// inclusive
int n = t.ChildCount;
for (int i = 0; i < n; i++)
{
IParseTree child = t.GetChild(i);
ParserRuleContext r = GetRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex);
if (r != null)
{
return(r);
}
}
if (t is ParserRuleContext)
{
ParserRuleContext r = (ParserRuleContext)t;
if (startTokenIndex >= r.Start.TokenIndex && stopTokenIndex <= r.Stop.TokenIndex)
{
// is range fully contained in t?
return(r);
}
}
return(null);
}
public void EvaluateErrors(IParseTree item)
{
if (item != null)
{
if (item is ErrorNodeImpl e)
{
this._errors.Add(new ErrorModel()
{
Filename = Filename,
Line = e.Symbol.Line,
StartIndex = e.Symbol.StartIndex,
Column = e.Symbol.Column,
Text = e.Symbol.Text,
Message = $"Failed to parse script at position {e.Symbol.StartIndex}, line {e.Symbol.Line}, col {e.Symbol.Column} ' {e.Symbol.Text}'"
});
}
int c = item.ChildCount;
for (int i = 0; i < c; i++)
{
IParseTree child = item.GetChild(i);
EvaluateErrors(child);
}
}
}
public static IList<IParseTree> Descendants(IParseTree t)
{
List<IParseTree> nodes = new List<IParseTree>();
nodes.Add(t);
int n = t.ChildCount;
for (int i = 0; i < n; i++)
{
nodes.AddRange(Descendants(t.GetChild(i)));
}
return nodes;
}
/// <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;
}
// --- Get tokens in terminal nodes ---
public static ITerminalNode GetFirstTerminalNode(IParseTree node)
{
while (!(node is ITerminalNode))
{
if (node.ChildCount == 0)
{
return null;
}
else
{
node = node.GetChild(0);
}
}
return (ITerminalNode)node;
}
public static IList<Token> GetTokensList(IParseTree node)
{
IList<Token> tokens = new List<Token>();
if(node is ITerminalNode)
{
tokens.Add(GetTokenFromTerminalNode((ITerminalNode)node));
}
else
{
for(int i=0; i<node.ChildCount; i++)
{
var childNode = node.GetChild(i);
if(childNode is ITerminalNode)
{
tokens.Add(GetTokenFromTerminalNode((ITerminalNode)childNode));
}
}
}
return tokens;
}
private static void _findAllNodes(IParseTree t, int index, bool findTokens, IList<IParseTree> nodes)
{
// check this node (the root) first
if (findTokens && t is ITerminalNode)
{
ITerminalNode tnode = (ITerminalNode)t;
if (tnode.Symbol.Type == index)
{
nodes.Add(t);
}
}
else
{
if (!findTokens && t is ParserRuleContext)
{
ParserRuleContext ctx = (ParserRuleContext)t;
if (ctx.RuleIndex == index)
{
nodes.Add(t);
}
}
}
// check children
for (int i = 0; i < t.ChildCount; i++)
{
_findAllNodes(t.GetChild(i), index, findTokens, nodes);
}
}
protected virtual ITerminalNode FindFirstNodeAfterOffset(IParseTree parseTree, int offset)
{
ITerminalNode lastNode = ParseTrees.GetStopNode(parseTree);
if (lastNode == null)
return null;
ICaretToken caretToken = lastNode.Symbol as ICaretToken;
if (caretToken != null)
throw new NotImplementedException();
else if (lastNode.Symbol.StartIndex < offset)
return null;
lastNode = parseTree as ITerminalNode;
if (lastNode != null)
return lastNode;
for (int i = 0; i < parseTree.ChildCount; i++)
{
ITerminalNode node = FindFirstNodeAfterOffset(parseTree.GetChild(i), offset);
if (node != null)
return node;
}
return null;
}
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;
}
protected internal virtual IParseTree MatchImpl(IParseTree tree, IParseTree patternTree, MultiMap<string, IParseTree> labels)
{
if (tree == null)
{
throw new ArgumentException("tree cannot be null");
}
if (patternTree == null)
{
throw new ArgumentException("patternTree cannot be null");
}
// x and <ID>, x and y, or x and x; or could be mismatched types
if (tree is ITerminalNode && patternTree is ITerminalNode)
{
ITerminalNode t1 = (ITerminalNode)tree;
ITerminalNode t2 = (ITerminalNode)patternTree;
IParseTree mismatchedNode = null;
// both are tokens and they have same type
if (t1.Symbol.Type == t2.Symbol.Type)
{
if (t2.Symbol is TokenTagToken)
{
// x and <ID>
TokenTagToken tokenTagToken = (TokenTagToken)t2.Symbol;
// track label->list-of-nodes for both token name and label (if any)
labels.Map(tokenTagToken.TokenName, tree);
if (tokenTagToken.Label != null)
{
labels.Map(tokenTagToken.Label, tree);
}
}
else
{
if (t1.GetText().Equals(t2.GetText(), StringComparison.Ordinal))
{
}
else
{
// x and x
// x and y
if (mismatchedNode == null)
{
mismatchedNode = t1;
}
}
}
}
else
{
if (mismatchedNode == null)
{
mismatchedNode = t1;
}
}
return mismatchedNode;
}
if (tree is ParserRuleContext && patternTree is ParserRuleContext)
{
ParserRuleContext r1 = (ParserRuleContext)tree;
ParserRuleContext r2 = (ParserRuleContext)patternTree;
IParseTree mismatchedNode = null;
// (expr ...) and <expr>
RuleTagToken ruleTagToken = GetRuleTagToken(r2);
if (ruleTagToken != null)
{
if (r1.RuleIndex == r2.RuleIndex)
{
// track label->list-of-nodes for both rule name and label (if any)
labels.Map(ruleTagToken.RuleName, tree);
if (ruleTagToken.Label != null)
{
labels.Map(ruleTagToken.Label, tree);
}
}
else
{
if (mismatchedNode == null)
{
mismatchedNode = r1;
}
}
return mismatchedNode;
}
// (expr ...) and (expr ...)
if (r1.ChildCount != r2.ChildCount)
{
if (mismatchedNode == null)
{
mismatchedNode = r1;
}
return mismatchedNode;
}
int n = r1.ChildCount;
for (int i = 0; i < n; i++)
{
IParseTree childMatch = MatchImpl(r1.GetChild(i), patternTree.GetChild(i), labels);
if (childMatch != null)
{
return childMatch;
}
}
return mismatchedNode;
}
// if nodes aren't both tokens or both rule nodes, can't match
return tree;
}
public static ParserRuleContext GetRootOfSubtreeEnclosingRegion(IParseTree t, int startTokenIndex, int stopTokenIndex)
{
// inclusive
// inclusive
int n = t.ChildCount;
for (int i = 0; i < n; i++)
{
IParseTree child = t.GetChild(i);
ParserRuleContext r = GetRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex);
if (r != null)
{
return r;
}
}
if (t is ParserRuleContext)
{
ParserRuleContext r = (ParserRuleContext)t;
if (startTokenIndex >= r.Start.TokenIndex && stopTokenIndex <= r.Stop.TokenIndex)
{
// is range fully contained in t?
return r;
}
}
return null;
}
// загрузить дерево в 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));
}
}
public static ParserRuleContext GetRootOfSubtreeEnclosingRegion(IParseTree t, int startTokenIndex, int stopTokenIndex)
{
// inclusive
// inclusive
int n = t.ChildCount;
for (int i = 0; i < n; i++)
{
IParseTree child = t.GetChild(i);
ParserRuleContext r = GetRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex);
if (r != null)
{
return r;
}
}
if (t is ParserRuleContext)
{
ParserRuleContext r = (ParserRuleContext)t;
if (startTokenIndex >= r.Start.TokenIndex && (r.Stop == null || stopTokenIndex <= r.Stop.TokenIndex))
{
// is range fully contained in t?
// note: r.getStop()==null likely implies that we bailed out of parser and there's nothing to the right
return r;
}
}
return null;
}
