bool DoExecute() { var abis = SupportedAbis.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries); var results = new List <ITaskItem> (); string bundlepath = Path.Combine(TempOutputPath, "bundles"); if (!Directory.Exists(bundlepath)) { Directory.CreateDirectory(bundlepath); } else { Directory.Delete(bundlepath, true); } foreach (var abi in abis) { AndroidTargetArch arch = AndroidTargetArch.Other; switch (abi) { case "arm64": case "arm64-v8a": case "aarch64": arch = AndroidTargetArch.Arm64; break; case "armeabi-v7a": arch = AndroidTargetArch.Arm; break; case "x86": arch = AndroidTargetArch.X86; break; case "x86_64": arch = AndroidTargetArch.X86_64; break; case "mips": arch = AndroidTargetArch.Mips; break; } if (!NdkUtil.ValidateNdkPlatform(Log, AndroidNdkDirectory, arch, enableLLVM: false)) { return(false); } int level = NdkUtil.GetMinimumApiLevelFor(arch, AndroidNdkDirectory); var outpath = Path.Combine(bundlepath, abi); if (!Directory.Exists(outpath)) { Directory.CreateDirectory(outpath); } var clb = new CommandLineBuilder(); clb.AppendSwitch("--dos2unix=false"); clb.AppendSwitch("--nomain"); clb.AppendSwitch("--i18n none"); clb.AppendSwitch("--bundled-header"); clb.AppendSwitch("--mono-api-struct-path"); clb.AppendFileNameIfNotNull(BundleApiPath); clb.AppendSwitch("--style"); clb.AppendSwitch("linux"); clb.AppendSwitch("-c"); clb.AppendSwitch("-o"); clb.AppendFileNameIfNotNull(Path.Combine(outpath, "temp.c")); clb.AppendSwitch("-oo"); clb.AppendFileNameIfNotNull(Path.Combine(outpath, "assemblies.o")); if (AutoDeps) { clb.AppendSwitch("--autodeps"); } if (KeepTemp) { clb.AppendSwitch("--keeptemp"); } clb.AppendSwitch("-z"); // Compress clb.AppendFileNamesIfNotNull(Assemblies, " "); var psi = new ProcessStartInfo() { FileName = MkbundlePath, Arguments = clb.ToString(), UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true, CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Hidden, }; var gccNoQuotes = NdkUtil.GetNdkTool(AndroidNdkDirectory, arch, "gcc"); var gcc = '"' + gccNoQuotes + '"'; var gas = '"' + NdkUtil.GetNdkTool(AndroidNdkDirectory, arch, "as") + '"'; psi.EnvironmentVariables ["CC"] = gcc; psi.EnvironmentVariables ["AS"] = gas; Log.LogDebugMessage("CC=" + gcc); Log.LogDebugMessage("AS=" + gas); //psi.EnvironmentVariables ["PKG_CONFIG_PATH"] = Path.Combine (Path.GetDirectoryName (MonoDroidSdk.MandroidTool), "lib", abi); Log.LogDebugMessage("[mkbundle] " + psi.FileName + " " + clb); var proc = new Process(); proc.OutputDataReceived += OnMkbundleOutputData; proc.ErrorDataReceived += OnMkbundleErrorData; proc.StartInfo = psi; proc.Start(); proc.BeginOutputReadLine(); proc.BeginErrorReadLine(); proc.WaitForExit(); if (proc.ExitCode != 0) { Log.LogCodedError("XA5102", "Conversion from assembly to native code failed. Exit code {0}", proc.ExitCode); return(false); } // then compile temp.c into temp.o and ... clb = new CommandLineBuilder(); clb.AppendSwitch("-c"); // This is necessary only when unified headers are in use but it won't hurt to have it // defined even if we don't use them clb.AppendSwitch($"-D__ANDROID_API__={level}"); // This is necessary because of the injected code, which is reused between libmonodroid // and the bundle clb.AppendSwitch("-DANDROID"); clb.AppendSwitch("-o"); clb.AppendFileNameIfNotNull(Path.Combine(outpath, "temp.o")); if (!string.IsNullOrWhiteSpace(IncludePath)) { clb.AppendSwitch("-I"); clb.AppendFileNameIfNotNull(IncludePath); } string asmIncludePath = NdkUtil.GetNdkAsmIncludePath(AndroidNdkDirectory, arch, level); if (!String.IsNullOrEmpty(asmIncludePath)) { clb.AppendSwitch("-I"); clb.AppendFileNameIfNotNull(asmIncludePath); } clb.AppendSwitch("-I"); clb.AppendFileNameIfNotNull(NdkUtil.GetNdkPlatformIncludePath(AndroidNdkDirectory, arch, level)); clb.AppendFileNameIfNotNull(Path.Combine(outpath, "temp.c")); Log.LogDebugMessage("[CC] " + gcc + " " + clb); if (MonoAndroidHelper.RunProcess(gccNoQuotes, clb.ToString(), OnCcOutputData, OnCcErrorData) != 0) { Log.LogCodedError("XA5103", "NDK C compiler resulted in an error. Exit code {0}", proc.ExitCode); return(false); } // ... link temp.o and assemblies.o into app.so clb = new CommandLineBuilder(); clb.AppendSwitch("--shared"); clb.AppendFileNameIfNotNull(Path.Combine(outpath, "temp.o")); clb.AppendFileNameIfNotNull(Path.Combine(outpath, "assemblies.o")); clb.AppendSwitch("-o"); clb.AppendFileNameIfNotNull(Path.Combine(outpath, "libmonodroid_bundle_app.so")); clb.AppendSwitch("-L"); clb.AppendFileNameIfNotNull(NdkUtil.GetNdkPlatformLibPath(AndroidNdkDirectory, arch, level)); clb.AppendSwitch("-lc"); clb.AppendSwitch("-lm"); clb.AppendSwitch("-ldl"); clb.AppendSwitch("-llog"); clb.AppendSwitch("-lz"); // Compress string ld = NdkUtil.GetNdkTool(AndroidNdkDirectory, arch, "ld"); Log.LogMessage(MessageImportance.Normal, "[LD] " + ld + " " + clb); if (MonoAndroidHelper.RunProcess(ld, clb.ToString(), OnLdOutputData, OnLdErrorData) != 0) { Log.LogCodedError("XA5201", "NDK Linker resulted in an error. Exit code {0}", proc.ExitCode); return(false); } results.Add(new TaskItem(Path.Combine(outpath, "libmonodroid_bundle_app.so"))); } OutputNativeLibraries = results.ToArray(); return(true); }
/// <summary> /// Generates the SvnAdmin command. /// </summary> /// <returns></returns> protected virtual void AppendCommand(CommandLineBuilder commandLine) { commandLine.AppendSwitch(Command); commandLine.AppendFileNameIfNotNull(RepositoryPath); }
/// <summary> /// Generates the command line arguments. /// </summary> /// <returns> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override void AppendCommand(CommandLineBuilder commandLine) { base.AppendCommand(commandLine); commandLine.AppendFileNameIfNotNull(BackupPath); }
protected override string GenerateCommandLineCommands() { var cmd = new CommandLineBuilder(); #if DEBUG cmd.AppendSwitch("/v"); #endif if (NoStdLib) { cmd.AppendSwitch("/nostdlib"); } cmd.AppendSwitchIfNotNull("/compiler:", CompilerPath); cmd.AppendSwitchIfNotNull("/baselib:", BaseLibDll); cmd.AppendSwitchIfNotNull("/out:", OutputAssembly); if (NoStdLib) { string dir; if (!string.IsNullOrEmpty(BaseLibDll)) { dir = Path.GetDirectoryName(BaseLibDll); } else { dir = null; } cmd.AppendSwitchIfNotNull("/lib:", dir); cmd.AppendSwitchIfNotNull("/r:", Path.Combine(dir, "mscorlib.dll")); } if (ProcessEnums) { cmd.AppendSwitch("/process-enums"); } if (EmitDebugInformation) { cmd.AppendSwitch("/debug"); } if (AllowUnsafeBlocks) { cmd.AppendSwitch("/unsafe"); } cmd.AppendSwitchIfNotNull("/ns:", Namespace); if (!string.IsNullOrEmpty(DefineConstants)) { var strv = DefineConstants.Split(new [] { ';' }); var sanitized = new List <string> (); foreach (var str in strv) { if (str != string.Empty) { sanitized.Add(str); } } if (sanitized.Count > 0) { cmd.AppendSwitchIfNotNull("/d:", string.Join(";", sanitized.ToArray())); } } //cmd.AppendSwitch ("/e"); foreach (var item in ApiDefinitions) { cmd.AppendFileNameIfNotNull(Path.GetFullPath(item.ItemSpec)); } if (CoreSources != null) { foreach (var item in CoreSources) { cmd.AppendSwitchIfNotNull("/s:", Path.GetFullPath(item.ItemSpec)); } } if (Sources != null) { foreach (var item in Sources) { cmd.AppendSwitchIfNotNull("/x:", Path.GetFullPath(item.ItemSpec)); } } if (AdditionalLibPaths != null) { foreach (var item in AdditionalLibPaths) { cmd.AppendSwitchIfNotNull("/lib:", Path.GetFullPath(item.ItemSpec)); } } HandleReferences(cmd); if (Resources != null) { foreach (var item in Resources) { var args = new List <string> (); string id; args.Add(item.ToString()); id = item.GetMetadata("LogicalName"); if (!string.IsNullOrEmpty(id)) { args.Add(id); } cmd.AppendSwitchIfNotNull("/res:", args.ToArray(), ","); } } if (NativeLibraries != null) { foreach (var item in NativeLibraries) { var args = new List <string> (); string id; args.Add(item.ToString()); id = item.GetMetadata("LogicalName"); if (string.IsNullOrEmpty(id)) { id = Path.GetFileName(args[0]); } args.Add(id); cmd.AppendSwitchIfNotNull("/link-with:", args.ToArray(), ","); } } if (GeneratedSourcesDir != null) { cmd.AppendSwitchIfNotNull("/tmpdir:", Path.GetFullPath(GeneratedSourcesDir)); } if (GeneratedSourcesFileList != null) { cmd.AppendSwitchIfNotNull("/sourceonly:", Path.GetFullPath(GeneratedSourcesFileList)); } cmd.AppendSwitch(GetTargetFrameworkArgument()); if (!string.IsNullOrEmpty(ExtraArgs)) { var extraArgs = CommandLineArgumentBuilder.Parse(ExtraArgs); var target = OutputAssembly; string projectDir; if (ProjectDir.StartsWith("~/", StringComparison.Ordinal)) { // Note: Since the Visual Studio plugin doesn't know the user's home directory on the Mac build host, // it simply uses paths relative to "~/". Expand these paths to their full path equivalents. var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); projectDir = Path.Combine(home, ProjectDir.Substring(2)); } else { projectDir = ProjectDir; } var customTags = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase) { { "projectdir", projectDir }, // Apparently msbuild doesn't propagate the solution path, so we can't get it. // { "solutiondir", proj.ParentSolution != null ? proj.ParentSolution.BaseDirectory : proj.BaseDirectory }, { "targetpath", Path.Combine(Path.GetDirectoryName(target), Path.GetFileName(target)) }, { "targetdir", Path.GetDirectoryName(target) }, { "targetname", Path.GetFileName(target) }, { "targetext", Path.GetExtension(target) }, }; for (int i = 0; i < extraArgs.Length; i++) { var argument = extraArgs[i]; cmd.AppendTextUnquoted(StringParserService.Parse(argument, customTags)); } } return(cmd.ToString()); }
/// <summary> /// Generates the svn command. /// </summary> /// <returns></returns> protected virtual void AppendCommand(CommandLineBuilder commandLine) { commandLine.AppendSwitch(Command); // import has paths in diff order if (Command == Commands.Import) { commandLine.AppendFileNameIfNotNull(LocalPath); commandLine.AppendFileNameIfNotNull(RepositoryPath); } else { commandLine.AppendFileNameIfNotNull(RepositoryPath); commandLine.AppendFileNameIfNotNull(LocalPath); } }
protected override string GenerateCommandLineCommands() { // Running command: C:\Program Files (x86)\Java\jdk1.6.0_20\bin\java.exe // "-jar" "C:\Program Files (x86)\Android\android-sdk-windows\platform-tools\jill.jar" // "--output-dex" "bin\classes" // "-classpath" "C:\Users\Jonathan\Documents\Visual Studio 2010\Projects\AndroidMSBuildTest\AndroidMSBuildTest\obj\Debug\android\bin\mono.android.jar" // "@C:\Users\Jonathan\AppData\Local\Temp\tmp79c4ac38.tmp" //var android_dir = MonoDroid.MonoDroidSdk.GetAndroidProfileDirectory (TargetFrameworkDirectory); var doc = AndroidAppManifest.Load(ManifestFile, MonoAndroidHelper.SupportedVersions); int minApiVersion = doc.MinSdkVersion == null ? 4 : (int)doc.MinSdkVersion; var cmd = new CommandLineBuilder(); // Add the JavaOptions if they are not null // These could be any of the additional options if (!string.IsNullOrEmpty(JavaOptions)) { cmd.AppendSwitch(JavaOptions); } // Add the specific -XmxN to override the default heap size for the JVM // N can be in the form of Nm or NGB (e.g 100m or 1GB ) cmd.AppendSwitchIfNotNull("-Xmx", JavaMaximumHeapSize); cmd.AppendSwitchIfNotNull("-jar ", DesugarJarPath); cmd.AppendSwitch("--bootclasspath_entry "); cmd.AppendFileNameIfNotNull(JavaPlatformJarPath); cmd.AppendSwitch("--min_sdk_version "); cmd.AppendSwitch(minApiVersion.ToString()); if (minApiVersion < 24) { cmd.AppendSwitch("--desugar_try_with_resources_omit_runtime_classes "); } //cmd.AppendSwitchIfNotNull ("-J-Dfile.encoding=", "UTF8"); if (!string.IsNullOrEmpty(DesugarExtraArguments)) { cmd.AppendSwitch(DesugarExtraArguments); // it should contain "--dex". } var outputs = new List <string> (); var md5 = System.Security.Cryptography.MD5.Create(); foreach (var jar in InputJars) { var output = Path.Combine(OutputDirectory, BitConverter.ToString(md5.ComputeHash(Encoding.UTF8.GetBytes(jar))) + Path.GetFileName(jar)); outputs.Add(output); cmd.AppendSwitch("--classpath_entry "); cmd.AppendFileNameIfNotNull(jar); cmd.AppendSwitch("--input "); cmd.AppendFileNameIfNotNull(jar); cmd.AppendSwitch("--output "); cmd.AppendFileNameIfNotNull(output); } OutputJars = outputs.ToArray(); return(cmd.ToString()); }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { CommandLineBuilder builder = new CommandLineBuilder(); builder.AppendFileNameIfNotNull(_sourceFolder); builder.AppendFileNameIfNotNull(_destinationFolder); builder.AppendFileNamesIfNotNull(_sourceFiles, " "); if (_subdirectories) { builder.AppendSwitch("/S"); } if (_allSubdirectories) { builder.AppendSwitch("/E"); } if (_restartableMode) { builder.AppendSwitch("/Z"); } if (_backupMode) { builder.AppendSwitch("/B"); } builder.AppendSwitchIfNotNull("/COPY:", _copyFlags); if (_copyAll) { builder.AppendSwitch("/COPYALL"); } if (_noCopy) { builder.AppendSwitch("/NOCOPY"); } if (_security) { builder.AppendSwitch("/SEC"); } if (_moveFiles) { builder.AppendSwitch("/MOV"); } if (_move) { builder.AppendSwitch("/move"); } if (_purge) { builder.AppendSwitch("/PURGE"); } if (_mirror) { builder.AppendSwitch("/MIR"); } if (_noCopy) { builder.AppendSwitch("/NOCOPY"); } if (_create) { builder.AppendSwitch("/CREATE"); } if (_fatFileNames) { builder.AppendSwitch("/FAT"); } if (_fatFileTimes) { builder.AppendSwitch("/FFT"); } builder.AppendSwitchIfNotNull("/IA:", _includeAttributes); builder.AppendSwitchIfNotNull("/XA:", _excluedAttributes); if (_includeArchive) { builder.AppendSwitch("/A"); } if (_includeArchiveClear) { builder.AppendSwitch("/M"); } if (_excludeJunctions) { builder.AppendSwitch("/XJ"); } builder.AppendSwitchIfNotNull("/XF ", _excludeFiles, " "); builder.AppendSwitchIfNotNull("/XD ", _excludeFolders, " "); if (_verbose) { builder.AppendSwitch("/V"); } if (_noFileLogging) { builder.AppendSwitch("/NFL"); } if (_noFolderLogging) { builder.AppendSwitch("/NDL"); } if (_noJobHeader) { builder.AppendSwitch("/NJH"); } if (_noJobSummary) { builder.AppendSwitch("/NJS"); } if (_noProgress) { builder.AppendSwitch("/NP"); } builder.AppendSwitchIfNotNull("/LOG:", _logFile); builder.AppendSwitchIfNotNull("/LOG+:", _appendLogFile); builder.AppendSwitchIfNotNull("", _options, " "); return(builder.ToString()); }
protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitch("/nologo"); builder.AppendSwitch("/quiet"); builder.AppendFileNameIfNotNull(Source); if (Resource != null) { builder.AppendSwitch("/resource=\"" + Resource + "\""); } if (Output != null) { builder.AppendSwitch("/output=\"" + Output + "\""); } if (string.Compare(OutputType, "library", true) == 0 || (string.IsNullOrEmpty(OutputType) && Output != null && !".exe".Equals(Path.GetExtension(Output), StringComparison.InvariantCultureIgnoreCase))) { builder.AppendSwitch("/dll"); } if (NoAutoInherit) { builder.AppendSwitch("/noautoinherit"); } if (CreatePdb) { builder.AppendSwitch("/pdb"); } if (Optimize) { builder.AppendSwitch("/optimize"); } if (Fold) { builder.AppendSwitch("/fold"); } if (NoCorStub) { builder.AppendSwitch("/nocorstub"); } if (StripReloc) { builder.AppendSwitch("/stripreloc"); } if (!string.IsNullOrEmpty(Debug)) { try { var debug = Convert.ToBoolean(Debug); if (debug) { builder.AppendSwitch("/debug"); } } catch { builder.AppendSwitch("/debug=" + Debug.ToLower()); } } if (Key != null) { builder.AppendSwitch("/key=" + Key); } if (Include != null) { builder.AppendSwitch("/include=" + Include); } if (MDV != null) { builder.AppendSwitch("/mdv=" + MDV); } if (MSV != null) { builder.AppendSwitch("/msv=" + MSV); } if (string.Compare(Platform, "x64") == 0) { builder.AppendSwitch("/x64"); } if (string.Compare(Platform, "itanium") == 0) { builder.AppendSwitch("/itanium"); } if (Subsystem != 0) { builder.AppendSwitch("/subsystem=" + Subsystem); } if (Flags != 0) { builder.AppendSwitch("/flags=" + Flags); } if (Alignment != 0) { builder.AppendSwitch("/alignment=" + Alignment); } if (Base != 0) { builder.AppendSwitch("/base=" + Base); } if (Stack != 0) { builder.AppendSwitch("/stack=" + Stack); } Log.LogMessage(MessageImportance.High, "Assembling {0}...", Source); return(builder.ToString()); }
protected virtual CommandLineBuilder GetCommandLineBuilder() { var cmd = new CommandLineBuilder(); if (!string.IsNullOrEmpty(JavaOptions)) { cmd.AppendSwitch(JavaOptions); } cmd.AppendSwitchIfNotNull("-Xmx", JavaMaximumHeapSize); cmd.AppendSwitchIfNotNull("-jar ", JarPath); if (!string.IsNullOrEmpty(ExtraArguments)) { cmd.AppendSwitch(ExtraArguments); // it should contain "--dex". } if (Debug) { cmd.AppendSwitch("--debug"); } else { cmd.AppendSwitch("--release"); } //NOTE: if this is blank, we can omit --min-api in this call if (!string.IsNullOrEmpty(AndroidManifestFile)) { var doc = AndroidAppManifest.Load(AndroidManifestFile, MonoAndroidHelper.SupportedVersions); int minApiVersion = doc.MinSdkVersion == null ? 4 : (int)doc.MinSdkVersion; cmd.AppendSwitchIfNotNull("--min-api ", minApiVersion.ToString()); } if (!EnableDesugar) { cmd.AppendSwitch("--no-desugaring"); } var injars = new List <string> (); var libjars = new List <string> (); if (AlternativeJarLibrariesToEmbed?.Length > 0) { Log.LogDebugMessage(" processing AlternativeJarLibrariesToEmbed..."); foreach (var jar in AlternativeJarLibrariesToEmbed) { injars.Add(jar.ItemSpec); } } else if (JavaLibrariesToEmbed != null) { Log.LogDebugMessage(" processing ClassesZip, JavaLibrariesToEmbed..."); if (File.Exists(ClassesZip)) { injars.Add(ClassesZip); } foreach (var jar in JavaLibrariesToEmbed) { injars.Add(jar.ItemSpec); } } libjars.Add(JavaPlatformJarPath); if (JavaLibrariesToReference != null) { foreach (var jar in JavaLibrariesToReference) { libjars.Add(jar.ItemSpec); } } cmd.AppendSwitchIfNotNull("--output ", OutputDirectory); foreach (var jar in libjars) { cmd.AppendSwitchIfNotNull("--lib ", jar); } foreach (var jar in injars) { cmd.AppendFileNameIfNotNull(jar); } return(cmd); }
private static unsafe CommandLineBuilder Init_MakeConEmuCommandLine([NotNull] ConEmuStartInfo startinfo, [NotNull] HostContext hostcontext, [CanBeNull] AnsiLog ansilog, [NotNull] DirectoryInfo dirLocalTempRoot) { if (startinfo == null) { throw new ArgumentNullException(nameof(startinfo)); } if (hostcontext == null) { throw new ArgumentNullException(nameof(hostcontext)); } var cmdl = new CommandLineBuilder(); // This sets up hosting of ConEmu in our control cmdl.AppendSwitch("-InsideWnd"); cmdl.AppendFileNameIfNotNull("0x" + ((ulong)hostcontext.HWndParent).ToString("X")); // Don't use keyboard hooks in ConEmu when embedded cmdl.AppendSwitch("-NoKeyHooks"); // Basic settings, like fonts and hidden tab bar // Plus some of the properties on this class cmdl.AppendSwitch("-LoadCfgFile"); cmdl.AppendFileNameIfNotNull(Init_MakeConEmuCommandLine_EmitConfigFile(dirLocalTempRoot, startinfo, hostcontext)); if (!string.IsNullOrEmpty(startinfo.StartupDirectory)) { cmdl.AppendSwitch("-Dir"); cmdl.AppendFileNameIfNotNull(startinfo.StartupDirectory); } // ANSI Log file if (ansilog != null) { cmdl.AppendSwitch("-AnsiLog"); cmdl.AppendFileNameIfNotNull(ansilog.Directory.FullName); } if (dirLocalTempRoot == null) { throw new ArgumentNullException(nameof(dirLocalTempRoot)); } // This one MUST be the last switch cmdl.AppendSwitch("-cmd"); // Console mode command // NOTE: if placed AFTER the payload command line, otherwise somehow conemu hooks won't fetch the switch out of the cmdline, e.g. with some complicated git fetch/push cmdline syntax which has a lot of colons inside on itself string sConsoleExitMode; switch (startinfo.WhenConsoleProcessExits) { case WhenConsoleProcessExits.CloseConsoleEmulator: sConsoleExitMode = "n"; break; case WhenConsoleProcessExits.KeepConsoleEmulator: sConsoleExitMode = "c0"; break; case WhenConsoleProcessExits.KeepConsoleEmulatorAndShowMessage: sConsoleExitMode = "c"; break; default: throw new ArgumentOutOfRangeException("ConEmuStartInfo" + "::" + "WhenConsoleProcessExits", startinfo.WhenConsoleProcessExits, "This is not a valid enum value."); } cmdl.AppendSwitchIfNotNull("-cur_console:", $"{(startinfo.IsElevated ? "a" : "")}{sConsoleExitMode}"); // And the shell command line itself cmdl.AppendSwitch(startinfo.ConsoleProcessCommandLine); return(cmdl); }
/// <summary> /// Launches Visual Studio. /// </summary> /// <param name="arguments">The current <see cref="ProgramArguments" />.</param> /// <param name="visualStudioInstance">A <see cref="VisualStudioInstance" /> object representing which instance of Visual Studio to launch.</param> /// <param name="solutionFileFullPath">The full path to the solution file.</param> /// <param name="logger">A <see cref="ISlnGenLogger" /> to use for logging.</param> /// <returns>true if Visual Studio was launched, otherwise false.</returns> public static bool TryLaunch(ProgramArguments arguments, VisualStudioInstance visualStudioInstance, string solutionFileFullPath, ISlnGenLogger logger) { if (!arguments.ShouldLaunchVisualStudio()) { return(true); } if (!Utility.RunningOnWindows) { logger.LogWarning("Launching Visual Studio is not currently supported on your operating system."); return(true); } string devEnvFullPath = arguments.GetDevEnvFullPath(visualStudioInstance); if (!devEnvFullPath.IsNullOrWhiteSpace()) { visualStudioInstance = VisualStudioConfiguration.GetInstanceForPath(devEnvFullPath); } if (visualStudioInstance == null) { logger.LogError( Program.CurrentDevelopmentEnvironment.IsCorext ? $"Could not find a Visual Studio {Environment.GetEnvironmentVariable("VisualStudioVersion")} installation. Please do one of the following:\n a) Specify a full path to devenv.exe via the -vs command-line argument\n b) Update your corext.config to specify a version of MSBuild.Corext that matches a Visual Studio version you have installed\n c) Install a version of Visual Studio that matches the version of MSBuild.Corext in your corext.config" : "Could not find a Visual Studio installation. Please run from a command window that has MSBuild.exe on the PATH or specify the full path to devenv.exe via the -vs command-line argument"); return(false); } if (visualStudioInstance.IsBuildTools) { logger.LogError("Cannot use a BuildTools instance of Visual Studio."); return(false); } if (!File.Exists(devEnvFullPath)) { logger.LogError($"The specified path to Visual Studio ({devEnvFullPath}) does not exist or is inaccessible."); return(false); } CommandLineBuilder commandLineBuilder = new CommandLineBuilder(); commandLineBuilder.AppendFileNameIfNotNull(solutionFileFullPath); if (!arguments.ShouldLoadProjectsInVisualStudio()) { commandLineBuilder.AppendSwitch(DoNotLoadProjectsCommandLineArgument); } try { Process process = new Process { StartInfo = new ProcessStartInfo { FileName = devEnvFullPath, Arguments = commandLineBuilder.ToString(), UseShellExecute = false, }, }; logger.LogMessageHigh("Launching Visual Studio..."); logger.LogMessageLow(" FileName = {0}", process.StartInfo.FileName); logger.LogMessageLow(" Arguments = {0}", process.StartInfo.Arguments); if (!process.Start()) { logger.LogError("Failed to launch Visual Studio."); } } catch (Exception e) { logger.LogError($"Failed to launch Visual Studio. {e.Message}"); } return(true); }
private void AppendScriptCommands(CommandLineBuilder builder) { builder.AppendSwitch("script"); builder.AppendFileNameIfNotNull(_output); builder.AppendSwitch("-f"); }
internal static string GenerateCompilerCommandLine( string outputFolder, ITaskItem[] references, ITaskItem[] sources, bool emitDebugInformation, string[] disabledWarnings) { var builder = new CommandLineBuilder(); #region javac <options> <source files> /* where possible options include: * -g Generate all debugging info * -g:none Generate no debugging info * -g:{lines,vars,source} Generate only some debugging info * -nowarn Generate no warnings * -verbose Output messages about what the compiler is doing * -deprecation Output source locations where deprecated APIs are used * -classpath <path> Specify where to find user class files and annotation processors * -cp <path> Specify where to find user class files and annotation processors * -sourcepath <path> Specify where to find input source files * -bootclasspath <path> Override location of bootstrap class files * -extdirs <dirs> Override location of installed extensions * -endorseddirs <dirs> Override location of endorsed standards path * -proc:{none,only} Control whether annotation processing and/or compilation is done. * -processor <class1>[,<class2>,<class3>...]Names of the annotation processors to run; bypasses default discovery process * -processorpath <path> Specify where to find annotation processors * -d <directory> Specify where to place generated class files * -s <directory> Specify where to place generated source files * -implicit:{none,class} Specify whether or not to generate class files for implicitly referenced files * -encoding <encoding> Specify character encoding used by source files * -source <release> Provide source compatibility with specified release * -target <release> Generate class files for specific VM version * -version Version information * -help Print a synopsis of standard options * -Akey[=value] Options to pass to annotation processors * -X Print a synopsis of nonstandard options * -J<flag> Pass <flag> directly to the runtime system */ #endregion #region Debugging information if (emitDebugInformation) { builder.AppendSwitch("-g"); } else { builder.AppendSwitch("-g:none"); } #endregion builder.AppendSwitch("-d"); builder.AppendFileNameIfNotNull(outputFolder); builder.AppendSwitch("-Xlint:all"); if (disabledWarnings != null) { foreach (string warning in disabledWarnings) { builder.AppendSwitch("-Xlint:-" + warning); } } #region Project references built into a classpath if (references != null) { builder.AppendSwitch("-classpath"); builder.AppendSwitch('"' + references.Join(";", (item) => item.GetMetadata("HintPath")) + '"'); } #endregion builder.AppendFileNamesIfNotNull(sources, " "); var result = builder.ToString(); return(result); }
/// <summary> /// Gets the MSBuild command-line based on the current properties of this object. /// </summary> /// <param name="useShortSwitchNames"><code>true</code> to use short command-line argument switches like '/nr' instead of '/NodeReuse', otherwise <code>false</code>.</param> /// <returns></returns> public string ToString(bool useShortSwitchNames) { CommandLineBuilder commandLineBuilder = new CommandLineBuilder(); commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "t" : "Target")}:", Targets); commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "p" : "Property")}:", Properties); commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "m" : "MaxCpuCount")}:", MaxCpuCount, minValue: 1); commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "tv" : "ToolsVersion")}:", ToolsVersion); commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "v" : "Verbosity")}:", Verbosity); commandLineBuilder.AppendSwitchIfNotNullOrEmpty($"/{(useShortSwitchNames ? "val" : "Validate")}:", Validate); commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "ignore" : "IgnoreProjectExtensions")}:", IgnoreProjectExtensions); if (ConsoleLoggerParameters != null) { commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "clp" : "ConsoleLoggerParameters")}:", ConsoleLoggerParameters.ToString(useShortSwitchNames)); } commandLineBuilder.AppendSwitchIfTrue($"/{(useShortSwitchNames ? "dfl" : "DistributedFileLogger")}", DistributedFileLogger); foreach (MSBuildLoggerParameters logger in Loggers) { commandLineBuilder.AppendSwitch($"\"/{(useShortSwitchNames ? "l" : "Logger")}:{logger}\""); } commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "nr" : "NodeReuse")}:", NodeReuse); commandLineBuilder.AppendSwitchIfTrue($"/{(useShortSwitchNames ? "noconlog" : "NoConsoleLogger")}", NoConsoleLogger); for (int i = 0; i < FileLoggers.Count; i++) { string index = FileLoggers.Count > 1 ? i.ToString() : String.Empty; commandLineBuilder.AppendSwitch($"/{(useShortSwitchNames ? "fl" : "FileLogger")}{index}"); commandLineBuilder.AppendSwitchIfNotNull($"/{(useShortSwitchNames ? "flp" : "FileLoggerParameters")}{index}:", FileLoggers[i].ToString(useShortSwitchNames)); } foreach (MSBuildDistributedLoggerParameters distributedLogger in DistributedLoggers) { commandLineBuilder.AppendSwitch($"\"/{(useShortSwitchNames ? "dl" : "DistributedLogger")}:{distributedLogger}\""); } if (BinaryLogger != null) { commandLineBuilder.AppendSwitch($"/{(useShortSwitchNames ? "bl" : "BinaryLogger")}{BinaryLogger}"); } commandLineBuilder.AppendSwitchIfNotNullOrEmpty($"/{(useShortSwitchNames ? "pp" : "PreProcess")}:", PreProcess); commandLineBuilder.AppendSwitchIfTrue($"/{(useShortSwitchNames ? "ds" : "DetailedSummary")}", DetailedSummary); commandLineBuilder.AppendSwitchIfTrue($"/{(useShortSwitchNames ? "noautorsp" : "NoAutoResponse")}", NoAutoResponse); commandLineBuilder.AppendSwitchIfTrue("/NoLogo", NoLogo); commandLineBuilder.AppendSwitchIfTrue($"/{(useShortSwitchNames ? "ver" : "Version")}", Version); foreach (string responseFile in ResponseFiles.Where(i => !String.IsNullOrWhiteSpace(i))) { commandLineBuilder.AppendSwitch("@"); commandLineBuilder.AppendTextUnquoted($"\"{responseFile}\""); } commandLineBuilder.AppendFileNameIfNotNull(Project); return(commandLineBuilder.ToString()); }
/// <summary> /// Launches Visual Studio. /// </summary> /// <param name="arguments">The current <see cref="ProgramArguments" />.</param> /// <param name="visualStudioInstance">A <see cref="VisualStudioInstance" /> object representing which instance of Visual Studio to launch.</param> /// <param name="solutionFileFullPath">The full path to the solution file.</param> /// <param name="logger">A <see cref="ISlnGenLogger" /> to use for logging.</param> /// <returns>true if Visual Studio was launched, otherwise false.</returns> public static bool TryLaunch(ProgramArguments arguments, VisualStudioInstance visualStudioInstance, string solutionFileFullPath, ISlnGenLogger logger) { if (!arguments.ShouldLaunchVisualStudio()) { return(true); } bool loadProjectsInVisualStudio = arguments.ShouldLoadProjectsInVisualStudio(); bool enableShellExecute = arguments.EnableShellExecute(); string devEnvFullPath = arguments.DevEnvFullPath?.LastOrDefault(); if (!enableShellExecute || !loadProjectsInVisualStudio || Program.IsCorext) { if (devEnvFullPath.IsNullOrWhiteSpace()) { if (visualStudioInstance == null) { logger.LogError( Program.IsCorext ? $"Could not find a Visual Studio {Environment.GetEnvironmentVariable("VisualStudioVersion")} installation. Please do one of the following:\n a) Specify a full path to devenv.exe via the -vs command-line argument\n b) Update your corext.config to specify a version of MSBuild.Corext that matches a Visual Studio version you have installed\n c) Install a version of Visual Studio that matches the version of MSBuild.Corext in your corext.config" : "Could not find a Visual Studio installation. Please specify the full path to devenv.exe via the -vs command-line argument"); return(false); } if (visualStudioInstance.IsBuildTools) { logger.LogError("Cannot use a BuildTools instance of Visual Studio."); return(false); } devEnvFullPath = Path.Combine(visualStudioInstance.InstallationPath, "Common7", "IDE", "devenv.exe"); } } if (solutionFileFullPath.IsNullOrWhiteSpace()) { throw new ArgumentNullException(nameof(solutionFileFullPath)); } CommandLineBuilder commandLineBuilder = new CommandLineBuilder(); ProcessStartInfo processStartInfo; if (!devEnvFullPath.IsNullOrWhiteSpace()) { if (!File.Exists(devEnvFullPath)) { logger.LogError($"The specified path to Visual Studio ({devEnvFullPath}) does not exist or is inaccessible."); return(false); } processStartInfo = new ProcessStartInfo { FileName = devEnvFullPath !, UseShellExecute = false, }; commandLineBuilder.AppendFileNameIfNotNull(solutionFileFullPath); if (!arguments.ShouldLoadProjectsInVisualStudio()) { commandLineBuilder.AppendSwitch(DoNotLoadProjectsCommandLineArgument); } } else { processStartInfo = new ProcessStartInfo { FileName = solutionFileFullPath, UseShellExecute = true, }; } try { processStartInfo.Arguments = commandLineBuilder.ToString(); Process process = new Process { StartInfo = processStartInfo, }; logger.LogMessageHigh("Launching Visual Studio..."); logger.LogMessageLow(" FileName = {0}", processStartInfo.FileName); logger.LogMessageLow(" Arguments = {0}", processStartInfo.Arguments); logger.LogMessageLow(" UseShellExecute = {0}", processStartInfo.UseShellExecute); logger.LogMessageLow(" WindowStyle = {0}", processStartInfo.WindowStyle); if (!process.Start()) { logger.LogError("Failed to launch Visual Studio."); } } catch (Exception e) { logger.LogError($"Failed to launch Visual Studio. {e.Message}"); } return(true); }