/// <summary> /// Identifies/detects a switch that takes no parameters. /// </summary> internal static bool IsParameterlessSwitch ( string switchName ) { ParameterlessSwitch parameterlessSwitch; string duplicateSwitchErrorMessage; return(CommandLineSwitches.IsParameterlessSwitch(switchName, out parameterlessSwitch, out duplicateSwitchErrorMessage)); }
/// <summary> /// Appends the given collection of command-line switches to this one. /// </summary> /// <remarks> /// Command-line switches have left-to-right precedence i.e. switches on the right override switches on the left. As a /// result, this "append" operation is also performed in a left-to-right manner -- the switches being appended to are /// considered to be on the "left", and the switches being appended are on the "right". /// </remarks> /// <param name="switchesToAppend"></param> internal void Append(CommandLineSwitches switchesToAppend) { // if this collection doesn't already have an error registered, but the collection being appended does if (!HaveErrors() && switchesToAppend.HaveErrors()) { // register the error from the given collection // NOTE: we always store the first error found (parsing left-to-right), and since this collection is considered to // be on the "left" of the collection being appended, the error flagged in this collection takes priority over the // error in the collection being appended _errorMessage = switchesToAppend._errorMessage; _badCommandLineArg = switchesToAppend._badCommandLineArg; _innerException = switchesToAppend._innerException; _isParameterError = switchesToAppend._isParameterError; } // NOTE: we might run into some duplicate switch errors below, but if we've already registered the error from the // collection being appended, all the duplicate switch errors will be ignored; this is fine because we really have no // way of telling which error would occur first in the left-to-right order without keeping track of a lot more error // information -- so we play it safe, and register the guaranteed error // append the parameterless switches with left-to-right precedence, flagging duplicate switches as necessary for (int i = 0; i < (int)ParameterlessSwitch.NumberOfParameterlessSwitches; i++) { if (switchesToAppend.IsParameterlessSwitchSet((ParameterlessSwitch)i)) { if (!IsParameterlessSwitchSet((ParameterlessSwitch)i) || (s_parameterlessSwitchesMap[i].duplicateSwitchErrorMessage == null)) { _parameterlessSwitches[i].commandLineArg = switchesToAppend._parameterlessSwitches[i].commandLineArg; } else { SetSwitchError(s_parameterlessSwitchesMap[i].duplicateSwitchErrorMessage, switchesToAppend.GetParameterlessSwitchCommandLineArg((ParameterlessSwitch)i)); } } } // append the parameterized switches with left-to-right precedence, flagging duplicate switches as necessary for (int j = 0; j < (int)ParameterizedSwitch.NumberOfParameterizedSwitches; j++) { if (switchesToAppend.IsParameterizedSwitchSet((ParameterizedSwitch)j)) { if (!IsParameterizedSwitchSet((ParameterizedSwitch)j) || (s_parameterizedSwitchesMap[j].duplicateSwitchErrorMessage == null)) { if (_parameterizedSwitches[j].commandLineArg == null) { _parameterizedSwitches[j].parameters = new ArrayList(); } _parameterizedSwitches[j].commandLineArg = switchesToAppend._parameterizedSwitches[j].commandLineArg; _parameterizedSwitches[j].parameters.AddRange(switchesToAppend._parameterizedSwitches[j].parameters); } else { SetSwitchError(s_parameterizedSwitchesMap[j].duplicateSwitchErrorMessage, switchesToAppend.GetParameterizedSwitchCommandLineArg((ParameterizedSwitch)j)); } } } }