public IEnumerable<CompileError> GetDiagnostics(string programText) { ScriptEngine py = null; SourceUnit src = null; LanguageContext pythonLanguageContext = null; CompilerContext cc = null; IronPython.PythonOptions pyOptions; IronPython.Compiler.Parser pyParser = null; IEnumerable<CompileError> errorList = Enumerable.Empty<CompileError>(); try { py = IronPython.Hosting.Python.CreateEngine(); src = HostingHelpers.GetSourceUnit(py.CreateScriptSourceFromString(programText)); pythonLanguageContext = HostingHelpers.GetLanguageContext(py); cc = new CompilerContext(src, pythonLanguageContext.GetCompilerOptions(), ErrorSink.Default); pyOptions = pythonLanguageContext.Options as IronPython.PythonOptions; pyParser = Parser.CreateParser(cc, pyOptions); pyParser.ParseFile(true); } catch (Microsoft.Scripting.SyntaxErrorException e) { CompileError syntaxError = new CompileError(e.Message, new FileSpan(e.RawSpan.Start.Line, e.RawSpan.Start.Column, e.RawSpan.End.Line, e.RawSpan.End.Column)); errorList = errorList.Concat(new[] { syntaxError }); } finally { pyParser?.Dispose(); } return errorList; }
public DocumentationComment Parse(ProjectDom dom, string fileName, string content) { var document = new DocumentationComment(fileName); var compilationUnit = new PythonCompilationUnit(fileName); document.CompilationUnit = compilationUnit; if (String.IsNullOrEmpty(content)) { return(document); } var scriptSource = pythonEngine.CreateScriptSourceFromString(content, SourceCodeKind.File); var context = new CompilerContext(HostingHelpers.GetSourceUnit(scriptSource), compilerOptions, ErrorSink.Default); var parser = IronPythonParserEngine.CreateParser(context, langOptions); IronPythonAst ast = null; try { ast = parser.ParseFile(false); } catch (SyntaxErrorException exc) { // We could likely improve the error message document.Errors.Add(new Error(exc.Line, exc.Column, exc.Message)); return(document); } walker.Reset(); ast.Walk(walker); compilationUnit.Module = walker.Module; compilationUnit.Build(); return(document); }
public CodeFile Parse(string programText, string fileName) { ScriptEngine py = null; SourceUnit src = null; LanguageContext pythonLanguageContext = null; CompilerContext cc = null; IronPython.PythonOptions pyOptions; IronPython.Compiler.Parser pyParser = null; PythonAst ast = null; try { py = IronPython.Hosting.Python.CreateEngine(); src = HostingHelpers.GetSourceUnit(py.CreateScriptSourceFromString(programText)); pythonLanguageContext = HostingHelpers.GetLanguageContext(py); cc = new CompilerContext(src, pythonLanguageContext.GetCompilerOptions(), ErrorSink.Default); pyOptions = pythonLanguageContext.Options as IronPython.PythonOptions; pyParser = Parser.CreateParser(cc, pyOptions); ast = pyParser.ParseFile(true); } finally { pyParser?.Dispose(); } PythonEntityCollector collector = new PythonEntityCollector(); ast.Walk(collector); var cf = collector.getCodeFile(); cf.Name = String.IsNullOrWhiteSpace(fileName) ? $"{rm.GetString("PythonString", CultureInfo.CurrentCulture)}" : fileName; return cf; }
public static PythonAst ParseFile(string path) { var py = Python.CreateEngine(); var src = HostingHelpers.GetSourceUnit(py.CreateScriptSourceFromFile(path)); return(Parse(src, py)); }
public static PythonAst ParseContent(string content) { var py = Python.CreateEngine(); var src = HostingHelpers.GetSourceUnit(py.CreateScriptSourceFromString(content)); return(Parse(src, py)); }
private static void Transformator(object context) { ThreadContext p = (ThreadContext)context; ScriptRuntime runtime = Python.CreateRuntime(); ScriptEngine engine = runtime.GetEngine("py"); LanguageContext languageContext = HostingHelpers.GetLanguageContext(engine); while (p.Running) { string pySrc; if (p.Queue.TryDequeue(out pySrc)) { LocalSink sink = new LocalSink(); try { SourceUnit src = HostingHelpers.GetSourceUnit(engine.CreateScriptSourceFromString(pySrc)); CompilerContext ctx = new CompilerContext(src, languageContext.GetCompilerOptions(), sink); Parser parser = Parser.CreateParser(ctx, (PythonOptions)languageContext.Options); PythonAst ast = parser.ParseFile(true); JavascriptGenerator generator = new JavascriptGenerator(src, sink); if (sink.IsError) { p.SetOutput(null); } else { p.SetOutput(generator.ToJavaScript(ast)); } } catch (Exception e) { if (!sink.IsError) { p.SetOutput(e.ToString()); } } finally { p.SetErrors(sink.Messages); } } else { Thread.Sleep(50); if (p.Queue.Count == 0) { p.Suspend(); } } } }
private PythonAst ParsePythonFile(string path) { var pythonEngine = Python.CreateEngine(); var pythonSource = pythonEngine.CreateScriptSourceFromFile(path); var pythonSourceUnit = HostingHelpers.GetSourceUnit(pythonSource); var context = new CompilerContext(pythonSourceUnit, pythonEngine.GetCompilerOptions(), ErrorSink.Default); var options = new PythonOptions(); var parser = Parser.CreateParser(context, options); return(parser.ParseFile(false)); }
public void Parse() { var srcunit = HostingHelpers.GetSourceUnit(source); var parser = new IronRuby.Compiler.Parser(errorSink); ast = parser.Parse(srcunit, new RubyCompilerOptions(), errorSink); var transformer = new Transformer.Transformer(ast); transformations = transformer.Transform(); }
protected override bool ShouldEvaluateForCompletion(string source) { var scriptSrc = _localEngine.CreateScriptSource(new StringTextContentProvider(source), "", SourceCodeKind.Expression); var context = new CompilerContext(HostingHelpers.GetSourceUnit(scriptSrc), HostingHelpers.GetLanguageContext(_localEngine).GetCompilerOptions(), ErrorSink.Null); var parser = Parser.CreateParser(context, new PythonOptions()); var stmt = parser.ParseSingleStatement(); var exprWalker = new ExprWalker(); stmt.Walk(exprWalker); return(exprWalker.ShouldExecute); }
//spawns the python compiler and analyzes a script // outputs: ParseInfo class containing: // errors // python ast public ParseInfo Parse(string source) { var parseErrorSink = new ScriptErrorSink(); ScriptSource script_source = scriptEngine.CreateScriptSourceFromString(source, SourceCodeKind.File); var source_unit = HostingHelpers.GetSourceUnit(script_source); var language_context = HostingHelpers.GetLanguageContext(scriptEngine); Parser parser = Parser.CreateParser( new CompilerContext(source_unit, language_context.GetCompilerOptions(), parseErrorSink), (PythonOptions)language_context.Options); var python_ast = parser.ParseFile(false); var info = new ParseInfo(parseErrorSink.Errors, python_ast); //no need for that //var walker = new TurtleScriptAstWalker(info); //python_ast.Walk(walker); return(info); }
private void ParsePythonCode(TextContentProvider content, out PythonAst ast, out CollectingErrorSink errorSink) { ast = null; errorSink = new CollectingErrorSink(); // parse the tree var source = _engine.CreateScriptSource(content, "", SourceCodeKind.File); var compOptions = (PythonCompilerOptions)HostingHelpers.GetLanguageContext(_engine).GetCompilerOptions(); var context = new CompilerContext(HostingHelpers.GetSourceUnit(source), compOptions, errorSink); //compOptions.Verbatim = true; using (var parser = MakeParser(context)) { if (parser != null) { try { ast = parser.ParseFile(false); } catch (Exception e) { Debug.Assert(false, String.Format("Failure in IronPython parser: {0}", e.ToString())); } } } }
internal PythonScript ParseScript(string filename, string content) { var sourceUnit = HostingHelpers.GetSourceUnit( _engine.CreateScriptSourceFromString(content, filename, SourceCodeKind.File)); var compilerContext = new CompilerContext(sourceUnit, _compilerOptions, ErrorSink.Default); var options = new PythonOptions(); var parser = Parser.CreateParser(compilerContext, options); PythonAst ast; try { ast = parser.ParseFile(false); } catch (SyntaxErrorException e) { throw new ArgumentException($"Failed to parse file '{filename}' at line {e.Line}.", e); } return(new PythonScript(filename, content, ast)); }
private PythonAst ParseSnippet(string snippet) { var sourceUnit = HostingHelpers.GetSourceUnit( _engine.CreateScriptSourceFromString(snippet, SourceCodeKind.SingleStatement)); var compilerContext = new CompilerContext(sourceUnit, _compilerOptions, ErrorSink.Default); var options = new PythonOptions(); var parser = Parser.CreateParser(compilerContext, options); PythonAst ast; try { ast = parser.ParseSingleStatement(); } catch (SyntaxErrorException e) { throw new ArgumentException($"Failed to parse snippet '{snippet}'.", e); } return(ast); }
private Parser CreatePythonParser(string script) { var src = HostingHelpers.GetSourceUnit(Engine.CreateScriptSourceFromString(script)); return(Parser.CreateParser(new CompilerContext(src, Engine.GetCompilerOptions(), ErrorSink.Default), new PythonOptions())); }
public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { throw new SyntaxErrorException(message, HostingHelpers.GetSourceUnit(source), span, errorCode, severity); }