private ICommandLine Parse(ICommandLineContext context, string[] commandLineArguments, Func <CommandLineParser, string, bool> parseCommand, Func <CommandLineParser, string, bool> parseArgument)
{
this.FlattenArgumentsWithResponseFilesIntoOriginalArguments(commandLineArguments);
this.QueueArgumentsAndLoadExtensions(this.OriginalArguments);
this.ProcessRemainingArguments(context, parseArgument, parseCommand);
return(this);
}
private ICommandLineParser Parse(ICommandLineContext context, Func <CommandLineParser, string, bool> parseCommand, Func <CommandLineParser, IParseCommandLine, string, bool> parseArgument)
{
var extensions = this.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))
{
if (!parseArgument(this, parser, arg) &&
!this.TryParseCommandLineArgumentWithExtension(arg, parser, extensions))
{
parser.ErrorArgument = arg;
}
}
else if (String.IsNullOrEmpty(this.ActiveCommand) && parseCommand != null) // First non-switch must be the command, if commands are supported.
{
if (parseCommand(this, arg))
{
this.ActiveCommand = arg;
}
else
{
parser.ErrorArgument = arg;
}
}
else if (!this.TryParseCommandLineArgumentWithExtension(arg, parser, extensions) &&
!parseArgument(this, parser, arg))
{
parser.ErrorArgument = arg;
}
}
foreach (var extension in extensions)
{
extension.PostParse();
}
return(this);
}
private ICommandLineCommand Parse(ICommandLineContext context)
{
var extensions = this.ExtensionManager.Create <IExtensionCommandLine>();
foreach (var extension in extensions)
{
extension.PreParse(context);
}
ICommandLineCommand command = null;
var parser = context.Arguments.Parse();
while (command?.StopParsing != true &&
String.IsNullOrEmpty(parser.ErrorArgument) &&
parser.TryGetNextSwitchOrArgument(out var arg))
{
if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments.
{
continue;
}
// First argument must be the command or global switch (that creates a command).
if (command == null)
{
if (!this.TryParseUnknownCommandArg(arg, parser, out command, extensions))
{
parser.ErrorArgument = arg;
}
}
else if (parser.IsSwitch(arg))
{
if (!command.TryParseArgument(parser, arg) && !TryParseCommandLineArgumentWithExtension(arg, parser, extensions))
{
parser.ErrorArgument = arg;
}
}
else if (!TryParseCommandLineArgumentWithExtension(arg, parser, extensions) && command?.TryParseArgument(parser, arg) == false)
{
parser.ErrorArgument = arg;
}
}
foreach (var extension in extensions)
{
extension.PostParse();
}
return(command ?? new HelpCommand());
}
public ICommandLineCommand ParseStandardCommandLine(ICommandLineContext context)
{
this.ServiceProvider = context.ServiceProvider;
this.Messaging = context.Messaging ?? this.ServiceProvider.GetService <IMessaging>();
this.ExtensionManager = context.ExtensionManager ?? this.ServiceProvider.GetService <IExtensionManager>();
var args = context.ParsedArguments ?? Array.Empty <string>();
if (!String.IsNullOrEmpty(context.Arguments))
{
args = CommandLineParser.ParseArgumentsToArray(context.Arguments).Concat(args).ToArray();
}
return(this.ParseStandardCommandLine(context, args));
}
private void ProcessRemainingArguments(ICommandLineContext context, Func <CommandLineParser, string, bool> parseArgument, Func <CommandLineParser, string, bool> parseCommand)
{
var extensions = this.ExtensionManager.Create <IExtensionCommandLine>();
foreach (var extension in extensions)
{
extension.PreParse(context);
}
while (!this.ShowHelp &&
String.IsNullOrEmpty(this.ErrorArgument) &&
TryDequeue(this.RemainingArguments, out var arg))
{
if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments.
{
continue;
}
if ('-' == arg[0] || '/' == arg[0])
{
if (!parseArgument(this, arg) &&
!this.TryParseCommandLineArgumentWithExtension(arg, extensions))
{
this.ErrorArgument = arg;
}
}
else if (String.IsNullOrEmpty(this.ActiveCommand) && parseCommand != null) // First non-switch must be the command, if commands are supported.
{
if (parseCommand(this, arg))
{
this.ActiveCommand = arg;
}
else
{
this.ErrorArgument = arg;
}
}
else if (!this.TryParseCommandLineArgumentWithExtension(arg, extensions) &&
!parseArgument(this, arg))
{
this.ErrorArgument = arg;
}
}
}
/// <summary>
/// See <see cref="IExtensionCommandLine.PreParse" />
/// </summary>
public virtual void PreParse(ICommandLineContext context)
{
}
private ICommandLineCommand ParseStandardCommandLine(ICommandLineContext context, string[] args)
{
var next = String.Empty;
var command = Commands.Unknown;
var showLogo = true;
var showVersion = false;
var outputFolder = String.Empty;
var outputFile = String.Empty;
var outputType = String.Empty;
var verbose = false;
var files = new List <string>();
var defines = new List <string>();
var includePaths = new List <string>();
var locFiles = new List <string>();
var libraryFiles = new List <string>();
var suppressedWarnings = new List <int>();
var bindFiles = false;
var bindPaths = new List <string>();
var intermediateFolder = String.Empty;
var cabCachePath = String.Empty;
var cultures = new List <string>();
var contentsFile = String.Empty;
var outputsFile = String.Empty;
var builtOutputsFile = String.Empty;
this.Parse(context, args, (cmdline, arg) => Enum.TryParse(arg, true, out command), (cmdline, arg) =>
{
if (cmdline.IsSwitch(arg))
{
var parameter = arg.Substring(1);
switch (parameter.ToLowerInvariant())
{
case "?":
case "h":
case "help":
cmdline.ShowHelp = true;
return(true);
case "bindfiles":
bindFiles = true;
return(true);
case "bindpath":
cmdline.GetNextArgumentOrError(bindPaths);
return(true);
case "cc":
cmdline.GetNextArgumentOrError(ref cabCachePath);
return(true);
case "culture":
cmdline.GetNextArgumentOrError(cultures);
return(true);
case "contentsfile":
cmdline.GetNextArgumentOrError(ref contentsFile);
return(true);
case "outputsfile":
cmdline.GetNextArgumentOrError(ref outputsFile);
return(true);
case "builtoutputsfile":
cmdline.GetNextArgumentOrError(ref builtOutputsFile);
return(true);
case "d":
case "define":
cmdline.GetNextArgumentOrError(defines);
return(true);
case "i":
case "includepath":
cmdline.GetNextArgumentOrError(includePaths);
return(true);
case "intermediatefolder":
cmdline.GetNextArgumentOrError(ref intermediateFolder);
return(true);
case "loc":
cmdline.GetNextArgumentAsFilePathOrError(locFiles, "localization files");
return(true);
case "lib":
cmdline.GetNextArgumentAsFilePathOrError(libraryFiles, "library files");
return(true);
case "o":
case "out":
cmdline.GetNextArgumentOrError(ref outputFile);
return(true);
case "outputtype":
cmdline.GetNextArgumentOrError(ref outputType);
return(true);
case "nologo":
showLogo = false;
return(true);
case "v":
case "verbose":
verbose = true;
return(true);
case "version":
case "-version":
showVersion = true;
return(true);
case "sval":
// todo: implement
return(true);
}
return(false);
}
else
{
files.AddRange(CommandLineHelper.GetFiles(arg, "source code"));
return(true);
}
});
this.Messaging.ShowVerboseMessages = verbose;
if (showVersion)
{
return(new VersionCommand());
}
if (showLogo)
{
AppCommon.DisplayToolHeader();
}
if (this.ShowHelp)
{
return(new HelpCommand(command));
}
switch (command)
{
case Commands.Build:
{
var sourceFiles = GatherSourceFiles(files, outputFolder);
var variables = this.GatherPreprocessorVariables(defines);
var bindPathList = this.GatherBindPaths(bindPaths);
var filterCultures = CalculateFilterCultures(cultures);
var type = CalculateOutputType(outputType, outputFile);
return(new BuildCommand(this.ServiceProvider, sourceFiles, variables, locFiles, libraryFiles, filterCultures, outputFile, type, cabCachePath, bindFiles, bindPathList, includePaths, intermediateFolder, contentsFile, outputsFile, builtOutputsFile));
}
case Commands.Compile:
{
var sourceFiles = GatherSourceFiles(files, outputFolder);
var variables = GatherPreprocessorVariables(defines);
return(new CompileCommand(this.ServiceProvider, sourceFiles, variables));
}
}
return(null);
}
/// <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()));
}
