示例#1
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;
		}
示例#2
0
文件: driver.cs 项目: rblenis/cudafy
        //
        // 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);
        }
        //public static string GetPackageFlags (string packages, Report report)
        //{
        //    ProcessStartInfo pi = new ProcessStartInfo ();
        //    pi.FileName = "pkg-config";
        //    pi.RedirectStandardOutput = true;
        //    pi.UseShellExecute = false;
        //    pi.Arguments = "--libs " + packages;
        //    Process p = null;
        //    try {
        //        p = Process.Start (pi);
        //    } catch (Exception e) {
        //        if (report == null)
        //            throw;
        //        report.Error (-27, "Couldn't run pkg-config: " + e.Message);
        //        return null;
        //    }
        //    if (p.StandardOutput == null) {
        //        if (report == null)
        //            throw new ApplicationException ("Specified package did not return any information");
        //        report.Warning (-27, 1, "Specified package did not return any information");
        //        p.Close ();
        //        return null;
        //    }
        //    string pkgout = p.StandardOutput.ReadToEnd ();
        //    p.WaitForExit ();
        //    if (p.ExitCode != 0) {
        //        if (report == null)
        //            throw new ApplicationException (pkgout);
        //        report.Error (-27, "Error running pkg-config. Check the above output.");
        //        p.Close ();
        //        return null;
        //    }
        //    p.Close ();
        //    return pkgout;
        //}
        //
        // 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 (Location.FirstFile == 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)
                return true;

            if (RootContext.ToplevelTypes.NamespaceEntry != null)
                throw new InternalErrorException ("who set it?");

            var output_file = settings.OutputFile;
            string output_file_name;
            if (output_file == null) {
                output_file_name = Location.FirstFile;

                if (output_file_name == null) {
                    Report.Error (1562, "If no source files are specified you must specify the output file with -out:");
                    return false;
                }

                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.BuildinTypes.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.BuildinTypes);
            assembly.Importer = importer;

            var loader = new DynamicLoader (importer, ctx);
            loader.LoadReferences (module);

            if (!ctx.BuildinTypes.CheckDefinitions (module))
                return false;

            if (!assembly.Create (AppDomain.CurrentDomain, AssemblyBuilderAccess.Run))
                return false;

            module.CreateType ();

            loader.LoadModules (assembly, module.GlobalRootNamespace);
            #endif
            tr.Start (TimeReporter.TimerType.ModuleDefinitionTotal);
            module.Define ();
            tr.Stop (TimeReporter.TimerType.ModuleDefinitionTotal);

            if (Report.Errors > 0)
                return false;

            //if (settings.Documentation != null &&
            //    !settings.Documentation.OutputDocComment (
            //        output_file, Report))
            //    return false;

            //
            // Verify using aliases now
            //
            tr.Start (TimeReporter.TimerType.UsingVerification);
            NamespaceEntry.VerifyAllUsing ();
            tr.Stop (TimeReporter.TimerType.UsingVerification);

            if (Report.Errors > 0){
                return false;
            }

            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;
        }