private void TestOneSnippet(string code, params NodeInfo[] nodes) { bool success = false; var result = ParseTreeWalker.Parse(code); try { Assert.AreEqual(nodes.Length, result.Count); for (int i = 0; i < nodes.Length; i++) { Assert.AreEqual(nodes[i], result[i]); } success = true; } finally { if (!success) { for (int i = 0; i < result.Count; i++) { Console.Write(result[i]); if (i == result.Count - 1) { Console.WriteLine(); } else { Console.WriteLine(","); } } } } }
public TraceForCase102(CSharpParser parser, ParserRuleContext treeContext, List <TempExpression> listExpression) { this.parser = parser; this.treeContext = treeContext; this.listExpression = listExpression; this.isVulnMethod = false; ParseTreeWalker walkerMethod = new ParseTreeWalker(); FindInputOfMethod findInput = new FindInputOfMethod(parser); walkerMethod.Walk(findInput, treeContext); this.listFormalInput = findInput.listVariable; this.listLocalVar = findInput.listLocalVariable; this.methodInfor = findInput.methodInfor; methodInfor.BaselineItem = 402; ParserRuleContext classContext = findInput.classTree; FindGlobalVariable findGlobalVar = new FindGlobalVariable(parser); walkerMethod.Walk(findGlobalVar, classContext); if (findGlobalVar.listGlobalVar != null) { this.listGlobalVar = findGlobalVar.listGlobalVar; } //FindVariableInMethod findVar = new FindVariableInMethod(parser,); //walkerMethod.Walk(findVar, treeContext); processTracer102(treeContext); }
public void CollectInfo(CodeSource grammarSource, ANTLRv4Parser.GrammarSpecContext context) { GrammarSource = grammarSource; var walker = new ParseTreeWalker(); walker.Walk(this, context); }
public Interpreter(string code, Builtins builtins) { errorBag = new CodeErrorBag(); var inputStream = new AntlrInputStream(code); var lexer = new PigeonLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); parser = new PigeonParser(tokenStream); var errorListener = new CodeErrorListener(errorBag); parser.AddErrorListener(errorListener); tree = parser.program(); var walker = new ParseTreeWalker(); var globalScope = new GlobalScope(); builtins.Register(globalScope); var functionDeclarator = new FunctionDeclarator(errorBag, globalScope); walker.Walk(functionDeclarator, tree); analyser = new SemanticAnalyser(errorBag, globalScope); walker.Walk(analyser, tree); }
public static OrderedDictionary Shred(byte[] content, string template) { Stream inputStream = new MemoryStream(Encoding.ASCII.GetBytes(template)); AntlrInputStream input = new AntlrInputStream(inputStream); BinShredLexer lexer = new BinShredLexer(input); lexer.RemoveErrorListeners(); lexer.AddErrorListener(new BinShredErrorListener <int>()); CommonTokenStream tokens = new CommonTokenStream(lexer); BinShredParser parser = new BinShredParser(tokens); parser.RemoveErrorListeners(); parser.AddErrorListener(new BinShredErrorListener <IToken>()); BinShredParser.TemplateContext context = parser.template(); ParseTreeWalker walker = new ParseTreeWalker(); BinShredAnalyzer contentAnalyzer = new BinShredAnalyzer(content); walker.Walk(contentAnalyzer, context); contentAnalyzer.Run(); return(contentAnalyzer.Result); }
static void Main(string[] args) { var lines = File.ReadAllLines("FL_insurance_sample.csv"); //IList<InsurancePolicyData> insurancePolicyDataList = new List<InsurancePolicyData>(); for (int i = 0; i < lines.Length / 1000; i++) { if (i == 0) { continue; } AntlrInputStream inputStream = new AntlrInputStream(lines[i]); InsurancePolicyRulesLexer lexer = new InsurancePolicyRulesLexer(inputStream); CommonTokenStream commonTokenStream = new CommonTokenStream(lexer); InsurancePolicyRulesParser parser = new InsurancePolicyRulesParser(commonTokenStream); var ctx = parser.csvFile(); InsurancePolicyRulesBaseVisitor <InsurancePolicyData> vis = new InsurancePolicyRulesBaseVisitor <InsurancePolicyData>(); InsurancePolicyCustomListener customListener = new InsurancePolicyCustomListener(); ParseTreeWalker parseTreeWalker = new ParseTreeWalker(); parseTreeWalker.Walk(customListener, ctx); var data = customListener.GetInsurancePolicyData(); string formattedData = string.Format("[{0} | {1} | {2} | {3} | {4} | {5} | {6} | {7}]", data.PolicyID, data.StateCode, data.EqSiteLimit, data.HuSiteLimit, data.FlSiteLimit, data.FrSiteLimit, data.Line, data.Construction); Console.WriteLine(formattedData); } Console.WriteLine("Press any key to exit"); Console.ReadLine(); }
static void Main(string[] args) { Console.WriteLine("We are starting"); // if (args.Length < 1) { // Console.WriteLine("You need a path"); // return; // } // string path = @"F:\vb6\TestProj\Class1.cls"; string path = @"F:\vb6\TestProj\Form1.frm"; string text = null; using (var reader = new StreamReader(File.Open(path, FileMode.Open))) { text = reader.ReadToEnd(); } var stream = new AntlrInputStream(text); var lexer = new VisualBasic6Lexer(stream); var tokenStream = new CommonTokenStream(lexer); var parser = new VisualBasic6Parser(tokenStream); var ctx = parser.startRule(); var treeWalker = new ParseTreeWalker(); if (!parser.BuildParseTree) { throw new Exception("We are not built"); } treeWalker.Walk(new VB6Listener(), ctx); Console.ReadKey(); }
/// <summary> /// 解析 /// </summary> /// <param name="request">请求对象</param> /// <returns>解析结果</returns> public LinqParserResponse Resolve(LinqParserRequest request) { _parserRequest = request; //执行解析 var stream = new AntlrInputStream(request.DslContent); var lexer = new LinqParserLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new LinqParserParser(tokens); parser.BuildParseTree = true; IParseTree tree = parser.linqStatement(); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(this, tree); // 获取解析command var commandText = GetStatement(tree); // 生成返回结果 var command = new ExcuteSqlCommand(commandText); foreach (var param in _params) { command.ParameterCollection[param.Key] = param.Value; } return(new LinqParserResponse { Command = command, ParserType = _linqParserType }); }
private void Load(AntlrInputStream input) { var scopedTypeMap = new TypeMap(_loader, _rootTypeMap); var parserContext = new ParserContext(_loader, scopedTypeMap); var listener = new RuleSharpParserListener(parserContext, _defaultRuleSet); var lexer = new RuleSharpLexer(input); var tokenStream = new CommonTokenStream(lexer); var walker = new ParseTreeWalker(); try { var parser = new RuleSharpParser(tokenStream); parser.ErrorHandler = new BailErrorStrategy(); var tree = parser.compilation_unit(); walker.Walk(listener, tree); } catch (ParseCanceledException pce) { var re = (RecognitionException)pce.InnerException; var location = tokenStream.GetSourceLocation(re.Context); throw new RulesParseException("Failed to parse rules", location, re); } catch (RecognitionException re) { var location = tokenStream.GetSourceLocation(re.Context); throw new RulesParseException("Failed to parse rules", location, re); } catch (InternalParseException pe) { var location = tokenStream.GetSourceLocation(pe.Context); throw new RulesParseException(pe.Message, location, pe.InnerException); } }
/// <summary> /// Execute parsing from specified rule with tree listener. /// This listener is not an error listener but tree listener. /// When parser enters/exits some of a rule listened by the listener, /// listener method will be invoked. /// </summary> /// <typeparam name="T">Type of a custom parse tree listener</typeparam> /// <param name="rule">Root rule name of parsing</param> /// <param name="listener">Instance of listener</param> /// <returns>Instance of parse tree</returns> public IParseTree Parse <T>(string rule, T listener) where T : IParseTreeListener { CheckInitialized(); if (listener == null) { throw new NullReferenceException(); } this.ParseListener = listener; // Try parsing by rule name. // When input rule name is "RootRule", actually `this.Parser.RootRule()` will be invoked. Type t = this.Parser.GetType(); MethodInfo method = t.GetMethod(rule); this.cst = (ParserRuleContext)method.Invoke(this.Parser, null); // Walk parse tree nodes and invoke listener methods if necessary. ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(this.ParseListener, this.cst); return(this.cst); }
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 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); }
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 void Parse(Response response, dynamic args) { string source = getString(args, "source"); NoCaseAntlrStringStream input = new NoCaseAntlrStringStream(source); AdvplLexer lexer = new AdvplLexer(input); CommonTokenStream commonTokenStream = new CommonTokenStream(lexer); AdvplParser advplParser = new AdvplParser(commonTokenStream); advplParser.RemoveErrorListeners(); AdvplErrorListener errorListener = new AdvplErrorListener(); advplParser.AddErrorListener(errorListener); ParserRuleContext tree = advplParser.program(); //Cria a tabela de symbolo SymbolTableDefPhase tableSymbolList = new SymbolTableDefPhase(); ParseTreeWalker walkerGeneral = new ParseTreeWalker(); walkerGeneral.Walk(tableSymbolList, tree); AdvplCompileInfo info = new AdvplCompileInfo(); info.Errors = errorListener.Errors; //string json = JsonConvert.SerializeObject(info); SendResponse(response, info); //System.Console.WriteLine(json); }
public void StreamScopeGenerated() { var metadataText = "stream { " + " event.header := struct { };" + " packet.context := struct { };" + "};"; var parser = GetParser(metadataText); var metadataContext = parser.file(); this.ValidateEmptyErrorListener(); var metadataCustomization = new TestCtfMetadataCustomization(); var listener = new CtfListener(parser, metadataCustomization, metadataCustomization); Assert.IsNotNull(listener.GlobalScope); var treeWalker = new ParseTreeWalker(); treeWalker.Walk(listener, metadataContext); Assert.IsTrue(listener.GlobalScope.Children.Count == 1); Assert.IsTrue(listener.GlobalScope.Children.First().Value.Name.Contains("[stream]")); }
public void TraceScopeGenerated() { var metadataText = "trace {" + " major = 1;" + " minor = 8;" + " byte_order = \"le\";" + " packet.header := struct { };" + "};"; var parser = GetParser(metadataText); var metadataContext = parser.file(); this.ValidateEmptyErrorListener(); var metadataCustomization = new TestCtfMetadataCustomization(); var listener = new CtfListener(parser, metadataCustomization, metadataCustomization); Assert.IsNotNull(listener.GlobalScope); var treeWalker = new ParseTreeWalker(); treeWalker.Walk(listener, metadataContext); Assert.IsTrue(listener.GlobalScope.Children.Count == 1); Assert.IsTrue(StringComparer.CurrentCulture.Equals(listener.GlobalScope.Children.First().Key, "trace")); Assert.IsNotNull(listener.GlobalScope.Children["trace"]); }
public static CsharpParseResults InvokeParse(string fileName) { if (string.IsNullOrWhiteSpace(fileName)) { return(null); } if (!System.IO.File.Exists(fileName)) { return(null); } var tr = System.IO.File.OpenRead(fileName); var input = new AntlrInputStream(tr); var lexer = new CSharpLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new CSharpParser(tokens); var tree = parser.compilation_unit(); var walker = new ParseTreeWalker(); var loader = new CsharpParseTree(); walker.Walk(loader, tree); var results = loader.Results; tr.Close(); results.SourceFile = fileName; return(results); }
static void ParseDDLClause(string input) { AntlrInputStream inputStream = new AntlrInputStream(input); TSqlLexer lexer = new TSqlLexer(inputStream); CommonTokenStream tokens = new CommonTokenStream(lexer); TSqlParser parser = new TSqlParser(tokens); var errorHandler = new SyntaxErrorListener(); parser.AddErrorListener(errorHandler); var parseTree = parser.ddl_clause(); ParseTreeWalker walker = new ParseTreeWalker(); TSqlParserListenerExtended loader = new TSqlParserListenerExtended(new SelectStatement()); loader.TokenStream = tokens; walker.Walk(loader, parseTree); Console.WriteLine("Parse Tree:"); Console.WriteLine(parseTree.ToStringTree(parser)); Console.WriteLine("Errors:"); foreach (var error in errorHandler.Errors) { Console.WriteLine(error.Message + " at position " + error.Line.ToString() + ":" + error.CharPositionInLine.ToString()); } Console.Write("Press enter key to continue"); Console.ReadLine(); }
private void button_Parse_Click(object sender, RoutedEventArgs e) { if (string.IsNullOrEmpty(textBox_Expr.Text)) { return; } AntlrInputStream input = new AntlrInputStream(textBox_Expr.Text); ParamExprGrammarLexer lexer = new ParamExprGrammarLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); ParamExprGrammarParser parser = new ParamExprGrammarParser(tokens); parser.RemoveErrorListeners(); Logger.resetStream(); parser.AddErrorListener(new ParamExprErrorListener()); //IParseTree tree = parser.start_rule(); IParseTree tree = parser.param_expr(); ParseTreeWalker walker = new ParseTreeWalker(); EvalListener eval = new EvalListener(parser); walker.Walk(eval, tree); // BIMRL_output.Text = tree.ToStringTree(parser); string toOutput = new string(Logger.getmStreamContent()); textBox_Output.Text = tree.ToStringTree(parser) + '\n' + toOutput; }
/// <summary> /// Parse the specified CQL to get all statements that are inside it. /// </summary> /// <param name="cql"> /// The CQL contains multiple statements separated with semi-colon. /// </param> /// <returns> /// List of statements. /// </returns> /// <exception cref="CqlException"> /// <paramref name="cql"/> contain invalid CQL. /// </exception> /// <remarks> /// No semi-colon in each result statement. /// </remarks> public static IEnumerable <string> ParseStatements(string cql) { var input = new AntlrInputStream(cql); var lexer = new CqlLexer(new CaseChangingCharStream(input, true)); var tokens = new CommonTokenStream(lexer); var parser = new Parsing.CqlParser(tokens) { ErrorHandler = new BailErrorStrategy() }; var walker = new ParseTreeWalker(); var extractor = new StatementExtractor(); try { walker.Walk(extractor, parser.root()); } catch (ParseCanceledException ex) { var token = (ex.InnerException as RecognitionException)?.OffendingToken; if (token == null) { throw; } throw new CqlException(token.Line, token.Column, token.Text, ex); } return(extractor.Statements); }
public SelectFunctionElement(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; }
static void Scrape(string input) { var str = new AntlrInputStream(input); //System.Console.WriteLine(input); var lexer = new ScrapeDartLexer(str); var tokens = new CommonTokenStream(lexer); var parser = new ScrapeDartParser(tokens); lexer.Mode(ScrapeDartLexer.Search); var listener_lexer = new ErrorListener <int>(); var listener_parser = new ErrorListener <IToken>(); lexer.AddErrorListener(listener_lexer); parser.AddErrorListener(listener_parser); var tree = parser.file(); if (listener_lexer.had_error || listener_parser.had_error) { System.Console.WriteLine("error in parse."); throw new Exception(); } else { System.Console.WriteLine("parse completed."); } var walker = new ParseTreeWalker(); var listener = new Listen(); walker.Walk(listener, tree); var code = listener.sb.ToString(); System.Console.WriteLine(code); }
object Process(ExpectedValueEnum expectedValueType) { object val = null; AntlrInputStream input = new AntlrInputStream(paramExprContent); ParamExprGrammarLexer lexer = new ParamExprGrammarLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); ParamExprGrammarParser parser = new ParamExprGrammarParser(tokens); parser.RemoveErrorListeners(); ParamExprLogger.resetStream(); parser.AddErrorListener(new ParamExprErrorListener()); IParseTree tree = parser.param_expr(); ParseTreeWalker walker = new ParseTreeWalker(); ParamExprListener eval = new ParamExprListener(tokens); eval.RevitElement = _element; eval.RevitParameterName = _paramName; try { walker.Walk(eval, tree); if (eval.HasValue) { val = eval.Value; UnitType = eval.UnitType; } } catch { } return(val); }
private void parseBtn_Click(object sender, EventArgs e) { #if DEBUG && HELLO String input = editor.Text; ICharStream stream = CharStreams.fromstring(input); ITokenSource lexer = new HelloLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); HelloParser parser = new HelloParser(tokens); HelloCustomListener helloListener = new HelloCustomListener(); parser.r().EnterRule(helloListener); #elif DEBUG && ADVANCED String input = editor.Text; ICharStream stream = CharStreams.fromstring(input); ITokenSource lexer = new VisualBasic6Lexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); VisualBasic6Parser parser = new VisualBasic6Parser(tokens); IParseTree tree = parser.startRule(); ParseTreeWalker walker = new ParseTreeWalker(); VisualBasic6CustomListener listener = new VisualBasic6CustomListener(); walker.Walk(listener, tree); //parser.startRule().EnterRule(listener); #endif }
public Grammar Parse(string grammarKey, string text) { var inputStream = new AntlrInputStream(text); var lexer = new CfgGramLexer(inputStream); var tStream = new CommonTokenStream(lexer); var parser = new CfgGramParser(tStream); parser.RemoveErrorListeners(); var errorListener = new ErrorListener(grammarKey, _logger); parser.AddErrorListener(errorListener); var cont = parser.gram(); ParseTreeWalker walker = new ParseTreeWalker(); var listener = new Main(); walker.Walk(listener, cont); if (errorListener.HasErrors) { return(new Grammar() { Key = grammarKey, Errors = errorListener.Errors.ToArray() }); } return(listener.Grammar); }
//Module quet LOG private static List <ItemObject> scanLogging(string fileName, List <ItemObject> listResult) { if (listResult == null || listResult.Count == 0) { listResult = new List <ItemObject>(); } string code = readFile2(fileName); CSharpLexer lexer = new CSharpLexer(new AntlrInputStream(code)); lexer.RemoveErrorListeners(); CommonTokenStream tokens = new CommonTokenStream(lexer); CSharpParser parser = new CSharpParser(tokens); IParseTree tree = parser.compilation_unit(); ParseTreeWalker walker = new ParseTreeWalker(); FindLoggingInMethod uploadListener = new FindLoggingInMethod(parser); walker.Walk(uploadListener, tree); if (uploadListener.listMethod != null) { foreach (var item in uploadListener.listMethod) { ItemObject obj = new ItemObject(item.BaselineItem, item.methodName, null, fileName, item.startLine, "FAIL"); listResult.Add(obj); } } return(listResult); }
static void HandleFileCs(TestVisitor visitor, string filePath) { FileInfo info = new FileInfo(filePath); if (info.Extension == ".cs") { AntlrFileStream stream = new AntlrFileStream(filePath); CSharpLexer lexer = new CSharpLexer(stream); CommonTokenStream tokens = new CommonTokenStream(lexer); CSharpParser parser = new CSharpParser(tokens); CSharpParser.Compilation_unitContext startContext = parser.compilation_unit(); TestListener listener = new TestListener(parser); IParseTree tree = parser.compilation_unit(); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(listener, startContext); StringBuilder streamwritter = new StringBuilder(stream.ToString()); foreach (Tuple <int, string> tup in listener.GetTuples()) { streamwritter.Remove(tup.Item1, tup.Item2.Length).Insert(tup.Item1, tup.Item2); } //visitor.Visit(startContext); StreamWriter writer = new StreamWriter(filePath); writer.Write(streamwritter); writer.Dispose(); } }
public Model Build(IDateProvider dateProvider = null, ISchemaProvider schemaProvider = null) { var model = new Model(); var walker = new ParseTreeWalker(); var listener = new MsdsListener(model) { DateProvider = dateProvider ?? new DateProvider(), SchemaProvider = schemaProvider ?? new SchemaProvider() }; foreach (var stream in _streams) { var filestream = stream as FileStream; var filename = filestream == null ? string.Empty : Path.GetFileNameWithoutExtension(((FileStream)stream).Name); using (NDC.Push(Path.GetFileNameWithoutExtension(filename))) { var lexer = new MsdsLexer(new AntlrInputStream(stream)); lexer.RemoveErrorListeners(); lexer.AddErrorListener(new LoggingErrorListener()); var tokens = new CommonTokenStream(lexer); var parser = new MsdsParser(tokens); parser.RemoveErrorListeners(); parser.AddErrorListener(new LoggingErrorListener()); walker.Walk(listener, parser.file()); } } return(model); }
public override void EnterAssignment([NotNull] CSharpParser.AssignmentContext context) { if (commandVar == null) { return; } foreach (var command in commandVar) { string partern = command + ".CommandText"; if (context.GetText().Contains(partern)) { if (!listExpressLine.Contains(context.Start.Line)) { listExpressLine.Add(context.Start.Line); if (!context.GetChild(2).GetText().StartsWith("\"")) { ParseTreeWalker methodWalker = new ParseTreeWalker(); FindCommandText commandListener = new FindCommandText(parser, context.GetChild(2).GetText()); methodWalker.Walk(commandListener, treeContext); if (commandListener.getListLine().Count > 0) { foreach (var item in commandListener.getListLine()) { if (!listExpressLine.Contains(item)) { listExpressLine.Add(item); } } } } } } } }
public static List <string> getFnames(string query) { IParseTree tree; string querynospaces = query.Replace(" ", ""); if (parseTrees.ContainsKey(querynospaces)) { tree = parseTrees[querynospaces]; } else { AntlrInputStream inputStream = new AntlrInputStream(query); LanguageLexer lexer = new LanguageLexer(inputStream); CommonTokenStream commonTokenStream = new CommonTokenStream(lexer); LanguageParser parser = new LanguageParser(commonTokenStream); parser.BuildParseTree = true; parser.AddErrorListener(new CommandErrorListener()); tree = parser.command(); parseTrees[querynospaces] = tree; } ParseTreeWalker walker = new ParseTreeWalker(); FNameListener listener = new FNameListener(); walker.Walk(listener, tree); return(listener.fnames); }
public static List<NodeInfo> Parse(string code) { var ast = ParseCode(code); var walker = new ParseTreeWalker(ast); ast.Walk(walker); return walker.Nodes; }