コード例 #1
0
        protected void AppendAdbOptions(CommandLineBuilder cmd)
        {
            var adb = string.IsNullOrEmpty(AdbToolExe) ? AdbToolName : AdbToolExe;

            cmd.AppendSwitchIfNotNull("--adb ", Path.Combine(AdbToolPath, adb));

            var adbTarget = AdbTarget;

            if (!string.IsNullOrEmpty(adbTarget))
            {
                // Normally of the form "-s emulator-5554"
                int index = adbTarget.IndexOf(' ');
                if (index != -1)
                {
                    adbTarget = adbTarget.Substring(index + 1, adbTarget.Length - index - 1);
                }
                cmd.AppendSwitchIfNotNull("--device-id ", adbTarget);
            }
        }
コード例 #2
0
 protected virtual void HandleReferences(CommandLineBuilder cmd)
 {
     if (References != null)
     {
         foreach (var item in References)
         {
             cmd.AppendSwitchIfNotNull("-r ", Path.GetFullPath(item.ItemSpec));
         }
     }
 }
コード例 #3
0
 /// <summary>
 /// Appends an array of command line switches. The switch name is repeated for each value.
 /// </summary>
 /// <param name="builder"></param>
 /// <param name="switchName"></param>
 /// <param name="values"></param>
 public static void AppendArrayIfNotNull(this CommandLineBuilder builder, string switchName, string[] values)
 {
     if (values != null)
     {
         foreach (string value in values)
         {
             builder.AppendSwitchIfNotNull(switchName, value);
         }
     }
 }
コード例 #4
0
 /// <summary>
 /// Append a switch to the command line if any values in the array have been specified.
 /// </summary>
 /// <param name="commandLine">Command line builder.</param>
 /// <param name="switchName">Switch to append.</param>
 /// <param name="values">Values specified by the user.</param>
 internal static void AppendArrayIfNotNull(CommandLineBuilder commandLine, string switchName, ITaskItem[] values)
 {
     if (values != null)
     {
         foreach (ITaskItem value in values)
         {
             commandLine.AppendSwitchIfNotNull(switchName, value);
         }
     }
 }
コード例 #5
0
ファイル: CompileToolTask.cs プロジェクト: mthalman/arcade
 protected override string GenerateCommandLineCommands()
 {
     CommandLineBuilder.AppendSwitchIfNotNull("-out ", OutputPath);
     // No trailing space, preprocessor definitions are passed as -d<Variable>=<Value>
     CommandLineBuilder.AppendArrayIfNotNull("-d", PreprocessorDefinitions.ToArray());
     CommandLineBuilder.AppendArrayIfNotNull("-ext ", Extensions.ToArray());
     CommandLineBuilder.AppendSwitchIfNotNull("-arch ", Arch);
     CommandLineBuilder.AppendFileNamesIfNotNull(SourceFiles.ToArray(), " ");
     return(CommandLineBuilder.ToString());
 }
コード例 #6
0
ファイル: NuGetPack.cs プロジェクト: vpfau/msbuildtasks
        /// <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()
        {
            var builder = new CommandLineBuilder();

            builder.AppendSwitch("pack");
            builder.AppendFileNameIfNotNull(File);
            builder.AppendSwitchIfNotNull("-OutputDirectory ", OutputDirectory);
            builder.AppendSwitchIfNotNull("-BasePath ", BasePath);
            builder.AppendSwitchIfNotNull("-Version ", Version);
            builder.AppendSwitchIfNotNull("-Verbosity ", Verbosity);
            builder.AppendSwitchIfNotNull("-MinClientVersion", MinClientVersion);

            if (ExcludeEmptyDirectories)
            {
                builder.AppendSwitch("-ExcludeEmptyDirectories");
            }

            if (Build)
            {
                builder.AppendSwitch("-Build");
            }

            if (Tool)
            {
                builder.AppendSwitch("-Tool");
            }

            // backward compatible with old Verbose property
            if (Verbosity == null && Verbose)
            {
                builder.AppendSwitch("-Verbosity detailed");
            }

            if (Symbols)
            {
                builder.AppendSwitch("-Symbols");
            }

            if (NoDefaultExcludes)
            {
                builder.AppendSwitch("-NoDefaultExcludes");
            }

            if (NoPackageAnalysis)
            {
                builder.AppendSwitch("-NoPackageAnalysis");
            }

            if (IncludeReferencedProjects)
            {
                builder.AppendSwitch("-IncludeReferencedProjects");
            }

            builder.AppendSwitchIfNotNull("-Exclude", Exclude);
            builder.AppendSwitchIfNotNull("-Properties ", Properties);

            return(builder.ToString());
        }
コード例 #7
0
        void GenerateMainDexListBuilderCommands(CommandLineBuilder cmd)
        {
            var jars = JavaLibraries.Select(i => i.ItemSpec).Concat(new string [] { ClassesOutputDirectory });

            cmd.AppendSwitchIfNotNull("-Djava.ext.dirs=", Path.Combine(AndroidSdkBuildToolsPath, "lib"));
            cmd.AppendSwitch("com.android.multidex.MainDexListBuilder");
            cmd.AppendSwitch(tempJar);
            cmd.AppendSwitchUnquotedIfNotNull("", "\"" + string.Join($"{Path.PathSeparator}", jars) + "\"");
            writeOutputToKeepFile = true;
        }
コード例 #8
0
ファイル: SvnClient.cs プロジェクト: springtg/SvnTools
        /// <summary>
        /// Generates the svn arguments.
        /// </summary>
        /// <returns></returns>
        protected virtual void AppendArguments(CommandLineBuilder commandLine)
        {
            commandLine.AppendSwitchIfNotNull("--username ", Username);
            commandLine.AppendSwitchIfNotNull("--password ", Password);
            commandLine.AppendSwitchIfNotNull("--message ", Message);

            commandLine.AppendSwitchIfTrue("--force", Force);
            commandLine.AppendSwitchIfTrue("--verbose", Verbose);

            commandLine.AppendSwitchIfTrue("--xml", Xml);
            commandLine.AppendSwitchIfTrue("--non-interactive", NonInteractive);
            commandLine.AppendSwitchIfTrue("--no-auth-cache", NoAuthCache);

            // raw arguments
            if (!string.IsNullOrEmpty(Arguments))
            {
                commandLine.AppendSwitch(Arguments);
            }
        }
コード例 #9
0
        /// <summary>
        /// Generates the commands for the switches that may have an array of arguments
        /// The switch may be empty.
        /// </summary>
        /// <remarks>For stringarray switches (e.g., Sources), the CommandLineToolSwitchName (if it exists) is emitted
        /// along with each and every one of the file names separately (if no separator is included), or with all of the
        /// file names separated by the separator.
        /// e.g., AdditionalIncludeDirectores = "@(Files)" where Files has File1, File2, and File3, the switch
        /// /IFile1 /IFile2 /IFile3 or the switch /IFile1;File2;File3 is emitted (the latter case has a separator
        /// ";" specified)</remarks>
        private static void EmitStringArraySwitch(CommandLineBuilder clb, CommandLineToolSwitch commandLineToolSwitch)
        {
            var stringList = new List <string>(commandLineToolSwitch.StringList.Length);

            for (int i = 0; i < commandLineToolSwitch.StringList.Length; ++i)
            {
                // Make sure the file doesn't contain escaped " (\")
                string value;
                if (commandLineToolSwitch.StringList[i].StartsWith("\"", StringComparison.OrdinalIgnoreCase) && commandLineToolSwitch.StringList[i].EndsWith("\"", StringComparison.OrdinalIgnoreCase))
                {
                    value = commandLineToolSwitch.StringList[i].Substring(1, commandLineToolSwitch.StringList[i].Length - 2).Trim();
                }
                else
                {
                    value = commandLineToolSwitch.StringList[i].Trim();
                }

                if (!String.IsNullOrEmpty(value))
                {
                    stringList.Add(value);
                }
            }

            string[] arrTrimStringList = stringList.ToArray();

            if (String.IsNullOrEmpty(commandLineToolSwitch.Separator))
            {
                foreach (string fileName in arrTrimStringList)
                {
                    if (!PerformSwitchValueSubstition(clb, commandLineToolSwitch, fileName))
                    {
                        clb.AppendSwitchIfNotNull(commandLineToolSwitch.SwitchValue, fileName);
                    }
                }
            }
            else
            {
                if (!PerformSwitchValueSubstition(clb, commandLineToolSwitch, String.Join(commandLineToolSwitch.Separator, arrTrimStringList)))
                {
                    clb.AppendSwitchIfNotNull(commandLineToolSwitch.SwitchValue, arrTrimStringList, commandLineToolSwitch.Separator);
                }
            }
        }
コード例 #10
0
        protected override string GenerateCommandLineCommands()
        {
            CommandLineBuilder.AppendSwitchIfNotNull("-o ", OutputFile);
            CommandLineBuilder.AppendSwitchIfTrue("-fv", AddFileVersion);
            CommandLineBuilder.AppendArrayIfNotNull("-ext ", Extensions.ToArray());
            CommandLineBuilder.AppendSwitchIfNotNull("-sice:", SuppressIces);
            CommandLineBuilder.AppendFileNamesIfNotNull(SourceFiles.ToArray(), " ");

            return(CommandLineBuilder.ToString());
        }
コード例 #11
0
        /// <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 commandLine = new CommandLineBuilder();

            commandLine.AppendSwitchIfNotNull("-c:", this.HelpCompiler);
            commandLine.AppendFileNameIfNotNull(this.TableOfContents);
            commandLine.AppendFileNameIfNotNull(this.HelpFile);

            return(commandLine.ToString());
        }
コード例 #12
0
        public void AppendSwitchWithParameterArrayQuoting()
        {
            CommandLineBuilder c = new CommandLineBuilder();

            c.AppendSwitch("/something");
            c.AppendSwitchIfNotNull("/switch:", new string[] { "Mer cury.cs", "Ve nus.cs", "Ear th.cs" }, ",");

            // Managed compilers use this function to append sources files.
            Assert.AreEqual("/something /switch:\"Mer cury.cs\",\"Ve nus.cs\",\"Ear th.cs\"", c.ToString());
        }
コード例 #13
0
 public static void AppendSwitchIfAny(this CommandLineBuilder commandLineBuilder, string switchName, IEnumerable <ITaskItem> items)
 {
     if (items != null)
     {
         foreach (var item in items)
         {
             commandLineBuilder.AppendSwitchIfNotNull(switchName, item.ItemSpec);
         }
     }
 }
コード例 #14
0
 /// <summary>
 /// Append a switch to the command line if any values in the array have been specified.
 /// </summary>
 /// <param name="commandLine">Command line builder.</param>
 /// <param name="switchName">Switch to append.</param>
 /// <param name="values">Values specified by the user.</param>
 internal static void AppendArrayIfNotNull(CommandLineBuilder commandLine, string switchName, string[] values)
 {
     if (values != null)
     {
         for (int i = 0; i < values.Length; i++)
         {
             commandLine.AppendSwitchIfNotNull(switchName, values[i]);
         }
     }
 }
コード例 #15
0
        public void AppendSwitchWithParameterArrayQuotingTaskItem()
        {
            CommandLineBuilder c = new CommandLineBuilder();

            c.AppendSwitch("/something");
            c.AppendSwitchIfNotNull("/switch:", new[] { new TaskItem("Mer cury.cs"), null, new TaskItem("Ve nus.cs"), new TaskItem("Ear th.cs") }, ",");

            // Managed compilers use this function to append sources files.
            c.ShouldBe("/something /switch:\"Mer cury.cs\",,\"Ve nus.cs\",\"Ear th.cs\"");
        }
コード例 #16
0
        protected override string GenerateCommandLineCommands()
        {
            var cmd = new CommandLineBuilder();

            cmd.AppendSwitch("--quiet");
            if (ConfigFiles != null && ConfigFiles.Any())
            {
                var config     = MergeConfigFiles();
                var configPath = Path.Combine(IntermediateOutputPath, "lint.xml");
                config.Save(configPath);
                cmd.AppendSwitchIfNotNull("--config ", configPath);
            }
            cmd.AppendSwitchIfNotNull("--enable ", EnabledIssues);
            cmd.AppendSwitchIfNotNull("--disable ", DisabledIssues);
            cmd.AppendSwitchIfNotNull("--check ", CheckIssues);
            foreach (var item in ResourceDirectories)
            {
                cmd.AppendSwitchIfNotNull("--resources ", item.ItemSpec);
            }
            foreach (var item in SourceDirectories)
            {
                cmd.AppendSwitchIfNotNull("--sources ", item.ItemSpec);
            }
            foreach (var item in ClassDirectories)
            {
                cmd.AppendSwitchIfNotNull("--classpath ", item.ItemSpec);
            }
            foreach (var item in ClassPathJars)
            {
                cmd.AppendSwitchIfNotNull("--classpath ", item.ItemSpec);
            }
            foreach (var item in LibraryDirectories)
            {
                cmd.AppendSwitchIfNotNull("--libraries ", item.ItemSpec);
            }
            foreach (var item in LibraryJars)
            {
                cmd.AppendSwitchIfNotNull("--libraries ", item.ItemSpec);
            }
            cmd.AppendFileNameIfNotNull(TargetDirectory);
            return(cmd.ToString());
        }
コード例 #17
0
ファイル: PdbStr.cs プロジェクト: julthep/CommunityServer
        /// <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()
        {
            // pdbstr -r/w -p:PdbFileName -i:StreamFileName -s:StreamName
            var builder = new CommandLineBuilder();

            if (string.Equals("write", Command, StringComparison.OrdinalIgnoreCase))
            {
                builder.AppendSwitch("-w");
            }
            else
            {
                builder.AppendSwitch("-r");
            }

            builder.AppendSwitchIfNotNull("-p:", PdbFile);
            builder.AppendSwitchIfNotNull("-i:", StreamFile);
            builder.AppendSwitchIfNotNull("-s:", StreamName);

            return(builder.ToString());
        }
コード例 #18
0
        void GenerateMainDexListBuilderCommands(CommandLineBuilder cmd)
        {
            var enclosingChar = OS.IsWindows ? "\"" : "'";
            var jars          = JavaLibraries.Select(i => i.ItemSpec).Concat(new string [] { Path.Combine(ClassesOutputDirectory, "classes.zip") });

            cmd.AppendSwitchIfNotNull("-Djava.ext.dirs=", Path.Combine(AndroidSdkBuildToolsPath, "lib"));
            cmd.AppendSwitch("com.android.multidex.MainDexListBuilder");
            cmd.AppendSwitchUnquotedIfNotNull("", $"{enclosingChar}{tempJar}{enclosingChar}");
            cmd.AppendSwitchUnquotedIfNotNull("", enclosingChar + string.Join($"{enclosingChar}{Path.PathSeparator}{enclosingChar}", jars) + enclosingChar);
            writeOutputToKeepFile = true;
        }
コード例 #19
0
        /// <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()
        {
            var builder = new CommandLineBuilder();

            builder.AppendSwitch("pack");
            builder.AppendFileNameIfNotNull(File);
            builder.AppendSwitchIfNotNull("-OutputDirectory ", OutputDirectory);
            builder.AppendSwitchIfNotNull("-BasePath ", BasePath);
            builder.AppendSwitchIfNotNull("-Version ", Version);
            if (Verbose)
            {
                builder.AppendSwitch("-Verbose");
            }
            if (Symbols)
            {
                builder.AppendSwitch("-Symbols");
            }

            return(builder.ToString());
        }
        public static void AppendSwitchIfNotNullOrEmpty(this CommandLineBuilder commandLine, string switchName, string parameter)
        {
            Contract.Requires <ArgumentNullException>(commandLine != null, "commandLine");
            Contract.Requires <ArgumentNullException>(switchName != null, "switchName");
            Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(switchName));

            if (!string.IsNullOrEmpty(parameter))
            {
                commandLine.AppendSwitchIfNotNull(switchName, parameter);
            }
        }
コード例 #21
0
ファイル: Javac.cs プロジェクト: pjcollins/xamarin-android
        protected override string GenerateCommandLineCommands()
        {
            //   Running command: C:\Program Files (x86)\Java\jdk1.6.0_20\bin\javac.exe
            //     "-J-Dfile.encoding=UTF8"
            //     "-d" "bin\classes"
            //     "-classpath" "C:\Users\Jonathan\Documents\Visual Studio 2010\Projects\AndroidMSBuildTest\AndroidMSBuildTest\obj\Debug\android\bin\mono.android.jar"
            //     "-bootclasspath" "C:\Program Files (x86)\Android\android-sdk-windows\platforms\android-8\android.jar"
            //     "-encoding" "UTF-8"
            //     "@C:\Users\Jonathan\AppData\Local\Temp\tmp79c4ac38.tmp"

            var cmd = new CommandLineBuilder();

            cmd.AppendSwitchIfNotNull("-J-Dfile.encoding=", "UTF8");

            cmd.AppendFileNameIfNotNull(string.Format("@{0}", TemporarySourceListFile));
            cmd.AppendSwitchIfNotNull("-target ", JavacTargetVersion);
            cmd.AppendSwitchIfNotNull("-source ", JavacSourceVersion);

            return(cmd.ToString());
        }
コード例 #22
0
        /// <inheritdoc/>
        protected override string GenerateCommandLineCommands()
        {
            var commandLineBuilder = new CommandLineBuilder();

            commandLineBuilder.AppendFileNameIfNotNull(this.Assembly);
            commandLineBuilder.AppendSwitchIfNotNull("/regfile:", RegAsm.GetRegFileTaskItem(this.Assembly));

            var result = commandLineBuilder.ToString();

            return(result);
        }
コード例 #23
0
        protected virtual CommandLineBuilder GetCommandLineBuilder()
        {
            var cmd = new CommandLineBuilder();

            if (!string.IsNullOrEmpty(JavaOptions))
            {
                cmd.AppendSwitch(JavaOptions);
            }
            cmd.AppendSwitchIfNotNull("-Xmx", JavaMaximumHeapSize);
            cmd.AppendSwitchIfNotNull("-cp ", $"{ManifestMergerJarPath}");
            cmd.AppendSwitch("com.xamarin.manifestmerger.Main");
            StringBuilder sb = new StringBuilder();

            sb.AppendLine("--main");
            sb.AppendLine(AndroidManifest);
            if (LibraryManifestFiles != null)
            {
                sb.AppendLine("--libs");
                sb.AppendLine($"{string.Join ($"{Path.PathSeparator}", LibraryManifestFiles)}");
            }
            if (ManifestPlaceholders != null)
            {
                foreach (var entry in ManifestPlaceholders.Select(e => e.Split(new char [] { '=' }, 2, StringSplitOptions.None)))
                {
                    if (entry.Length == 2)
                    {
                        sb.AppendLine("--placeholder");
                        sb.AppendLine($"{entry [0]}={entry [1]}");
                    }
                    else
                    {
                        Log.LogCodedWarning("XA1010", string.Format(Properties.Resources.XA1010, string.Join(";", ManifestPlaceholders)));
                    }
                }
            }
            sb.AppendLine("--out");
            sb.AppendLine(tempFile);
            File.WriteAllText(responseFile, sb.ToString());
            cmd.AppendFileNameIfNotNull(responseFile);
            return(cmd);
        }
コード例 #24
0
        protected virtual CommandLineBuilder GetCommandLineBuilder()
        {
            var cmd = new CommandLineBuilder();

            if (!string.IsNullOrEmpty(JavaOptions))
            {
                cmd.AppendSwitch(JavaOptions);
            }
            cmd.AppendSwitchIfNotNull("-Xmx", JavaMaximumHeapSize);
            cmd.AppendSwitchIfNotNull("-cp ", $"{ManifestMergerJarPath}");
            cmd.AppendSwitch("com.xamarin.manifestmerger.Main");
            StringBuilder sb = new StringBuilder();

            sb.AppendLine("--main");
            sb.AppendLine(AndroidManifest);
            if (LibraryManifestFiles != null)
            {
                sb.AppendLine("--libs");
                sb.AppendLine($"{string.Join ($"{Path.PathSeparator}", LibraryManifestFiles)}");
            }
            if (ManifestPlaceholders != null)
            {
                foreach (var entry in ManifestPlaceholders.Select(e => e.Split(new char [] { '=' }, 2, StringSplitOptions.None)))
                {
                    if (entry.Length == 2)
                    {
                        sb.AppendLine("--placeholder");
                        sb.AppendLine($"{entry [0]}={entry [1]}");
                    }
                    else
                    {
                        Log.LogWarning("Invalid application placeholders (AndroidApplicationPlaceholders) value. Use 'key1=value1;key2=value2, ...' format. The specified value was: " + ManifestPlaceholders);
                    }
                }
            }
            sb.AppendLine("--out");
            sb.AppendLine(tempFile);
            File.WriteAllText(responseFile, sb.ToString());
            cmd.AppendFileNameIfNotNull(responseFile);
            return(cmd);
        }
コード例 #25
0
ファイル: EmitWinmd.cs プロジェクト: wravery/win32metadata
        protected override string GenerateResponseFileCommands()
        {
            var builder    = new CommandLineBuilder();
            var staticLibs = this.GetStaticLibs();

            if (staticLibs.Length > 0)
            {
                builder.AppendSwitchIfNotNull("--staticLibs ", staticLibs, " ");
            }

            return(builder.ToString());
        }
コード例 #26
0
        protected string GenerateCommandLineCommands(ITaskItem dir, string outputArchive)
        {
            var cmd = new CommandLineBuilder();

            cmd.AppendSwitch("compile");
            cmd.AppendSwitchIfNotNull("-o ", outputArchive);
            if (!string.IsNullOrEmpty(ResourceSymbolsTextFile))
            {
                cmd.AppendSwitchIfNotNull("--output-text-symbols ", ResourceSymbolsTextFile);
            }
            cmd.AppendSwitchIfNotNull("--dir ", ResourceDirectoryFullPath(dir.ItemSpec));
            if (ExplicitCrunch)
            {
                cmd.AppendSwitch("--no-crunch");
            }
            if (MonoAndroidHelper.LogInternalExceptions)
            {
                cmd.AppendSwitch("-v");
            }
            return(cmd.ToString());
        }
コード例 #27
0
        /// <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()
        {
            var builder = new CommandLineBuilder();

            builder.AppendSwitch("delete");
            builder.AppendFileNameIfNotNull(Package);
            builder.AppendFileNameIfNotNull(Version);
            builder.AppendSwitchIfNotNull("-ApiKey ", ApiKey);
            builder.AppendSwitchIfNotNull("-Source ", Source);
            builder.AppendSwitchIfNotNull("-Verbosity ", Verbosity);
            builder.AppendSwitchIfNotNull("-ConfigFile ", ConfigFile);

            if (ForceEnglishOutput)
            {
                builder.AppendSwitch("-ForceEnglishOutput");
            }

            builder.AppendSwitch("-NonInteractive");

            return(builder.ToString());
        }
コード例 #28
0
        /// <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()
        {
            var builder = new CommandLineBuilder();

            builder.AppendSwitch("push");
            builder.AppendFileNameIfNotNull(File);
            builder.AppendFileNameIfNotNull(APIKey);
            builder.AppendSwitchIfNotNull("-Source ", Source);
            builder.AppendSwitchIfNotNull("-Verbosity ", Verbosity);
            builder.AppendSwitchIfNotNull("-ConfigFile ", ConfigFile);
            if (CreateOnly)
            {
                builder.AppendSwitch("-CreateOnly");
            }
            if (ForceEnglishOutput)
            {
                builder.AppendSwitch("-ForceEnglishOutput");
            }

            return(builder.ToString());
        }
コード例 #29
0
        protected string GenerateCommandLineCommands(ITaskItem dir, string outputArchive)
        {
            var cmd = new CommandLineBuilder();

            cmd.AppendSwitch("compile");
            cmd.AppendSwitchIfNotNull("-o ", outputArchive);
            if (!string.IsNullOrEmpty(ResourceSymbolsTextFile))
            {
                cmd.AppendSwitchIfNotNull("--output-text-symbols ", ResourceSymbolsTextFile);
            }
            cmd.AppendSwitchIfNotNull("--dir ", dir.ItemSpec.TrimEnd('\\'));
            if (!string.IsNullOrEmpty(ExtraArgs))
            {
                cmd.AppendSwitch(ExtraArgs);
            }
            if (MonoAndroidHelper.LogInternalExceptions)
            {
                cmd.AppendSwitch("-v");
            }
            return(cmd.ToString());
        }
コード例 #30
0
 protected override string GenerateCommandLineCommands()
 {
     Log.LogDebugMessage("MDoc");
     Log.LogDebugMessage("  RunExport: {0}", RunExport);
     Log.LogDebugMessage("  TargetAssembly: {0}", TargetAssembly);
     Log.LogDebugMessage("  References");
     if (References != null)
     {
         foreach (var reference in References)
         {
             Log.LogDebugMessage("    {0}", reference);
         }
     }
     Log.LogDebugMessage("  OutputDocDirectory: {0}", OutputDocDirectory);
     if (RunExport)
     {
         var cmd = new CommandLineBuilder();
         cmd.AppendSwitch("--debug");
         cmd.AppendSwitch("export-msxdoc");
         cmd.AppendSwitchIfNotNull("-o", Path.ChangeExtension(TargetAssembly, ".xml"));
         cmd.AppendSwitch(OutputDocDirectory);
         return(cmd.ToString());
     }
     else
     {
         var refPaths = References.Select(Path.GetDirectoryName).Distinct();
         var cmd      = new CommandLineBuilder();
         cmd.AppendSwitch("--debug");
         cmd.AppendSwitch("update");
         cmd.AppendSwitch("--delete");
         cmd.AppendSwitchIfNotNull("-L", Path.GetDirectoryName(TargetAssembly));
         foreach (var rp in refPaths)
         {
             cmd.AppendSwitchIfNotNull("-L", rp);
         }
         cmd.AppendSwitchIfNotNull("-o", OutputDocDirectory);
         cmd.AppendSwitch(Path.GetFullPath(TargetAssembly));
         return(cmd.ToString());
     }
 }
コード例 #31
0
ファイル: SvnClient.cs プロジェクト: modulexcite/SvnTools
        /// <summary>
        /// Generates the svn arguments.
        /// </summary>
        /// <returns></returns>
        protected virtual void AppendArguments(CommandLineBuilder commandLine)
        {
            commandLine.AppendSwitchIfNotNull("--username ", Username);
            commandLine.AppendSwitchIfNotNull("--password ", Password);
            commandLine.AppendSwitchIfNotNull("--message ", Message);

            commandLine.AppendSwitchIfTrue("--force", Force);
            commandLine.AppendSwitchIfTrue("--verbose", Verbose);

            commandLine.AppendSwitchIfTrue("--xml", Xml);
            commandLine.AppendSwitchIfTrue("--non-interactive", NonInteractive);
            commandLine.AppendSwitchIfTrue("--no-auth-cache", NoAuthCache);

            // raw arguments
            if (!string.IsNullOrEmpty(Arguments))
                commandLine.AppendSwitch(Arguments);
        }
コード例 #32
0
ファイル: SvnAdmin.cs プロジェクト: modulexcite/SvnTools
        /// <summary>
        /// Generates the SvnAdmin arguments.
        /// </summary>
        /// <returns></returns>
        protected virtual void AppendArguments(CommandLineBuilder commandLine)
        {
            commandLine.AppendSwitchIfTrue("--quiet", Quiet);

            // raw arguments
            commandLine.AppendSwitchIfNotNull("", Arguments);
        }