public static int Run(string[] args) { DebugHelper.HandleDebugSwitch(ref args); try { var commandFactory = new DotNetCommandFactory(); var scriptRunner = new ScriptRunner(); var managedCompiler = new ManagedCompiler(scriptRunner, commandFactory); var nativeCompiler = new NativeCompiler(); var compilationDriver = new CompilationDriver(managedCompiler, nativeCompiler); var compilerCommandArgs = new CompilerCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform"); return(compilerCommandArgs.Execute(compilationDriver.Compile, args)); } catch (Exception ex) { #if DEBUG Console.Error.WriteLine(ex); #else Console.Error.WriteLine(ex.Message); #endif return(1); } }
public static int Run(string[] args) { DebugHelper.HandleDebugSwitch(ref args); try { var commandFactory = new DotNetCommandFactory(); var scriptRunner = new ScriptRunner(); var managedCompiler = new ManagedCompiler(scriptRunner, commandFactory); var nativeCompiler = new NativeCompiler(); var compilationDriver = new CompilationDriver(managedCompiler, nativeCompiler); var compilerCommandArgs = new CompilerCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform"); return compilerCommandArgs.Execute(compilationDriver.Compile, args); } catch (Exception ex) { #if DEBUG Console.Error.WriteLine(ex); #else Console.Error.WriteLine(ex.Message); #endif return 1; } }
private static bool OnExecute(List<ProjectContext> contexts, CompilerCommandApp args) { var compileContexts = contexts.Select(context => new CompileContext(context, (BuilderCommandApp)args)).ToList(); var incrementalSafe = compileContexts.All(c => c.IsSafeForIncrementalCompilation); return compileContexts.All(c => c.Compile(incrementalSafe)); }
private static bool OnExecute(List<ProjectContext> contexts, CompilerCommandApp args) { var success = true; foreach (var context in contexts) { success &= CompileProject(context, args); if (args.IsNativeValue && success) { success &= CompileNative(context, args); } } return success; }
private static bool OnExecute(List <ProjectContext> contexts, CompilerCommandApp args) { var success = true; foreach (var context in contexts) { success &= CompileProject(context, args); if (args.IsNativeValue && success) { success &= CompileNative(context, args); } } return(success); }
public bool Compile(IEnumerable <ProjectContext> contexts, CompilerCommandApp args) { var success = true; foreach (var context in contexts) { success &= _managedCompiler.Compile(context, args); if (args.IsNativeValue && success) { var runtimeContext = context.CreateRuntimeContext(args.GetRuntimes()); success &= _nativeCompiler.Compile(runtimeContext, args); } } return(success); }
public bool Compile(IEnumerable<ProjectContext> contexts, CompilerCommandApp args) { var success = true; foreach (var context in contexts) { success &= _managedCompiler.Compile(context, args); if (args.IsNativeValue && success) { var runtimeContext = context.CreateRuntimeContext(args.GetRuntimes()); success &= _nativeCompiler.Compile(runtimeContext, args); } } return success; }
public static int Main(string[] args) { DebugHelper.HandleDebugSwitch(ref args); try { var compilerCommandArgs = new CompilerCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform"); return compilerCommandArgs.Execute(OnExecute, args); } catch (Exception ex) { #if DEBUG Console.Error.WriteLine(ex); #else Console.Error.WriteLine(ex.Message); #endif return 1; } }
public static int Main(string[] args) { DebugHelper.HandleDebugSwitch(ref args); try { var compilerCommandArgs = new CompilerCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform"); return(compilerCommandArgs.Execute(OnExecute, args)); } catch (Exception ex) { #if DEBUG Console.Error.WriteLine(ex); #else Console.Error.WriteLine(ex.Message); #endif return(1); } }
public GivenACompilationDriverController() { _projectJson = Path.Combine(AppContext.BaseDirectory, "TestAssets", "TestProjects", "TestAppWithLibrary", "TestApp", "project.json"); _managedCompilerMock = new Mock<ICompiler>(); _managedCompilerMock.Setup(c => c .Compile(It.IsAny<ProjectContext>(), It.IsAny<CompilerCommandApp>())) .Returns(true); _nativeCompilerMock = new Mock<ICompiler>(); _nativeCompilerMock.Setup(c => c .Compile(It.IsAny<ProjectContext>(), It.IsAny<CompilerCommandApp>())) .Returns(true); _contexts = new List<ProjectContext> { ProjectContext.Create(_projectJson, NuGetFramework.Parse("dnxcore50")) }; _args = new CompilerCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform"); }
private static bool CompileNative( ProjectContext context, CompilerCommandApp args) { var outputPath = context.GetOutputPath(args.ConfigValue, args.OutputValue); var nativeOutputPath = Path.Combine(outputPath, "native"); var intermediateOutputPath = context.GetIntermediateOutputPath(args.ConfigValue, args.IntermediateValue, outputPath); Directory.CreateDirectory(nativeOutputPath); Directory.CreateDirectory(intermediateOutputPath); var compilationOptions = context.ProjectFile.GetCompilerOptions(context.TargetFramework, args.ConfigValue); var managedOutput = GetProjectOutput(context.ProjectFile, context.TargetFramework, args.ConfigValue, outputPath); var nativeArgs = new List<string>(); // Input Assembly nativeArgs.Add($"{managedOutput}"); // ILC Args if (!string.IsNullOrWhiteSpace(args.IlcArgsValue)) { nativeArgs.Add("--ilcargs"); nativeArgs.Add($"{args.IlcArgsValue}"); } // ILC Path if (!string.IsNullOrWhiteSpace(args.IlcPathValue)) { nativeArgs.Add("--ilcpath"); nativeArgs.Add(args.IlcPathValue); } // ILC SDK Path if (!string.IsNullOrWhiteSpace(args.IlcSdkPathValue)) { nativeArgs.Add("--ilcsdkpath"); nativeArgs.Add(args.IlcSdkPathValue); } // AppDep SDK Path if (!string.IsNullOrWhiteSpace(args.AppDepSdkPathValue)) { nativeArgs.Add("--appdepsdk"); nativeArgs.Add(args.AppDepSdkPathValue); } // CodeGen Mode if(args.IsCppModeValue) { nativeArgs.Add("--mode"); nativeArgs.Add("cpp"); } if (!string.IsNullOrWhiteSpace(args.CppCompilerFlagsValue)) { nativeArgs.Add("--cppcompilerflags"); nativeArgs.Add(args.CppCompilerFlagsValue); } // Configuration if (args.ConfigValue != null) { nativeArgs.Add("--configuration"); nativeArgs.Add(args.ConfigValue); } // Architecture if (args.ArchValue != null) { nativeArgs.Add("--arch"); nativeArgs.Add(args.ArchValue); } // Intermediate Path nativeArgs.Add("--temp-output"); nativeArgs.Add($"{intermediateOutputPath}"); // Output Path nativeArgs.Add("--output"); nativeArgs.Add($"{nativeOutputPath}"); // Write Response File var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile-native.{context.ProjectFile.Name}.rsp"); File.WriteAllLines(rsp, nativeArgs); // TODO Add -r assembly.dll for all Nuget References // Need CoreRT Framework published to nuget // Do Native Compilation var result = Command.Create("dotnet-compile-native", $"--rsp \"{rsp}\"") .ForwardStdErr() .ForwardStdOut() .Execute(); return result.ExitCode == 0; }
public abstract bool Compile(ProjectContext context, CompilerCommandApp args);
private static bool CompileProject(ProjectContext context, CompilerCommandApp args) { // Set up Output Paths var outputPathCalculator = context.GetOutputPathCalculator(args.OutputValue); var outputPath = outputPathCalculator.GetOutputDirectoryPath(args.ConfigValue); var intermediateOutputPath = outputPathCalculator.GetIntermediateOutputDirectoryPath(args.ConfigValue, args.IntermediateValue); Directory.CreateDirectory(outputPath); Directory.CreateDirectory(intermediateOutputPath); // Create the library exporter var exporter = context.CreateExporter(args.ConfigValue); // Gather exports for the project var dependencies = exporter.GetDependencies().ToList(); Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}"); var sw = Stopwatch.StartNew(); var diagnostics = new List <DiagnosticMessage>(); var missingFrameworkDiagnostics = new List <DiagnosticMessage>(); // Collect dependency diagnostics foreach (var diag in context.LibraryManager.GetAllDiagnostics()) { if (diag.ErrorCode == ErrorCodes.DOTNET1011 || diag.ErrorCode == ErrorCodes.DOTNET1012) { missingFrameworkDiagnostics.Add(diag); } diagnostics.Add(diag); } if (missingFrameworkDiagnostics.Count > 0) { // The framework isn't installed so we should short circuit the rest of the compilation // so we don't get flooded with errors PrintSummary(missingFrameworkDiagnostics, sw); return(false); } // Get compilation options var outputName = outputPathCalculator.GetAssemblyPath(args.ConfigValue); // Assemble args var compilerArgs = new List <string>() { $"--temp-output:\"{intermediateOutputPath}\"", $"--out:\"{outputName}\"" }; var compilationOptions = CompilerUtil.ResolveCompilationOptions(context, args.ConfigValue); var languageId = CompilerUtil.ResolveLanguageId(context); var references = new List <string>(); // Add compilation options to the args compilerArgs.AddRange(compilationOptions.SerializeToArgs()); // Add metadata options compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context))); foreach (var dependency in dependencies) { references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath)); compilerArgs.AddRange(dependency.SourceReferences.Select(s => $"\"{s}\"")); // Add analyzer references compilerArgs.AddRange(dependency.AnalyzerReferences .Where(a => a.AnalyzerLanguage == languageId) .Select(a => $"--analyzer:\"{a.AssemblyPath}\"")); } compilerArgs.AddRange(references.Select(r => $"--reference:\"{r}\"")); if (compilationOptions.PreserveCompilationContext == true) { var dependencyContext = DependencyContextBuilder.Build(compilationOptions, exporter, args.ConfigValue, context.TargetFramework, context.RuntimeIdentifier); var writer = new DependencyContextWriter(); var depsJsonFile = Path.Combine(intermediateOutputPath, context.ProjectFile.Name + "dotnet-compile.deps.json"); using (var fileStream = File.Create(depsJsonFile)) { writer.Write(dependencyContext, fileStream); } compilerArgs.Add($"--resource:\"{depsJsonFile},{context.ProjectFile.Name}.deps.json\""); } if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath)) { return(false); } // Add project source files var sourceFiles = CompilerUtil.GetCompilationSources(context); compilerArgs.AddRange(sourceFiles); var compilerName = CompilerUtil.ResolveCompilerName(context); // Write RSP file var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.rsp"); File.WriteAllLines(rsp, compilerArgs); // Run pre-compile event var contextVariables = new Dictionary <string, string>() { { "compile:TargetFramework", context.TargetFramework.DotNetFrameworkName }, { "compile:Configuration", args.ConfigValue }, { "compile:OutputFile", outputName }, { "compile:OutputDir", outputPath }, { "compile:ResponseFile", rsp } }; RunScripts(context, ScriptNames.PreCompile, contextVariables); var result = Command.CreateDotNet($"compile-{compilerName}", new[] { "@" + $"{rsp}" }) .OnErrorLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Error.WriteLine(line); } }) .OnOutputLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Output.WriteLine(line); } }).Execute(); // Run post-compile event contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString(); RunScripts(context, ScriptNames.PostCompile, contextVariables); var success = result.ExitCode == 0; if (!success) { Reporter.Error.WriteLine($"{result.StartInfo.FileName} {result.StartInfo.Arguments} returned Exit Code {result.ExitCode}"); } if (success) { success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, intermediateOutputPath, outputPath); } return(PrintSummary(diagnostics, sw, success)); }
private static bool CompileProject(ProjectContext context, CompilerCommandApp args) { // Set up Output Paths var outputPathCalculator = context.GetOutputPathCalculator(args.OutputValue); var outputPath = outputPathCalculator.GetOutputDirectoryPath(args.ConfigValue); var intermediateOutputPath = outputPathCalculator.GetIntermediateOutputDirectoryPath(args.ConfigValue, args.IntermediateValue); Directory.CreateDirectory(outputPath); Directory.CreateDirectory(intermediateOutputPath); // Create the library exporter var exporter = context.CreateExporter(args.ConfigValue); // Gather exports for the project var dependencies = exporter.GetDependencies().ToList(); Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}"); var sw = Stopwatch.StartNew(); var diagnostics = new List<DiagnosticMessage>(); var missingFrameworkDiagnostics = new List<DiagnosticMessage>(); // Collect dependency diagnostics foreach (var diag in context.LibraryManager.GetAllDiagnostics()) { if (diag.ErrorCode == ErrorCodes.DOTNET1011 || diag.ErrorCode == ErrorCodes.DOTNET1012) { missingFrameworkDiagnostics.Add(diag); } diagnostics.Add(diag); } if (missingFrameworkDiagnostics.Count > 0) { // The framework isn't installed so we should short circuit the rest of the compilation // so we don't get flooded with errors PrintSummary(missingFrameworkDiagnostics, sw); return false; } // Get compilation options var outputName = outputPathCalculator.GetAssemblyPath(args.ConfigValue); // Assemble args var compilerArgs = new List<string>() { $"--temp-output:\"{intermediateOutputPath}\"", $"--out:\"{outputName}\"" }; var compilationOptions = CompilerUtil.ResolveCompilationOptions(context, args.ConfigValue); var languageId = CompilerUtil.ResolveLanguageId(context); var references = new List<string>(); // Add compilation options to the args compilerArgs.AddRange(compilationOptions.SerializeToArgs()); // Add metadata options compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context))); foreach (var dependency in dependencies) { references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath)); compilerArgs.AddRange(dependency.SourceReferences.Select(s => $"\"{s}\"")); // Add analyzer references compilerArgs.AddRange(dependency.AnalyzerReferences .Where(a => a.AnalyzerLanguage == languageId) .Select(a => $"--analyzer:\"{a.AssemblyPath}\"")); } compilerArgs.AddRange(references.Select(r => $"--reference:\"{r}\"")); if (compilationOptions.PreserveCompilationContext == true) { var dependencyContext = DependencyContextBuilder.Build(compilationOptions, exporter, args.ConfigValue, context.TargetFramework, context.RuntimeIdentifier); var writer = new DependencyContextWriter(); var depsJsonFile = Path.Combine(intermediateOutputPath, context.ProjectFile.Name + "dotnet-compile.deps.json"); using (var fileStream = File.Create(depsJsonFile)) { writer.Write(dependencyContext, fileStream); } compilerArgs.Add($"--resource:\"{depsJsonFile},{context.ProjectFile.Name}.deps.json\""); } if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath)) { return false; } // Add project source files var sourceFiles = CompilerUtil.GetCompilationSources(context); compilerArgs.AddRange(sourceFiles); var compilerName = CompilerUtil.ResolveCompilerName(context); // Write RSP file var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.rsp"); File.WriteAllLines(rsp, compilerArgs); // Run pre-compile event var contextVariables = new Dictionary<string, string>() { { "compile:TargetFramework", context.TargetFramework.DotNetFrameworkName }, { "compile:Configuration", args.ConfigValue }, { "compile:OutputFile", outputName }, { "compile:OutputDir", outputPath }, { "compile:ResponseFile", rsp } }; RunScripts(context, ScriptNames.PreCompile, contextVariables); var result = Command.Create($"dotnet-compile-{compilerName}", new[] { "@" + $"{rsp}" }) .OnErrorLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Error.WriteLine(line); } }) .OnOutputLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Output.WriteLine(line); } }).Execute(); // Run post-compile event contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString(); RunScripts(context, ScriptNames.PostCompile, contextVariables); var success = result.ExitCode == 0; if (!success) { Reporter.Error.WriteLine($"{result.StartInfo.FileName} {result.StartInfo.Arguments} returned Exit Code {result.ExitCode}"); } if (success) { success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, outputPath); } bool generateBindingRedirects = false; if (success && !args.NoHostValue && compilationOptions.EmitEntryPoint.GetValueOrDefault()) { generateBindingRedirects = true; var rids = PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers(); var runtimeContext = ProjectContext.Create(context.ProjectDirectory, context.TargetFramework, rids); runtimeContext .MakeCompilationOutputRunnable(outputPath, args.ConfigValue); } else if (!string.IsNullOrEmpty(context.ProjectFile.TestRunner)) { generateBindingRedirects = true; var projectContext = ProjectContext.Create(context.ProjectDirectory, context.TargetFramework, new[] { PlatformServices.Default.Runtime.GetLegacyRestoreRuntimeIdentifier() }); // Don't generate a deps file if we're on desktop if (!context.TargetFramework.IsDesktop()) { projectContext .CreateExporter(args.ConfigValue) .GetDependencies(LibraryType.Package) .WriteDepsTo(Path.Combine(outputPath, projectContext.ProjectFile.Name + FileNameSuffixes.Deps)); } } if (generateBindingRedirects && context.TargetFramework.IsDesktop()) { context.GenerateBindingRedirects(exporter, outputName); } return PrintSummary(diagnostics, sw, success); }
public override bool Compile(ProjectContext context, CompilerCommandApp args) { // Set up Output Paths var outputPaths = context.GetOutputPaths(args.ConfigValue, args.BuildBasePathValue); var outputPath = outputPaths.CompilationOutputPath; var intermediateOutputPath = outputPaths.IntermediateOutputDirectoryPath; Directory.CreateDirectory(outputPath); Directory.CreateDirectory(intermediateOutputPath); // Create the library exporter var exporter = context.CreateExporter(args.ConfigValue, args.BuildBasePathValue); // Gather exports for the project var dependencies = exporter.GetDependencies().ToList(); Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}"); var sw = Stopwatch.StartNew(); var diagnostics = new List<DiagnosticMessage>(); var missingFrameworkDiagnostics = new List<DiagnosticMessage>(); // Collect dependency diagnostics foreach (var diag in context.LibraryManager.GetAllDiagnostics()) { if (diag.ErrorCode == ErrorCodes.DOTNET1011 || diag.ErrorCode == ErrorCodes.DOTNET1012) { missingFrameworkDiagnostics.Add(diag); } diagnostics.Add(diag); } if (missingFrameworkDiagnostics.Count > 0) { // The framework isn't installed so we should short circuit the rest of the compilation // so we don't get flooded with errors PrintSummary(missingFrameworkDiagnostics, sw); return false; } // Get compilation options var outputName = outputPaths.CompilationFiles.Assembly; // Assemble args var compilerArgs = new List<string>() { $"--temp-output:{intermediateOutputPath}", $"--out:{outputName}" }; var compilationOptions = context.ResolveCompilationOptions(args.ConfigValue); var languageId = CompilerUtil.ResolveLanguageId(context); var references = new List<string>(); // Add compilation options to the args compilerArgs.AddRange(compilationOptions.SerializeToArgs()); // Add metadata options compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context))); foreach (var dependency in dependencies) { references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath)); compilerArgs.AddRange(dependency.SourceReferences.Select(s => s.GetTransformedFile(intermediateOutputPath))); foreach (var resourceFile in dependency.EmbeddedResources) { var transformedResource = resourceFile.GetTransformedFile(intermediateOutputPath); var resourceName = ResourceManifestName.CreateManifestName( Path.GetFileName(resourceFile.ResolvedPath), compilationOptions.OutputName); compilerArgs.Add($"--resource:\"{transformedResource}\",{resourceName}"); } // Add analyzer references compilerArgs.AddRange(dependency.AnalyzerReferences .Where(a => a.AnalyzerLanguage == languageId) .Select(a => $"--analyzer:{a.AssemblyPath}")); } compilerArgs.AddRange(references.Select(r => $"--reference:{r}")); if (compilationOptions.PreserveCompilationContext == true) { var allExports = exporter.GetAllExports().ToList(); var dependencyContext = new DependencyContextBuilder().Build(compilationOptions, allExports, allExports, false, // For now, just assume non-portable mode in the legacy deps file (this is going away soon anyway) context.TargetFramework, context.RuntimeIdentifier ?? string.Empty); var writer = new DependencyContextWriter(); var depsJsonFile = Path.Combine(intermediateOutputPath, compilationOptions.OutputName + "dotnet-compile.deps.json"); using (var fileStream = File.Create(depsJsonFile)) { writer.Write(dependencyContext, fileStream); } compilerArgs.Add($"--resource:\"{depsJsonFile}\",{compilationOptions.OutputName}.deps.json"); } if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath)) { return false; } // Add project source files var sourceFiles = CompilerUtil.GetCompilationSources(context); compilerArgs.AddRange(sourceFiles); var compilerName = context.ProjectFile.CompilerName; // Write RSP file var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.rsp"); File.WriteAllLines(rsp, compilerArgs); // Run pre-compile event var contextVariables = new Dictionary<string, string>() { { "compile:TargetFramework", context.TargetFramework.GetShortFolderName() }, { "compile:FullTargetFramework", context.TargetFramework.DotNetFrameworkName }, { "compile:Configuration", args.ConfigValue }, { "compile:OutputFile", outputName }, { "compile:OutputDir", outputPath.TrimEnd('\\', '/') }, { "compile:ResponseFile", rsp } }; if (context.ProjectFile.HasRuntimeOutput(args.ConfigValue)) { var runtimeContext = context.CreateRuntimeContext(args.GetRuntimes()); var runtimeOutputPath = runtimeContext.GetOutputPaths(args.ConfigValue, args.BuildBasePathValue, args.OutputValue); contextVariables.Add( "compile:RuntimeOutputDir", runtimeOutputPath.RuntimeOutputPath.TrimEnd('\\', '/')); contextVariables.Add( "compile:RuntimeIdentifier", runtimeContext.RuntimeIdentifier); } _scriptRunner.RunScripts(context, ScriptNames.PreCompile, contextVariables); var result = _commandFactory.Create($"compile-{compilerName}", new[] { "@" + $"{rsp}" }) .OnErrorLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Error.WriteLine(line); } }) .OnOutputLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Output.WriteLine(line); } }).Execute(); // Run post-compile event contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString(); _scriptRunner.RunScripts(context, ScriptNames.PostCompile, contextVariables); var success = result.ExitCode == 0; if (!success) { Reporter.Error.WriteLine($"{result.StartInfo.FileName} {result.StartInfo.Arguments} returned Exit Code {result.ExitCode}"); } if (success) { success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, intermediateOutputPath, outputPath); } return PrintSummary(diagnostics, sw, success); }
private static bool CompileProject(ProjectContext context, CompilerCommandApp args) { // Set up Output Paths string outputPath = context.GetOutputPath(args.ConfigValue, args.OutputValue); string intermediateOutputPath = context.GetIntermediateOutputPath(args.ConfigValue, args.IntermediateValue, outputPath); Directory.CreateDirectory(outputPath); Directory.CreateDirectory(intermediateOutputPath); // Create the library exporter var exporter = context.CreateExporter(args.ConfigValue); // Gather exports for the project var dependencies = exporter.GetDependencies().ToList(); Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}"); var sw = Stopwatch.StartNew(); var diagnostics = new List<DiagnosticMessage>(); var missingFrameworkDiagnostics = new List<DiagnosticMessage>(); // Collect dependency diagnostics foreach (var diag in context.LibraryManager.GetAllDiagnostics()) { if (diag.ErrorCode == ErrorCodes.DOTNET1011 || diag.ErrorCode == ErrorCodes.DOTNET1012) { missingFrameworkDiagnostics.Add(diag); } diagnostics.Add(diag); } if (missingFrameworkDiagnostics.Count > 0) { // The framework isn't installed so we should short circuit the rest of the compilation // so we don't get flooded with errors PrintSummary(missingFrameworkDiagnostics, sw); return false; } // Get compilation options var outputName = GetProjectOutput(context.ProjectFile, context.TargetFramework, args.ConfigValue, outputPath); // Assemble args var compilerArgs = new List<string>() { $"--temp-output:{intermediateOutputPath}", $"--out:{outputName}" }; var compilationOptions = context.ProjectFile.GetCompilerOptions(context.TargetFramework, args.ConfigValue); // Path to strong naming key in environment variable overrides path in project.json var environmentKeyFile = Environment.GetEnvironmentVariable(EnvironmentNames.StrongNameKeyFile); if (!string.IsNullOrWhiteSpace(environmentKeyFile)) { compilationOptions.KeyFile = environmentKeyFile; } else if (!string.IsNullOrWhiteSpace(compilationOptions.KeyFile)) { // Resolve full path to key file compilationOptions.KeyFile = Path.GetFullPath(Path.Combine(context.ProjectFile.ProjectDirectory, compilationOptions.KeyFile)); } var references = new List<string>(); // Add compilation options to the args compilerArgs.AddRange(compilationOptions.SerializeToArgs()); // Add metadata options compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context))); foreach (var dependency in dependencies) { var projectDependency = dependency.Library as ProjectDescription; if (projectDependency != null) { if (projectDependency.Project.Files.SourceFiles.Any()) { var projectOutputPath = GetProjectOutput(projectDependency.Project, projectDependency.Framework, args.ConfigValue, outputPath); references.Add(projectOutputPath); } } else { references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath)); } compilerArgs.AddRange(dependency.SourceReferences); } compilerArgs.AddRange(references.Select(r => $"--reference:{r}")); if (compilationOptions.PreserveCompilationContext == true) { var dependencyContext = DependencyContextBuilder.Build(compilationOptions, exporter, args.ConfigValue, context.TargetFramework, context.RuntimeIdentifier); var writer = new DependencyContextWriter(); var depsJsonFile = Path.Combine(intermediateOutputPath, context.ProjectFile.Name + "dotnet-compile.deps.json"); using (var fileStream = File.Create(depsJsonFile)) { writer.Write(dependencyContext, fileStream); } compilerArgs.Add($"--resource:\"{depsJsonFile}\",{context.ProjectFile.Name}.deps.json"); var refsFolder = Path.Combine(outputPath, "refs"); if (Directory.Exists(refsFolder)) { Directory.Delete(refsFolder, true); } Directory.CreateDirectory(refsFolder); foreach (var reference in references) { File.Copy(reference, Path.Combine(refsFolder, Path.GetFileName(reference))); } } if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath)) { return false; } // Add project source files var sourceFiles = context.ProjectFile.Files.SourceFiles; compilerArgs.AddRange(sourceFiles); var compilerName = CompilerUtil.ResolveCompilerName(context); // Write RSP file var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.{context.ProjectFile.Name}.rsp"); File.WriteAllLines(rsp, compilerArgs); // Run pre-compile event var contextVariables = new Dictionary<string, string>() { { "compile:TargetFramework", context.TargetFramework.DotNetFrameworkName }, { "compile:Configuration", args.ConfigValue }, { "compile:OutputFile", outputName }, { "compile:OutputDir", outputPath }, { "compile:ResponseFile", rsp } }; RunScripts(context, ScriptNames.PreCompile, contextVariables); var result = Command.Create($"dotnet-compile-{compilerName}", $"@\"{rsp}\"") .OnErrorLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Error.WriteLine(line); } }) .OnOutputLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Output.WriteLine(line); } }).Execute(); // Run post-compile event contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString(); RunScripts(context, ScriptNames.PostCompile, contextVariables); var success = result.ExitCode == 0; if (success) { success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, outputPath); } if (success && !args.NoHostValue && compilationOptions.EmitEntryPoint.GetValueOrDefault()) { var rids = PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers(); var runtimeContext = ProjectContext.Create(context.ProjectDirectory, context.TargetFramework, rids); runtimeContext .MakeCompilationOutputRunnable(outputPath, args.ConfigValue); } return PrintSummary(diagnostics, sw, success); }
public override bool Compile(ProjectContext context, CompilerCommandApp args) { var outputPaths = context.GetOutputPaths(args.ConfigValue, args.BuildBasePathValue, args.OutputValue); var outputPath = outputPaths.RuntimeOutputPath; var nativeOutputPath = Path.Combine(outputPath, "native"); var intermediateOutputPath = outputPaths.IntermediateOutputDirectoryPath; var nativeTempOutput = Path.Combine(intermediateOutputPath, "native"); Directory.CreateDirectory(nativeOutputPath); Directory.CreateDirectory(nativeTempOutput); var managedOutput = outputPaths.CompilationFiles.Assembly; // Create the library exporter var exporter = context.CreateExporter(args.ConfigValue); var exports = exporter.GetDependencies(); // Runtime assemblies. // TODO: native assets/resources. var references = exports .SelectMany(export => export.RuntimeAssemblies) .Select(r => r.ResolvedPath) .ToList(); // Setup native args. var nativeArgs = new List <string>(); // Input Assembly nativeArgs.Add($"{managedOutput}"); // Add Resolved Assembly References foreach (var reference in references) { nativeArgs.Add("--reference"); nativeArgs.Add(reference); } // ILC Args foreach (var ilcArg in args.IlcArgsValue) { nativeArgs.Add("--ilcarg"); nativeArgs.Add($"\"{ilcArg}\""); } // ILC Path if (!string.IsNullOrWhiteSpace(args.IlcPathValue)) { nativeArgs.Add("--ilcpath"); nativeArgs.Add(args.IlcPathValue); } // ILC SDK Path if (!string.IsNullOrWhiteSpace(args.IlcSdkPathValue)) { nativeArgs.Add("--ilcsdkpath"); nativeArgs.Add(args.IlcSdkPathValue); } // AppDep SDK Path if (!string.IsNullOrWhiteSpace(args.AppDepSdkPathValue)) { nativeArgs.Add("--appdepsdk"); nativeArgs.Add(args.AppDepSdkPathValue); } // CodeGen Mode if (args.IsCppModeValue) { nativeArgs.Add("--mode"); nativeArgs.Add("cpp"); } if (!string.IsNullOrWhiteSpace(args.CppCompilerFlagsValue)) { nativeArgs.Add("--cppcompilerflags"); nativeArgs.Add(args.CppCompilerFlagsValue); } // Configuration if (args.ConfigValue != null) { nativeArgs.Add("--configuration"); nativeArgs.Add(args.ConfigValue); } // Architecture if (args.ArchValue != null) { nativeArgs.Add("--arch"); nativeArgs.Add(args.ArchValue); } // Intermediate Path nativeArgs.Add("--temp-output"); nativeArgs.Add($"{nativeTempOutput}"); // Output Path nativeArgs.Add("--output"); nativeArgs.Add($"{nativeOutputPath}"); // Write Response File var rsp = Path.Combine(nativeTempOutput, $"dotnet-compile-native.{context.ProjectFile.Name}.rsp"); File.WriteAllLines(rsp, nativeArgs); // TODO Add -r assembly.dll for all Nuget References // Need CoreRT Framework published to nuget // Do Native Compilation var result = Native.CompileNativeCommand.Run(new string[] { "--rsp", $"{rsp}" }); return(result == 0); }
public override bool Compile(ProjectContext context, CompilerCommandApp args) { var outputPaths = context.GetOutputPaths(args.ConfigValue, args.BuildBasePathValue, args.OutputValue); var outputPath = outputPaths.RuntimeOutputPath; var nativeOutputPath = Path.Combine(outputPath, "native"); var intermediateOutputPath = outputPaths.IntermediateOutputDirectoryPath; var nativeTempOutput = Path.Combine(intermediateOutputPath, "native"); Directory.CreateDirectory(nativeOutputPath); Directory.CreateDirectory(nativeTempOutput); var managedOutput = outputPaths.CompilationFiles.Assembly; // Create the library exporter var exporter = context.CreateExporter(args.ConfigValue); // Gather exports for the project var exports = exporter.GetAllExports(); // Runtime assemblies. // TODO: native assets/resources. var references = exports .SelectMany(export => export.RuntimeAssemblies) .Select(r => r.ResolvedPath) .ToList(); // Setup native args. var nativeArgs = new List<string>(); // Input Assembly nativeArgs.Add($"{managedOutput}"); // Add Resolved Assembly References foreach (var reference in references) { nativeArgs.Add("--reference"); nativeArgs.Add(reference); } // ILC Args foreach (var ilcArg in args.IlcArgsValue) { nativeArgs.Add("--ilcarg"); nativeArgs.Add($"\"{ilcArg}\""); } // ILC Path if (!string.IsNullOrWhiteSpace(args.IlcPathValue)) { nativeArgs.Add("--ilcpath"); nativeArgs.Add(args.IlcPathValue); } // ILC SDK Path if (!string.IsNullOrWhiteSpace(args.IlcSdkPathValue)) { nativeArgs.Add("--ilcsdkpath"); nativeArgs.Add(args.IlcSdkPathValue); } // AppDep SDK Path if (!string.IsNullOrWhiteSpace(args.AppDepSdkPathValue)) { nativeArgs.Add("--appdepsdk"); nativeArgs.Add(args.AppDepSdkPathValue); } // CodeGen Mode if (args.IsCppModeValue) { nativeArgs.Add("--mode"); nativeArgs.Add("cpp"); } if (!string.IsNullOrWhiteSpace(args.CppCompilerFlagsValue)) { nativeArgs.Add("--cppcompilerflags"); nativeArgs.Add(args.CppCompilerFlagsValue); } // Configuration if (args.ConfigValue != null) { nativeArgs.Add("--configuration"); nativeArgs.Add(args.ConfigValue); } // Architecture if (args.ArchValue != null) { nativeArgs.Add("--arch"); nativeArgs.Add(args.ArchValue); } // Intermediate Path nativeArgs.Add("--temp-output"); nativeArgs.Add($"{nativeTempOutput}"); // Output Path nativeArgs.Add("--output"); nativeArgs.Add($"{nativeOutputPath}"); // Write Response File var rsp = Path.Combine(nativeTempOutput, $"dotnet-compile-native.{context.ProjectFile.Name}.rsp"); File.WriteAllLines(rsp, nativeArgs); // TODO Add -r assembly.dll for all Nuget References // Need CoreRT Framework published to nuget // Do Native Compilation var result = Native.CompileNativeCommand.Run(new string[] { "--rsp", $"{rsp}" }); return result == 0; }
private static bool CompileNative( ProjectContext context, CompilerCommandApp args) { var outputPath = context.GetOutputPath(args.ConfigValue, args.OutputValue); var nativeOutputPath = Path.Combine(outputPath, "native"); var intermediateOutputPath = context.GetIntermediateOutputPath(args.ConfigValue, args.IntermediateValue, outputPath); var nativeIntermediateOutputPath = Path.Combine(intermediateOutputPath, "native"); Directory.CreateDirectory(nativeOutputPath); Directory.CreateDirectory(nativeIntermediateOutputPath); var compilationOptions = context.ProjectFile.GetCompilerOptions(context.TargetFramework, args.ConfigValue); var managedOutput = GetProjectOutput(context.ProjectFile, context.TargetFramework, args.ConfigValue, outputPath); var nativeArgs = new List <string>(); // Input Assembly nativeArgs.Add($"{managedOutput}"); // ILC Args if (!string.IsNullOrWhiteSpace(args.IlcArgsValue)) { nativeArgs.Add("--ilcargs"); nativeArgs.Add($"{args.IlcArgsValue}"); } // ILC Path if (!string.IsNullOrWhiteSpace(args.IlcPathValue)) { nativeArgs.Add("--ilcpath"); nativeArgs.Add(args.IlcPathValue); } // ILC SDK Path if (!string.IsNullOrWhiteSpace(args.IlcSdkPathValue)) { nativeArgs.Add("--ilcsdkpath"); nativeArgs.Add(args.IlcSdkPathValue); } // AppDep SDK Path if (!string.IsNullOrWhiteSpace(args.AppDepSdkPathValue)) { nativeArgs.Add("--appdepsdk"); nativeArgs.Add(args.AppDepSdkPathValue); } // CodeGen Mode if (args.IsCppModeValue) { nativeArgs.Add("--mode"); nativeArgs.Add("cpp"); } if (!string.IsNullOrWhiteSpace(args.CppCompilerFlagsValue)) { nativeArgs.Add("--cppcompilerflags"); nativeArgs.Add(args.CppCompilerFlagsValue); } // Configuration if (args.ConfigValue != null) { nativeArgs.Add("--configuration"); nativeArgs.Add(args.ConfigValue); } // Architecture if (args.ArchValue != null) { nativeArgs.Add("--arch"); nativeArgs.Add(args.ArchValue); } // Intermediate Path nativeArgs.Add("--temp-output"); nativeArgs.Add($"{nativeIntermediateOutputPath}"); // Output Path nativeArgs.Add("--output"); nativeArgs.Add($"{nativeOutputPath}"); // Write Response File var rsp = Path.Combine(nativeIntermediateOutputPath, $"dotnet-compile-native.{context.ProjectFile.Name}.rsp"); File.WriteAllLines(rsp, nativeArgs); // TODO Add -r assembly.dll for all Nuget References // Need CoreRT Framework published to nuget // Do Native Compilation var result = Command.Create("dotnet-compile-native", $"--rsp \"{rsp}\"") .ForwardStdErr() .ForwardStdOut() .Execute(); return(result.ExitCode == 0); }
private static bool CompileProject(ProjectContext context, CompilerCommandApp args) { // Set up Output Paths string outputPath = context.GetOutputPath(args.ConfigValue, args.OutputValue); string intermediateOutputPath = context.GetIntermediateOutputPath(args.ConfigValue, args.IntermediateValue, outputPath); Directory.CreateDirectory(outputPath); Directory.CreateDirectory(intermediateOutputPath); // Create the library exporter var exporter = context.CreateExporter(args.ConfigValue); // Gather exports for the project var dependencies = exporter.GetDependencies().ToList(); Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}"); var sw = Stopwatch.StartNew(); var diagnostics = new List <DiagnosticMessage>(); var missingFrameworkDiagnostics = new List <DiagnosticMessage>(); // Collect dependency diagnostics foreach (var diag in context.LibraryManager.GetAllDiagnostics()) { if (diag.ErrorCode == ErrorCodes.DOTNET1011 || diag.ErrorCode == ErrorCodes.DOTNET1012) { missingFrameworkDiagnostics.Add(diag); } diagnostics.Add(diag); } if (missingFrameworkDiagnostics.Count > 0) { // The framework isn't installed so we should short circuit the rest of the compilation // so we don't get flooded with errors PrintSummary(missingFrameworkDiagnostics, sw); return(false); } // Get compilation options var outputName = GetProjectOutput(context.ProjectFile, context.TargetFramework, args.ConfigValue, outputPath); // Assemble args var compilerArgs = new List <string>() { $"--temp-output:{intermediateOutputPath}", $"--out:{outputName}" }; var compilationOptions = context.ProjectFile.GetCompilerOptions(context.TargetFramework, args.ConfigValue); // Path to strong naming key in environment variable overrides path in project.json var environmentKeyFile = Environment.GetEnvironmentVariable(EnvironmentNames.StrongNameKeyFile); if (!string.IsNullOrWhiteSpace(environmentKeyFile)) { compilationOptions.KeyFile = environmentKeyFile; } else if (!string.IsNullOrWhiteSpace(compilationOptions.KeyFile)) { // Resolve full path to key file compilationOptions.KeyFile = Path.GetFullPath(Path.Combine(context.ProjectFile.ProjectDirectory, compilationOptions.KeyFile)); } var references = new List <string>(); // Add compilation options to the args compilerArgs.AddRange(compilationOptions.SerializeToArgs()); // Add metadata options compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context))); foreach (var dependency in dependencies) { var projectDependency = dependency.Library as ProjectDescription; if (projectDependency != null) { if (projectDependency.Project.Files.SourceFiles.Any()) { var projectOutputPath = GetProjectOutput(projectDependency.Project, projectDependency.Framework, args.ConfigValue, outputPath); references.Add(projectOutputPath); } } else { references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath)); } compilerArgs.AddRange(dependency.SourceReferences); } compilerArgs.AddRange(references.Select(r => $"--reference:{r}")); if (compilationOptions.PreserveCompilationContext == true) { var dependencyContext = DependencyContextBuilder.Build(compilationOptions, exporter, args.ConfigValue, context.TargetFramework, context.RuntimeIdentifier); var writer = new DependencyContextWriter(); var depsJsonFile = Path.Combine(intermediateOutputPath, context.ProjectFile.Name + "dotnet-compile.deps.json"); using (var fileStream = File.Create(depsJsonFile)) { writer.Write(dependencyContext, fileStream); } compilerArgs.Add($"--resource:\"{depsJsonFile}\",{context.ProjectFile.Name}.deps.json"); var refsFolder = Path.Combine(outputPath, "refs"); if (Directory.Exists(refsFolder)) { Directory.Delete(refsFolder, true); } Directory.CreateDirectory(refsFolder); foreach (var reference in references) { File.Copy(reference, Path.Combine(refsFolder, Path.GetFileName(reference))); } } if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath)) { return(false); } // Add project source files var sourceFiles = context.ProjectFile.Files.SourceFiles; compilerArgs.AddRange(sourceFiles); var compilerName = CompilerUtil.ResolveCompilerName(context); // Write RSP file var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.{context.ProjectFile.Name}.rsp"); File.WriteAllLines(rsp, compilerArgs); // Run pre-compile event var contextVariables = new Dictionary <string, string>() { { "compile:TargetFramework", context.TargetFramework.DotNetFrameworkName }, { "compile:Configuration", args.ConfigValue }, { "compile:OutputFile", outputName }, { "compile:OutputDir", outputPath }, { "compile:ResponseFile", rsp } }; RunScripts(context, ScriptNames.PreCompile, contextVariables); var result = Command.Create($"dotnet-compile-{compilerName}", $"@\"{rsp}\"") .OnErrorLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Error.WriteLine(line); } }) .OnOutputLine(line => { var diagnostic = ParseDiagnostic(context.ProjectDirectory, line); if (diagnostic != null) { diagnostics.Add(diagnostic); } else { Reporter.Output.WriteLine(line); } }).Execute(); // Run post-compile event contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString(); RunScripts(context, ScriptNames.PostCompile, contextVariables); var success = result.ExitCode == 0; if (success) { success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, outputPath); } if (success && !args.NoHostValue && compilationOptions.EmitEntryPoint.GetValueOrDefault()) { var rids = PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers(); var runtimeContext = ProjectContext.Create(context.ProjectDirectory, context.TargetFramework, rids); runtimeContext .MakeCompilationOutputRunnable(outputPath, args.ConfigValue); } return(PrintSummary(diagnostics, sw, success)); }