1 files changed, 390 insertions, 88 deletions

diff --git a/src/WixToolset.Core/CommandLine/BuildCommand.cs b/src/WixToolset.Core/CommandLine/BuildCommand.cs
index 6052d979..87a3cd30 100644
--- a/src/WixToolset.Core/CommandLine/BuildCommand.cs
+++ b/src/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
 
 namespace WixToolset.Core.CommandLine
 {
@@ -14,83 +14,84 @@ namespace WixToolset.Core.CommandLine
 
     internal class BuildCommand : ICommandLineCommand
     {
-        public BuildCommand(IServiceProvider serviceProvider, IEnumerable<SourceFile> sources, IDictionary<string, string> preprocessorVariables, IEnumerable<string> locFiles, IEnumerable<string> libraryFiles, IEnumerable<string> filterCultures, string outputPath, OutputType outputType, Platform platform, string cabCachePath, bool bindFiles, IEnumerable<BindPath> bindPaths, IEnumerable<string> includeSearchPaths, string intermediateFolder, string contentsFile, string outputsFile, string builtOutputsFile)
+        private readonly CommandLine commandLine;
+
+        public BuildCommand(IServiceProvider serviceProvider)
         {
             this.ServiceProvider = serviceProvider;
             this.Messaging = serviceProvider.GetService<IMessaging>();
             this.ExtensionManager = serviceProvider.GetService<IExtensionManager>();
-            this.LocFiles = locFiles;
-            this.LibraryFiles = libraryFiles;
-            this.FilterCultures = filterCultures;
-            this.PreprocessorVariables = preprocessorVariables;
-            this.SourceFiles = sources;
-            this.OutputPath = outputPath;
-            this.OutputType = outputType;
-            this.Platform = platform;
-
-            this.CabCachePath = cabCachePath;
-            this.BindFiles = bindFiles;
-            this.BindPaths = bindPaths;
-            this.IncludeSearchPaths = includeSearchPaths;
-
-            this.IntermediateFolder = intermediateFolder ?? Path.GetTempPath();
-            this.ContentsFile = contentsFile;
-            this.OutputsFile = outputsFile;
-            this.BuiltOutputsFile = builtOutputsFile;
+            this.commandLine = new CommandLine(this.Messaging);
         }
 
-        public IServiceProvider ServiceProvider { get; }
+        public bool ShowLogo => this.commandLine.ShowLogo;
 
-        public IMessaging Messaging { get; }
+        public bool StopParsing => this.commandLine.ShowHelp;
 
-        public IExtensionManager ExtensionManager { get; }
+        private IServiceProvider ServiceProvider { get; }
 
-        public IEnumerable<string> FilterCultures { get; }
+        private IMessaging Messaging { get; }
 
-        public IEnumerable<string> IncludeSearchPaths { get; }
+        private IExtensionManager ExtensionManager { get; }
 
-        public IEnumerable<string> LocFiles { get; }
+        private string IntermediateFolder { get; set; }
 
-        public IEnumerable<string> LibraryFiles { get; }
+        private OutputType OutputType { get; set; }
 
-        private IEnumerable<SourceFile> SourceFiles { get; }
+        private List<string> IncludeSearchPaths { get; set; }
 
-        private IDictionary<string, string> PreprocessorVariables { get; }
+        private Platform Platform { get; set; }
 
-        private string OutputPath { get; }
+        private string OutputFile { get; set; }
 
-        private OutputType OutputType { get; }
+        private string ContentsFile { get; set; }
 
-        private Platform Platform { get; }
+        private string OutputsFile { get; set; }
 
-        public string CabCachePath { get; }
+        private string BuiltOutputsFile { get; set; }
 
-        public bool BindFiles { get; }
+        public int Execute()
+        {
+            if (this.commandLine.ShowHelp)
+            {
+                Console.WriteLine("TODO: Show build command help");
+                return -1;
+            }
 
-        public IEnumerable<BindPath> BindPaths { get; }
+            this.IntermediateFolder = this.commandLine.CalculateIntermedateFolder();
 
-        public string IntermediateFolder { get; }
+            this.OutputType = this.commandLine.CalculateOutputType();
 
-        public string ContentsFile { get; }
+            this.IncludeSearchPaths = this.commandLine.IncludeSearchPaths;
 
-        public string OutputsFile { get; }
+            this.Platform = this.commandLine.Platform;
 
-        public string BuiltOutputsFile { get; }
+            this.OutputFile = this.commandLine.OutputFile;
+
+            this.ContentsFile = this.commandLine.ContentsFile;
+
+            this.OutputsFile = this.commandLine.OutputsFile;
+
+            this.BuiltOutputsFile = this.commandLine.BuiltOutputsFile;
+
+            var preprocessorVariables = this.commandLine.GatherPreprocessorVariables();
+
+            var sourceFiles = this.commandLine.GatherSourceFiles(this.IntermediateFolder);
+
+            var filterCultures = this.commandLine.CalculateFilterCultures();
 
-        public int Execute()
-        {
             var creator = this.ServiceProvider.GetService<ITupleDefinitionCreator>();
 
-            this.EvaluateSourceFiles(creator, out var codeFiles, out var wixipl);
+            this.EvaluateSourceFiles(sourceFiles, creator, out var codeFiles, out var wixipl);
 
             if (this.Messaging.EncounteredError)
             {
                 return this.Messaging.LastErrorNumber;
             }
 
-            var wixobjs = this.CompilePhase(codeFiles);
+            var wixobjs = this.CompilePhase(preprocessorVariables, codeFiles);
 
-            var wxls = this.LoadLocalizationFiles().ToList();
+            var wxls = this.LoadLocalizationFiles(this.commandLine.LocalizationFilePaths, preprocessorVariables);
 
             if (this.Messaging.EncounteredError)
             {
@@ -99,29 +100,29 @@ namespace WixToolset.Core.CommandLine
 
             if (this.OutputType == OutputType.Library)
             {
-                var wixlib = this.LibraryPhase(wixobjs, wxls);
+                var wixlib = this.LibraryPhase(wixobjs, wxls, this.commandLine.BindFiles, this.commandLine.BindPaths);
 
                 if (!this.Messaging.EncounteredError)
                 {
-                    wixlib.Save(this.OutputPath);
+                    wixlib.Save(this.commandLine.OutputFile);
                 }
             }
             else
             {
                 if (wixipl == null)
                 {
-                    wixipl = this.LinkPhase(wixobjs, creator);
+                    wixipl = this.LinkPhase(wixobjs, this.commandLine.LibraryFilePaths, creator);
                 }
 
                 if (!this.Messaging.EncounteredError)
                 {
                     if (this.OutputType == OutputType.IntermediatePostLink)
                     {
-                        wixipl.Save(this.OutputPath);
+                        wixipl.Save(this.commandLine.OutputFile);
                     }
                     else
                     {
-                        this.BindPhase(wixipl, wxls);
+                        this.BindPhase(wixipl, wxls, filterCultures, this.commandLine.CabCachePath, this.commandLine.BindPaths);
                     }
                 }
             }
@@ -129,13 +130,18 @@ namespace WixToolset.Core.CommandLine
             return this.Messaging.LastErrorNumber;
         }
 
-        private void EvaluateSourceFiles(ITupleDefinitionCreator creator, out List<SourceFile> codeFiles, out Intermediate wixipl)
+        public bool TryParseArgument(ICommandLineParser parser, string argument)
+        {
+            return this.commandLine.TryParseArgument(argument, parser);
+        }
+
+        private void EvaluateSourceFiles(IEnumerable<SourceFile> sourceFiles, ITupleDefinitionCreator creator, out List<SourceFile> codeFiles, out Intermediate wixipl)
         {
             codeFiles = new List<SourceFile>();
 
             wixipl = null;
 
-            foreach (var sourceFile in this.SourceFiles)
+            foreach (var sourceFile in sourceFiles)
             {
                 var extension = Path.GetExtension(sourceFile.SourcePath);
 
@@ -167,13 +173,13 @@ namespace WixToolset.Core.CommandLine
             }
         }
 
-        private IEnumerable<Intermediate> CompilePhase(IEnumerable<SourceFile> sourceFiles)
+        private IEnumerable<Intermediate> CompilePhase(IDictionary<string, string> preprocessorVariables, IEnumerable<SourceFile> sourceFiles)
         {
             var intermediates = new List<Intermediate>();
 
             foreach (var sourceFile in sourceFiles)
             {
-                var document = this.Preprocess(sourceFile.SourcePath);
+                var document = this.Preprocess(preprocessorVariables, sourceFile.SourcePath);
 
                 if (this.Messaging.EncounteredError)
                 {
@@ -208,11 +214,11 @@ namespace WixToolset.Core.CommandLine
             return intermediates;
         }
 
-        private Intermediate LibraryPhase(IEnumerable<Intermediate> intermediates, IEnumerable<Localization> localizations)
+        private Intermediate LibraryPhase(IEnumerable<Intermediate> intermediates, IEnumerable<Localization> localizations, bool bindFiles, IEnumerable<BindPath> bindPaths)
         {
             var context = this.ServiceProvider.GetService<ILibraryContext>();
-            context.BindFiles = this.BindFiles;
-            context.BindPaths = this.BindPaths;
+            context.BindFiles = bindFiles;
+            context.BindPaths = bindPaths;
             context.Extensions = this.ExtensionManager.Create<ILibrarianExtension>();
             context.Localizations = localizations;
             context.Intermediates = intermediates;
@@ -230,10 +236,10 @@ namespace WixToolset.Core.CommandLine
 
             return library;
         }
-        
-        private Intermediate LinkPhase(IEnumerable<Intermediate> intermediates, ITupleDefinitionCreator creator)
+
+        private Intermediate LinkPhase(IEnumerable<Intermediate> intermediates, IEnumerable<string> libraryFiles, ITupleDefinitionCreator creator)
         {
-            var libraries = this.LoadLibraries(creator);
+            var libraries = this.LoadLibraries(libraryFiles, creator);
 
             if (this.Messaging.EncounteredError)
             {
@@ -251,7 +257,7 @@ namespace WixToolset.Core.CommandLine
             return linker.Link(context);
         }
 
-        private void BindPhase(Intermediate output, IEnumerable<Localization> localizations)
+        private void BindPhase(Intermediate output, IEnumerable<Localization> localizations, IEnumerable<string> filterCultures, string cabCachePath, IEnumerable<BindPath> bindPaths)
         {
             var intermediateFolder = this.IntermediateFolder;
             if (String.IsNullOrEmpty(intermediateFolder))
@@ -262,10 +268,10 @@ namespace WixToolset.Core.CommandLine
             ResolveResult resolveResult;
             {
                 var context = this.ServiceProvider.GetService<IResolveContext>();
-                context.BindPaths = this.BindPaths;
+                context.BindPaths = bindPaths;
                 context.Extensions = this.ExtensionManager.Create<IResolverExtension>();
                 context.ExtensionData = this.ExtensionManager.Create<IExtensionData>();
-                context.FilterCultures = this.FilterCultures;
+                context.FilterCultures = filterCultures;
                 context.IntermediateFolder = intermediateFolder;
                 context.IntermediateRepresentation = output;
                 context.Localizations = localizations;
@@ -284,7 +290,7 @@ namespace WixToolset.Core.CommandLine
             {
                 var context = this.ServiceProvider.GetService<IBindContext>();
                 //context.CabbingThreadCount = this.CabbingThreadCount;
-                context.CabCachePath = this.CabCachePath;
+                context.CabCachePath = cabCachePath;
                 context.Codepage = resolveResult.Codepage;
                 //context.DefaultCompressionLevel = this.DefaultCompressionLevel;
                 context.DelayedFields = resolveResult.DelayedFields;
@@ -293,8 +299,8 @@ namespace WixToolset.Core.CommandLine
                 context.Ices = Array.Empty<string>(); // TODO: set this correctly
                 context.IntermediateFolder = intermediateFolder;
                 context.IntermediateRepresentation = resolveResult.IntermediateRepresentation;
-                context.OutputPath = this.OutputPath;
-                context.OutputPdbPath = Path.ChangeExtension(this.OutputPath, ".wixpdb");
+                context.OutputPath = this.OutputFile;
+                context.OutputPdbPath = Path.ChangeExtension(this.OutputFile, ".wixpdb");
                 context.SuppressIces = Array.Empty<string>(); // TODO: set this correctly
                 context.SuppressValidation = true; // TODO: set this correctly
 
@@ -323,41 +329,39 @@ namespace WixToolset.Core.CommandLine
             }
         }
 
-        private IEnumerable<Intermediate> LoadLibraries(ITupleDefinitionCreator creator)
+        private IEnumerable<Intermediate> LoadLibraries(IEnumerable<string> libraryFiles, ITupleDefinitionCreator creator)
         {
             var libraries = new List<Intermediate>();
 
-            if (this.LibraryFiles != null)
+            foreach (var libraryFile in libraryFiles)
             {
-                foreach (var libraryFile in this.LibraryFiles)
+                try
                 {
-                    try
-                    {
-                        var library = Intermediate.Load(libraryFile, creator);
+                    var library = Intermediate.Load(libraryFile, creator);
 
-                        libraries.Add(library);
-                    }
-                    catch (WixCorruptFileException e)
-                    {
-                        this.Messaging.Write(e.Error);
-                    }
-                    catch (WixUnexpectedFileFormatException e)
-                    {
-                        this.Messaging.Write(e.Error);
-                    }
+                    libraries.Add(library);
+                }
+                catch (WixCorruptFileException e)
+                {
+                    this.Messaging.Write(e.Error);
+                }
+                catch (WixUnexpectedFileFormatException e)
+                {
+                    this.Messaging.Write(e.Error);
                 }
             }
 
             return libraries;
         }
 
-        private IEnumerable<Localization> LoadLocalizationFiles()
+        private IEnumerable<Localization> LoadLocalizationFiles(IEnumerable<string> locFiles, IDictionary<string, string> preprocessorVariables)
         {
-            var localizer = new Localizer(this.ServiceProvider);
+            var localizations = new List<Localization>();
+            var localizer = this.ServiceProvider.GetService<ILocalizer>();
 
-            foreach (var loc in this.LocFiles)
+            foreach (var loc in locFiles)
             {
-                var document = this.Preprocess(loc);
+                var document = this.Preprocess(preprocessorVariables, loc);
 
                 if (this.Messaging.EncounteredError)
                 {
@@ -365,18 +369,20 @@ namespace WixToolset.Core.CommandLine
                 }
 
                 var localization = localizer.ParseLocalizationFile(document);
-                yield return localization;
+                localizations.Add(localization);
             }
+
+            return localizations;
         }
 
-        private XDocument Preprocess(string sourcePath)
+        private XDocument Preprocess(IDictionary<string, string> preprocessorVariables, string sourcePath)
         {
             var context = this.ServiceProvider.GetService<IPreprocessContext>();
             context.Extensions = this.ExtensionManager.Create<IPreprocessorExtension>();
             context.Platform = this.Platform;
             context.IncludeSearchPaths = this.IncludeSearchPaths;
             context.SourcePath = sourcePath;
-            context.Variables = this.PreprocessorVariables;
+            context.Variables = preprocessorVariables;
 
             XDocument document = null;
             try
@@ -391,5 +397,301 @@ namespace WixToolset.Core.CommandLine
 
             return document;
         }
+
+        private class CommandLine
+        {
+            private static readonly char[] BindPathSplit = { '=' };
+
+            public bool BindFiles { get; private set; }
+
+            public List<BindPath> BindPaths { get; } = new List<BindPath>();
+
+            public string CabCachePath { get; private set; }
+
+            public List<string> Cultures { get; } = new List<string>();
+
+            public List<string> Defines { get; } = new List<string>();
+
+            public List<string> IncludeSearchPaths { get; } = new List<string>();
+
+            public List<string> LocalizationFilePaths { get; } = new List<string>();
+
+            public List<string> LibraryFilePaths { get; } = new List<string>();
+
+            public List<string> SourceFilePaths { get; } = new List<string>();
+
+            public Platform Platform { get; private set; }
+
+            public bool ShowLogo { get; private set; }
+
+            public bool ShowHelp { get; private set; }
+
+            public string IntermediateFolder { get; private set; }
+
+            public string OutputFile { get; private set; }
+
+            public string OutputType { get; private set; }
+
+            public string ContentsFile { get; private set; }
+
+            public string OutputsFile { get; private set; }
+
+            public string BuiltOutputsFile { get; private set; }
+            
+            public CommandLine(IMessaging messaging)
+            {
+                this.Messaging = messaging;
+            }
+
+            private IMessaging Messaging { get; }
+
+            public bool TryParseArgument(string arg, ICommandLineParser parser)
+            {
+                if (parser.IsSwitch(arg))
+                {
+                    var parameter = arg.Substring(1);
+                    switch (parameter.ToLowerInvariant())
+                    {
+                    case "?":
+                    case "h":
+                    case "help":
+                        this.ShowHelp = true;
+                        return true;
+
+                    case "arch":
+                    case "platform":
+                    {
+                        var value = parser.GetNextArgumentOrError(arg);
+                        if (Enum.TryParse(value, true, out Platform platform))
+                        {
+                            this.Platform = platform;
+                            return true;
+                        }
+                        break;
+                    }
+
+                    case "bindfiles":
+                        this.BindFiles = true;
+                        return true;
+
+                    case "bindpath":
+                    {
+                        var value = parser.GetNextArgumentOrError(arg);
+                        if (this.TryParseBindPath(value, out var bindPath))
+                        {
+                            this.BindPaths.Add(bindPath);
+                            return true;
+                        }
+                        break;
+                    }
+                    case "cc":
+                        this.CabCachePath = parser.GetNextArgumentOrError(arg);
+                        return true;
+
+                    case "culture":
+                        parser.GetNextArgumentOrError(arg, this.Cultures);
+                        return true;
+
+                    case "contentsfile":
+                        this.ContentsFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+                    case "outputsfile":
+                        this.OutputsFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+                    case "builtoutputsfile":
+                        this.BuiltOutputsFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+
+                    case "d":
+                    case "define":
+                        parser.GetNextArgumentOrError(arg, this.Defines);
+                        return true;
+
+                    case "i":
+                    case "includepath":
+                        parser.GetNextArgumentOrError(arg, this.IncludeSearchPaths);
+                        return true;
+
+                    case "intermediatefolder":
+                        this.IntermediateFolder = parser.GetNextArgumentAsDirectoryOrError(arg);
+                        return true;
+
+                    case "loc":
+                        parser.GetNextArgumentAsFilePathOrError(arg, "localization files", this.LocalizationFilePaths);
+                        return true;
+
+                    case "lib":
+                        parser.GetNextArgumentAsFilePathOrError(arg, "library files", this.LibraryFilePaths);
+                        return true;
+
+                    case "o":
+                    case "out":
+                        this.OutputFile = parser.GetNextArgumentAsFilePathOrError(arg);
+                        return true;
+
+                    case "outputtype":
+                        this.OutputType = parser.GetNextArgumentOrError(arg);
+                        return true;
+
+                    case "nologo":
+                        this.ShowLogo = false;
+                        return true;
+
+                    case "v":
+                    case "verbose":
+                        this.Messaging.ShowVerboseMessages = true;
+                        return true;
+
+                    case "sval":
+                        // todo: implement
+                        return true;
+
+                    case "sw":
+                    case "suppresswarning":
+                        var warning = parser.GetNextArgumentOrError(arg);
+                        if (!String.IsNullOrEmpty(warning))
+                        {
+                            var warningNumber = Convert.ToInt32(warning);
+                            this.Messaging.SuppressWarningMessage(warningNumber);
+                        }
+                        return true;
+                    }
+
+                    return false;
+                }
+                else
+                {
+                    parser.GetArgumentAsFilePathOrError(arg, "source code", this.SourceFilePaths);
+                    return true;
+                }
+            }
+
+            public string CalculateIntermedateFolder()
+            {
+                return String.IsNullOrEmpty(this.IntermediateFolder) ? Path.GetTempPath() : this.IntermediateFolder;
+            }
+
+            public OutputType CalculateOutputType()
+            {
+                if (String.IsNullOrEmpty(this.OutputType))
+                {
+                    this.OutputType = Path.GetExtension(this.OutputFile);
+                }
+
+                switch (this.OutputType.ToLowerInvariant())
+                {
+                case "bundle":
+                case ".exe":
+                    return Data.OutputType.Bundle;
+
+                case "library":
+                case ".wixlib":
+                    return Data.OutputType.Library;
+
+                case "module":
+                case ".msm":
+                    return Data.OutputType.Module;
+
+                case "patch":
+                case ".msp":
+                    return Data.OutputType.Patch;
+
+                case ".pcp":
+                    return Data.OutputType.PatchCreation;
+
+                case "product":
+                case "package":
+                case ".msi":
+                    return Data.OutputType.Product;
+
+                case "transform":
+                case ".mst":
+                    return Data.OutputType.Transform;
+
+                case "intermediatepostlink":
+                case ".wixipl":
+                    return Data.OutputType.IntermediatePostLink;
+                }
+
+                return Data.OutputType.Unknown;
+            }
+
+            public IEnumerable<string> CalculateFilterCultures()
+            {
+                var result = new List<string>();
+
+                if (this.Cultures == null)
+                {
+                }
+                else if (this.Cultures.Count == 1 && this.Cultures[0].Equals("null", StringComparison.OrdinalIgnoreCase))
+                {
+                    // When null is used treat it as if cultures wasn't specified. This is
+                    // needed for batching in the MSBuild task since MSBuild doesn't support
+                    // empty items.
+                }
+                else
+                {
+                    foreach (var culture in this.Cultures)
+                    {
+                        // Neutral is different from null. For neutral we still want to do culture filtering.
+                        // Set the culture to the empty string = identifier for the invariant culture.
+                        var filter = (culture.Equals("neutral", StringComparison.OrdinalIgnoreCase)) ? String.Empty : culture;
+                        result.Add(filter);
+                    }
+                }
+
+                return result;
+            }
+
+            public IDictionary<string, string> GatherPreprocessorVariables()
+            {
+                var variables = new Dictionary<string, string>();
+
+                foreach (var pair in this.Defines)
+                {
+                    var value = pair.Split(new[] { '=' }, 2);
+
+                    if (variables.ContainsKey(value[0]))
+                    {
+                        this.Messaging.Write(ErrorMessages.DuplicateVariableDefinition(value[0], (1 == value.Length) ? String.Empty : value[1], variables[value[0]]));
+                        continue;
+                    }
+
+                    variables.Add(value[0], (1 == value.Length) ? String.Empty : value[1]);
+                }
+
+                return variables;
+            }
+
+
+            public IEnumerable<SourceFile> GatherSourceFiles(string intermediateDirectory)
+            {
+                var files = new List<SourceFile>();
+
+                foreach (var item in this.SourceFilePaths)
+                {
+                    var sourcePath = item;
+                    var outputPath = Path.Combine(intermediateDirectory, Path.GetFileNameWithoutExtension(sourcePath) + ".wir");
+
+                    files.Add(new SourceFile(sourcePath, outputPath));
+                }
+
+                return files;
+            }
+
+            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;
+            }
+        }
     }
 }