@joebigelow / wix / commits / 50bd11c3

Code cleanup

Rob Mensching committed Oct 7, 2017 at 15:06 UTC 50bd11c35ebc48137eb01d69bdeb783c66479517
6 files changed +10 -1126
src/WixToolset.BuildTasks/Properties/AssemblyInfo.cs renamed
src/WixToolset.Core/CommandLine/CommandLineHelper.cs deleted
-255
@@ -1,255 +0,0 @@
1 -// 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.
2 -
3 -namespace WixToolset
4 -{
5 - using System;
6 - using System.Collections.Generic;
7 - using System.IO;
8 - using System.Text;
9 - using WixToolset.Data;
10 - using WixToolset.Extensibility;
11 -
12 - /// <summary>
13 - /// Common utilities for Wix command-line processing.
14 - /// </summary>
15 - public static class CommandLineHelper
16 - {
17 - /// <summary>
18 - /// Get a set of files that possibly have a search pattern in the path (such as '*').
19 - /// </summary>
20 - /// <param name="searchPath">Search path to find files in.</param>
21 - /// <param name="fileType">Type of file; typically "Source".</param>
22 - /// <returns>An array of files matching the search path.</returns>
23 - /// <remarks>
24 - /// This method is written in this verbose way because it needs to support ".." in the path.
25 - /// It needs the directory path isolated from the file name in order to use Directory.GetFiles
26 - /// or DirectoryInfo.GetFiles. The only way to get this directory path is manually since
27 - /// Path.GetDirectoryName does not support ".." in the path.
28 - /// </remarks>
29 - /// <exception cref="WixFileNotFoundException">Throws WixFileNotFoundException if no file matching the pattern can be found.</exception>
30 - public static string[] GetFiles(string searchPath, string fileType)
31 - {
32 - if (null == searchPath)
33 - {
34 - throw new ArgumentNullException("searchPath");
35 - }
36 -
37 - // convert alternate directory separators to the standard one
38 - string filePath = searchPath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
39 - int lastSeparator = filePath.LastIndexOf(Path.DirectorySeparatorChar);
40 - string[] files = null;
41 -
42 - try
43 - {
44 - if (0 > lastSeparator)
45 - {
46 - files = Directory.GetFiles(".", filePath);
47 - }
48 - else // found directory separator
49 - {
50 - files = Directory.GetFiles(filePath.Substring(0, lastSeparator + 1), filePath.Substring(lastSeparator + 1));
51 - }
52 - }
53 - catch (DirectoryNotFoundException)
54 - {
55 - // don't let this function throw the DirectoryNotFoundException. (this exception
56 - // occurs for non-existant directories and invalid characters in the searchPattern)
57 - }
58 - catch (ArgumentException)
59 - {
60 - // don't let this function throw the ArgumentException. (this exception
61 - // occurs in certain situations such as when passing a malformed UNC path)
62 - }
63 - catch (IOException)
64 - {
65 - throw new WixFileNotFoundException(searchPath, fileType);
66 - }
67 -
68 - // file could not be found or path is invalid in some way
69 - if (null == files || 0 == files.Length)
70 - {
71 - throw new WixFileNotFoundException(searchPath, fileType);
72 - }
73 -
74 - return files;
75 - }
76 -
77 - /// <summary>
78 - /// Validates that a valid string parameter (without "/" or "-"), and returns a bool indicating its validity
79 - /// </summary>
80 - /// <param name="args">The list of strings to check.</param>
81 - /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
82 - /// <returns>True if a valid string parameter exists there, false if not.</returns>
83 - public static bool IsValidArg(string[] args, int index)
84 - {
85 - if (args.Length <= index || String.IsNullOrEmpty(args[index]) || '/' == args[index][0] || '-' == args[index][0])
86 - {
87 - return false;
88 - }
89 - else
90 - {
91 - return true;
92 - }
93 - }
94 -
95 - /// <summary>
96 - /// Validates that a commandline parameter is a valid file or directory name, and throws appropriate warnings/errors if not
97 - /// </summary>
98 - /// <param name="path">The path to test.</param>
99 - /// <returns>The string if it is valid, null if it is invalid.</returns>
100 - public static string VerifyPath(string path)
101 - {
102 - return VerifyPath(path, false);
103 - }
104 -
105 - /// <summary>
106 - /// Validates that a commandline parameter is a valid file or directory name, and throws appropriate warnings/errors if not
107 - /// </summary>
108 - /// <param name="path">The path to test.</param>
109 - /// <param name="allowPrefix">Indicates if a colon-delimited prefix is allowed.</param>
110 - /// <returns>The full path if it is valid, null if it is invalid.</returns>
111 - public static string VerifyPath(string path, bool allowPrefix)
112 - {
113 - string fullPath;
114 -
115 - if (0 <= path.IndexOf('\"'))
116 - {
117 - Messaging.Instance.OnMessage(WixErrors.PathCannotContainQuote(path));
118 - return null;
119 - }
120 -
121 - try
122 - {
123 - string prefix = null;
124 - if (allowPrefix)
125 - {
126 - int prefixLength = path.IndexOf('=') + 1;
127 - if (0 != prefixLength)
128 - {
129 - prefix = path.Substring(0, prefixLength);
130 - path = path.Substring(prefixLength);
131 - }
132 - }
133 -
134 - if (String.IsNullOrEmpty(prefix))
135 - {
136 - fullPath = Path.GetFullPath(path);
137 - }
138 - else
139 - {
140 - fullPath = String.Concat(prefix, Path.GetFullPath(path));
141 - }
142 - }
143 - catch (Exception e)
144 - {
145 - Messaging.Instance.OnMessage(WixErrors.InvalidCommandLineFileName(path, e.Message));
146 - return null;
147 - }
148 -
149 - return fullPath;
150 - }
151 -
152 - /// <summary>
153 - /// Validates that a string is a valid bind path, and throws appropriate warnings/errors if not
154 - /// </summary>
155 - /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
156 - /// <param name="args">The list of strings to check.</param>
157 - /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
158 - /// <returns>The bind path if it is valid, null if it is invalid.</returns>
159 - public static BindPath GetBindPath(string commandlineSwitch, string[] args, int index)
160 - {
161 - commandlineSwitch = String.Concat("-", commandlineSwitch);
162 -
163 - if (!IsValidArg(args, index))
164 - {
165 - Messaging.Instance.OnMessage(WixErrors.DirectoryPathRequired(commandlineSwitch));
166 - return null;
167 - }
168 -
169 - BindPath bindPath = BindPath.Parse(args[index]);
170 -
171 - if (File.Exists(bindPath.Path))
172 - {
173 - Messaging.Instance.OnMessage(WixErrors.ExpectedDirectoryGotFile(commandlineSwitch, bindPath.Path));
174 - return null;
175 - }
176 -
177 - bindPath.Path = VerifyPath(bindPath.Path, true);
178 - return String.IsNullOrEmpty(bindPath.Path) ? null : bindPath;
179 - }
180 -
181 - /// <summary>
182 - /// Validates that a commandline parameter is a valid file or directory name, and throws appropriate warnings/errors if not
183 - /// </summary>
184 - /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
185 - /// <param name="messageHandler">The messagehandler to report warnings/errors to.</param>
186 - /// <param name="args">The list of strings to check.</param>
187 - /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
188 - /// <returns>The string if it is valid, null if it is invalid.</returns>
189 - public static string GetFileOrDirectory(string commandlineSwitch, string[] args, int index)
190 - {
191 - commandlineSwitch = String.Concat("-", commandlineSwitch);
192 -
193 - if (!IsValidArg(args, index))
194 - {
195 - Messaging.Instance.OnMessage(WixErrors.FileOrDirectoryPathRequired(commandlineSwitch));
196 - return null;
197 - }
198 -
199 - return VerifyPath(args[index]);
200 - }
201 -
202 - /// <summary>
203 - /// Validates that a string is a valid directory name, and throws appropriate warnings/errors if not
204 - /// </summary>
205 - /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
206 - /// <param name="args">The list of strings to check.</param>
207 - /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
208 - /// <param name="allowPrefix">Indicates if a colon-delimited prefix is allowed.</param>
209 - /// <returns>The string if it is valid, null if it is invalid.</returns>
210 - public static string GetDirectory(string commandlineSwitch, string[] args, int index, bool allowPrefix = false)
211 - {
212 - commandlineSwitch = String.Concat("-", commandlineSwitch);
213 -
214 - if (!IsValidArg(args, index))
215 - {
216 - Messaging.Instance.OnMessage(WixErrors.DirectoryPathRequired(commandlineSwitch));
217 - return null;
218 - }
219 -
220 - if (File.Exists(args[index]))
221 - {
222 - Messaging.Instance.OnMessage(WixErrors.ExpectedDirectoryGotFile(commandlineSwitch, args[index]));
223 - return null;
224 - }
225 -
226 - return VerifyPath(args[index], allowPrefix);
227 - }
228 -
229 - /// <summary>
230 - /// Validates that a string is a valid filename, and throws appropriate warnings/errors if not
231 - /// </summary>
232 - /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
233 - /// <param name="args">The list of strings to check.</param>
234 - /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
235 - /// <returns>The string if it is valid, null if it is invalid.</returns>
236 - public static string GetFile(string commandlineSwitch, string[] args, int index)
237 - {
238 - commandlineSwitch = String.Concat("-", commandlineSwitch);
239 -
240 - if (!IsValidArg(args, index))
241 - {
242 - Messaging.Instance.OnMessage(WixErrors.FilePathRequired(commandlineSwitch));
243 - return null;
244 - }
245 -
246 - if (Directory.Exists(args[index]))
247 - {
248 - Messaging.Instance.OnMessage(WixErrors.ExpectedFileGotDirectory(commandlineSwitch, args[index]));
249 - return null;
250 - }
251 -
252 - return VerifyPath(args[index]);
253 - }
254 - }
255 -}
src/WixToolset.Core/CommandLine/CommandLineResponseFile.cs
-5
@@ -102,11 +102,6 @@ namespace WixToolset
102 return argsList.ToArray();
103 }
104
105 - /// <summary>
106 - /// Expand enxironment variables contained in the passed string
107 - /// </summary>
108 - /// <param name="arguments"></param>
109 - /// <returns></returns>
105 static private string ExpandEnvVars(string arguments)
106 {
107 IDictionary id = Environment.GetEnvironmentVariables();
src/WixToolset.Core/Properties/AssemblyInfo.cs renamed
src/wix/Program.cs
+10 -472
@@ -6,16 +6,12 @@ namespace WixToolset.Core
6 using WixToolset.Data;
7
8 /// <summary>
9 - /// The main entry point for candle.
9 + /// Wix Toolset Command-Line Interface.
10 /// </summary>
11 public sealed class Program
12 {
13 - //private IEnumerable<IPreprocessorExtension> preprocessorExtensions;
14 - //private IEnumerable<ICompilerExtension> compilerExtensions;
15 - //private IEnumerable<IExtensionData> extensionData;
16 -
13 /// <summary>
18 - /// The main entry point for candle.
14 + /// The main entry point for wix command-line interface.
15 /// </summary>
16 /// <param name="args">Commandline arguments for the application.</param>
17 /// <returns>Returns the application error code.</returns>
@@ -33,474 +29,16 @@ namespace WixToolset.Core
29
30 private static void DisplayMessage(object sender, DisplayEventArgs e)
31 {
36 - Console.WriteLine(e.Message);
37 - }
38 -
39 -#if false
40 - private static ICommand ParseCommandLine(string[] args)
41 - {
42 - var next = String.Empty;
43 -
44 - var command = Commands.Unknown;
45 - var showLogo = true;
46 - var showVersion = false;
47 - var outputFolder = String.Empty;
48 - var outputFile = String.Empty;
49 - var sourceFile = String.Empty;
50 - var verbose = false;
51 - var files = new List<string>();
52 - var defines = new List<string>();
53 - var includePaths = new List<string>();
54 - var locFiles = new List<string>();
55 - var suppressedWarnings = new List<int>();
56 -
57 - var cli = CommandLine.Parse(args, (cmdline, arg) => Enum.TryParse(arg, true, out command), (cmdline, arg) =>
58 - {
59 - if (cmdline.IsSwitch(arg))
60 - {
61 - var parameter = arg.TrimStart(new[] { '-', '/' });
62 - switch (parameter.ToLowerInvariant())
63 - {
64 - case "?":
65 - case "h":
66 - case "help":
67 - cmdline.ShowHelp = true;
68 - return true;
69 -
70 - case "d":
71 - case "define":
72 - cmdline.GetNextArgumentOrError(defines);
73 - return true;
74 -
75 - case "i":
76 - case "includepath":
77 - cmdline.GetNextArgumentOrError(includePaths);
78 - return true;
79 -
80 - case "loc":
81 - cmdline.GetNextArgumentAsFilePathOrError(locFiles, "localization files");
82 - return true;
83 -
84 - case "o":
85 - case "out":
86 - cmdline.GetNextArgumentOrError(ref outputFile);
87 - return true;
88 -
89 - case "nologo":
90 - showLogo = false;
91 - return true;
92 -
93 - case "v":
94 - case "verbose":
95 - verbose = true;
96 - return true;
97 -
98 - case "version":
99 - case "-version":
100 - showVersion = true;
101 - return true;
102 - }
103 -
104 - return false;
105 - }
106 - else
107 - {
108 - files.AddRange(cmdline.GetFiles(arg, "source code"));
109 - return true;
110 - }
111 - });
112 -
113 - if (showVersion)
114 - {
115 - return new VersionCommand();
116 - }
117 -
118 - if (showLogo)
119 - {
120 - AppCommon.DisplayToolHeader();
121 - }
122 -
123 - if (cli.ShowHelp)
124 - {
125 - return new HelpCommand(command);
126 - }
127 -
128 - switch (command)
129 - {
130 - case Commands.Build:
131 - {
132 - var sourceFiles = GatherSourceFiles(files, outputFolder);
133 - var variables = GatherPreprocessorVariables(defines);
134 - var extensions = cli.ExtensionManager;
135 - return new BuildCommand(sourceFiles, variables, locFiles, outputFile);
136 - }
137 -
138 - case Commands.Compile:
139 - {
140 - var sourceFiles = GatherSourceFiles(files, outputFolder);
141 - var variables = GatherPreprocessorVariables(defines);
142 - return new CompileCommand(sourceFiles, variables);
143 - }
144 - }
145 -
146 - return null;
147 - }
148 -
149 - private static IEnumerable<SourceFile> GatherSourceFiles(IEnumerable<string> sourceFiles, string intermediateDirectory)
150 - {
151 - var files = new List<SourceFile>();
152 -
153 - foreach (var item in sourceFiles)
154 - {
155 - var sourcePath = item;
156 - var outputPath = Path.Combine(intermediateDirectory, Path.GetFileNameWithoutExtension(sourcePath) + ".wir");
157 -
158 - files.Add(new SourceFile(sourcePath, outputPath));
159 - }
160 -
161 - return files;
162 - }
163 -
164 - private static IDictionary<string, string> GatherPreprocessorVariables(IEnumerable<string> defineConstants)
165 - {
166 - var variables = new Dictionary<string, string>();
167 -
168 - foreach (var pair in defineConstants)
169 - {
170 - string[] value = pair.Split(new[] { '=' }, 2);
171 -
172 - if (variables.ContainsKey(value[0]))
173 - {
174 - Messaging.Instance.OnMessage(WixErrors.DuplicateVariableDefinition(value[0], (1 == value.Length) ? String.Empty : value[1], variables[value[0]]));
175 - continue;
176 - }
177 -
178 - variables.Add(value[0], (1 == value.Length) ? String.Empty : value[1]);
179 - }
180 -
181 - return variables;
182 - }
183 -#endif
184 -
185 -#if false
186 - private static ICommand ParseCommandLine2(string[] args)
187 - {
188 - var command = Commands.Unknown;
189 -
190 - var nologo = false;
191 - var outputFolder = String.Empty;
192 - var outputFile = String.Empty;
193 - var sourceFile = String.Empty;
194 - var verbose = false;
195 - IReadOnlyList<string> files = Array.Empty<string>();
196 - IReadOnlyList<string> defines = Array.Empty<string>();
197 - IReadOnlyList<string> includePaths = Array.Empty<string>();
198 - IReadOnlyList<int> suppressedWarnings = Array.Empty<int>();
199 - IReadOnlyList<string> locFiles = Array.Empty<string>();
200 -
201 - ArgumentSyntax parsed = null;
202 - try
203 - {
204 - parsed = ArgumentSyntax.Parse(args, syntax =>
205 - {
206 - syntax.HandleErrors = false;
207 - //syntax.HandleHelp = false;
208 - syntax.ErrorOnUnexpectedArguments = false;
209 -
210 - syntax.DefineCommand("build", ref command, Commands.Build, "Build to final output");
211 - syntax.DefineOptionList("d|D|define", ref defines, "Preprocessor name value pairs");
212 - syntax.DefineOptionList("I|includePath", ref includePaths, "Include search paths");
213 - syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
214 - syntax.DefineOption("o|out", ref outputFile, "Output file");
215 - syntax.DefineOptionList("sw", ref suppressedWarnings, false, "Do not display logo");
216 - syntax.DefineOption("v|verbose", ref verbose, false, "Display verbose messages");
217 - syntax.DefineOptionList("l|loc", ref locFiles, "Localization files to load (.wxl)");
218 - syntax.DefineParameterList("files", ref files, "Source files to compile (.wxs)");
219 -
220 - syntax.DefineCommand("preprocess", ref command, Commands.Preprocess, "Preprocess a source files");
221 - syntax.DefineOptionList("d|D|define", ref defines, "Preprocessor name value pairs");
222 - syntax.DefineOptionList("I|includePath", ref includePaths, "Include search paths");
223 - syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
224 - syntax.DefineOption("o|out", ref outputFile, "Output file");
225 - syntax.DefineParameter("file", ref sourceFile, "File to process");
226 -
227 - syntax.DefineCommand("compile", ref command, Commands.Compile, "Compile source files");
228 - syntax.DefineOptionList("I|includePath", ref includePaths, "Include search paths");
229 - syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
230 - syntax.DefineOption("o|out", ref outputFolder, "Output folder");
231 - syntax.DefineOptionList("sw", ref suppressedWarnings, false, "Do not display logo");
232 - syntax.DefineOption("v|verbose", ref verbose, false, "Display verbose messages");
233 - syntax.DefineParameterList("files", ref files, "Source files to compile (.wxs)");
234 -
235 - syntax.DefineCommand("link", ref command, Commands.Link, "Link intermediate files");
236 - syntax.DefineOption("nologo", ref nologo, "Do not display logo");
237 - syntax.DefineOption("o|out", ref outputFile, "Output intermediate file (.wir)");
238 - syntax.DefineParameterList("files", ref files, "Intermediate files to link (.wir)");
239 -
240 - syntax.DefineCommand("bind", ref command, Commands.Bind, "Bind to final output");
241 - syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
242 - syntax.DefineOption("o|out", ref outputFile, "Output file");
243 - syntax.DefineParameterList("files", ref files, "Intermediate files to bind (.wir)");
244 -
245 - syntax.DefineCommand("version", ref command, Commands.Version, "Display version information");
246 - });
247 -
248 - if (IsHelpRequested(parsed))
249 - {
250 - var width = Console.WindowWidth - 2;
251 - var text = parsed.GetHelpText(width < 20 ? 72 : width);
252 - Console.Error.WriteLine(text);
253 -
254 - return null;
255 - }
256 -
257 - //var u = result.GetArguments();
258 -
259 - //var p = result.GetActiveParameters();
260 -
261 - //var o = result.GetActiveOptions();
262 -
263 - //var a = result.GetActiveArguments();
264 -
265 - //var h = result.GetHelpText();
266 -
267 - //foreach (var x in p)
268 - //{
269 - // Console.WriteLine("{0}", x.Name);
270 - //}
271 -
272 - switch (command)
273 - {
274 - case Commands.Build:
275 - {
276 - var sourceFiles = GatherSourceFiles(files, outputFolder);
277 - var variables = GatherPreprocessorVariables(defines);
278 - return new BuildCommand(sourceFiles, variables, locFiles, outputFile);
279 - }
280 -
281 - case Commands.Compile:
282 - {
283 - var sourceFiles = GatherSourceFiles(files, outputFolder);
284 - var variables = GatherPreprocessorVariables(defines);
285 - return new CompileCommand(sourceFiles, variables);
286 - }
287 -
288 - case Commands.Version:
289 - return new VersionCommand();
290 - }
291 -
292 - //var preprocessorVariables = this.GatherPreprocessorVariables();
293 -
294 - //foreach (var sourceFile in sourceFiles)
295 - //{
296 - // var document = preprocessor.Process(sourceFile.SourcePath, preprocessorVariables);
297 -
298 - // var intermediate = compiler.Compile(document);
299 -
300 - // intermediate.Save(sourceFile.OutputPath);
301 - //}
302 - }
303 - //catch (ArgumentSyntaxException e)
304 - //{
305 - // if (IsHelpRequested(parsed))
306 - // {
307 - // var width = Console.WindowWidth - 2;
308 - // var text = parsed.GetHelpText(width < 20 ? 72 : width);
309 - // Console.Error.WriteLine(text);
310 - // }
311 - // else
312 - // {
313 - // Console.Error.WriteLine(e.Message);
314 - // }
315 - //}
316 -
317 - return null;
318 - }
319 -
320 - //private static bool IsHelpRequested(ArgumentSyntax syntax)
321 - //{
322 - // return syntax?.RemainingArguments
323 - // .Any(a => String.Equals(a, @"-?", StringComparison.Ordinal) ||
324 - // String.Equals(a, @"-h", StringComparison.Ordinal) ||
325 - // String.Equals(a, @"--help", StringComparison.Ordinal)) ?? false;
326 - //}
327 -#endif
328 -
329 -#if false
330 - private int Execute(string[] args)
331 - {
332 - try
333 - {
334 - string[] unparsed = this.ParseCommandLineAndLoadExtensions(args);
335 -
336 - if (!Messaging.Instance.EncounteredError)
337 - {
338 - if (this.commandLine.ShowLogo)
339 - {
340 - AppCommon.DisplayToolHeader();
341 - }
342 -
343 - if (this.commandLine.ShowHelp)
344 - {
345 - Console.WriteLine(CandleStrings.HelpMessage);
346 - AppCommon.DisplayToolFooter();
347 - }
348 - else
349 - {
350 - foreach (string arg in unparsed)
351 - {
352 - Messaging.Instance.OnMessage(WixWarnings.UnsupportedCommandLineArgument(arg));
353 - }
354 -
355 - this.Run();
356 - }
357 - }
358 - }
359 - catch (WixException we)
360 - {
361 - Messaging.Instance.OnMessage(we.Error);
362 - }
363 - catch (Exception e)
364 - {
365 - Messaging.Instance.OnMessage(WixErrors.UnexpectedException(e.Message, e.GetType().ToString(), e.StackTrace));
366 - if (e is NullReferenceException || e is SEHException)
367 - {
368 - throw;
369 - }
370 - }
371 -
372 - return Messaging.Instance.LastErrorNumber;
373 - }
374 -
375 - private string[] ParseCommandLineAndLoadExtensions(string[] args)
376 - {
377 - this.commandLine = new CandleCommandLine();
378 - string[] unprocessed = commandLine.Parse(args);
379 - if (Messaging.Instance.EncounteredError)
380 - {
381 - return unprocessed;
382 - }
383 -
384 - // Load extensions.
385 - ExtensionManager extensionManager = new ExtensionManager();
386 - foreach (string extension in this.commandLine.Extensions)
387 - {
388 - extensionManager.Load(extension);
389 - }
390 -
391 - // Preprocessor extension command line processing.
392 - this.preprocessorExtensions = extensionManager.Create<IPreprocessorExtension>();
393 - foreach (IExtensionCommandLine pce in this.preprocessorExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
394 - {
395 - pce.MessageHandler = Messaging.Instance;
396 - unprocessed = pce.ParseCommandLine(unprocessed);
397 - }
398 -
399 - // Compiler extension command line processing.
400 - this.compilerExtensions = extensionManager.Create<ICompilerExtension>();
401 - foreach (IExtensionCommandLine cce in this.compilerExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
402 - {
403 - cce.MessageHandler = Messaging.Instance;
404 - unprocessed = cce.ParseCommandLine(unprocessed);
405 - }
406 -
407 - // Extension data command line processing.
408 - this.extensionData = extensionManager.Create<IExtensionData>();
409 - foreach (IExtensionCommandLine dce in this.extensionData.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
32 + switch (e.Level)
33 {
411 - dce.MessageHandler = Messaging.Instance;
412 - unprocessed = dce.ParseCommandLine(unprocessed);
34 + case MessageLevel.Warning:
35 + case MessageLevel.Error:
36 + Console.Error.WriteLine(e.Message);
37 + break;
38 + default:
39 + Console.WriteLine(e.Message);
40 + break;
41 }
414 -
415 - return commandLine.ParsePostExtensions(unprocessed);
416 - }
417 -
418 - private void Run()
419 - {
420 - // Create the preprocessor and compiler
421 - Preprocessor preprocessor = new Preprocessor();
422 - preprocessor.CurrentPlatform = this.commandLine.Platform;
423 -
424 - foreach (string includePath in this.commandLine.IncludeSearchPaths)
425 - {
426 - preprocessor.IncludeSearchPaths.Add(includePath);
427 - }
428 -
429 - foreach (IPreprocessorExtension pe in this.preprocessorExtensions)
430 - {
431 - preprocessor.AddExtension(pe);
432 - }
433 -
434 - Compiler compiler = new Compiler();
435 - compiler.ShowPedanticMessages = this.commandLine.ShowPedanticMessages;
436 - compiler.CurrentPlatform = this.commandLine.Platform;
437 -
438 - foreach (IExtensionData ed in this.extensionData)
439 - {
440 - compiler.AddExtensionData(ed);
441 - }
442 -
443 - foreach (ICompilerExtension ce in this.compilerExtensions)
444 - {
445 - compiler.AddExtension(ce);
446 - }
447 -
448 - // Preprocess then compile each source file.
449 - foreach (CompileFile file in this.commandLine.Files)
450 - {
451 - // print friendly message saying what file is being compiled
452 - Console.WriteLine(file.SourcePath);
453 -
454 - // preprocess the source
455 - XDocument sourceDocument;
456 - try
457 - {
458 - if (!String.IsNullOrEmpty(this.commandLine.PreprocessFile))
459 - {
460 - preprocessor.PreprocessOut = this.commandLine.PreprocessFile.Equals("con:", StringComparison.OrdinalIgnoreCase) ? Console.Out : new StreamWriter(this.commandLine.PreprocessFile);
461 - }
462 -
463 - sourceDocument = preprocessor.Process(file.SourcePath, this.commandLine.PreprocessorVariables);
464 - }
465 - finally
466 - {
467 - if (null != preprocessor.PreprocessOut && Console.Out != preprocessor.PreprocessOut)
468 - {
469 - preprocessor.PreprocessOut.Close();
470 - }
471 - }
472 -
473 - // If we're not actually going to compile anything, move on to the next file.
474 - if (null == sourceDocument || !String.IsNullOrEmpty(this.commandLine.PreprocessFile))
475 - {
476 - continue;
477 - }
478 -
479 - // and now we do what we came here to do...
480 - Intermediate intermediate = compiler.Compile(sourceDocument);
481 -
482 - // save the intermediate to disk if no errors were found for this source file
483 - if (null != intermediate)
484 - {
485 - intermediate.Save(file.OutputPath);
486 - }
487 - }
488 - }
489 -
490 - public interface IOptions
491 - {
492 - IEnumerable<SourceFile> SourceFiles { get; }
493 - }
494 -
495 - public class CompilerOptions : IOptions
496 - {
497 - public CompilerOptions(IEnumerable<SourceFile> sources)
498 - {
499 - this.SourceFiles = sources;
500 - }
501 -
502 - public IEnumerable<SourceFile> SourceFiles { get; private set; }
42 }
504 -#endif
43 }
44 }
src/wix/X_CommandLine.cs deleted
-394
@@ -1,394 +0,0 @@
1 -// 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.
2 -
3 -namespace WixToolset.Core
4 -{
5 - using System;
6 - using System.Collections.Generic;
7 - using System.IO;
8 - using System.Linq;
9 - using System.Text;
10 - using System.Text.RegularExpressions;
11 - using WixToolset.Extensibility;
12 -
13 - internal class X_CommandLine
14 - {
15 - private X_CommandLine()
16 - {
17 - }
18 -
19 - public static string ExpectedArgument { get; } = "expected argument";
20 -
21 - public string ActiveCommand { get; private set; }
22 -
23 - public string[] OriginalArguments { get; private set; }
24 -
25 - public Queue<string> RemainingArguments { get; } = new Queue<string>();
26 -
27 - public ExtensionManager ExtensionManager { get; } = new ExtensionManager();
28 -
29 - public string ErrorArgument { get; set; }
30 -
31 - public bool ShowHelp { get; set; }
32 -
33 - public static X_CommandLine Parse(string commandLineString, Func<X_CommandLine, string, bool> parseArgument)
34 - {
35 - var arguments = X_CommandLine.ParseArgumentsToArray(commandLineString).ToArray();
36 -
37 - return X_CommandLine.Parse(arguments, null, parseArgument);
38 - }
39 -
40 - public static X_CommandLine Parse(string[] commandLineArguments, Func<X_CommandLine, string, bool> parseArgument)
41 - {
42 - return X_CommandLine.Parse(commandLineArguments, null, parseArgument);
43 - }
44 -
45 - public static X_CommandLine Parse(string[] commandLineArguments, Func<X_CommandLine, string, bool> parseCommand, Func<X_CommandLine, string, bool> parseArgument)
46 - {
47 - var cmdline = new X_CommandLine();
48 -
49 - cmdline.FlattenArgumentsWithResponseFilesIntoOriginalArguments(commandLineArguments);
50 -
51 - cmdline.QueueArgumentsAndLoadExtensions(cmdline.OriginalArguments);
52 -
53 - cmdline.ProcessRemainingArguments(parseArgument, parseCommand);
54 -
55 - return cmdline;
56 - }
57 -
58 - /// <summary>
59 - /// Get a set of files that possibly have a search pattern in the path (such as '*').
60 - /// </summary>
61 - /// <param name="searchPath">Search path to find files in.</param>
62 - /// <param name="fileType">Type of file; typically "Source".</param>
63 - /// <returns>An array of files matching the search path.</returns>
64 - /// <remarks>
65 - /// This method is written in this verbose way because it needs to support ".." in the path.
66 - /// It needs the directory path isolated from the file name in order to use Directory.GetFiles
67 - /// or DirectoryInfo.GetFiles. The only way to get this directory path is manually since
68 - /// Path.GetDirectoryName does not support ".." in the path.
69 - /// </remarks>
70 - /// <exception cref="WixFileNotFoundException">Throws WixFileNotFoundException if no file matching the pattern can be found.</exception>
71 - public string[] GetFiles(string searchPath, string fileType)
72 - {
73 - if (null == searchPath)
74 - {
75 - throw new ArgumentNullException(nameof(searchPath));
76 - }
77 -
78 - // Convert alternate directory separators to the standard one.
79 - string filePath = searchPath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
80 - int lastSeparator = filePath.LastIndexOf(Path.DirectorySeparatorChar);
81 - string[] files = null;
82 -
83 - try
84 - {
85 - if (0 > lastSeparator)
86 - {
87 - files = Directory.GetFiles(".", filePath);
88 - }
89 - else // found directory separator
90 - {
91 - files = Directory.GetFiles(filePath.Substring(0, lastSeparator + 1), filePath.Substring(lastSeparator + 1));
92 - }
93 - }
94 - catch (DirectoryNotFoundException)
95 - {
96 - // Don't let this function throw the DirectoryNotFoundException. This exception
97 - // occurs for non-existant directories and invalid characters in the searchPattern.
98 - }
99 - catch (ArgumentException)
100 - {
101 - // Don't let this function throw the ArgumentException. This exception
102 - // occurs in certain situations such as when passing a malformed UNC path.
103 - }
104 - catch (IOException)
105 - {
106 - throw new WixFileNotFoundException(searchPath, fileType);
107 - }
108 -
109 - if (null == files || 0 == files.Length)
110 - {
111 - throw new WixFileNotFoundException(searchPath, fileType);
112 - }
113 -
114 - return files;
115 - }
116 -
117 - /// <summary>
118 - /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
119 - /// </summary>
120 - /// <param name="args">The list of strings to check.</param>
121 - /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
122 - /// <returns>True if a valid switch exists there, false if not.</returns>
123 - public bool IsSwitch(string arg)
124 - {
125 - return arg != null && ('/' == arg[0] || '-' == arg[0]);
126 - }
127 -
128 - /// <summary>
129 - /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
130 - /// </summary>
131 - /// <param name="args">The list of strings to check.</param>
132 - /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
133 - /// <returns>True if a valid switch exists there, false if not.</returns>
134 - public bool IsSwitchAt(IEnumerable<string> args, int index)
135 - {
136 - var arg = args.ElementAtOrDefault(index);
137 - return IsSwitch(arg);
138 - }
139 -
140 - public void GetNextArgumentOrError(ref string arg)
141 - {
142 - this.TryGetNextArgumentOrError(out arg);
143 - }
144 -
145 - public void GetNextArgumentOrError(IList<string> args)
146 - {
147 - if (this.TryGetNextArgumentOrError(out var arg))
148 - {
149 - args.Add(arg);
150 - }
151 - }
152 -
153 - public void GetNextArgumentAsFilePathOrError(IList<string> args, string fileType)
154 - {
155 - if (this.TryGetNextArgumentOrError(out var arg))
156 - {
157 - foreach (var path in this.GetFiles(arg, fileType))
158 - {
159 - args.Add(path);
160 - }
161 - }
162 - }
163 -
164 - public bool TryGetNextArgumentOrError(out string arg)
165 - {
166 - if (this.RemainingArguments.TryDequeue(out arg) && !this.IsSwitch(arg))
167 - {
168 - return true;
169 - }
170 -
171 - this.ErrorArgument = arg ?? X_CommandLine.ExpectedArgument;
172 -
173 - return false;
174 - }
175 -
176 - private void FlattenArgumentsWithResponseFilesIntoOriginalArguments(string[] commandLineArguments)
177 - {
178 - List<string> args = new List<string>();
179 -
180 - foreach (var arg in commandLineArguments)
181 - {
182 - if ('@' == arg[0])
183 - {
184 - var responseFileArguments = X_CommandLine.ParseResponseFile(arg.Substring(1));
185 - args.AddRange(responseFileArguments);
186 - }
187 - else
188 - {
189 - args.Add(arg);
190 - }
191 - }
192 -
193 - this.OriginalArguments = args.ToArray();
194 - }
195 -
196 - private void QueueArgumentsAndLoadExtensions(string[] args)
197 - {
198 - for (var i = 0; i < args.Length; ++i)
199 - {
200 - var arg = args[i];
201 -
202 - if ("-ext" == arg || "/ext" == arg)
203 - {
204 - if (!this.IsSwitchAt(args, ++i))
205 - {
206 - this.ExtensionManager.Load(args[i]);
207 - }
208 - else
209 - {
210 - this.ErrorArgument = arg;
211 - break;
212 - }
213 - }
214 - else
215 - {
216 - this.RemainingArguments.Enqueue(arg);
217 - }
218 - }
219 - }
220 -
221 - private void ProcessRemainingArguments(Func<X_CommandLine, string, bool> parseArgument, Func<X_CommandLine, string, bool> parseCommand)
222 - {
223 - var extensions = this.ExtensionManager.Create<IExtensionCommandLine>();
224 -
225 - while (!this.ShowHelp &&
226 - String.IsNullOrEmpty(this.ErrorArgument) &&
227 - this.RemainingArguments.TryDequeue(out var arg))
228 - {
229 - if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments.
230 - {
231 - continue;
232 - }
233 -
234 - if ('-' == arg[0] || '/' == arg[0])
235 - {
236 - if (!parseArgument(this, arg) &&
237 - !this.TryParseCommandLineArgumentWithExtension(arg, extensions))
238 - {
239 - this.ErrorArgument = arg;
240 - }
241 - }
242 - else if (String.IsNullOrEmpty(this.ActiveCommand) && parseCommand != null) // First non-switch must be the command, if commands are supported.
243 - {
244 - if (parseCommand(this, arg))
245 - {
246 - this.ActiveCommand = arg;
247 - }
248 - else
249 - {
250 - this.ErrorArgument = arg;
251 - }
252 - }
253 - else if (!this.TryParseCommandLineArgumentWithExtension(arg, extensions) &&
254 - !parseArgument(this, arg))
255 - {
256 - this.ErrorArgument = arg;
257 - }
258 - }
259 - }
260 -
261 - private bool TryParseCommandLineArgumentWithExtension(string arg, IEnumerable<IExtensionCommandLine> extensions)
262 - {
263 - foreach (var extension in extensions)
264 - {
265 - //if (extension.ParseArgument(this, arg))
266 - //{
267 - // return true;
268 - //}
269 - }
270 -
271 - return false;
272 - }
273 -
274 - /// <summary>
275 - /// Parses a response file.
276 - /// </summary>
277 - /// <param name="responseFile">The file to parse.</param>
278 - /// <returns>The array of arguments.</returns>
279 - private static List<string> ParseResponseFile(string responseFile)
280 - {
281 - string arguments;
282 -
283 - using (StreamReader reader = new StreamReader(responseFile))
284 - {
285 - arguments = reader.ReadToEnd();
286 - }
287 -
288 - return X_CommandLine.ParseArgumentsToArray(arguments);
289 - }
290 -
291 - /// <summary>
292 - /// Parses an argument string into an argument array based on whitespace and quoting.
293 - /// </summary>
294 - /// <param name="arguments">Argument string.</param>
295 - /// <returns>Argument array.</returns>
296 - private static List<string> ParseArgumentsToArray(string arguments)
297 - {
298 - // Scan and parse the arguments string, dividing up the arguments based on whitespace.
299 - // Unescaped quotes cause whitespace to be ignored, while the quotes themselves are removed.
300 - // Quotes may begin and end inside arguments; they don't necessarily just surround whole arguments.
301 - // Escaped quotes and escaped backslashes also need to be unescaped by this process.
302 -
303 - // Collects the final list of arguments to be returned.
304 - var argsList = new List<string>();
305 -
306 - // True if we are inside an unescaped quote, meaning whitespace should be ignored.
307 - var insideQuote = false;
308 -
309 - // Index of the start of the current argument substring; either the start of the argument
310 - // or the start of a quoted or unquoted sequence within it.
311 - var partStart = 0;
312 -
313 - // The current argument string being built; when completed it will be added to the list.
314 - var arg = new StringBuilder();
315 -
316 - for (int i = 0; i <= arguments.Length; i++)
317 - {
318 - if (i == arguments.Length || (Char.IsWhiteSpace(arguments[i]) && !insideQuote))
319 - {
320 - // Reached a whitespace separator or the end of the string.
321 -
322 - // Finish building the current argument.
323 - arg.Append(arguments.Substring(partStart, i - partStart));
324 -
325 - // Skip over the whitespace character.
326 - partStart = i + 1;
327 -
328 - // Add the argument to the list if it's not empty.
329 - if (arg.Length > 0)
330 - {
331 - argsList.Add(X_CommandLine.ExpandEnvVars(arg.ToString()));
332 - arg.Length = 0;
333 - }
334 - }
335 - else if (i > partStart && arguments[i - 1] == '\\')
336 - {
337 - // Check the character following an unprocessed backslash.
338 - // Unescape quotes, and backslashes followed by a quote.
339 - if (arguments[i] == '"' || (arguments[i] == '\\' && arguments.Length > i + 1 && arguments[i + 1] == '"'))
340 - {
341 - // Unescape the quote or backslash by skipping the preceeding backslash.
342 - arg.Append(arguments.Substring(partStart, i - 1 - partStart));
343 - arg.Append(arguments[i]);
344 - partStart = i + 1;
345 - }
346 - }
347 - else if (arguments[i] == '"')
348 - {
349 - // Add the quoted or unquoted section to the argument string.
350 - arg.Append(arguments.Substring(partStart, i - partStart));
351 -
352 - // And skip over the quote character.
353 - partStart = i + 1;
354 -
355 - insideQuote = !insideQuote;
356 - }
357 - }
358 -
359 - return argsList;
360 - }
361 -
362 - /// <summary>
363 - /// Expand enxironment variables contained in the passed string
364 - /// </summary>
365 - /// <param name="arguments"></param>
366 - /// <returns></returns>
367 - private static string ExpandEnvVars(string arguments)
368 - {
369 - var id = Environment.GetEnvironmentVariables();
370 -
371 - var regex = new Regex("(?<=\\%)(?:[\\w\\.]+)(?=\\%)");
372 - MatchCollection matches = regex.Matches(arguments);
373 -
374 - string value = String.Empty;
375 - for (int i = 0; i <= (matches.Count - 1); i++)
376 - {
377 - try
378 - {
379 - var key = matches[i].Value;
380 - regex = new Regex(String.Concat("(?i)(?:\\%)(?:", key, ")(?:\\%)"));
381 - value = id[key].ToString();
382 - arguments = regex.Replace(arguments, value);
383 - }
384 - catch (NullReferenceException)
385 - {
386 - // Collapse unresolved environment variables.
387 - arguments = regex.Replace(arguments, value);
388 - }
389 - }
390 -
391 - return arguments;
392 - }
393 - }
394 -}