/// <summary> /// Loads the given assembly and exposes the API to the user. /// </summary> public void LoadAssembly (string file) { var loader = new DynamicLoader (importer, ctx); var assembly = loader.LoadAssemblyFile (file, false); if (assembly == null) return; lock (evaluator_lock){ importer.ImportAssembly (assembly, module.GlobalRootNamespace); } }
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); }
public override void LoadReferences(ModuleContainer module) { Assembly corlib, ravalib; List <Tuple <RootNamespace, Assembly> > loaded; base.LoadReferencesCore(module, out corlib, out ravalib, out loaded); if (corlib == null) { return; } importer.ImportAssembly(ravalib, module.GlobalRootNamespace); importer.ImportAssembly(corlib, module.GlobalRootNamespace); foreach (var entry in loaded) { importer.ImportAssembly(entry.Item2, entry.Item1); } }
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; }
private bool PrepareCompiler([NotNull] ModuleContainer container, out ExplicitDynamicAsseblyDefinition assemblyDefinitionDynamic) { assemblyDefinitionDynamic = new ExplicitDynamicAsseblyDefinition(container, ModuleName, _builder, _path); container.SetDeclaringAssembly(assemblyDefinitionDynamic); var importer = new ReflectionImporter(container, container.Compiler.BuiltinTypes); assemblyDefinitionDynamic.Importer = importer; foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) importer.ImportAssembly(assembly, container.GlobalRootNamespace); return container.Compiler.BuiltinTypes.CheckDefinitions(container); }