blob: 578c3b22bff4a75e03b69aca7186319ba1e9f941 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// 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
{
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
/// <summary>
/// Common utilities for Wix command-line processing.
/// </summary>
public static class CommandLineResponseFile
{
/// <summary>
/// Parses a response file.
/// </summary>
/// <param name="responseFile">The file to parse.</param>
/// <returns>The array of arguments.</returns>
public static string[] Parse(string responseFile)
{
string arguments;
using (StreamReader reader = new StreamReader(responseFile))
{
arguments = reader.ReadToEnd();
}
return CommandLineResponseFile.ParseArgumentsToArray(arguments);
}
/// <summary>
/// Parses an argument string into an argument array based on whitespace and quoting.
/// </summary>
/// <param name="arguments">Argument string.</param>
/// <returns>Argument array.</returns>
public static 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.
List<string> argsList = new List<string>();
// True if we are inside an unescaped quote, meaning whitespace should be ignored.
bool 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.
int partStart = 0;
// The current argument string being built; when completed it will be added to the list.
StringBuilder 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(CommandLineResponseFile.ExpandEnvVars(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.ToArray();
}
static private string ExpandEnvVars(string arguments)
{
IDictionary id = Environment.GetEnvironmentVariables();
Regex regex = new Regex("(?<=\\%)(?:[\\w\\.]+)(?=\\%)");
MatchCollection matches = regex.Matches(arguments);
string value = String.Empty;
for (int i = 0; i <= (matches.Count - 1); i++)
{
try
{
string 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;
}
}
}
|
