public static DynamicContext Create() { if (dc != null) { return(dc); } lock (compiler_initializer) { if (dc != null) { return(dc); } var settings = new Compiler.CompilerSettings() { WarningLevel = 0 }; var cc = new Compiler.CompilerContext(settings, ErrorPrinter.Instance) { IsRuntimeBinder = true }; // // Any later loaded assemblies are handled internally by GetAssemblyDefinition // domain.AssemblyLoad cannot be used as that would be too destructive as we // would hold all loaded assemblies even if they can be never visited // // TODO: Remove this code and rely on GetAssemblyDefinition only // var module = new Compiler.ModuleContainer(cc); module.HasTypesFullyDefined = true; // Setup fake assembly, it's used mostly to simplify checks like friend-access var temp = new Compiler.AssemblyDefinitionDynamic(module, "dynamic"); module.SetDeclaringAssembly(temp); var importer = new Compiler.ReflectionImporter(module, cc.BuiltinTypes) { IgnorePrivateMembers = false, IgnoreCompilerGeneratedField = false }; // Import all currently loaded assemblies // TODO: Rewrite this to populate type cache on-demand, that should greatly // reduce our start-up cost var domain = AppDomain.CurrentDomain; foreach (var a in AppDomain.CurrentDomain.GetAssemblies()) { importer.ImportAssembly(a, module.GlobalRootNamespace); } cc.BuiltinTypes.CheckDefinitions(module); module.InitializePredefinedTypes(); dc = new DynamicContext(module, importer); } return(dc); }
void Init() { var loader = new DynamicLoader(importer, ctx); RootContext.ToplevelTypes = module; //var startup_files = new List<string> (); //foreach (CompilationUnit file in Location.SourceFiles) // startup_files.Add (file.Path); loader.LoadReferences(module); ctx.BuiltinTypes.CheckDefinitions(module); module.InitializePredefinedTypes(); inited = true; }
// // Main compilation method // public bool Compile() { var settings = ctx.Settings; // // If we are an exe, require a source file for the entry point or // if there is nothing to put in the assembly, and we are not a library // if (settings.FirstSourceFile == null && ((settings.Target == Target.Exe || settings.Target == Target.WinExe || settings.Target == Target.Module) || settings.Resources == null)) { Report.Error(2008, "No files to compile were specified"); return(false); } TimeReporter tr = new TimeReporter(settings.Timestamps); ctx.TimeReporter = tr; tr.StartTotal(); var module = new ModuleContainer(ctx); RootContext.ToplevelTypes = module; tr.Start(TimeReporter.TimerType.ParseTotal); Parse(module); tr.Stop(TimeReporter.TimerType.ParseTotal); if (Report.Errors > 0) { return(false); } if (settings.TokenizeOnly || settings.ParseOnly) { tr.StopTotal(); tr.ShowStats(); return(true); } var output_file = settings.OutputFile; string output_file_name; if (output_file == null) { var source_file = settings.FirstSourceFile; if (source_file == null) { Report.Error(1562, "If no source files are specified you must specify the output file with -out:"); return(false); } output_file_name = source_file.Name; int pos = output_file_name.LastIndexOf('.'); if (pos > 0) { output_file_name = output_file_name.Substring(0, pos); } output_file_name += settings.TargetExt; output_file = output_file_name; } else { output_file_name = Path.GetFileName(output_file); } #if STATIC var importer = new StaticImporter(module); var references_loader = new StaticLoader(importer, ctx); tr.Start(TimeReporter.TimerType.AssemblyBuilderSetup); var assembly = new AssemblyDefinitionStatic(module, references_loader, output_file_name, output_file); assembly.Create(references_loader.Domain); tr.Stop(TimeReporter.TimerType.AssemblyBuilderSetup); // Create compiler types first even before any referenced // assembly is loaded to allow forward referenced types from // loaded assembly into compiled builder to be resolved // correctly tr.Start(TimeReporter.TimerType.CreateTypeTotal); module.CreateType(); importer.AddCompiledAssembly(assembly); tr.Stop(TimeReporter.TimerType.CreateTypeTotal); references_loader.LoadReferences(module); tr.Start(TimeReporter.TimerType.PredefinedTypesInit); if (!ctx.BuiltinTypes.CheckDefinitions(module)) { return(false); } tr.Stop(TimeReporter.TimerType.PredefinedTypesInit); references_loader.LoadModules(assembly, module.GlobalRootNamespace); #else var assembly = new AssemblyDefinitionDynamic(module, output_file_name, output_file); module.SetDeclaringAssembly(assembly); var importer = new ReflectionImporter(module, ctx.BuiltinTypes); assembly.Importer = importer; var loader = new DynamicLoader(importer, ctx); loader.LoadReferences(module); if (!ctx.BuiltinTypes.CheckDefinitions(module)) { return(false); } if (!assembly.Create(AppDomain.CurrentDomain, AssemblyBuilderAccess.Save)) { return(false); } module.CreateType(); loader.LoadModules(assembly, module.GlobalRootNamespace); #endif module.InitializePredefinedTypes(); tr.Start(TimeReporter.TimerType.UsingResolve); foreach (var source_file in ctx.SourceFiles) { source_file.NamespaceContainer.Resolve(); } tr.Stop(TimeReporter.TimerType.UsingResolve); tr.Start(TimeReporter.TimerType.ModuleDefinitionTotal); module.Define(); tr.Stop(TimeReporter.TimerType.ModuleDefinitionTotal); if (Report.Errors > 0) { return(false); } if (settings.DocumentationFile != null) { var doc = new DocumentationBuilder(module); doc.OutputDocComment(output_file, settings.DocumentationFile); } assembly.Resolve(); if (Report.Errors > 0) { return(false); } tr.Start(TimeReporter.TimerType.EmitTotal); assembly.Emit(); tr.Stop(TimeReporter.TimerType.EmitTotal); if (Report.Errors > 0) { return(false); } tr.Start(TimeReporter.TimerType.CloseTypes); module.CloseType(); tr.Stop(TimeReporter.TimerType.CloseTypes); tr.Start(TimeReporter.TimerType.Resouces); assembly.EmbedResources(); tr.Stop(TimeReporter.TimerType.Resouces); if (Report.Errors > 0) { return(false); } assembly.Save(); #if STATIC references_loader.Dispose(); #endif tr.StopTotal(); tr.ShowStats(); return(Report.Errors == 0); }
// // Main compilation method // public bool Compile () { var settings = ctx.Settings; // // If we are an exe, require a source file for the entry point or // if there is nothing to put in the assembly, and we are not a library // if (settings.FirstSourceFile == null && ((settings.Target == Target.Exe || settings.Target == Target.WinExe || settings.Target == Target.Module) || settings.Resources == null)) { Report.Error (2008, "No files to compile were specified"); return false; } if (settings.Platform == Platform.AnyCPU32Preferred && (settings.Target == Target.Library || settings.Target == Target.Module)) { Report.Error (4023, "Platform option `anycpu32bitpreferred' is valid only for executables"); return false; } TimeReporter tr = new TimeReporter (settings.Timestamps); ctx.TimeReporter = tr; tr.StartTotal (); var module = new ModuleContainer (ctx); RootContext.ToplevelTypes = module; tr.Start (TimeReporter.TimerType.ParseTotal); Parse (module); tr.Stop (TimeReporter.TimerType.ParseTotal); if (Report.Errors > 0) return false; if (settings.TokenizeOnly || settings.ParseOnly) { tr.StopTotal (); tr.ShowStats (); return true; } var output_file = settings.OutputFile; string output_file_name; if (output_file == null) { var source_file = settings.FirstSourceFile; if (source_file == null) { Report.Error (1562, "If no source files are specified you must specify the output file with -out:"); return false; } output_file_name = source_file.Name; int pos = output_file_name.LastIndexOf ('.'); if (pos > 0) output_file_name = output_file_name.Substring (0, pos); output_file_name += settings.TargetExt; output_file = output_file_name; } else { output_file_name = Path.GetFileName (output_file); if (string.IsNullOrEmpty (Path.GetFileNameWithoutExtension (output_file_name)) || output_file_name.IndexOfAny (Path.GetInvalidFileNameChars ()) >= 0) { Report.Error (2021, "Output file name is not valid"); return false; } } #if STATIC var importer = new StaticImporter (module); var references_loader = new StaticLoader (importer, ctx); tr.Start (TimeReporter.TimerType.AssemblyBuilderSetup); var assembly = new AssemblyDefinitionStatic (module, references_loader, output_file_name, output_file); assembly.Create (references_loader.Domain); tr.Stop (TimeReporter.TimerType.AssemblyBuilderSetup); // Create compiler types first even before any referenced // assembly is loaded to allow forward referenced types from // loaded assembly into compiled builder to be resolved // correctly tr.Start (TimeReporter.TimerType.CreateTypeTotal); module.CreateContainer (); importer.AddCompiledAssembly (assembly); tr.Stop (TimeReporter.TimerType.CreateTypeTotal); references_loader.LoadReferences (module); tr.Start (TimeReporter.TimerType.PredefinedTypesInit); if (!ctx.BuiltinTypes.CheckDefinitions (module)) return false; tr.Stop (TimeReporter.TimerType.PredefinedTypesInit); references_loader.LoadModules (assembly, module.GlobalRootNamespace); #else var assembly = new AssemblyDefinitionDynamic (module, output_file_name, output_file); module.SetDeclaringAssembly (assembly); var importer = new ReflectionImporter (module, ctx.BuiltinTypes); assembly.Importer = importer; var loader = new DynamicLoader (importer, ctx); loader.LoadReferences (module); if (!ctx.BuiltinTypes.CheckDefinitions (module)) return false; if (!assembly.Create (AppDomain.CurrentDomain, AssemblyBuilderAccess.Save)) return false; module.CreateContainer (); loader.LoadModules (assembly, module.GlobalRootNamespace); #endif module.InitializePredefinedTypes (); tr.Start (TimeReporter.TimerType.ModuleDefinitionTotal); module.Define (); tr.Stop (TimeReporter.TimerType.ModuleDefinitionTotal); if (Report.Errors > 0) return false; if (settings.DocumentationFile != null) { var doc = new DocumentationBuilder (module); doc.OutputDocComment (output_file, settings.DocumentationFile); } assembly.Resolve (); if (Report.Errors > 0) return false; tr.Start (TimeReporter.TimerType.EmitTotal); assembly.Emit (); tr.Stop (TimeReporter.TimerType.EmitTotal); if (Report.Errors > 0){ return false; } tr.Start (TimeReporter.TimerType.CloseTypes); module.CloseContainer (); tr.Stop (TimeReporter.TimerType.CloseTypes); tr.Start (TimeReporter.TimerType.Resouces); if (!settings.WriteMetadataOnly) assembly.EmbedResources (); tr.Stop (TimeReporter.TimerType.Resouces); if (Report.Errors > 0) return false; assembly.Save (); #if STATIC references_loader.Dispose (); #endif tr.StopTotal (); tr.ShowStats (); return Report.Errors == 0; }
public static DynamicContext Create () { if (dc != null) return dc; lock (compiler_initializer) { if (dc != null) return dc; var reporter = new Compiler.Report (ErrorPrinter.Instance) { WarningLevel = 0 }; var cc = new Compiler.CompilerContext (reporter) { IsRuntimeBinder = true }; //IList<Compiler.PredefinedTypeSpec> core_types = null; //// HACK: To avoid re-initializing static TypeManager types, like string_type //if (!Compiler.RootContext.EvalMode) { // core_types = Compiler.TypeManager.InitCoreTypes (); //} // // Any later loaded assemblies are handled internally by GetAssemblyDefinition // domain.AssemblyLoad cannot be used as that would be too destructive as we // would hold all loaded assemblies even if they can be never visited // // TODO: Remove this code and rely on GetAssemblyDefinition only // var module = new Compiler.ModuleContainer (cc); var temp = new Compiler.AssemblyDefinitionDynamic (module, "dynamic"); module.SetDeclaringAssembly (temp); // Import all currently loaded assemblies var domain = AppDomain.CurrentDomain; temp.Create (domain, System.Reflection.Emit.AssemblyBuilderAccess.Run); var importer = new Compiler.ReflectionImporter (cc.BuildinTypes) { IgnorePrivateMembers = false }; Compiler.RootContext.ToplevelTypes = module; foreach (var a in AppDomain.CurrentDomain.GetAssemblies ()) { importer.ImportAssembly (a, module.GlobalRootNamespace); } if (!Compiler.RootContext.EvalMode) { cc.BuildinTypes.CheckDefinitions (module); module.InitializePredefinedTypes (); } dc = new DynamicContext (module, importer); } return dc; }
public static DynamicContext Create() { if (dc != null) { return(dc); } lock (compiler_initializer) { if (dc != null) { return(dc); } var reporter = new Compiler.Report(ErrorPrinter.Instance) { WarningLevel = 0 }; var settings = new Compiler.CompilerSettings(); var cc = new Compiler.CompilerContext(settings, reporter) { IsRuntimeBinder = true }; //IList<Compiler.PredefinedTypeSpec> core_types = null; //// HACK: To avoid re-initializing static TypeManager types, like string_type //if (!Compiler.RootContext.EvalMode) { // core_types = Compiler.TypeManager.InitCoreTypes (); //} // // Any later loaded assemblies are handled internally by GetAssemblyDefinition // domain.AssemblyLoad cannot be used as that would be too destructive as we // would hold all loaded assemblies even if they can be never visited // // TODO: Remove this code and rely on GetAssemblyDefinition only // var module = new Compiler.ModuleContainer(cc); module.HasTypesFullyDefined = true; var temp = new Compiler.AssemblyDefinitionDynamic(module, "dynamic"); module.SetDeclaringAssembly(temp); // Import all currently loaded assemblies var domain = AppDomain.CurrentDomain; temp.Create(domain, System.Reflection.Emit.AssemblyBuilderAccess.Run); var importer = new Compiler.ReflectionImporter(module, cc.BuiltinTypes) { IgnorePrivateMembers = false }; foreach (var a in AppDomain.CurrentDomain.GetAssemblies()) { importer.ImportAssembly(a, module.GlobalRootNamespace); } cc.BuiltinTypes.CheckDefinitions(module); module.InitializePredefinedTypes(); dc = new DynamicContext(module, importer); } return(dc); }
public static DynamicContext Create () { if (dc != null) return dc; lock (compiler_initializer) { if (dc != null) return dc; var settings = new Compiler.CompilerSettings () { WarningLevel = 0 }; var cc = new Compiler.CompilerContext (settings, ErrorPrinter.Instance) { IsRuntimeBinder = true }; // // Any later loaded assemblies are handled internally by GetAssemblyDefinition // domain.AssemblyLoad cannot be used as that would be too destructive as we // would hold all loaded assemblies even if they can be never visited // // TODO: Remove this code and rely on GetAssemblyDefinition only // var module = new Compiler.ModuleContainer (cc); module.HasTypesFullyDefined = true; // Setup fake assembly, it's used mostly to simplify checks like friend-access var temp = new Compiler.AssemblyDefinitionDynamic (module, "dynamic"); module.SetDeclaringAssembly (temp); var importer = new Compiler.ReflectionImporter (module, cc.BuiltinTypes) { IgnorePrivateMembers = false }; // Import all currently loaded assemblies // TODO: Rewrite this to populate type cache on-demand, that should greatly // reduce our start-up cost var domain = AppDomain.CurrentDomain; foreach (var a in AppDomain.CurrentDomain.GetAssemblies ()) { importer.ImportAssembly (a, module.GlobalRootNamespace); } cc.BuiltinTypes.CheckDefinitions (module); module.InitializePredefinedTypes (); dc = new DynamicContext (module, importer); } return dc; }