command_line.cc revision 5e3f23d412006dc4db4e659864679f29341e113f 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/command_line.h"
6
7#include <algorithm>
8#include <ostream>
9
10#include "base/basictypes.h"
11#include "base/files/file_path.h"
12#include "base/logging.h"
13#include "base/strings/string_split.h"
14#include "base/strings/string_util.h"
15#include "base/strings/utf_string_conversions.h"
16#include "build/build_config.h"
17
18#if defined(OS_WIN)
19#include <windows.h>
20#include <shellapi.h>
21#endif
22
23using base::FilePath;
24
25CommandLine* CommandLine::current_process_commandline_ = NULL;
26
27namespace {
28const CommandLine::CharType kSwitchTerminator[] = FILE_PATH_LITERAL("--");
29const CommandLine::CharType kSwitchValueSeparator[] = FILE_PATH_LITERAL("=");
30// Since we use a lazy match, make sure that longer versions (like "--") are
31// listed before shorter versions (like "-") of similar prefixes.
32#if defined(OS_WIN)
33const CommandLine::CharType* const kSwitchPrefixes[] = {L"--", L"-", L"/"};
34#elif defined(OS_POSIX)
35// Unixes don't use slash as a switch.
36const CommandLine::CharType* const kSwitchPrefixes[] = {"--", "-"};
37#endif
38
39size_t GetSwitchPrefixLength(const CommandLine::StringType& string) {
40  for (size_t i = 0; i < arraysize(kSwitchPrefixes); ++i) {
41    CommandLine::StringType prefix(kSwitchPrefixes[i]);
42    if (string.compare(0, prefix.length(), prefix) == 0)
43      return prefix.length();
44  }
45  return 0;
46}
47
48// Fills in |switch_string| and |switch_value| if |string| is a switch.
49// This will preserve the input switch prefix in the output |switch_string|.
50bool IsSwitch(const CommandLine::StringType& string,
51              CommandLine::StringType* switch_string,
52              CommandLine::StringType* switch_value) {
53  switch_string->clear();
54  switch_value->clear();
55  size_t prefix_length = GetSwitchPrefixLength(string);
56  if (prefix_length == 0 || prefix_length == string.length())
57    return false;
58
59  const size_t equals_position = string.find(kSwitchValueSeparator);
60  *switch_string = string.substr(0, equals_position);
61  if (equals_position != CommandLine::StringType::npos)
62    *switch_value = string.substr(equals_position + 1);
63  return true;
64}
65
66// Append switches and arguments, keeping switches before arguments.
67void AppendSwitchesAndArguments(CommandLine& command_line,
68                                const CommandLine::StringVector& argv) {
69  bool parse_switches = true;
70  for (size_t i = 1; i < argv.size(); ++i) {
71    CommandLine::StringType arg = argv[i];
72    TrimWhitespace(arg, TRIM_ALL, &arg);
73
74    CommandLine::StringType switch_string;
75    CommandLine::StringType switch_value;
76    parse_switches &= (arg != kSwitchTerminator);
77    if (parse_switches && IsSwitch(arg, &switch_string, &switch_value)) {
78#if defined(OS_WIN)
79      command_line.AppendSwitchNative(WideToASCII(switch_string), switch_value);
80#elif defined(OS_POSIX)
81      command_line.AppendSwitchNative(switch_string, switch_value);
82#endif
83    } else {
84      command_line.AppendArgNative(arg);
85    }
86  }
87}
88
89// Lowercase switches for backwards compatiblity *on Windows*.
90std::string LowerASCIIOnWindows(const std::string& string) {
91#if defined(OS_WIN)
92  return StringToLowerASCII(string);
93#elif defined(OS_POSIX)
94  return string;
95#endif
96}
97
98
99#if defined(OS_WIN)
100// Quote a string as necessary for CommandLineToArgvW compatiblity *on Windows*.
101std::wstring QuoteForCommandLineToArgvW(const std::wstring& arg) {
102  // We follow the quoting rules of CommandLineToArgvW.
103  // http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
104  if (arg.find_first_of(L" \\\"") == std::wstring::npos) {
105    // No quoting necessary.
106    return arg;
107  }
108
109  std::wstring out;
110  out.push_back(L'"');
111  for (size_t i = 0; i < arg.size(); ++i) {
112    if (arg[i] == '\\') {
113      // Find the extent of this run of backslashes.
114      size_t start = i, end = start + 1;
115      for (; end < arg.size() && arg[end] == '\\'; ++end)
116        /* empty */;
117      size_t backslash_count = end - start;
118
119      // Backslashes are escapes only if the run is followed by a double quote.
120      // Since we also will end the string with a double quote, we escape for
121      // either a double quote or the end of the string.
122      if (end == arg.size() || arg[end] == '"') {
123        // To quote, we need to output 2x as many backslashes.
124        backslash_count *= 2;
125      }
126      for (size_t j = 0; j < backslash_count; ++j)
127        out.push_back('\\');
128
129      // Advance i to one before the end to balance i++ in loop.
130      i = end - 1;
131    } else if (arg[i] == '"') {
132      out.push_back('\\');
133      out.push_back('"');
134    } else {
135      out.push_back(arg[i]);
136    }
137  }
138  out.push_back('"');
139
140  return out;
141}
142#endif
143
144}  // namespace
145
146CommandLine::CommandLine(NoProgram no_program)
147    : argv_(1),
148      begin_args_(1) {
149}
150
151CommandLine::CommandLine(const FilePath& program)
152    : argv_(1),
153      begin_args_(1) {
154  SetProgram(program);
155}
156
157CommandLine::CommandLine(int argc, const CommandLine::CharType* const* argv)
158    : argv_(1),
159      begin_args_(1) {
160  InitFromArgv(argc, argv);
161}
162
163CommandLine::CommandLine(const StringVector& argv)
164    : argv_(1),
165      begin_args_(1) {
166  InitFromArgv(argv);
167}
168
169CommandLine::~CommandLine() {
170}
171
172// static
173bool CommandLine::Init(int argc, const char* const* argv) {
174  if (current_process_commandline_) {
175    // If this is intentional, Reset() must be called first. If we are using
176    // the shared build mode, we have to share a single object across multiple
177    // shared libraries.
178    return false;
179  }
180
181  current_process_commandline_ = new CommandLine(NO_PROGRAM);
182#if defined(OS_WIN)
183  current_process_commandline_->ParseFromString(::GetCommandLineW());
184#elif defined(OS_POSIX)
185  current_process_commandline_->InitFromArgv(argc, argv);
186#endif
187
188  return true;
189}
190
191// static
192void CommandLine::Reset() {
193  DCHECK(current_process_commandline_);
194  delete current_process_commandline_;
195  current_process_commandline_ = NULL;
196}
197
198// static
199CommandLine* CommandLine::ForCurrentProcess() {
200  DCHECK(current_process_commandline_);
201  return current_process_commandline_;
202}
203
204#if defined(OS_WIN)
205// static
206CommandLine CommandLine::FromString(const std::wstring& command_line) {
207  CommandLine cmd(NO_PROGRAM);
208  cmd.ParseFromString(command_line);
209  return cmd;
210}
211#endif
212
213void CommandLine::InitFromArgv(int argc,
214                               const CommandLine::CharType* const* argv) {
215  StringVector new_argv;
216  for (int i = 0; i < argc; ++i)
217    new_argv.push_back(argv[i]);
218  InitFromArgv(new_argv);
219}
220
221void CommandLine::InitFromArgv(const StringVector& argv) {
222  argv_ = StringVector(1);
223  begin_args_ = 1;
224  SetProgram(argv.empty() ? FilePath() : FilePath(argv[0]));
225  AppendSwitchesAndArguments(*this, argv);
226}
227
228CommandLine::StringType CommandLine::GetCommandLineString() const {
229  StringType string(argv_[0]);
230#if defined(OS_WIN)
231  string = QuoteForCommandLineToArgvW(string);
232#endif
233  StringType params(GetArgumentsString());
234  if (!params.empty()) {
235    string.append(StringType(FILE_PATH_LITERAL(" ")));
236    string.append(params);
237  }
238  return string;
239}
240
241CommandLine::StringType CommandLine::GetArgumentsString() const {
242  StringType params;
243  // Append switches and arguments.
244  bool parse_switches = true;
245  for (size_t i = 1; i < argv_.size(); ++i) {
246    StringType arg = argv_[i];
247    StringType switch_string;
248    StringType switch_value;
249    parse_switches &= arg != kSwitchTerminator;
250    if (i > 1)
251      params.append(StringType(FILE_PATH_LITERAL(" ")));
252    if (parse_switches && IsSwitch(arg, &switch_string, &switch_value)) {
253      params.append(switch_string);
254      if (!switch_value.empty()) {
255#if defined(OS_WIN)
256        switch_value = QuoteForCommandLineToArgvW(switch_value);
257#endif
258        params.append(kSwitchValueSeparator + switch_value);
259      }
260    }
261    else {
262#if defined(OS_WIN)
263      arg = QuoteForCommandLineToArgvW(arg);
264#endif
265      params.append(arg);
266    }
267  }
268  return params;
269}
270
271FilePath CommandLine::GetProgram() const {
272  return FilePath(argv_[0]);
273}
274
275void CommandLine::SetProgram(const FilePath& program) {
276  TrimWhitespace(program.value(), TRIM_ALL, &argv_[0]);
277}
278
279bool CommandLine::HasSwitch(const std::string& switch_string) const {
280  return switches_.find(LowerASCIIOnWindows(switch_string)) != switches_.end();
281}
282
283std::string CommandLine::GetSwitchValueASCII(
284    const std::string& switch_string) const {
285  StringType value = GetSwitchValueNative(switch_string);
286  if (!IsStringASCII(value)) {
287    DLOG(WARNING) << "Value of switch (" << switch_string << ") must be ASCII.";
288    return std::string();
289  }
290#if defined(OS_WIN)
291  return WideToASCII(value);
292#else
293  return value;
294#endif
295}
296
297FilePath CommandLine::GetSwitchValuePath(
298    const std::string& switch_string) const {
299  return FilePath(GetSwitchValueNative(switch_string));
300}
301
302CommandLine::StringType CommandLine::GetSwitchValueNative(
303    const std::string& switch_string) const {
304  SwitchMap::const_iterator result = switches_.end();
305  result = switches_.find(LowerASCIIOnWindows(switch_string));
306  return result == switches_.end() ? StringType() : result->second;
307}
308
309void CommandLine::AppendSwitch(const std::string& switch_string) {
310  AppendSwitchNative(switch_string, StringType());
311}
312
313void CommandLine::AppendSwitchPath(const std::string& switch_string,
314                                   const FilePath& path) {
315  AppendSwitchNative(switch_string, path.value());
316}
317
318void CommandLine::AppendSwitchNative(const std::string& switch_string,
319                                     const CommandLine::StringType& value) {
320  std::string switch_key(LowerASCIIOnWindows(switch_string));
321#if defined(OS_WIN)
322  StringType combined_switch_string(ASCIIToWide(switch_key));
323#elif defined(OS_POSIX)
324  StringType combined_switch_string(switch_string);
325#endif
326  size_t prefix_length = GetSwitchPrefixLength(combined_switch_string);
327  switches_[switch_key.substr(prefix_length)] = value;
328  // Preserve existing switch prefixes in |argv_|; only append one if necessary.
329  if (prefix_length == 0)
330    combined_switch_string = kSwitchPrefixes[0] + combined_switch_string;
331  if (!value.empty())
332    combined_switch_string += kSwitchValueSeparator + value;
333  // Append the switch and update the switches/arguments divider |begin_args_|.
334  argv_.insert(argv_.begin() + begin_args_++, combined_switch_string);
335}
336
337void CommandLine::AppendSwitchASCII(const std::string& switch_string,
338                                    const std::string& value_string) {
339#if defined(OS_WIN)
340  AppendSwitchNative(switch_string, ASCIIToWide(value_string));
341#elif defined(OS_POSIX)
342  AppendSwitchNative(switch_string, value_string);
343#endif
344}
345
346void CommandLine::CopySwitchesFrom(const CommandLine& source,
347                                   const char* const switches[],
348                                   size_t count) {
349  for (size_t i = 0; i < count; ++i) {
350    if (source.HasSwitch(switches[i]))
351      AppendSwitchNative(switches[i], source.GetSwitchValueNative(switches[i]));
352  }
353}
354
355CommandLine::StringVector CommandLine::GetArgs() const {
356  // Gather all arguments after the last switch (may include kSwitchTerminator).
357  StringVector args(argv_.begin() + begin_args_, argv_.end());
358  // Erase only the first kSwitchTerminator (maybe "--" is a legitimate page?)
359  StringVector::iterator switch_terminator =
360      std::find(args.begin(), args.end(), kSwitchTerminator);
361  if (switch_terminator != args.end())
362    args.erase(switch_terminator);
363  return args;
364}
365
366void CommandLine::AppendArg(const std::string& value) {
367#if defined(OS_WIN)
368  DCHECK(IsStringUTF8(value));
369  AppendArgNative(UTF8ToWide(value));
370#elif defined(OS_POSIX)
371  AppendArgNative(value);
372#endif
373}
374
375void CommandLine::AppendArgPath(const FilePath& path) {
376  AppendArgNative(path.value());
377}
378
379void CommandLine::AppendArgNative(const CommandLine::StringType& value) {
380  argv_.push_back(value);
381}
382
383void CommandLine::AppendArguments(const CommandLine& other,
384                                  bool include_program) {
385  if (include_program)
386    SetProgram(other.GetProgram());
387  AppendSwitchesAndArguments(*this, other.argv());
388}
389
390void CommandLine::PrependWrapper(const CommandLine::StringType& wrapper) {
391  if (wrapper.empty())
392    return;
393  // The wrapper may have embedded arguments (like "gdb --args"). In this case,
394  // we don't pretend to do anything fancy, we just split on spaces.
395  StringVector wrapper_argv;
396  base::SplitString(wrapper, FILE_PATH_LITERAL(' '), &wrapper_argv);
397  // Prepend the wrapper and update the switches/arguments |begin_args_|.
398  argv_.insert(argv_.begin(), wrapper_argv.begin(), wrapper_argv.end());
399  begin_args_ += wrapper_argv.size();
400}
401
402#if defined(OS_WIN)
403void CommandLine::ParseFromString(const std::wstring& command_line) {
404  std::wstring command_line_string;
405  TrimWhitespace(command_line, TRIM_ALL, &command_line_string);
406  if (command_line_string.empty())
407    return;
408
409  int num_args = 0;
410  wchar_t** args = NULL;
411  args = ::CommandLineToArgvW(command_line_string.c_str(), &num_args);
412
413  DPLOG_IF(FATAL, !args) << "CommandLineToArgvW failed on command line: "
414                         << command_line;
415  InitFromArgv(num_args, args);
416  LocalFree(args);
417}
418#endif
419