Refactor command line parsing to enable extensions there in light.exe

Fixes wixtoolset/issues#5845

1 files changed, 165 insertions, 428 deletions

diff --git a/src/WixToolset.Core/CommandLine/CommandLineParser.cs b/src/WixToolset.Core/CommandLine/CommandLineParser.cs
index f4bc8ade..da0e979c 100644
--- a/src/WixToolset.Core/CommandLine/CommandLineParser.cs
+++ b/src/WixToolset.Core/CommandLine/CommandLineParser.cs
@@ -5,9 +5,6 @@ namespace WixToolset.Core.CommandLine
     using System;
     using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
-    using System.Text;
-    using System.Text.RegularExpressions;
     using WixToolset.Data;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Services;
@@ -22,7 +19,7 @@ namespace WixToolset.Core.CommandLine
         Bind,
     }
 
-    internal class CommandLineParser : ICommandLine, IParseCommandLine
+    internal class CommandLineParser : ICommandLine
     {
         private IServiceProvider ServiceProvider { get; set; }
 
@@ -32,14 +29,8 @@ namespace WixToolset.Core.CommandLine
 
         public string ActiveCommand { get; private set; }
 
-        public string[] OriginalArguments { get; private set; }
-
-        public Queue<string> RemainingArguments { get; } = new Queue<string>();
-
         public IExtensionManager ExtensionManager { get; private set; }
 
-        public string ErrorArgument { get; set; }
-
         public bool ShowHelp { get; set; }
 
         public ICommandLineCommand ParseStandardCommandLine(ICommandLineContext context)
@@ -50,18 +41,6 @@ namespace WixToolset.Core.CommandLine
 
             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 ICommandLineCommand ParseStandardCommandLine(ICommandLineContext context, string[] args)
-        {
             var next = String.Empty;
 
             var command = Commands.Unknown;
@@ -89,99 +68,99 @@ namespace WixToolset.Core.CommandLine
             var outputsFile = String.Empty;
             var builtOutputsFile = String.Empty;
 
-            this.Parse(context, args, (cmdline, arg) => Enum.TryParse(arg, true, out command), (cmdline, arg) =>
+            this.Parse(context, (cmdline, arg) => Enum.TryParse(arg, true, out command), (cmdline, parser, arg) =>
             {
-                if (cmdline.IsSwitch(arg))
+                if (parser.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;
+                    case "?":
+                    case "h":
+                    case "help":
+                        cmdline.ShowHelp = true;
+                        return true;
+
+                    case "bindfiles":
+                        bindFiles = true;
+                        return true;
+
+                    case "bindpath":
+                        parser.GetNextArgumentOrError(arg, bindPaths);
+                        return true;
+
+                    case "cc":
+                        cabCachePath = parser.GetNextArgumentOrError(arg);
+                        return true;
+
+                    case "culture":
+                        parser.GetNextArgumentOrError(arg, cultures);
+                        return true;
+                    case "contentsfile":
+                        contentsFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+                    case "outputsfile":
+                        outputsFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+                    case "builtoutputsfile":
+                        builtOutputsFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+
+                    case "d":
+                    case "define":
+                        parser.GetNextArgumentOrError(arg, defines);
+                        return true;
+
+                    case "i":
+                    case "includepath":
+                        parser.GetNextArgumentOrError(arg, includePaths);
+                        return true;
+
+                    case "intermediatefolder":
+                        intermediateFolder = parser.GetNextArgumentAsDirectoryOrError(arg);
+                        return true;
+
+                    case "loc":
+                        parser.GetNextArgumentAsFilePathOrError(arg, "localization files", locFiles);
+                        return true;
+
+                    case "lib":
+                        parser.GetNextArgumentAsFilePathOrError(arg, "library files", libraryFiles);
+                        return true;
+
+                    case "o":
+                    case "out":
+                        outputFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+
+                    case "outputtype":
+                        outputType= parser.GetNextArgumentOrError(arg);
+                        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"));
+                    parser.GetArgumentAsFilePathOrError(arg, "source code", files);
                     return true;
                 }
             });
@@ -205,22 +184,22 @@ namespace WixToolset.Core.CommandLine
 
             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.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);
-                    }
+            case Commands.Compile:
+            {
+                var sourceFiles = GatherSourceFiles(files, outputFolder);
+                var variables = GatherPreprocessorVariables(defines);
+                return new CompileCommand(this.ServiceProvider, sourceFiles, variables);
+            }
             }
 
             return null;
@@ -262,63 +241,87 @@ namespace WixToolset.Core.CommandLine
 
             switch (outputType.ToLowerInvariant())
             {
-                case "bundle":
-                case ".exe":
-                    return OutputType.Bundle;
+            case "bundle":
+            case ".exe":
+                return OutputType.Bundle;
 
-                case "library":
-                case ".wixlib":
-                    return OutputType.Library;
+            case "library":
+            case ".wixlib":
+                return OutputType.Library;
 
-                case "module":
-                case ".msm":
-                    return OutputType.Module;
+            case "module":
+            case ".msm":
+                return OutputType.Module;
 
-                case "patch":
-                case ".msp":
-                    return OutputType.Patch;
+            case "patch":
+            case ".msp":
+                return OutputType.Patch;
 
-                case ".pcp":
-                    return OutputType.PatchCreation;
+            case ".pcp":
+                return OutputType.PatchCreation;
 
-                case "product":
-                case "package":
-                case ".msi":
-                    return OutputType.Product;
+            case "product":
+            case "package":
+            case ".msi":
+                return OutputType.Product;
 
-                case "transform":
-                case ".mst":
-                    return OutputType.Transform;
+            case "transform":
+            case ".mst":
+                return OutputType.Transform;
 
-                case "intermediatepostlink":
-                case ".wixipl":
-                    return OutputType.IntermediatePostLink;
+            case "intermediatepostlink":
+            case ".wixipl":
+                return OutputType.IntermediatePostLink;
             }
 
             return OutputType.Unknown;
         }
 
-#if UNUSED
-        private static CommandLine Parse(string commandLineString, Func<CommandLine, string, bool> parseArgument)
+        private ICommandLine Parse(ICommandLineContext context, Func<CommandLineParser, string, bool> parseCommand, Func<CommandLineParser, IParseCommandLine, string, bool> parseArgument)
         {
-            var arguments = CommandLine.ParseArgumentsToArray(commandLineString).ToArray();
-
-            return CommandLine.Parse(arguments, null, parseArgument);
-        }
+            var extensions = this.ExtensionManager.Create<IExtensionCommandLine>();
 
-        private static CommandLine Parse(string[] commandLineArguments, Func<CommandLine, string, bool> parseArgument)
-        {
-            return CommandLine.Parse(commandLineArguments, null, parseArgument);
-        }
-#endif
+            foreach (var extension in extensions)
+            {
+                extension.PreParse(context);
+            }
 
-        private ICommandLine Parse(ICommandLineContext context, string[] commandLineArguments, Func<CommandLineParser, string, bool> parseCommand, Func<CommandLineParser, string, bool> parseArgument)
-        {
-            this.FlattenArgumentsWithResponseFilesIntoOriginalArguments(commandLineArguments);
+            var parser = context.Arguments.Parse();
 
-            this.QueueArgumentsAndLoadExtensions(this.OriginalArguments);
+            while (!this.ShowHelp &&
+                   String.IsNullOrEmpty(parser.ErrorArgument) &&
+                   parser.TryGetNextSwitchOrArgument(out var arg))
+            {
+                if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments.
+                {
+                    continue;
+                }
 
-            this.ProcessRemainingArguments(context, parseArgument, parseCommand);
+                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;
+                }
+            }
 
             return this;
         }
@@ -358,7 +361,7 @@ namespace WixToolset.Core.CommandLine
             return variables;
         }
 
-        private  IEnumerable<BindPath> GatherBindPaths(IEnumerable<string> bindPaths)
+        private IEnumerable<BindPath> GatherBindPaths(IEnumerable<string> bindPaths)
         {
             var result = new List<BindPath>();
 
@@ -379,172 +382,11 @@ namespace WixToolset.Core.CommandLine
             return result;
         }
 
-        /// <summary>
-        /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
-        /// </summary>
-        /// <param name="args">The list of strings to check.</param>
-        /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
-        /// <returns>True if a valid switch exists there, false if not.</returns>
-        public bool IsSwitch(string arg)
-        {
-            return arg != null && arg.Length > 1 && ('/' == arg[0] || '-' == arg[0]);
-        }
-
-        /// <summary>
-        /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
-        /// </summary>
-        /// <param name="args">The list of strings to check.</param>
-        /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
-        /// <returns>True if a valid switch exists there, false if not.</returns>
-        public bool IsSwitchAt(IEnumerable<string> args, int index)
-        {
-            var arg = args.ElementAtOrDefault(index);
-            return IsSwitch(arg);
-        }
-
-        public void GetNextArgumentOrError(ref string arg)
-        {
-            this.TryGetNextArgumentOrError(out arg);
-        }
-
-        public void GetNextArgumentOrError(IList<string> args)
-        {
-            if (this.TryGetNextArgumentOrError(out var arg))
-            {
-                args.Add(arg);
-            }
-        }
-
-        public void GetNextArgumentAsFilePathOrError(IList<string> args, string fileType)
-        {
-            if (this.TryGetNextArgumentOrError(out var arg))
-            {
-                foreach (var path in CommandLineHelper.GetFiles(arg, fileType))
-                {
-                    args.Add(path);
-                }
-            }
-        }
-
-        public bool TryGetNextArgumentOrError(out string arg)
-        {
-            if (TryDequeue(this.RemainingArguments, out arg) && !this.IsSwitch(arg))
-            {
-                return true;
-            }
-
-            this.ErrorArgument = arg ?? CommandLineParser.ExpectedArgument;
-
-            return false;
-        }
-
-        private static bool TryDequeue(Queue<string> q, out string arg)
-        {
-            if (q.Count > 0)
-            {
-                arg = q.Dequeue();
-                return true;
-            }
-
-            arg = null;
-            return false;
-        }
-
-        private void FlattenArgumentsWithResponseFilesIntoOriginalArguments(string[] commandLineArguments)
-        {
-            List<string> args = new List<string>();
-
-            foreach (var arg in commandLineArguments)
-            {
-                if ('@' == arg[0])
-                {
-                    var responseFileArguments = CommandLineParser.ParseResponseFile(arg.Substring(1));
-                    args.AddRange(responseFileArguments);
-                }
-                else
-                {
-                    args.Add(arg);
-                }
-            }
-
-            this.OriginalArguments = args.ToArray();
-        }
-
-        private void QueueArgumentsAndLoadExtensions(string[] args)
+        private bool TryParseCommandLineArgumentWithExtension(string arg, IParseCommandLine parse, IEnumerable<IExtensionCommandLine> extensions)
         {
-            for (var i = 0; i < args.Length; ++i)
-            {
-                var arg = args[i];
-
-                if ("-ext" == arg || "/ext" == arg)
-                {
-                    if (!this.IsSwitchAt(args, ++i))
-                    {
-                        this.ExtensionManager.Load(args[i]);
-                    }
-                    else
-                    {
-                        this.ErrorArgument = arg;
-                        break;
-                    }
-                }
-                else
-                {
-                    this.RemainingArguments.Enqueue(arg);
-                }
-            }
-        }
-
-        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;
-                }
-            }
-        }
-
-        private bool TryParseCommandLineArgumentWithExtension(string arg, IEnumerable<IExtensionCommandLine> extensions)
-        {
-            foreach (var extension in extensions)
-            {
-                if (extension.TryParseArgument(this, arg))
+                if (extension.TryParseArgument(parse, arg))
                 {
                     return true;
                 }
@@ -552,110 +394,5 @@ namespace WixToolset.Core.CommandLine
 
             return false;
         }
-
-        private static List<string> ParseResponseFile(string responseFile)
-        {
-            string arguments;
-
-            using (StreamReader reader = new StreamReader(responseFile))
-            {
-                arguments = reader.ReadToEnd();
-            }
-
-            return CommandLineParser.ParseArgumentsToArray(arguments);
-        }
-
-        private static List<string> ParseArgumentsToArray(string arguments)
-        {
-            // Scan and parse the arguments string, dividing up the arguments based on whitespace.
-            // Unescaped quotes cause whitespace to be ignored, while the quotes themselves are removed.
-            // Quotes may begin and end inside arguments; they don't necessarily just surround whole arguments.
-            // Escaped quotes and escaped backslashes also need to be unescaped by this process.
-
-            // Collects the final list of arguments to be returned.
-            var argsList = new List<string>();
-
-            // True if we are inside an unescaped quote, meaning whitespace should be ignored.
-            var insideQuote = false;
-
-            // Index of the start of the current argument substring; either the start of the argument
-            // or the start of a quoted or unquoted sequence within it.
-            var partStart = 0;
-
-            // The current argument string being built; when completed it will be added to the list.
-            var arg = new StringBuilder();
-
-            for (int i = 0; i <= arguments.Length; i++)
-            {
-                if (i == arguments.Length || (Char.IsWhiteSpace(arguments[i]) && !insideQuote))
-                {
-                    // Reached a whitespace separator or the end of the string.
-
-                    // Finish building the current argument.
-                    arg.Append(arguments.Substring(partStart, i - partStart));
-
-                    // Skip over the whitespace character.
-                    partStart = i + 1;
-
-                    // Add the argument to the list if it's not empty.
-                    if (arg.Length > 0)
-                    {
-                        argsList.Add(CommandLineParser.ExpandEnvironmentVariables(arg.ToString()));
-                        arg.Length = 0;
-                    }
-                }
-                else if (i > partStart && arguments[i - 1] == '\\')
-                {
-                    // Check the character following an unprocessed backslash.
-                    // Unescape quotes, and backslashes followed by a quote.
-                    if (arguments[i] == '"' || (arguments[i] == '\\' && arguments.Length > i + 1 && arguments[i + 1] == '"'))
-                    {
-                        // Unescape the quote or backslash by skipping the preceeding backslash.
-                        arg.Append(arguments.Substring(partStart, i - 1 - partStart));
-                        arg.Append(arguments[i]);
-                        partStart = i + 1;
-                    }
-                }
-                else if (arguments[i] == '"')
-                {
-                    // Add the quoted or unquoted section to the argument string.
-                    arg.Append(arguments.Substring(partStart, i - partStart));
-
-                    // And skip over the quote character.
-                    partStart = i + 1;
-
-                    insideQuote = !insideQuote;
-                }
-            }
-
-            return argsList;
-        }
-
-        private static string ExpandEnvironmentVariables(string arguments)
-        {
-            var id = Environment.GetEnvironmentVariables();
-
-            var regex = new Regex("(?<=\\%)(?:[\\w\\.]+)(?=\\%)");
-            MatchCollection matches = regex.Matches(arguments);
-
-            string value = String.Empty;
-            for (int i = 0; i <= (matches.Count - 1); i++)
-            {
-                try
-                {
-                    var key = matches[i].Value;
-                    regex = new Regex(String.Concat("(?i)(?:\\%)(?:", key, ")(?:\\%)"));
-                    value = id[key].ToString();
-                    arguments = regex.Replace(arguments, value);
-                }
-                catch (NullReferenceException)
-                {
-                    // Collapse unresolved environment variables.
-                    arguments = regex.Replace(arguments, value);
-                }
-            }
-
-            return arguments;
-        }
     }
 }