public void TestSuite3() { var symbols = new Dictionary <string, int> { { "Val1", 0x11 }, { "Val2", 0x22 }, { "Val3", 0xff }, { "Loc1", 0xd020 }, { "Loc2", 0xd021 }, { "Loc3", 0xd022 } }; var symbolFile = new SymbolFile(symbols); var tree = GetContext("GrammarTests/test-3.txt"); var walker = new ParseTreeWalker(); var sbl = new SimBaseListener { Symbols = symbolFile }; walker.Walk(sbl, tree); Assert.AreEqual(0x11, sbl.Proc.ReadMemoryValueWithoutCycle(0xd020)); Assert.AreEqual(0x22, sbl.Proc.ReadMemoryValueWithoutCycle(0xd021)); Assert.AreEqual(0xff, sbl.Proc.ReadMemoryValueWithoutCycle(0xd022)); }
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 UpgradeResult Upgrade(UpgradeJob upgradeJob) { var outputFiles = new List <UpgradeResult.OutputFile>(); foreach (var file in upgradeJob.Files) { var replacements = new List <TextReplacement>(); ICharStream input = CharStreams.fromstring(file.Source); YarnSpinnerV1Lexer lexer = new YarnSpinnerV1Lexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); YarnSpinnerV1Parser parser = new YarnSpinnerV1Parser(tokens); var tree = parser.dialogue(); var walker = new ParseTreeWalker(); var formatFunctionListener = new FormatFunctionListener(file.Source, parser, (replacement) => replacements.Add(replacement)); walker.Walk(formatFunctionListener, tree); outputFiles.Add(new UpgradeResult.OutputFile(file.FileName, replacements, file.Source)); } return(new UpgradeResult { Files = outputFiles, }); }
public override void EnterBinaryComparasionPredicate([NotNull] MySqlParser.BinaryComparasionPredicateContext context) {//обернуть в два листенера if (_depth == _tmpDepth) { if (!context.GetChild(2).GetChild(0).GetType().ToString().Contains("SubqueryExpessionAtom")) { if (context.Stop.Type != 968) { ExprColumnNames.Add(context.left.GetText()); WhereList.Add(new WhereStructure(context.GetText(), context.left.GetText())); } else { if (context.Stop.Type == 968) { JoinListener tmpJoinListener = new JoinListener(); ParseTreeWalker wlk = new ParseTreeWalker(); wlk.Walk(tmpJoinListener, context); JoinStructures.Add(new JoinStructure(context.Start.Text, context.Stop.Text, tmpJoinListener.Output)); } } } } }
internal static ScriptFile ParseFile(IAddonManager addonManager, string content) { if (addonManager == null) { addonManager = AddonManager.Create(); addonManager.AddAssembly(typeof(Math).Assembly, false); addonManager.AddAssembly(typeof(Enumerable).Assembly, false); } addonManager.AddAssembly(AddonManager.StepBroCoreAssembly, true); // Add StepBro.Core always. ITokenSource lexer = new Grammar.StepBroLexer(new AntlrInputStream(content)); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new SBP(tokens); var file = new ScriptFile(); parser.RemoveErrorListeners(); parser.AddErrorListener(file.Errors as ErrorCollector); parser.BuildParseTree = true; var listener = new StepBroListener(file.Errors as ErrorCollector, addonManager, file); var context = parser.compilationUnit(); var walker = new ParseTreeWalker(); walker.Walk(listener, context); if (file.Errors.ErrorCount > 0) { throw new Exception("PARSING ERRORS: " + file.Errors[0].ToString()); } //file?.InitializeFileVariables(); return(file); }
public void CollectInfo(CodeSource grammarSource, ANTLRv4Parser.GrammarSpecContext context) { GrammarSource = grammarSource; var walker = new ParseTreeWalker(); walker.Walk(this, context); }
internal static SBExpressionData ParsePrimary(string content, ScriptFile file = null) { ITokenSource lexer = new Grammar.StepBroLexer(new AntlrInputStream(content)); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new SBP(tokens); ErrorCollector errors = (file != null) ? file.Errors as ErrorCollector : new ErrorCollector(null, false); parser.AddErrorListener(errors); parser.BuildParseTree = true; StepBroListener listener = new StepBroListener(errors, null, file ?? new ScriptFile()); listener.PrepareForExpressionParsing("StepBroFileBuilder.ParsePrimary"); var context = parser.primary(); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(listener, context); if (errors.ErrorCount > 0) { throw new Exception("PARSING ERRORS"); } return(listener.GetExpressionResult()); }
public Expressions(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; }
internal static Tuple <Stack <SBExpressionData>, IErrorCollector> ParseSimpleArguments(string expression) { var addons = AddonManager.Create(); addons.AddAssembly(AddonManager.StepBroCoreAssembly, true); addons.AddAssembly(typeof(System.Math).Assembly, false); addons.AddAssembly(typeof(System.Linq.Enumerable).Assembly, false); //if (module != null) addons.AddAssembly(module, false); var file = new ScriptFile(); file.AddNamespaceUsing(-1, addons.Lookup(null, "System")); file.AddNamespaceUsing(-1, addons.Lookup(null, "System.Linq")); //foreach (var u in usings) //{ // file.AddNamespaceUsing(addons.Lookup(null, u.FullName)); //} var builder = new FileBuilder(new AntlrInputStream(expression), addons, file); builder.Listener.PrepareForExpressionParsing("StepBroFileBuilder.ParseExpression"); var context = builder.Parser.arguments(); var walker = new ParseTreeWalker(); walker.Walk(builder.Listener, context); return(new Tuple <Stack <SBExpressionData>, IErrorCollector>(builder.Listener.GetArguments(), builder.Errors)); }
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; } } catch { } return(val); }
/// <summary> /// Locates all declared symbols (identifiers) in the project. /// </summary> /// <remarks> /// This method walks the entire parse tree for each module. /// </remarks> private void IdentifySymbols() { foreach (var componentParseResult in _parseResults.Where(r => r.Component != null)) { try { var listener = new DeclarationSymbolsListener(componentParseResult); var walker = new ParseTreeWalker(); walker.Walk(listener, componentParseResult.ParseTree); if (!_declarations.Items.Any()) { var projectIdentifier = componentParseResult.QualifiedName.Project.Name; var memberName = componentParseResult.QualifiedName.QualifyMemberName(projectIdentifier); var projectDeclaration = new Declaration(memberName, "VBE", projectIdentifier, false, false, Accessibility.Global, DeclarationType.Project, false); _declarations.Add(projectDeclaration); } foreach (var declaration in listener.Declarations.Items) { _declarations.Add(declaration); } } catch (COMException) { // something happened, couldn't access VBComponent for some reason } } }
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); }
internal static FileBuilder ParseProcedure( IAddonManager addonManager, string[] usings, Type usingType, params string[] content) { if (addonManager == null) { addonManager = AddonManager.Create(); addonManager.AddAssembly(typeof(Math).Assembly, false); addonManager.AddAssembly(typeof(Enumerable).Assembly, false); } addonManager.AddAssembly(AddonManager.StepBroCoreAssembly, true); // Add StepBro.Core always. if (usingType != null) { addonManager.AddAssembly(usingType.Assembly, false); } var contentBuilder = new StringBuilder(); foreach (var s in content) { contentBuilder.AppendLine(s); } var file = new ScriptFile(); file.AddNamespaceUsing(-1, addonManager.Lookup(null, "System")); file.AddNamespaceUsing(-1, addonManager.Lookup(null, "System.Linq")); file.AddNamespaceUsing(-1, addonManager.Lookup(null, typeof(StepBro.Core.DataReport).Namespace)); if (usings != null) { foreach (var u in usings) { file.AddNamespaceUsing(-1, addonManager.Lookup(null, u)); } } if (usingType != null) { file.AddNamespaceUsing(-1, addonManager.Lookup(null, usingType.Namespace)); } var builder = new FileBuilder(new AntlrInputStream(contentBuilder.ToString()), addonManager, file); builder.Listener.PrepareForExpressionParsing("StepBroFileBuilder.ParseExpression"); var context = builder.Parser.procedureDeclaration(); var walker = new ParseTreeWalker(); walker.Walk(builder.Listener, context); if (file.Errors.ErrorCount > 0) { throw new Exception("PARSING ERRORS"); } return(builder); }
static void Main(string[] args) { ParseOptions(args); if (showHelp) { return; } var generators = new List <Tuple <ILanguageGenerator, IFunctionsGenerator> >(); if (language == "csharp") { generators.Add(new Tuple <ILanguageGenerator, IFunctionsGenerator>( new CsharpLanguageGenerator(), new CsharpFunctionsGenerator())); } else if (language == "proto") { generators.Add(new Tuple <ILanguageGenerator, IFunctionsGenerator>(new ProtobufGenerator(), null)); } else if (language == "ts") { generators.Add(new Tuple <ILanguageGenerator, IFunctionsGenerator>(new TypescriptGenerator(), new TypescriptFunctionsGenerator())); } using (FileStream fs = new FileStream(expressPath, FileMode.Open)) { var input = new AntlrInputStream(fs); var lexer = new Express.ExpressLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new Express.ExpressParser(tokens); parser.BuildParseTree = true; var tree = parser.schemaDecl(); var walker = new ParseTreeWalker(); var testSb = new StringBuilder(); foreach (var generator in generators) { var listener = new Express.ExpressListener(generator.Item1); walker.Walk(listener, tree); Generate(listener, outDir, generator.Item1, generator.Item2); } if (!outputTokens) { return; } var tokenStr = new StringBuilder(); foreach (var t in tokens.GetTokens()) { tokenStr.AppendLine(t.ToString()); } Console.WriteLine(tokenStr); } }
public ComparisonOperator(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; this.DivideSym = ""; }
public AtomTableItem(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; _text = text; }
//private bool _isRealised = false; public FullColumnName(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; _text = text; }
public SelectElements(Interval ruleInterval, MySqlParser.SelectElementsContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; _text = text; }
public AggregateWindowedFunction(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; _text = text; }
public static IEnumerable <TContext> FindChildren <TContext>(this ParserRuleContext context) where TContext : ParserRuleContext { var walker = new ParseTreeWalker(); var listener = new ChildNodeListener <TContext>(); walker.Walk(listener, context); return(listener.Matches); }
public ExtractFunctionCall(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text) { ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(_listener, context); Rules = _listener.Rules; _text = text; }
/// <summary> /// Create a Model given a STEP file. /// </summary> /// <param name="STEPfilePath">The path to the STEP file.</param> /// <param name="errors">A list of errors generated during creation of the Document.</param> /// <returns>A Model.</returns> /// <exception cref="FileNotFoundException">The specified file path does not exist.</exception> public Model(string STEPfilePath, IDictionary <Guid, BaseIfc> storage, out IList <STEPError> errors) { if (!File.Exists(STEPfilePath)) { throw new FileNotFoundException($"The specified IFC STEP file does not exist: {STEPfilePath}."); } this.storage = storage; using (FileStream fs = new FileStream(STEPfilePath, FileMode.Open)) { var sw = new Stopwatch(); sw.Start(); var input = new AntlrInputStream(fs); var lexer = new STEP.STEPLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new STEP.STEPParser(tokens); parser.BuildParseTree = true; var tree = parser.file(); var walker = new ParseTreeWalker(); var listener = new STEP.STEPListener(); walker.Walk(listener, tree); sw.Stop(); Console.WriteLine($"{sw.Elapsed} for parsing STEP file {STEPfilePath}."); sw.Reset(); sw.Start(); var err = new List <STEPError>(); foreach (var data in listener.InstanceData) { if (listener.InstanceData[data.Key].ConstructedInstance != null) { // Instance may have been previously constructed as the result // of another construction. continue; } ConstructAndStoreInstance(data.Value, listener.InstanceData, data.Key, err, 0); } // Transfer the constructed instances to storage. foreach (var data in listener.InstanceData) { var inst = (BaseIfc)data.Value.ConstructedInstance; storage.Add(inst.Id, inst); } sw.Stop(); Console.WriteLine($"{sw.Elapsed} for creating instances."); errors = err; } }
public static void ParseProgramOrClass(TextSourceInfo textSourceInfo, ISearchableReadOnlyList <CodeElementsLine> codeElementsLines, TypeCobolOptions compilerOptions, SymbolTable customSymbols, out Program newProgram, out Class newClass, out IList <ParserDiagnostic> diagnostics) { // Create an Antlr compatible token source on top a the token iterator CodeElementsLinesTokenSource tokenSource = new CodeElementsLinesTokenSource( textSourceInfo.Name, codeElementsLines); // Init parser ITokenStream tokenStream = new TokensLinesTokenStream(tokenSource, Token.CHANNEL_SourceTokens); ProgramClassParser cobolParser = new ProgramClassParser(tokenStream); // -> activate full ambiguities detection //parser.Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection; // Register all parse errors in a list in memory ParserDiagnosticErrorListener errorListener = new ParserDiagnosticErrorListener(); cobolParser.RemoveErrorListeners(); cobolParser.AddErrorListener(errorListener); // Try to parse a Cobol program or class ProgramClassParser.CobolCompilationUnitContext programClassParseTree = cobolParser.cobolCompilationUnit(); // Visit the parse tree to build a first class object representing a Cobol program or class ParseTreeWalker walker = new ParseTreeWalker(); CobolNodeBuilder programClassBuilder = new CobolNodeBuilder(); programClassBuilder.CustomSymbols = customSymbols; programClassBuilder.Dispatcher = new NodeDispatcher(); programClassBuilder.Dispatcher.CreateListeners(); ParserDiagnostic programClassBuilderError = null; try { walker.Walk(programClassBuilder, programClassParseTree); } catch (Exception ex) { var code = Diagnostics.MessageCode.ImplementationError; programClassBuilderError = new ParserDiagnostic(ex.ToString(), null, null, code); } //Complete some information on Node and run checker that need a full AST if (programClassBuilder.Program != null) { programClassBuilder.Program.SyntaxTree.Root.AcceptASTVisitor(new Cobol85CompleteASTChecker()); } // Register compiler results newProgram = programClassBuilder.Program; newClass = programClassBuilder.Class; diagnostics = programClassBuilder.GetDiagnostics(programClassParseTree); if (programClassBuilderError != null) { if (diagnostics == null) { diagnostics = new List <ParserDiagnostic>(); } diagnostics.Add(programClassBuilderError); } }
static void Main(string[] args) { string filename = "code.txt"; using (StreamReader file = new StreamReader(filename)) { AntlrInputStream inputStream = new AntlrInputStream(file.ReadToEnd()); ClojureObrLexer lexer = new ClojureObrLexer(inputStream); CommonTokenStream commonTokenStream = new CommonTokenStream(lexer); ClojureObrParser parser = new ClojureObrParser(commonTokenStream); ObrErrorListener errorListener = new ObrErrorListener(); parser.AddErrorListener(errorListener); ClojureObrParser.FileContext tree = parser.file(); if (parser.NumberOfSyntaxErrors != 0) { Console.WriteLine($"Syntax is bad :( "); foreach (var error in errorListener.Errors) { Console.WriteLine(error); } Console.ReadKey(); return; } if (R) { ParseTreeWalker walker = new ParseTreeWalker(); ObrListener semantic = new ObrListener(); try { walker.Walk(semantic, tree); } catch (Exception e) { Console.WriteLine($" :( Error: {e.ToString()}"); Console.ReadKey(); return; } var typedRoot = semantic.typedRoot; var options = new JsonSerializerSettings { Formatting = Formatting.Indented, NullValueHandling = NullValueHandling.Ignore }; string typedTree = JsonConvert.SerializeObject(typedRoot, options); File.WriteAllText("typedTree.json", typedTree); GraphProcessor.BuildGraph(semantic.root, "tree"); } } Console.WriteLine("Syntax not so bad :| "); Console.ReadKey(); }
public IExpression parse_expression() { IParseTree tree = expression(); EPromptoBuilder builder = new EPromptoBuilder(this); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(builder, tree); return(builder.GetNodeValue <IExpression>(tree)); }
public IStatement parse_statement() { IParseTree tree = statement(); EPromptoBuilder builder = new EPromptoBuilder(this); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(builder, tree); return(builder.GetNodeValue <IStatement>(tree)); }
public NativeCall parse_native_statement() { IParseTree tree = native_statement(); EPromptoBuilder builder = new EPromptoBuilder(this); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(builder, tree); return(builder.GetNodeValue <NativeCall>(tree)); }
public AssignInstanceStatement parse_assign_instance_statement() { IParseTree tree = assign_instance_statement(); EPromptoBuilder builder = new EPromptoBuilder(this); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(builder, tree); return(builder.GetNodeValue <AssignInstanceStatement>(tree)); }
public ConcreteMethodDeclaration parse_concrete_method_declaration() { IParseTree tree = concrete_method_declaration(); EPromptoBuilder builder = new EPromptoBuilder(this); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(builder, tree); return(builder.GetNodeValue <ConcreteMethodDeclaration>(tree)); }
public UnresolvedCall parse_method_call() { IParseTree tree = method_call_statement(); EPromptoBuilder builder = new EPromptoBuilder(this); ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(builder, tree); return(builder.GetNodeValue <UnresolvedCall>(tree)); }