private static ProtectionLevel ParseProtectionLevel(CrawlParser.Protection_levelContext protectionLevel)
{
TerminalNodeImpl tnode = (TerminalNodeImpl)protectionLevel.GetChild(0);
switch (tnode.Payload.Type)
{
case CrawlLexer.PUBLIC:
return(ProtectionLevel.Public);
case CrawlLexer.PRIVATE:
return(ProtectionLevel.Private);
case CrawlLexer.PROTECTED:
return(ProtectionLevel.Protected);
case CrawlLexer.INTERNAL:
return(ProtectionLevel.Internal);
case CrawlLexer.PROTECTED_INTERNAL:
return(ProtectionLevel.ProtectedInternal);
default:
throw new CrawlImpossibleStateException("Unknown protection level", protectionLevel.SourceInterval);
}
}
private object Eval(TerminalNodeImpl arg)
{
if (arg.Symbol.Type == STRING)
{
return(arg.ToString());
}
if (arg.Symbol.Type == NUMBER)
{
return(arg.ToString());
}
if (arg.Symbol.Type == VARIABLE)
{
return(ENVIRONMENT[arg.ToString()]);
}
if (arg.Symbol.Type == BOOL_TRUE)
{
return(true);
}
if (arg.Symbol.Type == VARIABLE)
{
return(false);
}
throw new ChildLangRuntimeException();
}
public static TerminalNodeImpl Find(int index, Document document)
{
ParsingResults pd = ParsingResultsFactory.Create(document);
var workspace = document.Workspace;
if (pd.ParseTree == null)
{
new Module().Compile(workspace);
}
foreach (IParseTree node in DFSVisitor.DFS(pd.ParseTree as ParserRuleContext))
{
if (node as TerminalNodeImpl == null)
{
continue;
}
TerminalNodeImpl leaf = node as TerminalNodeImpl;
if (leaf.Symbol.StartIndex <= index && index <= leaf.Symbol.StopIndex)
{
return(leaf);
}
}
return(null);
}
public override List <IParseTree> VisitItem([NotNull] sexpressionParser.ItemContext context)
{
if (context.atom() != null)
{
// What *type* of token to use??? There is not enough information in the s-expression
// to know what lexer type to use!!!
// Run lexer on a bare string and see what we get.
var str = context.atom().GetText();
var stream = new AntlrInputStream(str);
_lexer.SetInputStream(stream);
var token = _lexer.NextToken();
var new_sym = new TerminalNodeImpl(token);
return(new List <IParseTree>()
{
new_sym
});
}
else if (context.list() != null)
{
return(VisitList(context.list()));
}
else
{
throw new Exception("Cannot build an s-expr pair.");
}
}
public void Execute(Repl repl, ReplParser.CtreeContext tree, bool piped)
{
var lines = repl.input_output_stack.Pop();
var serializeOptions = new JsonSerializerOptions();
serializeOptions.Converters.Add(new AntlrJson.ParseTreeConverter());
serializeOptions.WriteIndented = false;
var in_tuple = JsonSerializer.Deserialize <AntlrJson.ParsingResultSet>(lines, serializeOptions);
var nodes = in_tuple.Nodes;
var lexer = in_tuple.Lexer;
var parser = in_tuple.Parser;
StringBuilder sb = new StringBuilder();
foreach (var node in nodes)
{
TerminalNodeImpl x = TreeEdits.LeftMostToken(node);
var ts = x.Payload.TokenSource;
sb.AppendLine();
sb.AppendLine(
TreeOutput.OutputTree(
node,
lexer,
parser,
null).ToString());
}
repl.input_output_stack.Push(sb.ToString());
}
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 override void EnterId([NotNull] ANTLRv4Parser.IdContext context)
{
if (context.Parent is ANTLRv4Parser.ModeSpecContext)
{
TerminalNodeImpl term = context.GetChild(0) as TerminalNodeImpl;
string id = term.GetText();
ISymbol sym = new ModeSymbol(id, term.Symbol);
_pd.RootScope.define(ref sym);
CombinedScopeSymbol s = (CombinedScopeSymbol)sym;
_pd.Attributes[context] = new List <CombinedScopeSymbol>()
{
s
};
_pd.Attributes[context.GetChild(0)] = new List <CombinedScopeSymbol>()
{
s
};
}
else if (context.Parent is ANTLRv4Parser.IdListContext && context.Parent?.Parent is ANTLRv4Parser.ChannelsSpecContext)
{
TerminalNodeImpl term = context.GetChild(0) as TerminalNodeImpl;
string id = term.GetText();
ISymbol sym = new ChannelSymbol(id, term.Symbol);
_pd.RootScope.define(ref sym);
CombinedScopeSymbol s = (CombinedScopeSymbol)sym;
_pd.Attributes[context] = new List <CombinedScopeSymbol>()
{
s
};
_pd.Attributes[term] = new List <CombinedScopeSymbol>()
{
s
};
}
}
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;
}
}
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;
}
}
// public void trace(int s) {
// if ( states==null ) states = new ArrayList<Integer>();
// states.add(s);
// }
public virtual ITerminalNode AddChild(IToken matchedToken)
{
TerminalNodeImpl t = new TerminalNodeImpl(matchedToken);
AddChild(t);
t.parent = this;
return(t);
}
public override void EnterInterfaceMethodDeclaration(Java9Parser.InterfaceMethodDeclarationContext context)
{
int i;
for (i = 0; i < context.ChildCount; ++i)
{
if (context.GetChild(i) as Java9Parser.MethodHeaderContext != null)
{
break;
}
}
var mh = context.GetChild(i) as Java9Parser.MethodHeaderContext;
int j;
for (j = 0; j < mh.ChildCount; ++j)
{
if (mh.GetChild(j) as Java9Parser.MethodDeclaratorContext != null)
{
break;
}
}
var md = mh.GetChild(j) as Java9Parser.MethodDeclaratorContext;
var node = md.GetChild(0);
var name = node.GetText();
TerminalNodeImpl term = null;
IParseTree t = node;
for (; t != null; t = t.GetChild(0))
{
if (t is TerminalNodeImpl)
{
term = t as TerminalNodeImpl;
break;
}
else if (t.ChildCount == 0)
{
term = null;
break;
}
}
ISymbol m = new Symtab.MethodSymbol(name, term?.Symbol);
var scope = GetScope(NearestScope(context));
scope.define(ref m);
_pd.Attributes[node] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)m
};
_pd.Attributes[context.GetChild(0)] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)m
};
_pd.Attributes[context] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)m
};
}
private double GetDoubleValue(TerminalNodeImpl t)
{
if (t.Symbol.Type == VARIABLE)
{
return(Convert.ToDouble(ENVIRONMENT[t.ToString()]));
}
return(double.Parse(t.GetText()));
}
public override void EnterTerminal([NotNull] ANTLRv4Parser.TerminalContext context)
{
TerminalNodeImpl first = context.GetChild(0) as TerminalNodeImpl;
if (first.Symbol.Type == ANTLRv4Parser.STRING_LITERAL)
{
Literals.Add(first);
}
}
/// <summary>
/// Constructs the AST recursively from the ANTLR Java Parser classes.
/// </summary>
/// <param name="ctx"></param>
/// <returns></returns>
public static JavaAST ConstructAST(TerminalNodeImpl ctx)
{
if (literals.Contains(ctx.Symbol.Type))
{
return(JavaAST.CreateToken(ctx.Symbol.Type, ctx.GetText()));
}
else
{
return(JavaAST.CreateToken(ctx.Symbol.Type));
}
}
public void SetPosition(TerminalNodeImpl terminalNodeImpl)
{
if (LineBeg == 0)
{
LineBeg = terminalNodeImpl.Symbol.Line;
ColumnBeg = terminalNodeImpl.Symbol.Column;
}
LineEnd = terminalNodeImpl.Symbol.Line;
ColumnEnd = terminalNodeImpl.Symbol.Column + terminalNodeImpl.Symbol.StopIndex - terminalNodeImpl.Symbol.StartIndex;
}
private string GetTerminalString(TerminalNodeImpl t)
{
if (t.Symbol.Type == VARIABLE)
{
return(ENVIRONMENT[t.ToString()].ToString());
}
if (t.Symbol.Type == NUMBER)
{
return(t.GetText());
}
throw new ChildLangRuntimeException();
}
public override void EnterNormalInterfaceDeclaration(Java9Parser.NormalInterfaceDeclarationContext context)
{
int i;
for (i = 0; i < context.ChildCount; ++i)
{
if (context.GetChild(i) as Java9Parser.IdentifierContext != null)
{
break;
}
}
var node = context.GetChild(i) as Java9Parser.IdentifierContext;
var id_name = node.GetText();
TerminalNodeImpl term = null;
IParseTree t = node;
for (; t != null; t = t.GetChild(0))
{
if (t is TerminalNodeImpl)
{
term = t as TerminalNodeImpl;
break;
}
else if (t.ChildCount == 0)
{
term = null;
break;
}
}
ISymbol cs = new Symtab.InterfaceSymbol(id_name, term?.Symbol);
var scope = GetScope(NearestScope(context));
scope.define(ref cs);
_pd.Attributes[node] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)cs
};
IScope s = (IScope)cs;
_pd.Attributes[context.GetChild(0)] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)s
};
_pd.Attributes[context] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)s
};
}
public override void EnterEnumDeclaration(Java9Parser.EnumDeclarationContext context)
{
int i;
for (i = 0; i < context.ChildCount; ++i)
{
if (context.GetChild(i).GetText() == "enum")
{
break;
}
}
var node = context.GetChild(i + 1) as Java9Parser.IdentifierContext;
TerminalNodeImpl term = null;
IParseTree t = node;
for (; t != null; t = t.GetChild(0))
{
if (t is TerminalNodeImpl)
{
term = t as TerminalNodeImpl;
break;
}
else if (t.ChildCount == 0)
{
term = null;
break;
}
}
var name = node.GetText();
ISymbol e = new Symtab.EnumSymbol(name, term?.Symbol);
var scope = GetScope(NearestScope(context));
scope.define(ref e);
_pd.Attributes[node] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)e
};
_pd.Attributes[context.GetChild(0)] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)e
};
_pd.Attributes[context] = new List <CombinedScopeSymbol>()
{
(CombinedScopeSymbol)e
};
}
public override void EnterId([NotNull] ANTLRv4Parser.IdContext context)
{
if (context.Parent is ANTLRv4Parser.LexerCommandExprContext && context.Parent.Parent is ANTLRv4Parser.LexerCommandContext)
{
ANTLRv4Parser.LexerCommandContext lc = context.Parent.Parent as ANTLRv4Parser.LexerCommandContext;
if (lc.GetChild(0)?.GetChild(0)?.GetText() == "pushMode")
{
TerminalNodeImpl term = context.GetChild(0) as TerminalNodeImpl;
string id = term.GetText();
IList <ISymbol> sym_list = _pd.RootScope.LookupType(id);
if (!sym_list.Any())
{
ISymbol sym = new ModeSymbol(id, null);
_pd.RootScope.define(ref sym);
}
List <CombinedScopeSymbol> ref_list = new List <CombinedScopeSymbol>();
foreach (ISymbol sym in sym_list)
{
CombinedScopeSymbol s = new RefSymbol(term.Symbol, sym);
ref_list.Add(s);
}
_pd.Attributes[context] = ref_list;
_pd.Attributes[context.GetChild(0)] = ref_list;
}
else if (lc.GetChild(0)?.GetChild(0)?.GetText() == "channel")
{
TerminalNodeImpl term = context.GetChild(0) as TerminalNodeImpl;
string id = term.GetText();
IList <ISymbol> sym_list = _pd.RootScope.LookupType(id);
if (!sym_list.Any())
{
ISymbol sym = new ChannelSymbol(id, null);
_pd.RootScope.define(ref sym);
}
List <CombinedScopeSymbol> ref_list = new List <CombinedScopeSymbol>();
foreach (ISymbol sym in sym_list)
{
CombinedScopeSymbol s = new RefSymbol(term.Symbol, sym);
ref_list.Add(s);
}
_pd.Attributes[context] = ref_list;
_pd.Attributes[context.GetChild(0)] = ref_list;
}
}
}
public virtual void GatherDefs()
{
Workspaces.Document item = Item;
string ffn = item.FullPath;
IGrammarDescription gd = GrammarDescriptionFactory.Create(ffn);
if (gd == null)
{
throw new Exception();
}
for (int classification = 0; classification < gd.IdentifyDefinition.Count; ++classification)
{
Func <IGrammarDescription, Dictionary <IParseTree, IList <CombinedScopeSymbol> >, IParseTree, bool> fun = gd.IdentifyDefinition[classification];
if (fun == null)
{
continue;
}
IEnumerable <IParseTree> it = AllNodes.Where(t => fun(gd, Attributes, t));
foreach (IParseTree t in it)
{
TerminalNodeImpl x = (t as TerminalNodeImpl);
if (x == null)
{
continue;
}
if (x.Symbol == null)
{
continue;
}
try
{
Defs.Add(x, classification);
Tags.Add(x, classification);
}
catch (ArgumentException)
{
// Duplicate
}
}
}
}
public IEnumerable <TerminalNodeImpl> GetDefsLeaf(Document doc)
{
List <TerminalNodeImpl> result = new List <TerminalNodeImpl>();
ParsingResults ref_pd = ParsingResultsFactory.Create(doc);
var workspace = doc.Workspace;
if (ref_pd.ParseTree == null)
{
Compile(workspace);
}
foreach (KeyValuePair <TerminalNodeImpl, int> value in ref_pd.Defs)
{
TerminalNodeImpl key = value.Key;
result.Add(key);
}
return(result);
}
public override SqlObject VisitLiteralScalarExpression([NotNull] sqlParser.LiteralScalarExpressionContext context)
{
Contract.Requires(context != null);
Contract.Requires(context.ChildCount == 1);
Contract.Requires(context.children[0].ChildCount == 1);
TerminalNodeImpl terminalNode = (TerminalNodeImpl)(context.children[0].GetChild(0));
SqlLiteralScalarExpression sqlLiteralScalarExpression;
switch (terminalNode.Symbol.Type)
{
case sqlParser.STRING_LITERAL:
string value = CstToAstVisitor.GetStringValueFromNode(terminalNode);
sqlLiteralScalarExpression = SqlLiteralScalarExpression.Create(SqlStringLiteral.Create(value));
break;
case sqlParser.NUMERIC_LITERAL:
Number64 number64 = CstToAstVisitor.GetNumber64ValueFromNode(terminalNode);
sqlLiteralScalarExpression = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(number64));
break;
case sqlParser.K_TRUE:
sqlLiteralScalarExpression = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.Create(true));
break;
case sqlParser.K_FALSE:
sqlLiteralScalarExpression = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.Create(false));
break;
case sqlParser.K_NULL:
sqlLiteralScalarExpression = SqlLiteralScalarExpression.Create(SqlNullLiteral.Create());
break;
case sqlParser.K_UNDEFINED:
sqlLiteralScalarExpression = SqlLiteralScalarExpression.Create(SqlUndefinedLiteral.Create());
break;
default:
throw new ArgumentOutOfRangeException($"Unknown symbol type: {terminalNode.Symbol.Type}");
}
return(sqlLiteralScalarExpression);
}
private object InterpretTerminalNodeImpl(IParseTree node)
{
TerminalNodeImpl term = (TerminalNodeImpl)node;
if (term.Symbol.Type == JsonLTParser.STRING)
{
StringBuilder text = new StringBuilder(term.GetText());
text.Remove(0, 1);
text.Remove(text.Length - 1, 1);
text.Replace("\\t", "\t");
text.Replace("\\r", "\r");
text.Replace("\\n", "\n");
text.Replace("\\\\", "\\");
text.Replace("\\", "");
return(text.ToString());
}
if (term.Symbol.Type == JsonLTParser.NUMBER)
{
string text = term.GetText();
if (text.Contains(".") || text.Contains("E") || text.Contains("e"))
{
return(Convert.ToDouble(text));
}
else
{
return(Convert.ToInt64(text));
}
}
if (term.Symbol.Type == JsonLTParser.TRUE)
{
return(true);
}
if (term.Symbol.Type == JsonLTParser.FALSE)
{
return(false);
}
if (term.Symbol.Type == JsonLTParser.NULL)
{
return(null);
}
return(null);
}
public int GetTag(int index, Document doc)
{
ParsingResults pd = ParsingResultsFactory.Create(doc);
var workspace = doc.Workspace;
if (pd.ParseTree == null)
{
Compile(workspace);
}
Antlr4.Runtime.Tree.IParseTree pt = LanguageServer.Util.Find(index, doc);
var gd = ParserDescriptionFactory.Create(doc);
if (pt == null)
{
return(-1);
}
Antlr4.Runtime.Tree.IParseTree p = pt;
TerminalNodeImpl q = p as Antlr4.Runtime.Tree.TerminalNodeImpl;
bool found = pd.PopupList.TryGetValue(q, out int tag_type);
if (found)
{
return(tag_type);
}
if (q.Symbol == null)
{
return(-1);
}
bool found2 = pd.Comments.TryGetValue(q.Symbol, out int tag2);
if (found2)
{
return(tag2);
}
return(-1);
}
public override void EnterRuleref([NotNull] ANTLRv4Parser.RulerefContext context)
{
TerminalNodeImpl first = context.GetChild(0) as TerminalNodeImpl;
string id = context.GetChild(0).GetText();
IList <ISymbol> list = _pd.RootScope.LookupType(id);
if (!list.Any())
{
ISymbol sym = new NonterminalSymbol(id, first.Symbol);
_pd.RootScope.define(ref sym);
}
List <CombinedScopeSymbol> new_attrs = new List <CombinedScopeSymbol>();
foreach (ISymbol sym in list)
{
CombinedScopeSymbol s = new RefSymbol(first.Symbol, sym);
new_attrs.Add(s);
}
_pd.Attributes[context] = new_attrs;
_pd.Attributes[context.GetChild(0)] = new_attrs;
}
public override SqlObject VisitLiteral([NotNull] sqlParser.LiteralContext context)
{
TerminalNodeImpl terminalNode = (TerminalNodeImpl)context.children[0];
SqlLiteral sqlLiteral;
switch (terminalNode.Symbol.Type)
{
case sqlParser.STRING_LITERAL:
string value = CstToAstVisitor.GetStringValueFromNode(terminalNode);
sqlLiteral = SqlStringLiteral.Create(value);
break;
case sqlParser.NUMERIC_LITERAL:
Number64 number64 = CstToAstVisitor.GetNumber64ValueFromNode(terminalNode);
sqlLiteral = SqlNumberLiteral.Create(number64);
break;
case sqlParser.K_TRUE:
sqlLiteral = SqlBooleanLiteral.Create(true);
break;
case sqlParser.K_FALSE:
sqlLiteral = SqlBooleanLiteral.Create(false);
break;
case sqlParser.K_NULL:
sqlLiteral = SqlNullLiteral.Create();
break;
case sqlParser.K_UNDEFINED:
sqlLiteral = SqlUndefinedLiteral.Create();
break;
default:
throw new ArgumentOutOfRangeException($"Unknown symbol type: {terminalNode.Symbol.Type}");
}
return(sqlLiteral);
}
public static int GetTag(int index, Document doc)
{
ParserDetails pd = ParserDetailsFactory.Create(doc);
if (pd.ParseTree == null)
{
LanguageServer.Module.Compile();
}
Antlr4.Runtime.Tree.IParseTree pt = LanguageServer.Util.Find(index, doc);
IGrammarDescription gd = GrammarDescriptionFactory.Create(doc.FullPath);
if (pt == null)
{
return(-1);
}
Antlr4.Runtime.Tree.IParseTree p = pt;
TerminalNodeImpl q = p as Antlr4.Runtime.Tree.TerminalNodeImpl;
bool found = pd.Tags.TryGetValue(q, out int tag_type);
if (found)
{
return(tag_type);
}
if (q.Symbol == null)
{
return(-1);
}
bool found2 = pd.Comments.TryGetValue(q.Symbol, out int tag2);
if (found2)
{
return(tag2);
}
return(-1);
}
public DocumentSymbol GetDocumentSymbol(int index, Document doc)
{
ParsingResults pd = ParsingResultsFactory.Create(doc);
var workspace = doc.Workspace;
if (pd.ParseTree == null)
{
Compile(workspace);
}
Antlr4.Runtime.Tree.IParseTree pt = LanguageServer.Util.Find(index, doc);
var gd = ParserDescriptionFactory.Create(doc);
if (pt == null)
{
return(default(DocumentSymbol));
}
Antlr4.Runtime.Tree.IParseTree p = pt;
TerminalNodeImpl q = p as Antlr4.Runtime.Tree.TerminalNodeImpl;
bool found = pd.PopupList.TryGetValue(q, out int tag_type);
if (!found)
{
return(null);
}
if (q.Symbol == null)
{
return(null);
}
return(new DocumentSymbol()
{
name = q.Symbol.Text,
range = new Workspaces.Range(q.Symbol.StartIndex, q.Symbol.StopIndex),
kind = tag_type
});
}
static void Decorate(IParseTree tree, Parser parser)
{
// DFS walk, add in nodes bottom up.
if (tree is ParserRuleContext internal_node)
{
var old_children = internal_node.children.ToArray();
for (int i = 0; i < old_children.Length; ++i)
{
var c = old_children[i];
var as_terminal_node = c as TerminalNodeImpl;
if (as_terminal_node != null)
{
var interval = as_terminal_node.SourceInterval;
var stream = parser.TokenStream as CommonTokenStream;
IList <IToken> inter = null;
if (as_terminal_node.Symbol.TokenIndex >= 0)
{
inter = stream?.GetHiddenTokensToLeft(as_terminal_node.Symbol.TokenIndex);
}
if (inter != null)
{
foreach (var t in inter.Reverse())
{
var new_child = new TerminalNodeImpl(t);
internal_node.children.Insert(i, new_child);
}
}
}
Decorate(c, parser);
}
}
else if (tree is TerminalNodeImpl terminal_node)
{
}
else
{
throw new Exception();
}
}
public static IEnumerable <IParseTree> DFS(IParseTree root)
{
Stack <IParseTree> toVisit = new Stack <IParseTree>();
Stack <IParseTree> 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);
if (node as TerminalNodeImpl != null)
{
TerminalNodeImpl leaf = node as TerminalNodeImpl;
}
else
{
ParserRuleContext internal_node = node as ParserRuleContext;
int child_count = internal_node.children.Count;
for (int i = node.ChildCount - 1; i >= 0; --i)
{
IParseTree o = internal_node.children[i];
Type t = o.GetType();
toVisit.Push(o);
}
continue;
}
}
visitedAncestors.Pop();
}
yield return(node);
toVisit.Pop();
}
}
