protected bool VerifyRequiredArgumentsArePresent(ToolSwitch property, bool throwOnError) { if (property.ArgumentRelationList != null) { foreach (ArgumentRelation argumentRelation in property.ArgumentRelationList) { if (argumentRelation.Required && (property.Value == argumentRelation.Value || argumentRelation.Value == string.Empty) && !this.HasSwitch(argumentRelation.Argument)) { string message; if (string.Empty == argumentRelation.Value) { message = this.Log.FormatResourceString("MissingRequiredArgument", (object)argumentRelation.Argument, (object)property.Name); } else { message = this.Log.FormatResourceString("MissingRequiredArgumentWithValue", (object)argumentRelation.Argument, (object)property.Name, (object)argumentRelation.Value); } this.Log.LogError(message); if (throwOnError) { throw new LoggerException(message); } return(false); } } } return(true); }
private static void EmitStringArraySwitch(CommandLineBuilder builder, ToolSwitch toolSwitch, VCToolTask.CommandLineFormat format = VCToolTask.CommandLineFormat.ForBuildLog, VCToolTask.EscapeFormat escapeFormat = VCToolTask.EscapeFormat.Default) { string[] parameters = new string[toolSwitch.StringList.Length]; for (int index = 0; index < toolSwitch.StringList.Length; ++index) { string str = !toolSwitch.StringList[index].StartsWith("\"", StringComparison.Ordinal) || !toolSwitch.StringList[index].EndsWith("\"", StringComparison.Ordinal) ? Environment.ExpandEnvironmentVariables(toolSwitch.StringList[index]) : Environment.ExpandEnvironmentVariables(toolSwitch.StringList[index].Substring(1, toolSwitch.StringList[index].Length - 2)); if (!string.IsNullOrEmpty(str)) { if (format == VCToolTask.CommandLineFormat.ForTracking) { str = str.ToUpperInvariant(); } if (escapeFormat.HasFlag((Enum)VCToolTask.EscapeFormat.EscapeTrailingSlash) && !str.Contains(" ") && (str.EndsWith("\\", StringComparison.Ordinal) && !str.EndsWith("\\\\", StringComparison.Ordinal))) { str += "\\"; } parameters[index] = str; } } if (string.IsNullOrEmpty(toolSwitch.Separator)) { foreach (string parameter in parameters) { builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, parameter); } } else { builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, parameters, toolSwitch.Separator); } }
private static void EmitTaskItemSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch) { if (!string.IsNullOrEmpty(toolSwitch.Name)) { builder.AppendSwitch(Environment.ExpandEnvironmentVariables(toolSwitch.Name + toolSwitch.Separator)); } }
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); } } }
protected bool VerifyRequiredArgumentsArePresent(ToolSwitch property, bool throwOnError) { if (property.ArgumentRelationList != null) { foreach (ArgumentRelation current in property.ArgumentRelationList) { if ((current.Required && ((property.Value == current.Value) || (current.Value == string.Empty))) && !this.HasSwitch(current.Argument)) { string message = ""; if (string.Empty == current.Value) { object[] args = new object[] { current.Argument, property.Name }; message = base.Log.FormatResourceString("MissingRequiredArgument", args); } else { object[] args = new object[] { current.Argument, property.Name, current.Value }; message = base.Log.FormatResourceString("MissingRequiredArgumentWithValue", args); } base.Log.LogError(message, new object[0]); if (throwOnError) { throw new LoggerException(message); } return(false); } } } return(true); }
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 void RemoveSwitchToolBasedOnValue(string switchValue) { if ((this.ActiveToolSwitchesValues.Count > 0) && this.ActiveToolSwitchesValues.ContainsKey("/" + switchValue)) { ToolSwitch switch2 = this.ActiveToolSwitchesValues["/" + switchValue]; if (switch2 != null) { this.ActiveToolSwitches.Remove(switch2.Name); } } }
protected void GenerateCommandsAccordingToType(CommandLineBuilder builder, ToolSwitch toolSwitch, bool recursive, VCToolTask.CommandLineFormat format = VCToolTask.CommandLineFormat.ForBuildLog, VCToolTask.EscapeFormat escapeFormat = VCToolTask.EscapeFormat.Default) { if (toolSwitch.Parents.Count > 0 && !recursive) { return; } switch (toolSwitch.Type) { case ToolSwitchType.Boolean: this.EmitBooleanSwitch(builder, toolSwitch); break; case ToolSwitchType.Integer: this.EmitIntegerSwitch(builder, toolSwitch); break; case ToolSwitchType.String: this.EmitStringSwitch(builder, toolSwitch); break; case ToolSwitchType.StringArray: VCToolTask.EmitStringArraySwitch(builder, toolSwitch, VCToolTask.CommandLineFormat.ForBuildLog, VCToolTask.EscapeFormat.Default); break; case ToolSwitchType.File: VCToolTask.EmitFileSwitch(builder, toolSwitch, format); break; case ToolSwitchType.Directory: VCToolTask.EmitDirectorySwitch(builder, toolSwitch, format); break; case ToolSwitchType.ITaskItem: VCToolTask.EmitTaskItemSwitch(builder, toolSwitch); break; case ToolSwitchType.ITaskItemArray: VCToolTask.EmitTaskItemArraySwitch(builder, toolSwitch, format); break; case ToolSwitchType.AlwaysAppend: VCToolTask.EmitAlwaysAppendSwitch(builder, toolSwitch); break; case ToolSwitchType.StringPathArray: VCToolTask.EmitStringArraySwitch(builder, toolSwitch, format, escapeFormat); break; default: ErrorUtilities.VerifyThrow(false, "InternalError"); break; } }
private void EmitReversibleBooleanSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch) { if (!string.IsNullOrEmpty(toolSwitch.ReverseSwitchValue)) { StringBuilder builder2 = new StringBuilder(this.GetEffectiveArgumentsValues(toolSwitch)); builder2.Insert(0, toolSwitch.BooleanValue ? toolSwitch.TrueSuffix : toolSwitch.FalseSuffix); builder2.Insert(0, toolSwitch.Separator); builder2.Insert(0, toolSwitch.TrueSuffix); builder2.Insert(0, toolSwitch.ReverseSwitchValue); builder.AppendSwitch(builder2.ToString()); } }
protected void AddActiveSwitchToolValue(ToolSwitch switchToAdd) { if ((switchToAdd.Type == ToolSwitchType.Boolean) && !switchToAdd.BooleanValue) { if (switchToAdd.ReverseSwitchValue != string.Empty) { this.ActiveToolSwitchesValues.Add(switchToAdd.ReverseSwitchValue, switchToAdd); } } else if (switchToAdd.SwitchValue != string.Empty) { this.ActiveToolSwitchesValues.Add(switchToAdd.SwitchValue, switchToAdd); } }
private void EmitIntegerSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch) { if (toolSwitch.IsValid) { if (!string.IsNullOrEmpty(toolSwitch.Separator)) { builder.AppendSwitch(toolSwitch.SwitchValue + toolSwitch.Separator + toolSwitch.Number.ToString(CultureInfo.InvariantCulture) + this.GetEffectiveArgumentsValues(toolSwitch)); } else { builder.AppendSwitch(toolSwitch.SwitchValue + toolSwitch.Number.ToString(CultureInfo.InvariantCulture) + this.GetEffectiveArgumentsValues(toolSwitch)); } } }
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); } } }
protected void RemoveSwitchToolBasedOnValue(string switchValue) { if (this.ActiveToolSwitchesValues.Count <= 0 || !this.ActiveToolSwitchesValues.ContainsKey("/" + switchValue)) { return; } ToolSwitch toolSwitch = this.ActiveToolSwitchesValues["/" + switchValue]; if (toolSwitch == null) { return; } this.ActiveToolSwitches.Remove(toolSwitch.Name); }
protected virtual bool VerifyDependenciesArePresent(ToolSwitch value) { if (value.Parents.Count <= 0) { return(true); } bool flag = false; foreach (string propertyName in value.Parents) { flag = flag || this.HasSwitch(propertyName); } return(flag); }
protected virtual string GenerateResponseFileCommandsExceptSwitches(string[] switchesToRemove, VCToolTask.CommandLineFormat format = VCToolTask.CommandLineFormat.ForBuildLog, VCToolTask.EscapeFormat escapeFormat = VCToolTask.EscapeFormat.Default) { bool flag1 = false; this.AddDefaultsToActiveSwitchList(); this.AddFallbacksToActiveSwitchList(); this.PostProcessSwitchList(); CommandLineBuilder commandLineBuilder = new CommandLineBuilder(true); foreach (string index in this.SwitchOrderList) { if (this.IsPropertySet(index)) { ToolSwitch toolSwitch = this.activeToolSwitches[index]; if (this.VerifyDependenciesArePresent(toolSwitch) && this.VerifyRequiredArgumentsArePresent(toolSwitch, false)) { bool flag2 = true; if (switchesToRemove != null) { foreach (string str in switchesToRemove) { if (index.Equals(str, StringComparison.OrdinalIgnoreCase)) { flag2 = false; break; } } } if (flag2) { this.GenerateCommandsAccordingToType(commandLineBuilder, toolSwitch, false, format, escapeFormat); } } } else if (string.Equals(index, "additionaloptions", StringComparison.OrdinalIgnoreCase)) { this.BuildAdditionalArgs(commandLineBuilder); flag1 = true; } else if (string.Equals(index, "AlwaysAppend", StringComparison.OrdinalIgnoreCase)) { commandLineBuilder.AppendSwitch(this.AlwaysAppend); } } if (!flag1) { this.BuildAdditionalArgs(commandLineBuilder); } return(commandLineBuilder.ToString()); }
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 void EmitBooleanSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch) { if (toolSwitch.BooleanValue) { if (string.IsNullOrEmpty(toolSwitch.SwitchValue)) { return; } StringBuilder stringBuilder = new StringBuilder(this.GetEffectiveArgumentsValues(toolSwitch)); stringBuilder.Insert(0, toolSwitch.Separator); stringBuilder.Insert(0, toolSwitch.TrueSuffix); stringBuilder.Insert(0, toolSwitch.SwitchValue); builder.AppendSwitch(stringBuilder.ToString()); } else { this.EmitReversibleBooleanSwitch(builder, toolSwitch); } }
protected void AddActiveSwitchToolValue(ToolSwitch switchToAdd) { if (switchToAdd.Type != ToolSwitchType.Boolean || switchToAdd.BooleanValue) { if (!(switchToAdd.SwitchValue != string.Empty)) { return; } this.ActiveToolSwitchesValues.Add(switchToAdd.SwitchValue, switchToAdd); } else { if (!(switchToAdd.ReverseSwitchValue != string.Empty)) { return; } this.ActiveToolSwitchesValues.Add(switchToAdd.ReverseSwitchValue, switchToAdd); } }
private void EmitStringSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch) { string switchName = string.Empty + toolSwitch.SwitchValue + toolSwitch.Separator; StringBuilder builder2 = new StringBuilder(this.GetEffectiveArgumentsValues(toolSwitch)); string str2 = toolSwitch.Value; if (!toolSwitch.MultipleValues) { str2 = str2.Trim(); if (!str2.StartsWith("\"", StringComparison.Ordinal)) { str2 = "\"" + str2; str2 = (!str2.EndsWith(@"\", StringComparison.Ordinal) || str2.EndsWith(@"\\", StringComparison.Ordinal)) ? (str2 + "\"") : (str2 + "\\\""); } builder2.Insert(0, str2); } if ((switchName.Length != 0) || (builder2.ToString().Length != 0)) { builder.AppendSwitchUnquotedIfNotNull(switchName, builder2.ToString()); } }
private void EmitStringSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch) { string switchName = string.Empty + toolSwitch.SwitchValue + toolSwitch.Separator; StringBuilder stringBuilder = new StringBuilder(this.GetEffectiveArgumentsValues(toolSwitch)); string str1 = toolSwitch.Value; if (!toolSwitch.MultipleValues) { string str2 = str1.Trim(); if (!str2.StartsWith("\"", StringComparison.Ordinal)) { string str3 = "\"" + str2; str2 = !str3.EndsWith("\\", StringComparison.Ordinal) || str3.EndsWith("\\\\", StringComparison.Ordinal) ? str3 + "\"" : str3 + "\\\""; } stringBuilder.Insert(0, str2); } if (switchName.Length == 0 && stringBuilder.ToString().Length == 0) { return; } builder.AppendSwitchUnquotedIfNotNull(switchName, stringBuilder.ToString()); }
private static void EmitTaskItemArraySwitch(CommandLineBuilder builder, ToolSwitch toolSwitch, VCToolTask.CommandLineFormat format = VCToolTask.CommandLineFormat.ForBuildLog) { if (string.IsNullOrEmpty(toolSwitch.Separator)) { foreach (ITaskItem taskItem in toolSwitch.TaskItemArray) { builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, Environment.ExpandEnvironmentVariables(taskItem.ItemSpec)); } } else { ITaskItem[] parameters = new ITaskItem[toolSwitch.TaskItemArray.Length]; for (int index = 0; index < toolSwitch.TaskItemArray.Length; ++index) { parameters[index] = (ITaskItem) new TaskItem(Environment.ExpandEnvironmentVariables(toolSwitch.TaskItemArray[index].ItemSpec)); if (format == VCToolTask.CommandLineFormat.ForTracking) { parameters[index].ItemSpec = parameters[index].ItemSpec.ToUpperInvariant(); } } builder.AppendSwitchIfNotNull(toolSwitch.SwitchValue, parameters, toolSwitch.Separator); } }
protected string GetEffectiveArgumentsValues(ToolSwitch property) { StringBuilder stringBuilder = new StringBuilder(); bool flag = false; string str = string.Empty; if (property.ArgumentRelationList != null) { foreach (ArgumentRelation argumentRelation in property.ArgumentRelationList) { if (str != string.Empty && str != argumentRelation.Argument) { flag = true; } str = argumentRelation.Argument; if ((property.Value == argumentRelation.Value || argumentRelation.Value == string.Empty || property.Type == ToolSwitchType.Boolean && property.BooleanValue) && this.HasSwitch(argumentRelation.Argument)) { ToolSwitch toolSwitch = this.ActiveToolSwitches[argumentRelation.Argument]; stringBuilder.Append(argumentRelation.Separator); CommandLineBuilder builder = new CommandLineBuilder(); this.GenerateCommandsAccordingToType(builder, toolSwitch, true, VCToolTask.CommandLineFormat.ForBuildLog, VCToolTask.EscapeFormat.Default); stringBuilder.Append(builder.ToString()); } } } CommandLineBuilder commandLineBuilder = new CommandLineBuilder(); if (flag) { commandLineBuilder.AppendSwitchIfNotNull("", stringBuilder.ToString()); } else { commandLineBuilder.AppendSwitchUnquotedIfNotNull("", stringBuilder.ToString()); } return(commandLineBuilder.ToString()); }
protected string GetEffectiveArgumentsValues(ToolSwitch property) { StringBuilder builder = new StringBuilder(); bool flag = false; string argument = string.Empty; if (property.ArgumentRelationList != null) { foreach (ArgumentRelation relation in property.ArgumentRelationList) { if ((argument != string.Empty) && (argument != relation.Argument)) { flag = true; } argument = relation.Argument; if (((property.Value == relation.Value) || ((relation.Value == string.Empty) || ((property.Type == ToolSwitchType.Boolean) && property.BooleanValue))) && this.HasSwitch(relation.Argument)) { builder.Append(relation.Separator); CommandLineBuilder builder3 = new CommandLineBuilder(); this.GenerateCommandsAccordingToType(builder3, this.ActiveToolSwitches[relation.Argument], true, CommandLineFormat.ForBuildLog, EscapeFormat.Default); builder.Append(builder3.ToString()); } } } CommandLineBuilder builder2 = new CommandLineBuilder(); if (flag) { builder2.AppendSwitchIfNotNull("", builder.ToString()); } else { builder2.AppendSwitchUnquotedIfNotNull("", builder.ToString()); } return(builder2.ToString()); }
private static void EmitAlwaysAppendSwitch(CommandLineBuilder builder, ToolSwitch toolSwitch) { builder.AppendSwitch(toolSwitch.Name); }
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"); } }