public string[] ParsePostExtensions(string[] remaining)
{
List <string> unprocessed = new List <string>();
for (int i = 0; i < remaining.Length; ++i)
{
string arg = remaining[i];
if (String.IsNullOrEmpty(arg)) // skip blank arguments
{
continue;
}
if (1 < arg.Length && ('-' == arg[0] || '/' == arg[0]))
{
unprocessed.Add(arg);
}
else
{
this.Files.AddRange(CommandLine.GetFiles(arg, "Source"));
}
}
if (0 == this.Files.Count)
{
this.ShowHelp = true;
}
else if (String.IsNullOrEmpty(this.OutputFile))
{
if (1 < this.Files.Count)
{
Messaging.Instance.OnMessage(WixErrors.MustSpecifyOutputWithMoreThanOneInput());
}
// After the linker tells us what the output type actually is, we'll change the ".wix" to the correct extension.
this.OutputFile = Path.ChangeExtension(Path.GetFileName(this.Files[0]), ".wix");
// Add the directories of the input files as unnamed bind paths.
foreach (string file in this.Files)
{
BindPath bindPath = new BindPath(Path.GetDirectoryName(Path.GetFullPath(file)));
this.BindPaths.Add(bindPath);
}
}
if (!this.SuppressWixPdb && String.IsNullOrEmpty(this.PdbFile) && !String.IsNullOrEmpty(this.OutputFile))
{
this.PdbFile = Path.ChangeExtension(this.OutputFile, ".wixpdb");
}
return(unprocessed.ToArray());
}
private bool TryParseBindPath(string bindPath, out BindPath bp)
{
var namedPath = bindPath.Split(BindPathSplit, 2);
bp = (1 == namedPath.Length) ? new BindPath(namedPath[0]) : new BindPath(namedPath[0], namedPath[1]);
if (File.Exists(bp.Path))
{
this.Messaging.Write(ErrorMessages.ExpectedDirectoryGotFile("-bindpath", bp.Path));
return(false);
}
return(true);
}
private string[] ParsePostExtensions(IParseCommandLine parser, string[] remaining)
{
var unprocessed = new List <string>();
for (int i = 0; i < remaining.Length; ++i)
{
var arg = remaining[i];
if (parser.IsSwitch(arg))
{
unprocessed.Add(arg);
}
else
{
parser.GetArgumentAsFilePathOrError(arg, "source files", this.Files);
}
}
if (0 == this.Files.Count)
{
this.ShowHelp = true;
}
else if (String.IsNullOrEmpty(this.OutputFile))
{
if (1 < this.Files.Count)
{
this.Messaging.Write(ErrorMessages.MustSpecifyOutputWithMoreThanOneInput());
}
// After the linker tells us what the output type actually is, we'll change the ".wix" to the correct extension.
this.OutputFile = Path.ChangeExtension(Path.GetFileName(this.Files[0]), ".wix");
// Add the directories of the input files as unnamed bind paths.
foreach (string file in this.Files)
{
var bindPath = new BindPath(Path.GetDirectoryName(Path.GetFullPath(file)));
this.BindPaths.Add(bindPath);
}
}
if (!this.SuppressWixPdb && String.IsNullOrEmpty(this.PdbFile) && !String.IsNullOrEmpty(this.OutputFile))
{
this.PdbFile = Path.ChangeExtension(this.OutputFile, ".wixpdb");
}
return(unprocessed.ToArray());
}
private IEnumerable <BindPath> GatherBindPaths(IEnumerable <string> bindPaths)
{
var result = new List <BindPath>();
foreach (var bindPath in bindPaths)
{
var bp = BindPath.Parse(bindPath);
if (Directory.Exists(bp.Path))
{
result.Add(bp);
}
else if (File.Exists(bp.Path))
{
this.Messaging.Write(ErrorMessages.ExpectedDirectoryGotFile("-bindpath", bp.Path));
}
}
return(result);
}
/// <summary>
/// Validates that a string is a valid bind path, and throws appropriate warnings/errors if not
/// </summary>
/// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
/// <param name="args">The list of strings to check.</param>
/// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
/// <returns>The bind path if it is valid, null if it is invalid.</returns>
public static BindPath GetBindPath(string commandlineSwitch, string[] args, int index)
{
commandlineSwitch = String.Concat("-", commandlineSwitch);
if (!IsValidArg(args, index))
{
Messaging.Instance.OnMessage(WixErrors.DirectoryPathRequired(commandlineSwitch));
return(null);
}
BindPath bindPath = BindPath.Parse(args[index]);
if (File.Exists(bindPath.Path))
{
Messaging.Instance.OnMessage(WixErrors.ExpectedDirectoryGotFile(commandlineSwitch, bindPath.Path));
return(null);
}
bindPath.Path = VerifyPath(bindPath.Path, true);
return(String.IsNullOrEmpty(bindPath.Path) ? null : bindPath);
}
/// <summary>
/// Parse the commandline arguments.
/// </summary>
/// <param name="args">Commandline arguments.</param>
public string[] Parse(string[] args)
{
List <string> unprocessed = new List <string>();
for (int i = 0; i < args.Length; ++i)
{
string arg = args[i];
if (String.IsNullOrEmpty(arg)) // skip blank arguments
{
continue;
}
if (1 == arg.Length) // treat '-' and '@' as filenames when by themselves.
{
unprocessed.Add(arg);
}
else if ('-' == arg[0] || '/' == arg[0])
{
string parameter = arg.Substring(1);
if ("bt" == parameter)
{
BindPath bindPath = CommandLine.GetBindPath(parameter, args, ++i);
if (null == bindPath)
{
break;
}
this.TargetBindPaths.Add(bindPath);
}
else if ("bu" == parameter)
{
BindPath bindPath = CommandLine.GetBindPath(parameter, args, ++i);
if (null == bindPath)
{
break;
}
this.UpdatedBindPaths.Add(bindPath);
}
else if (parameter.Equals("cc", StringComparison.Ordinal))
{
this.CabCachePath = CommandLine.GetDirectory(parameter, args, ++i);
if (String.IsNullOrEmpty(this.CabCachePath))
{
break;
}
}
else if (parameter.Equals("delta", StringComparison.Ordinal))
{
this.Delta = true;
}
else if (parameter.Equals("ext", StringComparison.Ordinal))
{
if (!CommandLine.IsValidArg(args, ++i))
{
Messaging.Instance.OnMessage(WixErrors.TypeSpecificationForExtensionRequired("-ext"));
break;
}
this.Extensions.Add(args[i]);
}
else if ("nologo" == parameter)
{
this.ShowLogo = false;
}
else if ("notidy" == parameter)
{
this.Tidy = false;
}
else if ("o" == parameter || "out" == parameter)
{
this.OutputFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.OutputFile))
{
break;
}
}
else if (parameter.Equals("pdbout", StringComparison.Ordinal))
{
this.PdbFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.PdbFile))
{
break;
}
}
else if (parameter.Equals("reusecab", StringComparison.Ordinal))
{
Messaging.Instance.OnMessage(WixWarnings.DeprecatedCommandLineSwitch(arg, "-cc"));
}
else if (parameter.Equals("spdb", StringComparison.Ordinal))
{
this.SuppressWixPdb = true;
}
else if (parameter.Equals("sacl", StringComparison.Ordinal))
{
this.SuppressAclReset = true;
}
else if (parameter.Equals("t", StringComparison.Ordinal))
{
string baseline;
string transformPath;
if (!CommandLine.IsValidArg(args, ++i))
{
Messaging.Instance.OnMessage(WixErrors.BaselineRequired());
break;
}
baseline = args[i];
transformPath = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(transformPath))
{
break;
}
// Verify the transform hasn't been added already.
if (this.PatchTransforms.Any(t => t.TransformPath.Equals(transformPath, StringComparison.OrdinalIgnoreCase)))
{
Messaging.Instance.OnMessage(WixErrors.DuplicateTransform(transformPath));
break;
}
this.PatchTransforms.Add(new PatchTransform(transformPath, baseline));
}
else if (parameter.StartsWith("sw", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
Messaging.Instance.SuppressAllWarnings = true;
}
else
{
int suppressWarning = 0;
if (!Int32.TryParse(paramArg, out suppressWarning) || 0 >= suppressWarning)
{
Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg));
}
else
{
Messaging.Instance.SuppressWarningMessage(suppressWarning);
}
}
}
else if (parameter.StartsWith("wx", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
Messaging.Instance.WarningsAsError = true;
}
else
{
int elevateWarning = 0;
if (!Int32.TryParse(paramArg, out elevateWarning) || 0 >= elevateWarning)
{
Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg));
}
else
{
Messaging.Instance.ElevateWarningMessage(elevateWarning);
}
}
}
else if ("v" == parameter)
{
Messaging.Instance.ShowVerboseMessages = true;
}
else if ("?" == parameter || "help" == parameter)
{
this.ShowHelp = true;
break;
}
else
{
unprocessed.Add(arg);
}
}
else if ('@' == arg[0])
{
string[] parsedArgs = CommandLineResponseFile.Parse(arg.Substring(1));
string[] unparsedArgs = this.Parse(parsedArgs);
unprocessed.AddRange(unparsedArgs);
}
else
{
unprocessed.Add(arg);
}
}
return(unprocessed.ToArray());
}
/// <summary>
/// Parse the commandline arguments.
/// </summary>
/// <param name="args">Commandline arguments.</param>
public string[] Parse(string[] args)
{
List <string> unprocessed = new List <string>();
for (int i = 0; i < args.Length; ++i)
{
string arg = args[i];
if (String.IsNullOrEmpty(arg)) // skip blank arguments
{
continue;
}
if (1 == arg.Length) // treat '-' and '@' as filenames when by themselves.
{
unprocessed.Add(arg);
}
else if ('-' == arg[0] || '/' == arg[0])
{
string parameter = arg.Substring(1);
if (parameter.Equals("b", StringComparison.Ordinal))
{
BindPath bindPath = CommandLine.GetBindPath(parameter, args, ++i);
if (null == bindPath)
{
break;
}
this.BindPaths.Add(bindPath);
}
else if (parameter.StartsWith("cultures:", StringComparison.Ordinal))
{
string culturesString = arg.Substring(10).ToLower(CultureInfo.InvariantCulture);
// When null is used treat it as if cultures wasn't specified.
// This is needed for batching over the light task when using MSBuild which doesn't
// support empty items
if (culturesString.Equals("null", StringComparison.OrdinalIgnoreCase))
{
this.Cultures = null;
}
else
{
this.Cultures = culturesString.Split(';', ',');
for (int c = 0; c < this.Cultures.Length; ++c)
{
// Neutral is different from null. For neutral we still want to do WXL filtering.
// Set the culture to the empty string = identifier for the invariant culture
if (this.Cultures[c].Equals("neutral", StringComparison.OrdinalIgnoreCase))
{
this.Cultures[c] = String.Empty;
}
}
}
}
else if (parameter.StartsWith("dcl:", StringComparison.Ordinal))
{
string defaultCompressionLevel = arg.Substring(5);
if (String.IsNullOrEmpty(defaultCompressionLevel))
{
break;
}
this.DefaultCompressionLevel = WixCreateCab.CompressionLevelFromString(defaultCompressionLevel);
}
else if (parameter.StartsWith("d", StringComparison.Ordinal))
{
parameter = arg.Substring(2);
string[] value = parameter.Split("=".ToCharArray(), 2);
string preexisting;
if (1 == value.Length)
{
Messaging.Instance.OnMessage(WixErrors.ExpectedWixVariableValue(value[0]));
}
else if (this.Variables.TryGetValue(value[0], out preexisting))
{
Messaging.Instance.OnMessage(WixErrors.WixVariableCollision(null, value[0]));
}
else
{
this.Variables.Add(value[0], value[1]);
}
}
else if (parameter.Equals("ext", StringComparison.Ordinal))
{
if (!CommandLine.IsValidArg(args, ++i))
{
Messaging.Instance.OnMessage(WixErrors.TypeSpecificationForExtensionRequired("-ext"));
break;
}
this.Extensions.Add(args[i]);
}
else if (parameter.Equals("loc", StringComparison.Ordinal))
{
string locFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(locFile))
{
break;
}
this.LocalizationFiles.Add(locFile);
}
else if (parameter.Equals("nologo", StringComparison.Ordinal))
{
this.ShowLogo = false;
}
else if (parameter.Equals("notidy", StringComparison.Ordinal))
{
this.Tidy = false;
}
else if ("o" == parameter || "out" == parameter)
{
this.OutputFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.OutputFile))
{
break;
}
}
else if (parameter.Equals("pedantic", StringComparison.Ordinal))
{
this.ShowPedanticMessages = true;
}
else if (parameter.Equals("sloc", StringComparison.Ordinal))
{
this.SuppressLocalization = true;
}
else if (parameter.Equals("usf", StringComparison.Ordinal))
{
this.UnreferencedSymbolsFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.UnreferencedSymbolsFile))
{
break;
}
}
else if (parameter.Equals("xo", StringComparison.Ordinal))
{
this.OutputXml = true;
}
else if (parameter.Equals("cc", StringComparison.Ordinal))
{
this.CabCachePath = CommandLine.GetDirectory(parameter, args, ++i);
if (String.IsNullOrEmpty(this.CabCachePath))
{
break;
}
}
else if (parameter.Equals("ct", StringComparison.Ordinal))
{
if (!CommandLine.IsValidArg(args, ++i))
{
Messaging.Instance.OnMessage(WixErrors.IllegalCabbingThreadCount(String.Empty));
break;
}
int ct = 0;
if (!Int32.TryParse(args[i], out ct) || 0 >= ct)
{
Messaging.Instance.OnMessage(WixErrors.IllegalCabbingThreadCount(args[i]));
break;
}
this.CabbingThreadCount = ct;
Messaging.Instance.OnMessage(WixVerboses.SetCabbingThreadCount(this.CabbingThreadCount.ToString()));
}
else if (parameter.Equals("cub", StringComparison.Ordinal))
{
string cubeFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(cubeFile))
{
break;
}
this.CubeFiles.Add(cubeFile);
}
else if (parameter.Equals("eav", StringComparison.Ordinal))
{
Messaging.Instance.OnMessage(WixWarnings.DeprecatedCommandLineSwitch(arg));
}
else if (parameter.StartsWith("ice:", StringComparison.Ordinal))
{
this.Ices.Add(parameter.Substring(4));
}
else if (parameter.Equals("contentsfile", StringComparison.Ordinal))
{
this.ContentsFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.ContentsFile))
{
break;
}
}
else if (parameter.Equals("outputsfile", StringComparison.Ordinal))
{
this.OutputsFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.OutputsFile))
{
break;
}
}
else if (parameter.Equals("builtoutputsfile", StringComparison.Ordinal))
{
this.BuiltOutputsFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.BuiltOutputsFile))
{
break;
}
}
else if (parameter.Equals("wixprojectfile", StringComparison.Ordinal))
{
this.WixprojectFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.WixprojectFile))
{
break;
}
}
else if (parameter.Equals("pdbout", StringComparison.Ordinal))
{
this.PdbFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.PdbFile))
{
break;
}
}
else if (parameter.Equals("reusecab", StringComparison.Ordinal))
{
Messaging.Instance.OnMessage(WixWarnings.DeprecatedCommandLineSwitch(arg, "-cc"));
}
else if (parameter.StartsWith("sice:", StringComparison.Ordinal))
{
this.SuppressIces.Add(parameter.Substring(5));
}
else if (parameter.Equals("sl", StringComparison.Ordinal))
{
this.SuppressLayout = true;
}
else if (parameter.Equals("spdb", StringComparison.Ordinal))
{
this.SuppressWixPdb = true;
}
else if (parameter.Equals("sacl", StringComparison.Ordinal))
{
this.SuppressAclReset = true;
}
else if (parameter.Equals("sval", StringComparison.Ordinal))
{
this.SuppressValidation = true;
}
else if ("sv" == parameter)
{
this.SuppressVersionCheck = true;
}
else if (parameter.StartsWith("sw", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
Messaging.Instance.SuppressAllWarnings = true;
}
else
{
int suppressWarning = 0;
if (!Int32.TryParse(paramArg, out suppressWarning) || 0 >= suppressWarning)
{
Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg));
}
else
{
Messaging.Instance.SuppressWarningMessage(suppressWarning);
}
}
}
else if (parameter.StartsWith("wx", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
Messaging.Instance.WarningsAsError = true;
}
else
{
int elevateWarning = 0;
if (!Int32.TryParse(paramArg, out elevateWarning) || 0 >= elevateWarning)
{
Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg));
}
else
{
Messaging.Instance.ElevateWarningMessage(elevateWarning);
}
}
}
else if ("v" == parameter)
{
Messaging.Instance.ShowVerboseMessages = true;
}
else if ("?" == parameter || "help" == parameter)
{
this.ShowHelp = true;
break;
}
else
{
unprocessed.Add(arg);
}
}
else if ('@' == arg[0])
{
string[] parsedArgs = CommandLineResponseFile.Parse(arg.Substring(1));
string[] unparsedArgs = this.Parse(parsedArgs);
unprocessed.AddRange(unparsedArgs);
}
else
{
unprocessed.Add(arg);
}
}
return(unprocessed.ToArray());
}
/// <summary>
/// Parse the commandline arguments.
/// </summary>
/// <param name="args">Commandline arguments.</param>
public string[] Parse(string[] args)
{
List <string> unprocessed = new List <string>();
for (int i = 0; i < args.Length; ++i)
{
string arg = args[i];
if (String.IsNullOrEmpty(arg)) // skip blank arguments
{
continue;
}
if (1 == arg.Length) // treat '-' and '@' as filenames when by themselves.
{
unprocessed.Add(arg);
}
else if ('-' == arg[0] || '/' == arg[0])
{
string parameter = arg.Substring(1);
if ("b" == parameter)
{
BindPath bindPath = CommandLine.GetBindPath(parameter, args, ++i);
if (null == bindPath)
{
break;
}
this.BindPaths.Add(bindPath);
}
else if ("bf" == parameter)
{
this.BindFiles = true;
}
else if ("ext" == parameter)
{
if (!CommandLine.IsValidArg(args, ++i))
{
Messaging.Instance.OnMessage(WixErrors.TypeSpecificationForExtensionRequired("-ext"));
break;
}
this.Extensions.Add(args[i]);
}
else if ("loc" == parameter)
{
string locFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(locFile))
{
break;
}
this.LocalizationFiles.Add(locFile);
}
else if ("nologo" == parameter)
{
this.ShowLogo = false;
}
else if ("o" == parameter || "out" == parameter)
{
this.OutputFile = CommandLine.GetFile(parameter, args, ++i);
if (String.IsNullOrEmpty(this.OutputFile))
{
break;
}
}
else if ("pedantic" == parameter)
{
this.ShowPedanticMessages = true;
}
else if ("sv" == parameter)
{
this.SuppressVersionCheck = true;
}
else if (parameter.StartsWith("sw", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
Messaging.Instance.SuppressAllWarnings = true;
}
else
{
int suppressWarning = 0;
if (!Int32.TryParse(paramArg, out suppressWarning) || 0 >= suppressWarning)
{
Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg));
}
else
{
Messaging.Instance.SuppressWarningMessage(suppressWarning);
}
}
}
else if (parameter.StartsWith("wx", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
Messaging.Instance.WarningsAsError = true;
}
else
{
int elevateWarning = 0;
if (!Int32.TryParse(paramArg, out elevateWarning) || 0 >= elevateWarning)
{
Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg));
}
else
{
Messaging.Instance.ElevateWarningMessage(elevateWarning);
}
}
}
else if ("v" == parameter)
{
Messaging.Instance.ShowVerboseMessages = true;
}
else if ("?" == parameter || "help" == parameter)
{
this.ShowHelp = true;
break;
}
else
{
unprocessed.Add(arg);
}
}
else if ('@' == arg[0])
{
string[] parsedArgs = CommandLineResponseFile.Parse(arg.Substring(1));
string[] unparsedArgs = this.Parse(parsedArgs);
unprocessed.AddRange(unparsedArgs);
}
else
{
unprocessed.Add(arg);
}
}
return(unprocessed.ToArray());
}
/// <summary>
/// Parse the commandline arguments.
/// </summary>
/// <param name="args">Commandline arguments.</param>
public string[] Parse(ICommandLineContext context)
{
var unprocessed = new List <string>();
var extensions = context.ExtensionManager.Create <IExtensionCommandLine>();
foreach (var extension in extensions)
{
extension.PreParse(context);
}
var parser = context.Arguments.Parse();
while (!this.ShowHelp &&
String.IsNullOrEmpty(parser.ErrorArgument) &&
parser.TryGetNextSwitchOrArgument(out var arg))
{
if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments.
{
continue;
}
if (parser.IsSwitch(arg))
{
var parameter = arg.Substring(1);
if (parameter.Equals("b", StringComparison.Ordinal))
{
var result = parser.GetNextArgumentOrError(arg);
if (!String.IsNullOrEmpty(result))
{
var bindPath = BindPath.Parse(result);
this.BindPaths.Add(bindPath);
}
}
else if (parameter.StartsWith("cultures:", StringComparison.Ordinal))
{
string culturesString = arg.Substring(10).ToLower(CultureInfo.InvariantCulture);
// When null is used treat it as if cultures wasn't specified.
// This is needed for batching over the light task when using MSBuild which doesn't
// support empty items
if (culturesString.Equals("null", StringComparison.OrdinalIgnoreCase))
{
this.Cultures = null;
}
else
{
this.Cultures = culturesString.Split(';', ',');
for (int c = 0; c < this.Cultures.Length; ++c)
{
// Neutral is different from null. For neutral we still want to do WXL filtering.
// Set the culture to the empty string = identifier for the invariant culture
if (this.Cultures[c].Equals("neutral", StringComparison.OrdinalIgnoreCase))
{
this.Cultures[c] = String.Empty;
}
}
}
}
else if (parameter.StartsWith("dcl:", StringComparison.Ordinal))
{
string defaultCompressionLevel = arg.Substring(5);
if (String.IsNullOrEmpty(defaultCompressionLevel))
{
break;
}
else if (Enum.TryParse(defaultCompressionLevel, true, out CompressionLevel compressionLevel))
{
this.DefaultCompressionLevel = compressionLevel;
}
}
else if (parameter.StartsWith("d", StringComparison.Ordinal))
{
parameter = arg.Substring(2);
string[] value = parameter.Split("=".ToCharArray(), 2);
string preexisting;
if (1 == value.Length)
{
this.Messaging.Write(ErrorMessages.ExpectedWixVariableValue(value[0]));
}
else if (this.Variables.TryGetValue(value[0], out preexisting))
{
this.Messaging.Write(ErrorMessages.WixVariableCollision(null, value[0]));
}
else
{
this.Variables.Add(value[0], value[1]);
}
}
else if (parameter.Equals("loc", StringComparison.Ordinal))
{
parser.GetNextArgumentAsFilePathOrError(arg, "localization files", this.LocalizationFiles);
}
else if (parameter.Equals("nologo", StringComparison.Ordinal))
{
this.ShowLogo = false;
}
else if (parameter.Equals("notidy", StringComparison.Ordinal))
{
this.Tidy = false;
}
else if ("o" == parameter || "out" == parameter)
{
this.OutputFile = parser.GetNextArgumentAsFilePathOrError(arg);
}
else if (parameter.Equals("pedantic", StringComparison.Ordinal))
{
this.ShowPedanticMessages = true;
}
else if (parameter.Equals("sloc", StringComparison.Ordinal))
{
this.SuppressLocalization = true;
}
else if (parameter.Equals("usf", StringComparison.Ordinal))
{
this.UnreferencedSymbolsFile = parser.GetNextArgumentAsDirectoryOrError(arg);
}
else if (parameter.Equals("xo", StringComparison.Ordinal))
{
this.OutputXml = true;
}
else if (parameter.Equals("cc", StringComparison.Ordinal))
{
this.CabCachePath = parser.GetNextArgumentAsDirectoryOrError(arg);
}
else if (parameter.Equals("ct", StringComparison.Ordinal))
{
var result = parser.GetNextArgumentOrError(arg);
if (!String.IsNullOrEmpty(result))
{
if (!Int32.TryParse(result, out var ct) || 0 >= ct)
{
this.Messaging.Write(ErrorMessages.IllegalCabbingThreadCount(result));
parser.ErrorArgument = arg;
break;
}
this.CabbingThreadCount = ct;
this.Messaging.Write(VerboseMessages.SetCabbingThreadCount(this.CabbingThreadCount.ToString()));
}
}
else if (parameter.Equals("cub", StringComparison.Ordinal))
{
parser.GetNextArgumentAsFilePathOrError(arg, "static validation files", this.CubeFiles);
}
else if (parameter.StartsWith("ice:", StringComparison.Ordinal))
{
this.Ices.Add(parameter.Substring(4));
}
else if (parameter.Equals("intermediatefolder", StringComparison.OrdinalIgnoreCase))
{
this.IntermediateFolder = parser.GetNextArgumentAsDirectoryOrError(arg);
}
else if (parameter.Equals("contentsfile", StringComparison.Ordinal))
{
this.ContentsFile = parser.GetNextArgumentAsFilePathOrError(arg);
}
else if (parameter.Equals("outputsfile", StringComparison.Ordinal))
{
this.OutputsFile = parser.GetNextArgumentAsFilePathOrError(arg);
}
else if (parameter.Equals("builtoutputsfile", StringComparison.Ordinal))
{
this.BuiltOutputsFile = parser.GetNextArgumentAsFilePathOrError(arg);
}
else if (parameter.Equals("wixprojectfile", StringComparison.Ordinal))
{
this.WixprojectFile = parser.GetNextArgumentAsFilePathOrError(arg);
}
else if (parameter.Equals("pdbout", StringComparison.Ordinal))
{
this.PdbFile = parser.GetNextArgumentAsFilePathOrError(arg);
}
else if (parameter.StartsWith("sice:", StringComparison.Ordinal))
{
this.SuppressIces.Add(parameter.Substring(5));
}
else if (parameter.Equals("sl", StringComparison.Ordinal))
{
this.SuppressLayout = true;
}
else if (parameter.Equals("spdb", StringComparison.Ordinal))
{
this.SuppressWixPdb = true;
}
else if (parameter.Equals("sacl", StringComparison.Ordinal))
{
this.SuppressAclReset = true;
}
else if (parameter.Equals("sval", StringComparison.Ordinal))
{
this.SuppressValidation = true;
}
else if ("sv" == parameter)
{
this.SuppressVersionCheck = true;
}
else if (parameter.StartsWith("sw", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
this.Messaging.SuppressAllWarnings = true;
}
else
{
int suppressWarning = 0;
if (!Int32.TryParse(paramArg, out suppressWarning) || 0 >= suppressWarning)
{
this.Messaging.Write(ErrorMessages.IllegalSuppressWarningId(paramArg));
}
else
{
this.Messaging.SuppressWarningMessage(suppressWarning);
}
}
}
else if (parameter.StartsWith("wx", StringComparison.Ordinal))
{
string paramArg = parameter.Substring(2);
if (0 == paramArg.Length)
{
this.Messaging.WarningsAsError = true;
}
else
{
int elevateWarning = 0;
if (!Int32.TryParse(paramArg, out elevateWarning) || 0 >= elevateWarning)
{
this.Messaging.Write(ErrorMessages.IllegalWarningIdAsError(paramArg));
}
else
{
this.Messaging.ElevateWarningMessage(elevateWarning);
}
}
}
else if ("v" == parameter)
{
this.Messaging.ShowVerboseMessages = true;
}
else if ("?" == parameter || "help" == parameter)
{
this.ShowHelp = true;
break;
}
else if (!this.TryParseCommandLineArgumentWithExtension(arg, parser, extensions))
{
unprocessed.Add(arg);
}
}
else if (!this.TryParseCommandLineArgumentWithExtension(arg, parser, extensions))
{
unprocessed.Add(arg);
}
}
return(this.ParsePostExtensions(parser, unprocessed.ToArray()));
}
