public string GenerateCommandLine(CommandLineFormat format = 0, EscapeFormat escapeFormat = 0) { string str = this.GenerateCommandLineCommands(format, escapeFormat); string str2 = this.GenerateResponseFileCommands(format, escapeFormat); return(string.IsNullOrEmpty(str) ? str2 : (str + " " + str2)); }
public string GenerateCommandLineExceptSwitches(string[] switchesToRemove, CommandLineFormat format = 0, EscapeFormat escapeFormat = 0) { string str = this.GenerateCommandLineCommandsExceptSwitches(switchesToRemove, format, escapeFormat); string str2 = this.GenerateResponseFileCommandsExceptSwitches(switchesToRemove, format, escapeFormat); return(string.IsNullOrEmpty(str) ? str2 : (str + " " + str2)); }
protected virtual string GenerateResponseFileCommandsExceptSwitches( string[] switchesToRemove, CommandLineFormat format = CommandLineFormat.ForBuildLog, EscapeFormat escapeFormat = EscapeFormat.Default) { this.AddDefaultsToActiveSwitchList(); this.AddFallbacksToActiveSwitchList(); this.PostProcessSwitchList(); CommandLineBuilder commandLineBuilder = new CommandLineBuilder(true); bool hasBuiltAdditionalArgs = false; foreach (string switchOrder in this.SwitchOrderList) { if (this.IsPropertySet(switchOrder)) { ToolSwitch activeToolSwitch = this.activeToolSwitches[switchOrder]; if (this.VerifyDependenciesArePresent(activeToolSwitch) && this.VerifyRequiredArgumentsArePresent(activeToolSwitch, false)) { bool notRemove = true; if (switchesToRemove != null) { foreach (string strRemove in switchesToRemove) { if (switchOrder.Equals(strRemove, StringComparison.OrdinalIgnoreCase)) { notRemove = false; break; } } } if (notRemove) { this.GenerateCommandsAccordingToType(commandLineBuilder, activeToolSwitch, false, format, escapeFormat); } } } else if (string.Equals(switchOrder, "additionaloptions", StringComparison.OrdinalIgnoreCase)) { this.BuildAdditionalArgs(commandLineBuilder); hasBuiltAdditionalArgs = true; } else if (string.Equals(switchOrder, "AlwaysAppend", StringComparison.OrdinalIgnoreCase)) { commandLineBuilder.AppendSwitch(this.AlwaysAppend); } } if (!hasBuiltAdditionalArgs) { this.BuildAdditionalArgs(commandLineBuilder); } return(commandLineBuilder.ToString()); }
protected internal string GenerateCommandLine(CommandLineFormat format = 0) { string cmdLineCommands = GenerateCommandLineCommands(format); string rspFileCommands = GenerateResponseFileCommands(format); if (!string.IsNullOrEmpty(cmdLineCommands)) { return(cmdLineCommands + " " + rspFileCommands); } return(rspFileCommands); }
protected string GenerateCommandLineExcept( OptSpecifier[] excludeOpts, CommandLineFormat format = 0) { string cmdLineCommands = GenerateCommandLineCommands(format); string rspFileCommands = GenerateResponseFileCommandsExceptSwitches(excludeOpts, format); if (!string.IsNullOrEmpty(cmdLineCommands)) { return(cmdLineCommands + " " + rspFileCommands); } return(rspFileCommands); }
protected override string GenerateCommandLineExceptSources(CommandLineFormat format) { OptSpecifier[] excludeOpts; if (SourcesOption != null) { excludeOpts = new[] { SourcesOption.Value } } ; else { excludeOpts = new OptSpecifier[0]; } return(GenerateCommandLineExcept(excludeOpts, format)); }
protected virtual string GenerateResponseFileCommandsExceptSwitches( OptSpecifier[] switchesToRemove, CommandLineFormat format = 0) { PostProcessOptions(); var builder = new CommandLineBuilder(true); foreach (OptSpecifier opt in OptionOrder) { if (!IsOptionSet(opt)) { continue; } if (switchesToRemove == null || !switchesToRemove.Any(o => opt.Id == o.Id)) { GenerateCommandsAccordingToType(builder, activeArgs[opt.Id]); } } BuildAdditionalArgs(builder); return(builder.ToString()); }
protected virtual string GenerateCommandLineCommandsExceptSwitches(string[] switchesToRemove, CommandLineFormat format = 0, EscapeFormat escapeFormat = 0) => string.Empty;
protected virtual string GenerateCommandLineCommands(CommandLineFormat format, EscapeFormat escapeFormat) => this.GenerateCommandLineCommandsExceptSwitches(new string[0], format, escapeFormat);
private static void EmitTaskItemArraySwitch(CommandLineBuilder builder, ToolSwitch toolSwitch, CommandLineFormat format = 0) { if (string.IsNullOrEmpty(toolSwitch.Separator)) { foreach (ITaskItem item in toolSwitch.TaskItemArray) { builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, Environment.ExpandEnvironmentVariables(item.ItemSpec)); } } else { ITaskItem[] parameters = new ITaskItem[toolSwitch.TaskItemArray.Length]; for (int i = 0; i < toolSwitch.TaskItemArray.Length; i++) { parameters[i] = new TaskItem(Environment.ExpandEnvironmentVariables(toolSwitch.TaskItemArray[i].ItemSpec)); if (format == CommandLineFormat.ForTracking) { parameters[i].ItemSpec = parameters[i].ItemSpec.ToUpperInvariant(); } } builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, parameters, toolSwitch.Separator); } }
/// <inheritdoc/> protected override string GenerateResponseFileCommands(CommandLineFormat format, EscapeFormat escapeFormat) { // DO NOT USE RESPONSE FILE GENERATION. // return base.GenerateResponseFileCommands(format, escapeFormat); return(string.Empty); }
protected virtual string GenerateResponseFileCommands(CommandLineFormat format, EscapeFormat escapeFormat) => this.GenerateResponseFileCommandsExceptSwitches(null, format, escapeFormat);
protected override string GenerateResponseFileCommands(CommandLineFormat format, EscapeFormat escapeFormat) { return(GenerateResponseFileCommands()); }
protected abstract string GenerateCommandLineExceptSources(CommandLineFormat format);
protected abstract string GenerateResponseFileCommands(CommandLineFormat format);
protected virtual string GenerateCommandLineCommands(CommandLineFormat format) { return(string.Empty); }
protected virtual void GenerateCommandsAccordingToType(CommandLineBuilder builder, ToolSwitch toolSwitch, bool recursive, CommandLineFormat format = 0, EscapeFormat escapeFormat = 0) { if ((toolSwitch.Parents.Count <= 0) || recursive) { switch (toolSwitch.Type) { case ToolSwitchType.Boolean: this.EmitBooleanSwitch(builder, toolSwitch); return; case ToolSwitchType.Integer: this.EmitIntegerSwitch(builder, toolSwitch); return; case ToolSwitchType.String: this.EmitStringSwitch(builder, toolSwitch); return; case ToolSwitchType.StringArray: EmitStringArraySwitch(builder, toolSwitch, CommandLineFormat.ForBuildLog, EscapeFormat.Default); return; case ToolSwitchType.File: EmitFileSwitch(builder, toolSwitch, format); return; case ToolSwitchType.Directory: EmitDirectorySwitch(builder, toolSwitch, format); return; case ToolSwitchType.ITaskItem: EmitTaskItemSwitch(builder, toolSwitch); return; case ToolSwitchType.ITaskItemArray: EmitTaskItemArraySwitch(builder, toolSwitch, format); return; case ToolSwitchType.AlwaysAppend: EmitAlwaysAppendSwitch(builder, toolSwitch); return; case ToolSwitchType.StringPathArray: EmitStringArraySwitch(builder, toolSwitch, format, escapeFormat); return; } ErrorUtilities.VerifyThrow(false, "InternalError"); } }
private static void EmitDirectorySwitch(CommandLineBuilder builder, ToolSwitch toolSwitch, CommandLineFormat format = 0) { if (!string.IsNullOrEmpty(toolSwitch.SwitchValue)) { if (format == CommandLineFormat.ForBuildLog) { builder.AppendSwitch(toolSwitch.SwitchValue + toolSwitch.Separator); } else { builder.AppendSwitch(toolSwitch.SwitchValue.ToUpperInvariant() + toolSwitch.Separator); } } }
private static void EmitFileSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch, CommandLineFormat format = 0) { if (!string.IsNullOrEmpty(toolSwitch.Value)) { string parameter = Environment.ExpandEnvironmentVariables(toolSwitch.Value).Trim(); if (format == CommandLineFormat.ForTracking) { parameter = parameter.ToUpperInvariant(); } if (!parameter.StartsWith("\"", StringComparison.Ordinal)) { parameter = "\"" + parameter; parameter = (!parameter.EndsWith(@"\", StringComparison.Ordinal) || parameter.EndsWith(@"\\", StringComparison.Ordinal)) ? (parameter + "\"") : (parameter + "\\\""); } builder.AppendSwitchUnquotedIfNotNull(toolSwitch.SwitchValue + toolSwitch.Separator, parameter); } }
private static void EmitStringArraySwitch(CommandLineBuilder builder, ToolSwitch toolSwitch, CommandLineFormat format = 0, EscapeFormat escapeFormat = 0) { string[] parameters = new string[toolSwitch.StringList.Length]; char[] anyOf = new char[] { ' ', '|', '<', '>', ',', ';', '-', '\r', '\n', '\t', '\f' }; for (int i = 0; i < toolSwitch.StringList.Length; i++) { string str = (!toolSwitch.StringList[i].StartsWith("\"", StringComparison.Ordinal) || !toolSwitch.StringList[i].EndsWith("\"", StringComparison.Ordinal)) ? Environment.ExpandEnvironmentVariables(toolSwitch.StringList[i]) : Environment.ExpandEnvironmentVariables(toolSwitch.StringList[i].Substring(1, toolSwitch.StringList[i].Length - 2)); if (!string.IsNullOrEmpty(str)) { if (format == CommandLineFormat.ForTracking) { str = str.ToUpperInvariant(); } if (escapeFormat.HasFlag(EscapeFormat.EscapeTrailingSlash) && ((str.IndexOfAny(anyOf) == -1) && (str.EndsWith(@"\", StringComparison.Ordinal) && !str.EndsWith(@"\\", StringComparison.Ordinal)))) { str = str + @"\"; } parameters[i] = str; } } if (!string.IsNullOrEmpty(toolSwitch.Separator)) { builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, parameters, toolSwitch.Separator); } else { foreach (string str2 in parameters) { builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, str2); } } }
/// <inheritdoc/> protected override string GenerateCommandLineCommands(CommandLineFormat format, EscapeFormat escapeFormat) { // Use the response file command line generation for the normal command line. return(base.GenerateResponseFileCommands(format, escapeFormat)); }
protected override string GenerateResponseFileCommands(CommandLineFormat format) { return(GenerateResponseFileCommandsExceptSwitches(new OptSpecifier[0], format)); }