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;
}
