public static List<Error> Translate(Source source) { var err = new List<Error>(); var prg = new Program(); try { var input = new ANTLRStringStream(source.GetSourceData()); var lexer = new PascalLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new PascalParser(tokens); prg = parser.program(); prg.SetSourceIdentifier(source.GetSourceIdentifier()); } catch (RecognitionException e) { err.Add(new Error(FormatRecognitionException(e, source.GetSourceIdentifier()))); } if (err.Count != 0) return err; var val = new Validator(); err = val.Validate(prg); Root = prg; return err; }
public static void Main(string[] args) { if (args.Length == 1) { string fullpath; if ( Path.IsPathRooted(args[0]) ) fullpath = args[0]; else fullpath = Path.Combine(Environment.CurrentDirectory, args[0]); Console.Out.WriteLine("Processing file: {0}", fullpath); ICharStream input = new ANTLRFileStream(fullpath); SimpleCLexer lex = new SimpleCLexer(input); CommonTokenStream tokens = new CommonTokenStream(lex); SimpleCParser parser = new SimpleCParser(tokens); SimpleCParser.program_return r = parser.program(); Console.Out.WriteLine("tree="+((ITree)r.Tree).ToStringTree()); if ( parser.NumberOfSyntaxErrors > 0 ) { // don't tree parse if has errors return; } CommonTreeNodeStream nodes = new CommonTreeNodeStream((ITree)r.Tree); nodes.TokenStream = tokens; SimpleCWalker walker = new SimpleCWalker(nodes); walker.program(); } else Console.Error.WriteLine("Usage: SimpleC <input-file>"); }
public void VisitLine(String line) { Core interp_visitor = new Core(); PrintVisitor print_visitor = new PrintVisitor(interp_visitor); ANTLRStringStream string_stream = new ANTLRStringStream(line); spinachLexer lexer = new spinachLexer(string_stream); CommonTokenStream tokens = new CommonTokenStream(lexer); spinachParser parser = new Test_Core(tokens, ""); try { spinachParser.program_return program = parser.program(); //h= (l+j)*h*l+l-h; if (strBuilder.ToString() == "") { List<Element> elements = program.ret; ///-- call core function. to pass list of element. for (int i = 0; i < elements.Count; i++) { Element curr = elements[i]; curr.Accept(print_visitor); curr.Accept(interp_visitor);//PlotReceiver } } else { Onerror(101, strBuilder.ToString()); } } catch (RecognitionException e) { Onerror(102, e.Message); } }
public ASMParser GetParser(string script) { var input = new ANTLRStringStream(script); var lexer = new ASMLexer(input); var tokens = new CommonTokenStream(lexer); return new ASMParser(tokens); }
/// <summary> /// Parses input stream to tokens and then according to CSS grammar. /// </summary> /// <param name="inp">file name of input stream.</param> public void Parse(string inp) { string fullpath; if (Path.IsPathRooted(inp)) fullpath = inp; else fullpath = Common.PathCombine(Environment.CurrentDirectory, inp); ICharStream input = new ANTLRFileStream(fullpath, Encoding.UTF8); csst3Lexer lex = new csst3Lexer(input); CommonTokenStream tokens = new CommonTokenStream(lex); csst3Parser parser = new csst3Parser(tokens); // return results as parameters try { Root = (CommonTree)parser.stylesheet().Tree; Errors = parser.GetErrors(); } catch (Exception) { Errors = parser.GetErrors(); throw; } }
public Boolean RunTest() { try { GlobalMemory.Clear(); var sStream = new ANTLRStringStream(input); var lexer = new SGLLexer(sStream); var tStream = new CommonTokenStream(lexer); // Parsing var parser = new SGLParser(tStream); var t = (CommonTree) parser.main().Tree; // Printing tree Console.WriteLine("; " + t.ToStringTree()); // TreeWalking var treeStream = new CommonTreeNodeStream(t); var tw = new SGLTreeWalker(treeStream, true); AbstractNode returned = tw.main(); returned.Evaluate(); if (debug) { realOutput = GlobalMemory.Instance.DebugString; } else { realOutput = GlobalMemory.Instance.StoryboardCode.ToString(); } // comparison realOutput = realOutput.Trim(); output.Trim(); if (output.Equals(realOutput)) { return true; } else { return false; } } catch (CompilerException ce) { Console.WriteLine(ce.GetExceptionAsString()); return false; } catch (Exception ex) { Console.WriteLine("Es ist ein Fehler aufgetreten."); Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); return false; } }
public static MAst Compile(AstHelper runtime, ICharStream stream) { var lexer = new TigerLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(tokens); ProgramExpression programExpression = parser.parse(); if (parser.NumberOfSyntaxErrors > 0) { IEnumerable<string> errors = from e in parser.Errors select e.ToString(); throw new SyntaxException(errors); } AstHelper helper = runtime.CreateChild(function: true, variables: true, types: true); programExpression.CheckSemantics(helper); if (helper.Errors.HasErrors) { throw new SemanticException(helper.Errors); } return programExpression.Transform(); }
public Expression Compile(String relinqScript) { var input = new ANTLRStringStream(relinqScript); var lex = new EcmaScriptV3Lexer(input); var tokens = new CommonTokenStream(lex); var parser = new EcmaScriptV3Parser(tokens); var es3Ast = parser.expression(); var rsAst = new RelinqScriptParser().Visit((CommonTree)es3Ast.Tree); var compilerAst = new TypeInferenceAstBuilder().Visit(rsAst); using (var engine = new TypeInferenceEngine(compilerAst)) { #if DEBUG try { var wtf = 0; while(!engine.Run()) if (wtf++ == 10) break; return new StronglyTypedAstBuilder().Visit(compilerAst); } catch (Exception) { engine.Dump(); throw; } #else engine.Run(); return new StronglyTypedAstBuilder().Visit(tiAst); #endif } }
public void Execute() { string input = @" Sart(0,0) End(12,15) "; ANTLRStringStream inStream = new ANTLRStringStream(input); ConfLexer lexer = new ConfLexer(inStream); CommonTokenStream tokens = new CommonTokenStream(lexer); ConfParser parser = new ConfParser(tokens); ConfParser.prog_return returnParser = parser.prog(); var tree = returnParser.Tree as CommonTree; foreach (CommonTree item in tree.Children) { if (item.Type == ConfLexer.ID) Console.WriteLine("function=" + item.Text); else if(item.Type == ConfLexer.INT) Console.WriteLine("params:" + item.Text); } Console.ReadKey(); }
/// <summary> /// Parse the fragment of the source code already given. /// </summary> /// <param name="parser"></param> /// <param name="tokenStream"></param> private static CstNode ParseFragment(TParser parser, CommonTokenStream tokenStream) { var builder = new CstBuilderForAntlr3WithMemorizingError( tokenStream, parser.TokenNames); parser.TreeAdaptor = builder; tokenStream.Mark(); var methodInfos = parser.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance); foreach (var methodInfo in methodInfos) { if (methodInfo.ReturnType.IsSubclassOf(typeof(ParserRuleContext)) && methodInfo.GetParameters().Length == 0) { builder.Initialize(); parser.Reset(); var ret = methodInfo.Invoke(parser, new object[0]); if (!builder.HasErrors) { return(builder.FinishParsing((CstNode)ret)); } } } throw builder.LastException; }
public static string Compile(string input) { input = input.Replace("\r", ""); ANTLRStringStream Input = new ANTLRStringStream(input); SugarCppLexer lexer = new SugarCppLexer(Input); CommonTokenStream tokens = new CommonTokenStream(lexer); SugarCppParser parser = new SugarCppParser(tokens); AstParserRuleReturnScope<CommonTree, IToken> t = parser.root(); CommonTree ct = (CommonTree)t.Tree; if (parser.errors.Count() > 0) { StringBuilder sb = new StringBuilder(); foreach (var error in parser.errors) { sb.Append(error); sb.Append("\n"); } throw new Exception(sb.ToString()); } CommonTreeNodeStream nodes = new CommonTreeNodeStream(ct); SugarWalker walker = new SugarWalker(nodes); Root ast = walker.root(); TargetCpp target_cpp = new TargetCpp(); return ast.Accept(target_cpp).Render(); }
/// <summary> /// Parses an expression in text form for later evaluation. /// </summary> /// <param name="pszCode">The expression to be parsed.</param> /// <param name="dwFlags">A combination of flags from the PARSEFLAGS enumeration that controls parsing.</param> /// <param name="nRadix">The radix to be used in parsing any numerical information in pszCode.</param> /// <param name="ppExpr">Returns the IDebugExpression2 object that represents the parsed expression, which is ready for binding and evaluation.</param> /// <param name="pbstrError">Returns the error message if the expression contains an error.</param> /// <param name="pichError">Returns the character index of the error in pszCode if the expression contains an error.</param> /// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns> /// <remarks> /// When this method is called, a debug engine (DE) should parse the expression and validate it for correctness. /// The pbstrError and pichError parameters may be filled in if the expression is invalid. /// /// Note that the expression is not evaluated, only parsed. A later call to the IDebugExpression2.EvaluateSync /// or IDebugExpression2.EvaluateAsync methods evaluates the parsed expression. /// </remarks> public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError) { if (pszCode == null) throw new ArgumentNullException("pszCode"); if (pszCode.Length == 0) throw new ArgumentException(); // dwFlags=0 in the Immediate window if (dwFlags != enum_PARSEFLAGS.PARSE_EXPRESSION && dwFlags != 0) throw new NotImplementedException(); try { var expressionInput = new ANTLRStringStream(pszCode); var expressionUnicodeInput = new JavaUnicodeStream(expressionInput); var expressionLexer = new Java2Lexer(expressionUnicodeInput); var expressionTokens = new CommonTokenStream(expressionLexer); var expressionParser = new Java2Parser(expressionTokens); IAstRuleReturnScope<CommonTree> result = expressionParser.standaloneExpression(); ppExpr = new JavaDebugExpression(this, result.Tree, pszCode); pbstrError = null; pichError = 0; return VSConstants.S_OK; } catch (RecognitionException e) { ppExpr = null; pbstrError = e.Message; pichError = (uint)Math.Max(0, e.Index); return VSConstants.E_FAIL; } }
public void Compile(ICharStream input) { try { AssemblerLexer lex = new AssemblerLexer(input); CommonTokenStream tokens = new CommonTokenStream(lex); AssemblerParser p = new AssemblerParser(tokens); BytecodeGenerator gen = new BytecodeGenerator(Defaults.SystemMethods.Values); p.SetGenerator(gen); p.TraceDestination = _traceDestination; p.program(); if (p.NumberOfSyntaxErrors > 0 && _listener != null) { _listener.Error(Convert.ToString(p.NumberOfSyntaxErrors) + " syntax error(s)"); return; } _result = gen.Result; } catch (GenerationException ex) { _listener.Error(ex.Message); } }
public static MySQL51Parser.program_return ParseSql(string sql, bool expectErrors, out StringBuilder sb, Version version ) { // The grammar supports upper case only MemoryStream ms = new MemoryStream(ASCIIEncoding.ASCII.GetBytes(sql/*.ToUpper() */)); CaseInsensitiveInputStream input = new CaseInsensitiveInputStream(ms); //ANTLRInputStream input = new ANTLRInputStream(ms); MySQLLexer lexer = new MySQLLexer(input); lexer.MySqlVersion = version; CommonTokenStream tokens = new CommonTokenStream(lexer); MySQLParser parser = new MySQLParser(tokens); parser.MySqlVersion = version; sb = new StringBuilder(); TextWriter tw = new StringWriter(sb); parser.TraceDestination = tw; MySQL51Parser.program_return r = parser.program(); if (!expectErrors) { if (0 != parser.NumberOfSyntaxErrors) Assert.AreEqual("", sb.ToString()); //Assert.AreEqual( 0, parser.NumberOfSyntaxErrors); } else { Assert.AreNotEqual(0, parser.NumberOfSyntaxErrors); } return r; }
public static InOutStep<EvilLexer, Tuple<CommonTokenStream, CommonTree>> Parse() { return new InOutStep<EvilLexer, Tuple<CommonTokenStream, CommonTree>>((lexer) => { CommonTokenStream tokens = new CommonTokenStream(lexer); EvilParser parser = new EvilParser(tokens); EvilParser.program_return ret = null; parser.TraceDestination = Console.Out; try { ret = parser.Program(); } catch (RecognitionException e) { throw new EvilException(EvilSystem.Parsing, "Error parsing.", e); } if (parser.NumberOfSyntaxErrors != 0) throw new EvilException(EvilSystem.Parsing, "Syntax errors."); CommonTree t = (CommonTree)ret.Tree; return new Tuple<CommonTokenStream, CommonTree>(tokens, t); }); }
public Context From(string source) { var stream = new ANTLRStringStream(source); var lexer = new MessageContractsLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new MessageContractsParser(tokens) { TreeAdaptor = new CommonTreeAdaptor() }; var program = parser.GetProgram(); var commonTree = (CommonTree)program.Tree; var node = commonTree as CommonErrorNode; if (node != null) { throw new InvalidOperationException(node.ToString()); } var ctx = new Context(); foreach (var child in commonTree.Children) { WalkDeclarations(child, ctx); } return ctx; }
public BlaiseInstrumentTreeWalker(CommonTree tree, CommonTokenStream tokens, BlaiseImportOptions options, string agencyId, string mainLanguage) { this.tree = tree; this.tokens = tokens; this.options = options; this.MainLanguage = mainLanguage; this.AgencyId = agencyId; Result = new XDocument(); DdiInstance = Ddi.Element(Ddi.DdiInstance); Ddi.AddNamespaces(DdiInstance); ResourcePackage = Ddi.Element(Ddi.ResourcePackage); // Required in DDI 3.1 var purpose = Ddi.Element(Ddi.Purpose); purpose.Add(Ddi.XmlLang(MainLanguage)); purpose.Add(new XElement(Ddi.Content, "Not Specified")); ResourcePackage.Add(purpose); Instrument = Ddi.Element(Ddi.Instrument); ControlConstructScheme = Ddi.Element(Ddi.ControlConstructScheme); XElement groupDataCollection = Ddi.Element(Ddi.GroupDataCollection, false); XElement dataCollection = Ddi.Element(Ddi.DataCollection); groupDataCollection.Add(dataCollection); dataCollection.Add(Instrument); ResourcePackage.Add(groupDataCollection); ResourcePackage.Add(ControlConstructScheme); DdiInstance.Add(ResourcePackage); }
public static void Main(string[] args) { if (args.Length == 1) { string fullpath; if ( Path.IsPathRooted(args[0]) ) fullpath = args[0]; else fullpath = Path.Combine(Environment.CurrentDirectory, args[0]); Console.Out.WriteLine("Processing file: {0}", fullpath); ICharStream input = new ANTLRFileStream(fullpath); LangLexer lex = new LangLexer(input); CommonTokenStream tokens = new CommonTokenStream(lex); LangParser parser = new LangParser(tokens); //LangParser.decl_return r = parser.decl(); LangParser.start_return r = parser.start(); Console.Out.WriteLine("tree: "+((ITree)r.Tree).ToStringTree()); CommonTree r0 = ((CommonTree)r.Tree); CommonTreeNodeStream nodes = new CommonTreeNodeStream(r0); nodes.TokenStream = tokens; LangDumpDecl walker = new LangDumpDecl(nodes); walker.decl(); } else Console.Error.WriteLine("Usage: TreeParser <input-file>"); }
public static LuaResult Compile( StaticMetaTables staticTables, string source, dynamic globals = null, string name = null) { var result = new LuaResult(); var stopwatch = new Stopwatch(); stopwatch.Start(); try { var stream = new ANTLRStringStream(source); var lexer = new ChunkLexer(stream); var tokenStream = new CommonTokenStream(lexer); var parser = new ChunkParser(tokenStream); var r = parser.chunk(); result.Errors.AddRange(parser.Errors); Expression e; var scope = Scope.NewTopLevelScop(); var chunk = new Chunk(); result.Errors.AddRange(chunk.Generate(staticTables, scope, r.Tree, out e)); var fnExp = Expression.Lambda<Func<Table, object>>(e, scope.Env.GlobalParameter); result.Chunk = new CompiledChunk(fnExp.Compile(), globals ?? new Table(), name); } finally { stopwatch.Stop(); result.ElapsedTime = stopwatch.Elapsed; result.Success = !result.Errors.ContainsError(); } return result; }
public Feature Parse(TextReader featureFileReader) { var fileContent = featureFileReader.ReadToEnd() + Environment.NewLine; CultureInfo language = GetLanguage(fileContent); var inputStream = new ANTLRReaderStream(new StringReader(fileContent)); var lexer = GetLexter(language, inputStream); var tokenStream = new CommonTokenStream(lexer); var parser = new Grammar.SpecFlowLangParser(tokenStream); var featureTree = parser.feature().Tree as CommonTree; if (featureTree == null || parser.ParserErrors.Count > 0 || lexer.LexerErrors.Count > 0) { throw new SpecFlowParserException("Invalid Gherkin file!", lexer.LexerErrors.Concat(parser.ParserErrors).ToArray()); } var walker = new SpecFlowLangWalker(new CommonTreeNodeStream(featureTree)); Feature feature = walker.feature(); if (feature == null) throw new SpecFlowParserException("Invalid Gherkin file!"); feature.Language = language.Name; return feature; }
public Boolean RunTest() { try { ANTLRStringStream sStream = new ANTLRStringStream(input); SGLLexer lexer = new SGLLexer(sStream); CommonTokenStream tStream = new CommonTokenStream(lexer); // Parsing SGLParser parser = new SGLParser(tStream); CommonTree t = (CommonTree)parser.compilationUnit().Tree; // Printing tree Console.WriteLine("; " + t.ToStringTree()); // TreeWalking CommonTreeNodeStream treeStream = new CommonTreeNodeStream(t); SGLTreeWalker tw = new SGLTreeWalker(treeStream); SGLNode returned = tw.compilationUnit(); returned.Evaluate(); realOutput = tw.GetStoryboardCode().ToString(); // comparison realOutput = realOutput.Trim(); output.Trim(); if (output.Equals(realOutput)) { return true; } else { return false; } } catch (SGLCompilerException ce) { if (ce.ErrorType.Equals("Antlr.Parser")) { Console.WriteLine("Error (wrong syntax) on " + ce.Message); } else { Console.WriteLine("Error (" + ce.ErrorType + ") on line " + ce.Line + ": " + ce.Message); } return false; } catch (Exception ex) { Console.WriteLine("Es ist ein Fehler aufgetreten."); Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); return false; } }
private void compilacion(ICharStream input, string pathSalida) { compilacionOK = false; //Plantillas //TextReader groupFileR = new StreamReader("C:\\Proyectos\\ProyectosVS\\FKVM\\FKVM\\src\\antlr\\FkvmIL.stg"); TextReader groupFileR = new StreamReader( System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("FKVM.src.antlr.FkvmIL.stg")); StringTemplateGroup templates = new StringTemplateGroup(groupFileR); groupFileR.Close(); //Análisis Léxico-Sintáctico Console.WriteLine("Análisis léxico-sintáctico..."); //ANTLRFileStream input = new ANTLRFileStream(pathEntrada); FKVMLexer lexer = new FKVMLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); FKVMParser parser = new FKVMParser(tokens); parser.TreeAdaptor = adaptor; parser.reportarError = re; FKVMParser.programa_return result = parser.programa(); //Si no hay errores léxicos ni sintácticos ==> Análisis Semántico if (lexer.numErrors + parser.numErrors == 0) { //Analisis Semántico Console.WriteLine("Análisis semántico..."); CommonTree t = ((CommonTree)result.Tree); //Console.WriteLine(t.ToStringTree() + "\n\n"); // CommonTreeNodeStream nodes2 = new CommonTreeNodeStream(t); nodes2.TokenStream = tokens; FKVMSem walker2 = new FKVMSem(nodes2); walker2.reportarError = re; walker2.programa(parser.symtable); //Si no hay errores en el análisis semántico ==> Generación de código if (walker2.numErrors == 0) { //Generación de Código Console.WriteLine("Generación de código..."); CommonTreeNodeStream nodes = new CommonTreeNodeStream(t); nodes.TokenStream = tokens; FKVMGen walker = new FKVMGen(nodes); walker.TemplateLib = templates; FKVMGen.programa_return r2 = walker.programa(parser.numVars); //Presentación de resultados StringTemplate output = (StringTemplate)r2.Template; //Console.WriteLine(output.ToString()); StreamWriter pw = new StreamWriter(pathSalida); pw.WriteLine(output.ToString()); pw.Flush(); pw.Close(); compilacionOK = true; } } }
public static JsonParser jsonParserFromString(string input) { var inputStream = new ANTLRStringStream(input); var lexer = new JsonLexer(inputStream); var tokens = new CommonTokenStream(lexer); var parser = new JsonParser(tokens); return parser; }
/// <summary> /// Creates a CPL parser for the given code, using the given error tracker. /// </summary> /// <param name="p_strCode">The code be parsed.</param> /// <param name="p_ertErrorTracker">The error tracker to use to log /// parsing errors.</param> /// <returns>A CPL parser for the given code.</returns> public AntlrParserBase CreateParser(string p_strCode, ErrorTracker p_ertErrorTracker) { AntlrLexerBase lexLexer = CreateLexer(p_strCode, p_ertErrorTracker); CommonTokenStream ctsTokens = new CommonTokenStream(lexLexer); CPLParser prsParser = new CPLParser(ctsTokens); prsParser.ErrorTracker = p_ertErrorTracker; return prsParser; }
public static Definitions Parse(TextReader source) { var lex = new ParserImpl.WebIDLLexer(new ANTLRReaderStream(source)); var tokens = new CommonTokenStream(lex); var parser = new ParserImpl.WebIDLParser(tokens); return parser.definitions(); }
private static AntlrCalcEngineParser CreateParser( string parseText ) { var input = new ANTLRStringStream( parseText ); var lex = new AntlrCalcEngineLexer( input ); var tokens = new CommonTokenStream( lex ); return new AntlrCalcEngineParser( tokens ); }
private CommonTree ParseViaAntlrOnly(String relinqScriptCode) { var input = new ANTLRStringStream(relinqScriptCode); var lex = new EcmaScriptV3Lexer(input); var tokens = new CommonTokenStream(lex); var parser = new EcmaScriptV3Parser(tokens); return (CommonTree)parser.expression().Tree; }
/// <summary> /// Creates a CPL parser for the given code, using the given error tracker. /// </summary> /// <param name="p_strCode">The code be parsed.</param> /// <param name="p_ertErrorTracker">The error tracker to use to log /// parsing errors.</param> /// <returns>A CPL parser for the given code.</returns> public AntlrParserBase CreateParser(string p_strCode, ErrorTracker p_ertErrorTracker) { AntlrLexerBase lexLexer = CreateLexer(p_strCode, p_ertErrorTracker); CommonTokenStream ctsTokens = new CommonTokenStream(lexLexer); SkyrimCplParser prsParser = new SkyrimCplParser(ctsTokens, ""); prsParser.SetErrorTracker(p_ertErrorTracker); return prsParser; }
private static CommonTree GetAst(FileInfo file) { var v = new ANTLRFileStream(file.FullName); var lex = new vguiLexer(v); var cts = new CommonTokenStream(lex); var prs = new vguiParser(cts) {TreeAdaptor = new CommonTreeAdaptor()}; return (CommonTree) prs.start().Tree; }
protected override void ReParseImpl() { var outputWindow = OutputWindowService.TryGetPane(PredefinedOutputWindowPanes.TvlIntellisense); try { Stopwatch stopwatch = Stopwatch.StartNew(); var snapshot = TextBuffer.CurrentSnapshot; SnapshotCharStream input = new SnapshotCharStream(snapshot, new Span(0, snapshot.Length)); GoLexer lexer = new GoLexer(input); GoSemicolonInsertionTokenSource tokenSource = new GoSemicolonInsertionTokenSource(lexer); CommonTokenStream tokens = new CommonTokenStream(tokenSource); GoParser parser = new GoParser(tokens); List<ParseErrorEventArgs> errors = new List<ParseErrorEventArgs>(); parser.ParseError += (sender, e) => { errors.Add(e); string message = e.Message; ITextDocument document; if (TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out document) && document != null) { string fileName = document.FilePath; var line = snapshot.GetLineFromPosition(e.Span.Start); message = string.Format("{0}({1},{2}): {3}", fileName, line.LineNumber + 1, e.Span.Start - line.Start.Position + 1, message); } if (message.Length > 100) message = message.Substring(0, 100) + " ..."; if (outputWindow != null) outputWindow.WriteLine(message); if (errors.Count > 100) throw new OperationCanceledException(); }; var result = parser.compilationUnit(); OnParseComplete(new AntlrParseResultEventArgs(snapshot, errors, stopwatch.Elapsed, tokens.GetTokens(), result)); } catch (Exception e) { if (ErrorHandler.IsCriticalException(e)) throw; try { if (outputWindow != null) outputWindow.WriteLine(e.Message); } catch (Exception ex2) { if (ErrorHandler.IsCriticalException(ex2)) throw; } } }
public static void Main(string[] args) { Stream inputStream = Console.OpenStandardInput(); ANTLRInputStream input = new ANTLRInputStream(inputStream); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); parser.stat(); }
static void Main(string[] args) { if (args.Length == 2) { Antlr.Runtime.ANTLRFileStream inStream = new Antlr.Runtime.ANTLRFileStream(args[0]); testLexer lexer = new testLexer(inStream); Emitter emitter = new Emitter(); Antlr.Runtime.CommonTokenStream tokenStream = new Antlr.Runtime.CommonTokenStream(lexer); testParser parser = new testParser(tokenStream, emitter); //вызываем разбор правил programm parser.program(); emitter.SaveMSIL(args[1]); } else { Console.WriteLine("usege: <program> <inputfile> <outputfile>"); Console.ReadKey(); } }