public static Driver Create (string[] args, bool require_files, Func<string [], int, int> unknown_option_parser, ReportPrinter printer) { Driver d = new Driver (new CompilerContext (new Report (printer))); if (!d.ParseArguments (args, require_files, unknown_option_parser)) return null; return d; }
public static Driver Create (string[] args, bool require_files, ReportPrinter printer) { Driver d = new Driver (new CompilerContext (new Report (printer))); if (!d.ParseArguments (args, require_files)) return null; return d; }
public static bool InvokeCompiler(string [] args, TextWriter error) { try { CommandLineParser cmd = new CommandLineParser (error); var setting = cmd.ParseArguments (args); if (setting == null) return false; var d = new Driver (new CompilerContext (setting, new StreamReportPrinter (error))); return d.Compile (); } finally { Reset (); } }
/// <summary> /// Optional initialization for the Evaluator. /// </summary> /// <remarks> /// Initializes the Evaluator with the command line options /// that would be processed by the command line compiler. Only /// the first call to Init will work, any future invocations are /// ignored. /// /// You can safely avoid calling this method if your application /// does not need any of the features exposed by the command line /// interface. /// </remarks> public static void Init (string [] args) { lock (evaluator_lock){ if (inited) return; RootContext.Version = LanguageVersion.Default; driver = Driver.Create (args, false); if (driver == null) throw new Exception ("Failed to create compiler driver with the given arguments"); driver.ProcessDefaultConfig (); CompilerCallableEntryPoint.Reset (); Driver.LoadReferences (); RootContext.EvalMode = true; inited = true; } }
public bool Compile(CompilerOptions options, ErrorReporterWrapper er) { string intermediateAssemblyFile = Path.GetTempFileName(), intermediateDocFile = Path.GetTempFileName(); try { // Compile the assembly var settings = MapSettings(options, intermediateAssemblyFile, intermediateDocFile, er); if (er.HasErrors) return false; if (!options.AlreadyCompiled) { // Compile the assembly var ctx = new CompilerContext(settings, new ConvertingReportPrinter(er)); var d = new Mono.CSharp.Driver(ctx); d.Compile(); if (er.HasErrors) return false; } // Compile the script var md = new MetadataImporter.ScriptSharpMetadataImporter(options.MinimizeScript); var n = new DefaultNamer(); PreparedCompilation compilation = null; var rtl = new ScriptSharpRuntimeLibrary(md, er, n.GetTypeParameterName, tr => { var t = tr.Resolve(compilation.Compilation).GetDefinition(); return new JsTypeReferenceExpression(t.ParentAssembly, md.GetTypeSemantics(t).Name); }); var compiler = new Compiler.Compiler(md, n, rtl, er, allowUserDefinedStructs: options.References.Count == 0 /* We allow user-defined structs in mscorlib only, which can be identified by the fact that it has no references*/); var references = LoadReferences(settings.AssemblyReferences, er); if (references == null) return false; compilation = compiler.CreateCompilation(options.SourceFiles.Select(f => new SimpleSourceFile(f, settings.Encoding)), references, options.DefineConstants); var compiledTypes = compiler.Compile(compilation); var js = new ScriptSharpOOPEmulator(compilation.Compilation, md, rtl, er).Rewrite(compiledTypes, compilation.Compilation); js = new GlobalNamespaceReferenceImporter().ImportReferences(js); if (er.HasErrors) return false; string outputAssemblyPath = !string.IsNullOrEmpty(options.OutputAssemblyPath) ? options.OutputAssemblyPath : Path.ChangeExtension(options.SourceFiles[0], ".dll"); string outputScriptPath = !string.IsNullOrEmpty(options.OutputScriptPath) ? options.OutputScriptPath : Path.ChangeExtension(options.SourceFiles[0], ".js"); if (!options.AlreadyCompiled) { try { File.Copy(intermediateAssemblyFile, outputAssemblyPath, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7950, ex.Message); return false; } if (!string.IsNullOrEmpty(options.DocumentationFile)) { try { File.Copy(intermediateDocFile, options.DocumentationFile, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7952, ex.Message); return false; } } } string script = string.Join("", js.Select(s => options.MinimizeScript ? OutputFormatter.FormatMinified(Minifier.Process(s)) : OutputFormatter.Format(s))); try { File.WriteAllText(outputScriptPath, script, settings.Encoding); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7951, ex.Message); return false; } return true; } catch (Exception ex) { er.Region = DomRegion.Empty; er.InternalError(ex.ToString()); return false; } finally { if (!options.AlreadyCompiled) { try { File.Delete(intermediateAssemblyFile); } catch {} try { File.Delete(intermediateDocFile); } catch {} } } }
public static int Main (string[] args) { Location.InEmacs = Environment.GetEnvironmentVariable ("EMACS") == "t"; CommandLineParser cmd = new CommandLineParser (Console.Out); var settings = cmd.ParseArguments (args); if (settings == null) return 1; if (cmd.HasBeenStopped) return 0; Driver d = new Driver (new CompilerContext (settings, new ConsoleReportPrinter ())); if (d.Compile () && d.Report.Errors == 0) { if (d.Report.Warnings > 0) { Console.WriteLine ("Compilation succeeded - {0} warning(s)", d.Report.Warnings); } Environment.Exit (0); return 0; } Console.WriteLine("Compilation failed: {0} error(s), {1} warnings", d.Report.Errors, d.Report.Warnings); Environment.Exit (1); return 1; }
public static Driver Create (string [] args, bool require_files) { Driver d = new Driver (); if (!d.ParseArguments (args, require_files)) return null; return d; }
public bool Compile(CompilerOptions options, ErrorReporterWrapper er) { string intermediateAssemblyFile = Path.GetTempFileName(), intermediateDocFile = Path.GetTempFileName(); try { // Compile the assembly var settings = MapSettings(options, intermediateAssemblyFile, intermediateDocFile, er); if (er.HasErrors) return false; var ctx = new CompilerContext(settings, new ConvertingReportPrinter(er)); var d = new Mono.CSharp.Driver(ctx); d.Compile(); if (er.HasErrors) return false; // Compile the script var nc = new MetadataImporter.ScriptSharpMetadataImporter(options.MinimizeScript); PreparedCompilation compilation = null; var rtl = new ScriptSharpRuntimeLibrary(nc, tr => { var t = tr.Resolve(compilation.Compilation).GetDefinition(); return new JsTypeReferenceExpression(t.ParentAssembly, nc.GetTypeSemantics(t).Name); }); var compiler = new Saltarelle.Compiler.Compiler.Compiler(nc, rtl, er); var references = LoadReferences(ctx.Settings.AssemblyReferences, er); if (references == null) return false; compilation = compiler.CreateCompilation(options.SourceFiles.Select(f => new SimpleSourceFile(f)), references, options.DefineConstants); var compiledTypes = compiler.Compile(compilation); var js = new OOPEmulator.ScriptSharpOOPEmulator(nc, er).Rewrite(compiledTypes, compilation.Compilation); js = new GlobalNamespaceReferenceImporter().ImportReferences(js); if (er.HasErrors) return false; string outputAssemblyPath = !string.IsNullOrEmpty(options.OutputAssemblyPath) ? options.OutputAssemblyPath : Path.ChangeExtension(options.SourceFiles[0], ".dll"); string outputScriptPath = !string.IsNullOrEmpty(options.OutputScriptPath) ? options.OutputScriptPath : Path.ChangeExtension(options.SourceFiles[0], ".js"); try { File.Copy(intermediateAssemblyFile, outputAssemblyPath, true); } catch (IOException ex) { er.Message(7950, null, TextLocation.Empty, ex.Message); return false; } if (!string.IsNullOrEmpty(options.DocumentationFile)) { try { File.Copy(intermediateDocFile, options.DocumentationFile, true); } catch (IOException ex) { er.Message(7952, null, TextLocation.Empty, ex.Message); return false; } } string script = string.Join("", js.Select(s => OutputFormatter.Format(s, allowIntermediates: false))); try { File.WriteAllText(outputScriptPath, script); } catch (IOException ex) { er.Message(7951, null, TextLocation.Empty, ex.Message); return false; } return true; } catch (Exception ex) { er.InternalError(ex.ToString(), DomRegion.Empty); return false; } finally { try { File.Delete(intermediateAssemblyFile); } catch {} try { File.Delete(intermediateDocFile); } catch {} } }
void ParseStartupFiles () { Driver d = new Driver (ctx); Location.Initialize (ctx.SourceFiles); var parser_session = new ParserSession (); for (int i = 0; i < startup_files; ++i) { var sf = ctx.SourceFiles [i]; d.Parse (sf, module, parser_session, ctx.Report); } }
/// <summary> /// Optional initialization for the Evaluator. /// </summary> /// <remarks> /// Initializes the Evaluator with the command line /// options that would be processed by the command /// line compiler. Only the first call to /// InitAndGetStartupFiles or Init will work, any future /// invocations are ignored. /// /// You can safely avoid calling this method if your application /// does not need any of the features exposed by the command line /// interface. /// /// This method return an array of strings that contains any /// files that were specified in `args'. /// </remarks> public static string [] InitAndGetStartupFiles (string [] args) { lock (evaluator_lock){ if (inited) return new string [0]; driver = Driver.Create (args, false, new ConsoleReportPrinter ()); if (driver == null) throw new Exception ("Failed to create compiler driver with the given arguments"); RootContext.ToplevelTypes = new ModuleContainer (ctx, true); driver.ProcessDefaultConfig (); ArrayList startup_files = new ArrayList (); foreach (CompilationUnit file in Location.SourceFiles) startup_files.Add (file.Path); CompilerCallableEntryPoint.Reset (); RootContext.ToplevelTypes = new ModuleContainer (ctx, true); driver.LoadReferences (); RootContext.EvalMode = true; inited = true; return (string []) startup_files.ToArray (typeof (string)); } }
public CompilationUnit Parse (Stream stream, string fileName, int lineModifier = 0) { lock (parseLock) { errorReportPrinter = new ErrorReportPrinter (""); var ctx = new CompilerContext (CompilerSettings, errorReportPrinter); ctx.Settings.TabSize = 1; var reader = new SeekableStreamReader (stream, Encoding.UTF8); var file = new SourceFile (fileName, fileName, 0); Location.Initialize (new List<SourceFile> (new [] { file })); var module = new ModuleContainer (ctx); var driver = new Driver (ctx); var parser = driver.Parse (reader, file, module); var top = new CompilerCompilationUnit () { ModuleCompiled = module, LocationsBag = parser.LocationsBag, SpecialsBag = parser.Lexer.sbag }; var unit = Parse (top, fileName, lineModifier); unit.Errors.AddRange (errorReportPrinter.Errors); CompilerCallableEntryPoint.Reset (); return unit; } }
public static CompilerCompilationUnit ParseFile (string[] args, Stream input, string inputFile, ReportPrinter reportPrinter) { lock (parseLock) { try { // Driver d = Driver.Create (args, false, null, reportPrinter); // if (d == null) // return null; var r = new Report (reportPrinter); CommandLineParser cmd = new CommandLineParser (r, Console.Out); var setting = cmd.ParseArguments (args); if (setting == null || r.Errors > 0) return null; CompilerContext ctx = new CompilerContext (setting, r); var d = new Driver (ctx); Location.AddFile (null, inputFile); Location.Initialize (); // TODO: encoding from driver SeekableStreamReader reader = new SeekableStreamReader (input, Encoding.Default); RootContext.ToplevelTypes = new ModuleContainer (ctx); CompilationUnit unit = null; try { unit = (CompilationUnit) Location.SourceFiles [0]; } catch (Exception) { string path = Path.GetFullPath (inputFile); unit = new CompilationUnit (inputFile, path, 0); } CSharpParser parser = new CSharpParser (reader, unit, RootContext.ToplevelTypes); parser.Lexer.TabSize = 1; parser.Lexer.sbag = new SpecialsBag (); parser.LocationsBag = new LocationsBag (); parser.UsingsBag = new UsingsBag (); parser.parse (); return new CompilerCompilationUnit () { ModuleCompiled = RootContext.ToplevelTypes, LocationsBag = parser.LocationsBag, UsingsBag = parser.UsingsBag, SpecialsBag = parser.Lexer.sbag }; } finally { Reset (); } } }
public bool Compile(CompilerOptions options, ErrorReporterWrapper er) { string intermediateAssemblyFile = Path.GetTempFileName(), intermediateDocFile = Path.GetTempFileName(); try { // Compile the assembly var settings = MapSettings(options, intermediateAssemblyFile, intermediateDocFile, er); if (er.HasErrors) { return(false); } if (!options.AlreadyCompiled) { // Compile the assembly var ctx = new CompilerContext(settings, new ConvertingReportPrinter(er)); var d = new Mono.CSharp.Driver(ctx); d.Compile(); if (er.HasErrors) { return(false); } } // Compile the script var md = new MetadataImporter.ScriptSharpMetadataImporter(options.MinimizeScript); var n = new DefaultNamer(); PreparedCompilation compilation = null; var rtl = new ScriptSharpRuntimeLibrary(md, er, n.GetTypeParameterName, tr => new JsTypeReferenceExpression(tr.Resolve(compilation.Compilation).GetDefinition())); var compiler = new Compiler.Compiler(md, n, rtl, er, allowUserDefinedStructs: options.References.Count == 0 /* We allow user-defined structs in mscorlib only, which can be identified by the fact that it has no references*/); var references = LoadReferences(settings.AssemblyReferences, er); if (references == null) { return(false); } compilation = compiler.CreateCompilation(options.SourceFiles.Select(f => new SimpleSourceFile(f, settings.Encoding)), references, options.DefineConstants); var compiledTypes = compiler.Compile(compilation); IMethod entryPoint = null; if (options.HasEntryPoint) { List <IMethod> candidates; if (!string.IsNullOrEmpty(options.EntryPointClass)) { var t = compilation.Compilation.MainAssembly.GetTypeDefinition(new FullTypeName(options.EntryPointClass)); if (t == null) { er.Region = DomRegion.Empty; er.Message(7950, "Could not find the entry point class " + options.EntryPointClass + "."); return(false); } candidates = t.Methods.Where(IsEntryPointCandidate).ToList(); } else { candidates = compilation.Compilation.MainAssembly.GetAllTypeDefinitions().SelectMany(t => t.Methods).Where(IsEntryPointCandidate).ToList(); } if (candidates.Count != 1) { er.Region = DomRegion.Empty; er.Message(7950, "Could not find a unique entry point."); return(false); } entryPoint = candidates[0]; } var js = new ScriptSharpOOPEmulator(compilation.Compilation, md, rtl, n, er).Process(compiledTypes, compilation.Compilation, entryPoint); js = new DefaultLinker(md, n).Process(js, compilation.Compilation.MainAssembly); if (er.HasErrors) { return(false); } string outputAssemblyPath = !string.IsNullOrEmpty(options.OutputAssemblyPath) ? options.OutputAssemblyPath : Path.ChangeExtension(options.SourceFiles[0], ".dll"); string outputScriptPath = !string.IsNullOrEmpty(options.OutputScriptPath) ? options.OutputScriptPath : Path.ChangeExtension(options.SourceFiles[0], ".js"); if (!options.AlreadyCompiled) { try { File.Copy(intermediateAssemblyFile, outputAssemblyPath, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7950, ex.Message); return(false); } if (!string.IsNullOrEmpty(options.DocumentationFile)) { try { File.Copy(intermediateDocFile, options.DocumentationFile, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7952, ex.Message); return(false); } } } if (options.MinimizeScript) { js = ((JsBlockStatement)Minifier.Process(new JsBlockStatement(js))).Statements; } string script = string.Join("", js.Select(s => options.MinimizeScript ? OutputFormatter.FormatMinified(s) : OutputFormatter.Format(s))); try { File.WriteAllText(outputScriptPath, script, settings.Encoding); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7951, ex.Message); return(false); } return(true); } catch (Exception ex) { er.Region = DomRegion.Empty; er.InternalError(ex.ToString()); return(false); } finally { if (!options.AlreadyCompiled) { try { File.Delete(intermediateAssemblyFile); } catch {} try { File.Delete(intermediateDocFile); } catch {} } } }
/// <summary> /// Optional initialization for the Evaluator. /// </summary> /// <remarks> /// Initializes the Evaluator with the command line /// options that would be processed by the command /// line compiler. Only the first call to /// InitAndGetStartupFiles or Init will work, any future /// invocations are ignored. /// /// You can safely avoid calling this method if your application /// does not need any of the features exposed by the command line /// interface. /// /// This method return an array of strings that contains any /// files that were specified in `args'. /// /// If the unknownOptionParser is not null, this function is invoked /// with the current args array and the index of the option that is not /// known. A value of true means that the value was processed, otherwise /// it will be reported as an error /// </remarks> public static string [] InitAndGetStartupFiles (string [] args, Func<string [], int, int> unknownOptionParser) { lock (evaluator_lock){ if (inited) return new string [0]; CompilerCallableEntryPoint.Reset (); var crp = new ConsoleReportPrinter (); driver = Driver.Create (args, false, unknownOptionParser, crp); if (driver == null) throw new Exception ("Failed to create compiler driver with the given arguments"); crp.Fatal = driver.fatal_errors; ctx = driver.ctx; RootContext.ToplevelTypes = new ModuleContainer (ctx); var startup_files = new List<string> (); foreach (CompilationUnit file in Location.SourceFiles) startup_files.Add (file.Path); CompilerCallableEntryPoint.PartialReset (); var importer = new ReflectionImporter (ctx.BuildinTypes); loader = new DynamicLoader (importer, ctx); RootContext.ToplevelTypes.SetDeclaringAssembly (new AssemblyDefinitionDynamic (RootContext.ToplevelTypes, "temp")); loader.LoadReferences (RootContext.ToplevelTypes); ctx.BuildinTypes.CheckDefinitions (RootContext.ToplevelTypes); RootContext.ToplevelTypes.InitializePredefinedTypes (); RootContext.EvalMode = true; inited = true; return startup_files.ToArray (); } }
public bool Compile(CompilerOptions options, ErrorReporterWrapper er) { string intermediateAssemblyFile = Path.GetTempFileName(), intermediateDocFile = Path.GetTempFileName(); try { // Compile the assembly var settings = MapSettings(options, intermediateAssemblyFile, intermediateDocFile, er); if (er.HasErrors) { return(false); } if (!options.AlreadyCompiled) { // Compile the assembly var ctx = new CompilerContext(settings, new ConvertingReportPrinter(er)); var d = new Mono.CSharp.Driver(ctx); d.Compile(); if (er.HasErrors) { return(false); } } var references = LoadReferences(settings.AssemblyReferences, er); if (references == null) { return(false); } PreparedCompilation compilation = PreparedCompilation.CreateCompilation(options.SourceFiles.Select(f => new SimpleSourceFile(f, settings.Encoding)), references.Select(r => r.Item1), options.DefineConstants); IMethod entryPoint = FindEntryPoint(options, er, compilation); var container = new WindsorContainer(); foreach (var plugin in TopologicalSortPlugins(references).Reverse()) { RegisterPlugin(container, plugin); } // Compile the script container.Register(Component.For <IErrorReporter>().Instance(er), Component.For <CompilerOptions>().Instance(options), Component.For <ICompilation>().Instance(compilation.Compilation), Component.For <ICompiler>().ImplementedBy <Compiler.Compiler>() ); container.Resolve <IMetadataImporter>().Prepare(compilation.Compilation.GetAllTypeDefinitions()); var compiledTypes = container.Resolve <ICompiler>().Compile(compilation); foreach (var rewriter in container.ResolveAll <IJSTypeSystemRewriter>()) { compiledTypes = rewriter.Rewrite(compiledTypes); } var js = container.Resolve <IOOPEmulator>().Process(compiledTypes, entryPoint); js = container.Resolve <ILinker>().Process(js); if (er.HasErrors) { return(false); } string outputAssemblyPath = !string.IsNullOrEmpty(options.OutputAssemblyPath) ? options.OutputAssemblyPath : Path.ChangeExtension(options.SourceFiles[0], ".dll"); string outputScriptPath = !string.IsNullOrEmpty(options.OutputScriptPath) ? options.OutputScriptPath : Path.ChangeExtension(options.SourceFiles[0], ".js"); if (!options.AlreadyCompiled) { try { File.Copy(intermediateAssemblyFile, outputAssemblyPath, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(Messages._7950, ex.Message); return(false); } if (!string.IsNullOrEmpty(options.DocumentationFile)) { try { File.Copy(intermediateDocFile, options.DocumentationFile, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(Messages._7952, ex.Message); return(false); } } } if (options.MinimizeScript) { js = ((JsBlockStatement)Minifier.Process(new JsBlockStatement(js))).Statements; } string script = string.Join("", js.Select(s => options.MinimizeScript ? OutputFormatter.FormatMinified(s) : OutputFormatter.Format(s))); try { File.WriteAllText(outputScriptPath, script, settings.Encoding); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(Messages._7951, ex.Message); return(false); } return(true); } catch (Exception ex) { er.Region = DomRegion.Empty; er.InternalError(ex.ToString()); return(false); } finally { if (!options.AlreadyCompiled) { try { File.Delete(intermediateAssemblyFile); } catch {} try { File.Delete(intermediateDocFile); } catch {} } } }
/// <summary> /// Optional initialization for the Evaluator. /// </summary> /// <remarks> /// Initializes the Evaluator with the command line /// options that would be processed by the command /// line compiler. Only the first call to /// InitAndGetStartupFiles or Init will work, any future /// invocations are ignored. /// /// You can safely avoid calling this method if your application /// does not need any of the features exposed by the command line /// interface. /// /// This method return an array of strings that contains any /// files that were specified in `args'. /// </remarks> public static string [] InitAndGetStartupFiles (string [] args) { lock (evaluator_lock){ if (inited) return new string [0]; driver = Driver.Create (args, false, new ConsoleReportPrinter ()); if (driver == null) throw new Exception ("Failed to create compiler driver with the given arguments"); ctx = driver.ctx; RootContext.ToplevelTypes = new ModuleCompiled (ctx, true); driver.ProcessDefaultConfig (); var startup_files = new List<string> (); foreach (CompilationUnit file in Location.SourceFiles) startup_files.Add (file.Path); CompilerCallableEntryPoint.Reset (); RootContext.ToplevelTypes = new ModuleCompiled (ctx, true); var ctypes = TypeManager.InitCoreTypes (); ctx.MetaImporter.Initialize (); driver.LoadReferences (); TypeManager.InitCoreTypes (ctx, ctypes); TypeManager.InitOptionalCoreTypes (ctx); RootContext.EvalMode = true; inited = true; return startup_files.ToArray (); } }
public bool Compile(CompilerOptions options) { string intermediateAssemblyFile = Path.GetTempFileName(), intermediateDocFile = Path.GetTempFileName(); var actualOut = Console.Out; var er = new ErrorReporterWrapper(_errorReporter, actualOut); try { Console.SetOut(new StringWriter()); // I don't trust the third-party libs to not generate spurious random messages, so make sure that any of those messages are suppressed. var settings = MapSettings(options, intermediateAssemblyFile, intermediateDocFile, er); if (er.HasErrors) return false; if (!options.AlreadyCompiled) { // Compile the assembly var ctx = new CompilerContext(settings, new ConvertingReportPrinter(er)); var d = new Mono.CSharp.Driver(ctx); d.Compile(); if (er.HasErrors) return false; } var references = LoadReferences(settings.AssemblyReferences, er); if (references == null) return false; PreparedCompilation compilation = PreparedCompilation.CreateCompilation(settings.AssemblyName, options.SourceFiles.Select(f => new SimpleSourceFile(f, settings.Encoding)), references.Select(r => r.Item1), options.DefineConstants, LoadResources(options.EmbeddedResources)); IMethod entryPoint = FindEntryPoint(options, er, compilation); var container = new WindsorContainer(); foreach (var plugin in TopologicalSortPlugins(references).Reverse()) RegisterPlugin(container, plugin); container.Register(Component.For<IErrorReporter>().Instance(er), Component.For<CompilerOptions>().Instance(options), Component.For<ICompilation>().Instance(compilation.Compilation), Component.For<ICompiler>().ImplementedBy<Compiler.Compiler>() ); container.Resolve<IMetadataImporter>().Prepare(compilation.Compilation.GetAllTypeDefinitions()); var compiledTypes = container.Resolve<ICompiler>().Compile(compilation); foreach (var rewriter in container.ResolveAll<IJSTypeSystemRewriter>()) compiledTypes = rewriter.Rewrite(compiledTypes); var invoker = new OOPEmulatorInvoker(container.Resolve<IOOPEmulator>(), container.Resolve<IMetadataImporter>(), container.Resolve<IErrorReporter>()); var js = invoker.Process(compiledTypes.ToList(), entryPoint); js = container.Resolve<ILinker>().Process(js); if (er.HasErrors) return false; string outputAssemblyPath = !string.IsNullOrEmpty(options.OutputAssemblyPath) ? options.OutputAssemblyPath : Path.ChangeExtension(options.SourceFiles[0], ".dll"); string outputScriptPath = !string.IsNullOrEmpty(options.OutputScriptPath) ? options.OutputScriptPath : Path.ChangeExtension(options.SourceFiles[0], ".js"); if (!options.AlreadyCompiled) { try { File.Copy(intermediateAssemblyFile, outputAssemblyPath, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(Messages._7950, ex.Message); return false; } if (!string.IsNullOrEmpty(options.DocumentationFile)) { try { File.Copy(intermediateDocFile, options.DocumentationFile, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(Messages._7952, ex.Message); return false; } } } if (options.MinimizeScript) { js = ((JsBlockStatement)Minifier.Process(JsStatement.Block(js))).Statements; } string script = options.MinimizeScript ? OutputFormatter.FormatMinified(js) : OutputFormatter.Format(js); try { File.WriteAllText(outputScriptPath, script, settings.Encoding); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(Messages._7951, ex.Message); return false; } return true; } catch (Exception ex) { er.Region = DomRegion.Empty; er.InternalError(ex.ToString()); return false; } finally { if (!options.AlreadyCompiled) { try { File.Delete(intermediateAssemblyFile); } catch {} try { File.Delete(intermediateDocFile); } catch {} } if (actualOut != null) { Console.SetOut(actualOut); } } }
void ParseStartupFiles () { Driver d = new Driver (ctx); Location.Initialize (ctx.SourceFiles); for (int i = 0; i < startup_files; ++i) { var sf = ctx.SourceFiles [i]; d.Parse (sf, module); } }
public bool Compile(CompilerOptions options, ErrorReporterWrapper er) { string intermediateAssemblyFile = Path.GetTempFileName(), intermediateDocFile = Path.GetTempFileName(); try { // Compile the assembly var settings = MapSettings(options, intermediateAssemblyFile, intermediateDocFile, er); if (er.HasErrors) { return(false); } if (!options.AlreadyCompiled) { // Compile the assembly var ctx = new CompilerContext(settings, new ConvertingReportPrinter(er)); var d = new Mono.CSharp.Driver(ctx); d.Compile(); if (er.HasErrors) { return(false); } } // Compile the script var md = new MetadataImporter.ScriptSharpMetadataImporter(options.MinimizeScript); var n = new DefaultNamer(); PreparedCompilation compilation = null; var rtl = new ScriptSharpRuntimeLibrary(md, er, n.GetTypeParameterName, tr => { var t = tr.Resolve(compilation.Compilation).GetDefinition(); return(new JsTypeReferenceExpression(t.ParentAssembly, md.GetTypeSemantics(t).Name)); }); var compiler = new Compiler.Compiler(md, n, rtl, er, allowUserDefinedStructs: options.References.Count == 0 /* We allow user-defined structs in mscorlib only, which can be identified by the fact that it has no references*/); var references = LoadReferences(settings.AssemblyReferences, er); if (references == null) { return(false); } compilation = compiler.CreateCompilation(options.SourceFiles.Select(f => new SimpleSourceFile(f, settings.Encoding)), references, options.DefineConstants); var compiledTypes = compiler.Compile(compilation); var js = new ScriptSharpOOPEmulator(compilation.Compilation, md, rtl, er).Rewrite(compiledTypes, compilation.Compilation); js = new GlobalNamespaceReferenceImporter().ImportReferences(js); if (er.HasErrors) { return(false); } string outputAssemblyPath = !string.IsNullOrEmpty(options.OutputAssemblyPath) ? options.OutputAssemblyPath : Path.ChangeExtension(options.SourceFiles[0], ".dll"); string outputScriptPath = !string.IsNullOrEmpty(options.OutputScriptPath) ? options.OutputScriptPath : Path.ChangeExtension(options.SourceFiles[0], ".js"); if (!options.AlreadyCompiled) { try { File.Copy(intermediateAssemblyFile, outputAssemblyPath, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7950, ex.Message); return(false); } if (!string.IsNullOrEmpty(options.DocumentationFile)) { try { File.Copy(intermediateDocFile, options.DocumentationFile, true); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7952, ex.Message); return(false); } } } string script = string.Join("", js.Select(s => options.MinimizeScript ? OutputFormatter.FormatMinified(Minifier.Process(s)) : OutputFormatter.Format(s))); try { File.WriteAllText(outputScriptPath, script, settings.Encoding); } catch (IOException ex) { er.Region = DomRegion.Empty; er.Message(7951, ex.Message); return(false); } return(true); } catch (Exception ex) { er.Region = DomRegion.Empty; er.InternalError(ex.ToString()); return(false); } finally { if (!options.AlreadyCompiled) { try { File.Delete(intermediateAssemblyFile); } catch {} try { File.Delete(intermediateDocFile); } catch {} } } }