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