public StaticLoader(StaticImporter importer, CompilerContext compiler)
: base(compiler)
{
this.importer = importer;
domain = new Universe();
domain.EnableMissingMemberResolution();
domain.AssemblyResolve += AssemblyReferenceResolver;
loaded_names = new List <Tuple <AssemblyName, string, Assembly> > ();
var corlib_path = Path.GetDirectoryName(typeof(object).Assembly.Location);
string fx_path = corlib_path.Substring(0, corlib_path.LastIndexOf(Path.DirectorySeparatorChar));
if (compiler.Settings.StdLib)
{
string sdk_path = null;
string sdk_version = compiler.Settings.SdkVersion ?? "4.5";
string[] sdk_sub_dirs;
if (!sdk_directory.TryGetValue(sdk_version, out sdk_sub_dirs))
{
sdk_sub_dirs = new string[] { sdk_version }
}
;
foreach (var dir in sdk_sub_dirs)
{
sdk_path = Path.Combine(fx_path, dir);
if (File.Exists(Path.Combine(sdk_path, "mscorlib.dll")))
{
break;
}
sdk_path = null;
}
if (sdk_path == null)
{
compiler.Report.Warning(-1, 1, "SDK path could not be resolved");
sdk_path = corlib_path;
}
paths.Add(sdk_path);
}
}
//
// 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);
}
