1//===-- CommandLine.cpp - Command line parser implementation --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This class implements a command line argument processor that is useful when 11// creating a tool. It provides a simple, minimalistic interface that is easily 12// extensible and supports nonlocal (library) command line options. 13// 14// Note that rather than trying to figure out what this code does, you could try 15// reading the library documentation located in docs/CommandLine.html 16// 17//===----------------------------------------------------------------------===// 18 19#include "llvm/Support/CommandLine.h" 20#include "llvm-c/Support.h" 21#include "llvm/ADT/ArrayRef.h" 22#include "llvm/ADT/STLExtras.h" 23#include "llvm/ADT/SmallPtrSet.h" 24#include "llvm/ADT/SmallString.h" 25#include "llvm/ADT/StringMap.h" 26#include "llvm/ADT/Twine.h" 27#include "llvm/Config/config.h" 28#include "llvm/Support/ConvertUTF.h" 29#include "llvm/Support/Debug.h" 30#include "llvm/Support/ErrorHandling.h" 31#include "llvm/Support/Host.h" 32#include "llvm/Support/ManagedStatic.h" 33#include "llvm/Support/MemoryBuffer.h" 34#include "llvm/Support/Path.h" 35#include "llvm/Support/raw_ostream.h" 36#include <cstdlib> 37#include <map> 38using namespace llvm; 39using namespace cl; 40 41#define DEBUG_TYPE "commandline" 42 43//===----------------------------------------------------------------------===// 44// Template instantiations and anchors. 45// 46namespace llvm { 47namespace cl { 48TEMPLATE_INSTANTIATION(class basic_parser<bool>); 49TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>); 50TEMPLATE_INSTANTIATION(class basic_parser<int>); 51TEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 52TEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>); 53TEMPLATE_INSTANTIATION(class basic_parser<double>); 54TEMPLATE_INSTANTIATION(class basic_parser<float>); 55TEMPLATE_INSTANTIATION(class basic_parser<std::string>); 56TEMPLATE_INSTANTIATION(class basic_parser<char>); 57 58TEMPLATE_INSTANTIATION(class opt<unsigned>); 59TEMPLATE_INSTANTIATION(class opt<int>); 60TEMPLATE_INSTANTIATION(class opt<std::string>); 61TEMPLATE_INSTANTIATION(class opt<char>); 62TEMPLATE_INSTANTIATION(class opt<bool>); 63} 64} // end namespace llvm::cl 65 66// Pin the vtables to this file. 67void GenericOptionValue::anchor() {} 68void OptionValue<boolOrDefault>::anchor() {} 69void OptionValue<std::string>::anchor() {} 70void Option::anchor() {} 71void basic_parser_impl::anchor() {} 72void parser<bool>::anchor() {} 73void parser<boolOrDefault>::anchor() {} 74void parser<int>::anchor() {} 75void parser<unsigned>::anchor() {} 76void parser<unsigned long long>::anchor() {} 77void parser<double>::anchor() {} 78void parser<float>::anchor() {} 79void parser<std::string>::anchor() {} 80void parser<char>::anchor() {} 81void StringSaver::anchor() {} 82 83//===----------------------------------------------------------------------===// 84 85namespace { 86 87class CommandLineParser { 88public: 89 // Globals for name and overview of program. Program name is not a string to 90 // avoid static ctor/dtor issues. 91 std::string ProgramName; 92 const char *ProgramOverview; 93 94 // This collects additional help to be printed. 95 std::vector<const char *> MoreHelp; 96 97 SmallVector<Option *, 4> PositionalOpts; 98 SmallVector<Option *, 4> SinkOpts; 99 StringMap<Option *> OptionsMap; 100 101 Option *ConsumeAfterOpt; // The ConsumeAfter option if it exists. 102 103 // This collects the different option categories that have been registered. 104 SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories; 105 106 CommandLineParser() : ProgramOverview(nullptr), ConsumeAfterOpt(nullptr) {} 107 108 void ParseCommandLineOptions(int argc, const char *const *argv, 109 const char *Overview); 110 111 void addLiteralOption(Option &Opt, const char *Name) { 112 if (!Opt.hasArgStr()) { 113 if (!OptionsMap.insert(std::make_pair(Name, &Opt)).second) { 114 errs() << ProgramName << ": CommandLine Error: Option '" << Name 115 << "' registered more than once!\n"; 116 report_fatal_error("inconsistency in registered CommandLine options"); 117 } 118 } 119 } 120 121 void addOption(Option *O) { 122 bool HadErrors = false; 123 if (O->ArgStr[0]) { 124 // Add argument to the argument map! 125 if (!OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) { 126 errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr 127 << "' registered more than once!\n"; 128 HadErrors = true; 129 } 130 } 131 132 // Remember information about positional options. 133 if (O->getFormattingFlag() == cl::Positional) 134 PositionalOpts.push_back(O); 135 else if (O->getMiscFlags() & cl::Sink) // Remember sink options 136 SinkOpts.push_back(O); 137 else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { 138 if (ConsumeAfterOpt) { 139 O->error("Cannot specify more than one option with cl::ConsumeAfter!"); 140 HadErrors = true; 141 } 142 ConsumeAfterOpt = O; 143 } 144 145 // Fail hard if there were errors. These are strictly unrecoverable and 146 // indicate serious issues such as conflicting option names or an 147 // incorrectly 148 // linked LLVM distribution. 149 if (HadErrors) 150 report_fatal_error("inconsistency in registered CommandLine options"); 151 } 152 153 void removeOption(Option *O) { 154 SmallVector<const char *, 16> OptionNames; 155 O->getExtraOptionNames(OptionNames); 156 if (O->ArgStr[0]) 157 OptionNames.push_back(O->ArgStr); 158 for (auto Name : OptionNames) 159 OptionsMap.erase(StringRef(Name)); 160 161 if (O->getFormattingFlag() == cl::Positional) 162 for (auto Opt = PositionalOpts.begin(); Opt != PositionalOpts.end(); 163 ++Opt) { 164 if (*Opt == O) { 165 PositionalOpts.erase(Opt); 166 break; 167 } 168 } 169 else if (O->getMiscFlags() & cl::Sink) 170 for (auto Opt = SinkOpts.begin(); Opt != SinkOpts.end(); ++Opt) { 171 if (*Opt == O) { 172 SinkOpts.erase(Opt); 173 break; 174 } 175 } 176 else if (O == ConsumeAfterOpt) 177 ConsumeAfterOpt = nullptr; 178 } 179 180 bool hasOptions() { 181 return (!OptionsMap.empty() || !PositionalOpts.empty() || 182 nullptr != ConsumeAfterOpt); 183 } 184 185 void updateArgStr(Option *O, const char *NewName) { 186 if (!OptionsMap.insert(std::make_pair(NewName, O)).second) { 187 errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr 188 << "' registered more than once!\n"; 189 report_fatal_error("inconsistency in registered CommandLine options"); 190 } 191 OptionsMap.erase(StringRef(O->ArgStr)); 192 } 193 194 void printOptionValues(); 195 196 void registerCategory(OptionCategory *cat) { 197 assert(std::count_if(RegisteredOptionCategories.begin(), 198 RegisteredOptionCategories.end(), 199 [cat](const OptionCategory *Category) { 200 return cat->getName() == Category->getName(); 201 }) == 0 && 202 "Duplicate option categories"); 203 204 RegisteredOptionCategories.insert(cat); 205 } 206 207private: 208 Option *LookupOption(StringRef &Arg, StringRef &Value); 209}; 210 211} // namespace 212 213static ManagedStatic<CommandLineParser> GlobalParser; 214 215void cl::AddLiteralOption(Option &O, const char *Name) { 216 GlobalParser->addLiteralOption(O, Name); 217} 218 219extrahelp::extrahelp(const char *Help) : morehelp(Help) { 220 GlobalParser->MoreHelp.push_back(Help); 221} 222 223void Option::addArgument() { 224 GlobalParser->addOption(this); 225 FullyInitialized = true; 226} 227 228void Option::removeArgument() { GlobalParser->removeOption(this); } 229 230void Option::setArgStr(const char *S) { 231 if (FullyInitialized) 232 GlobalParser->updateArgStr(this, S); 233 ArgStr = S; 234} 235 236// Initialise the general option category. 237OptionCategory llvm::cl::GeneralCategory("General options"); 238 239void OptionCategory::registerCategory() { 240 GlobalParser->registerCategory(this); 241} 242 243//===----------------------------------------------------------------------===// 244// Basic, shared command line option processing machinery. 245// 246 247/// LookupOption - Lookup the option specified by the specified option on the 248/// command line. If there is a value specified (after an equal sign) return 249/// that as well. This assumes that leading dashes have already been stripped. 250Option *CommandLineParser::LookupOption(StringRef &Arg, StringRef &Value) { 251 // Reject all dashes. 252 if (Arg.empty()) 253 return nullptr; 254 255 size_t EqualPos = Arg.find('='); 256 257 // If we have an equals sign, remember the value. 258 if (EqualPos == StringRef::npos) { 259 // Look up the option. 260 StringMap<Option *>::const_iterator I = OptionsMap.find(Arg); 261 return I != OptionsMap.end() ? I->second : nullptr; 262 } 263 264 // If the argument before the = is a valid option name, we match. If not, 265 // return Arg unmolested. 266 StringMap<Option *>::const_iterator I = 267 OptionsMap.find(Arg.substr(0, EqualPos)); 268 if (I == OptionsMap.end()) 269 return nullptr; 270 271 Value = Arg.substr(EqualPos + 1); 272 Arg = Arg.substr(0, EqualPos); 273 return I->second; 274} 275 276/// LookupNearestOption - Lookup the closest match to the option specified by 277/// the specified option on the command line. If there is a value specified 278/// (after an equal sign) return that as well. This assumes that leading dashes 279/// have already been stripped. 280static Option *LookupNearestOption(StringRef Arg, 281 const StringMap<Option *> &OptionsMap, 282 std::string &NearestString) { 283 // Reject all dashes. 284 if (Arg.empty()) 285 return nullptr; 286 287 // Split on any equal sign. 288 std::pair<StringRef, StringRef> SplitArg = Arg.split('='); 289 StringRef &LHS = SplitArg.first; // LHS == Arg when no '=' is present. 290 StringRef &RHS = SplitArg.second; 291 292 // Find the closest match. 293 Option *Best = nullptr; 294 unsigned BestDistance = 0; 295 for (StringMap<Option *>::const_iterator it = OptionsMap.begin(), 296 ie = OptionsMap.end(); 297 it != ie; ++it) { 298 Option *O = it->second; 299 SmallVector<const char *, 16> OptionNames; 300 O->getExtraOptionNames(OptionNames); 301 if (O->ArgStr[0]) 302 OptionNames.push_back(O->ArgStr); 303 304 bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed; 305 StringRef Flag = PermitValue ? LHS : Arg; 306 for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 307 StringRef Name = OptionNames[i]; 308 unsigned Distance = StringRef(Name).edit_distance( 309 Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance); 310 if (!Best || Distance < BestDistance) { 311 Best = O; 312 BestDistance = Distance; 313 if (RHS.empty() || !PermitValue) 314 NearestString = OptionNames[i]; 315 else 316 NearestString = (Twine(OptionNames[i]) + "=" + RHS).str(); 317 } 318 } 319 } 320 321 return Best; 322} 323 324/// CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence() 325/// that does special handling of cl::CommaSeparated options. 326static bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos, 327 StringRef ArgName, StringRef Value, 328 bool MultiArg = false) { 329 // Check to see if this option accepts a comma separated list of values. If 330 // it does, we have to split up the value into multiple values. 331 if (Handler->getMiscFlags() & CommaSeparated) { 332 StringRef Val(Value); 333 StringRef::size_type Pos = Val.find(','); 334 335 while (Pos != StringRef::npos) { 336 // Process the portion before the comma. 337 if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg)) 338 return true; 339 // Erase the portion before the comma, AND the comma. 340 Val = Val.substr(Pos + 1); 341 Value.substr(Pos + 1); // Increment the original value pointer as well. 342 // Check for another comma. 343 Pos = Val.find(','); 344 } 345 346 Value = Val; 347 } 348 349 if (Handler->addOccurrence(pos, ArgName, Value, MultiArg)) 350 return true; 351 352 return false; 353} 354 355/// ProvideOption - For Value, this differentiates between an empty value ("") 356/// and a null value (StringRef()). The later is accepted for arguments that 357/// don't allow a value (-foo) the former is rejected (-foo=). 358static inline bool ProvideOption(Option *Handler, StringRef ArgName, 359 StringRef Value, int argc, 360 const char *const *argv, int &i) { 361 // Is this a multi-argument option? 362 unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); 363 364 // Enforce value requirements 365 switch (Handler->getValueExpectedFlag()) { 366 case ValueRequired: 367 if (!Value.data()) { // No value specified? 368 if (i + 1 >= argc) 369 return Handler->error("requires a value!"); 370 // Steal the next argument, like for '-o filename' 371 assert(argv && "null check"); 372 Value = argv[++i]; 373 } 374 break; 375 case ValueDisallowed: 376 if (NumAdditionalVals > 0) 377 return Handler->error("multi-valued option specified" 378 " with ValueDisallowed modifier!"); 379 380 if (Value.data()) 381 return Handler->error("does not allow a value! '" + Twine(Value) + 382 "' specified."); 383 break; 384 case ValueOptional: 385 break; 386 } 387 388 // If this isn't a multi-arg option, just run the handler. 389 if (NumAdditionalVals == 0) 390 return CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value); 391 392 // If it is, run the handle several times. 393 bool MultiArg = false; 394 395 if (Value.data()) { 396 if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg)) 397 return true; 398 --NumAdditionalVals; 399 MultiArg = true; 400 } 401 402 while (NumAdditionalVals > 0) { 403 if (i + 1 >= argc) 404 return Handler->error("not enough values!"); 405 assert(argv && "null check"); 406 Value = argv[++i]; 407 408 if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg)) 409 return true; 410 MultiArg = true; 411 --NumAdditionalVals; 412 } 413 return false; 414} 415 416static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) { 417 int Dummy = i; 418 return ProvideOption(Handler, Handler->ArgStr, Arg, 0, nullptr, Dummy); 419} 420 421// Option predicates... 422static inline bool isGrouping(const Option *O) { 423 return O->getFormattingFlag() == cl::Grouping; 424} 425static inline bool isPrefixedOrGrouping(const Option *O) { 426 return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 427} 428 429// getOptionPred - Check to see if there are any options that satisfy the 430// specified predicate with names that are the prefixes in Name. This is 431// checked by progressively stripping characters off of the name, checking to 432// see if there options that satisfy the predicate. If we find one, return it, 433// otherwise return null. 434// 435static Option *getOptionPred(StringRef Name, size_t &Length, 436 bool (*Pred)(const Option *), 437 const StringMap<Option *> &OptionsMap) { 438 439 StringMap<Option *>::const_iterator OMI = OptionsMap.find(Name); 440 441 // Loop while we haven't found an option and Name still has at least two 442 // characters in it (so that the next iteration will not be the empty 443 // string. 444 while (OMI == OptionsMap.end() && Name.size() > 1) { 445 Name = Name.substr(0, Name.size() - 1); // Chop off the last character. 446 OMI = OptionsMap.find(Name); 447 } 448 449 if (OMI != OptionsMap.end() && Pred(OMI->second)) { 450 Length = Name.size(); 451 return OMI->second; // Found one! 452 } 453 return nullptr; // No option found! 454} 455 456/// HandlePrefixedOrGroupedOption - The specified argument string (which started 457/// with at least one '-') does not fully match an available option. Check to 458/// see if this is a prefix or grouped option. If so, split arg into output an 459/// Arg/Value pair and return the Option to parse it with. 460static Option * 461HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value, 462 bool &ErrorParsing, 463 const StringMap<Option *> &OptionsMap) { 464 if (Arg.size() == 1) 465 return nullptr; 466 467 // Do the lookup! 468 size_t Length = 0; 469 Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap); 470 if (!PGOpt) 471 return nullptr; 472 473 // If the option is a prefixed option, then the value is simply the 474 // rest of the name... so fall through to later processing, by 475 // setting up the argument name flags and value fields. 476 if (PGOpt->getFormattingFlag() == cl::Prefix) { 477 Value = Arg.substr(Length); 478 Arg = Arg.substr(0, Length); 479 assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt); 480 return PGOpt; 481 } 482 483 // This must be a grouped option... handle them now. Grouping options can't 484 // have values. 485 assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 486 487 do { 488 // Move current arg name out of Arg into OneArgName. 489 StringRef OneArgName = Arg.substr(0, Length); 490 Arg = Arg.substr(Length); 491 492 // Because ValueRequired is an invalid flag for grouped arguments, 493 // we don't need to pass argc/argv in. 494 assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 495 "Option can not be cl::Grouping AND cl::ValueRequired!"); 496 int Dummy = 0; 497 ErrorParsing |= 498 ProvideOption(PGOpt, OneArgName, StringRef(), 0, nullptr, Dummy); 499 500 // Get the next grouping option. 501 PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap); 502 } while (PGOpt && Length != Arg.size()); 503 504 // Return the last option with Arg cut down to just the last one. 505 return PGOpt; 506} 507 508static bool RequiresValue(const Option *O) { 509 return O->getNumOccurrencesFlag() == cl::Required || 510 O->getNumOccurrencesFlag() == cl::OneOrMore; 511} 512 513static bool EatsUnboundedNumberOfValues(const Option *O) { 514 return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 515 O->getNumOccurrencesFlag() == cl::OneOrMore; 516} 517 518static bool isWhitespace(char C) { return strchr(" \t\n\r\f\v", C); } 519 520static bool isQuote(char C) { return C == '\"' || C == '\''; } 521 522static bool isGNUSpecial(char C) { return strchr("\\\"\' ", C); } 523 524void cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver, 525 SmallVectorImpl<const char *> &NewArgv, 526 bool MarkEOLs) { 527 SmallString<128> Token; 528 for (size_t I = 0, E = Src.size(); I != E; ++I) { 529 // Consume runs of whitespace. 530 if (Token.empty()) { 531 while (I != E && isWhitespace(Src[I])) { 532 // Mark the end of lines in response files 533 if (MarkEOLs && Src[I] == '\n') 534 NewArgv.push_back(nullptr); 535 ++I; 536 } 537 if (I == E) 538 break; 539 } 540 541 // Backslashes can escape backslashes, spaces, and other quotes. Otherwise 542 // they are literal. This makes it much easier to read Windows file paths. 543 if (I + 1 < E && Src[I] == '\\' && isGNUSpecial(Src[I + 1])) { 544 ++I; // Skip the escape. 545 Token.push_back(Src[I]); 546 continue; 547 } 548 549 // Consume a quoted string. 550 if (isQuote(Src[I])) { 551 char Quote = Src[I++]; 552 while (I != E && Src[I] != Quote) { 553 // Backslashes are literal, unless they escape a special character. 554 if (Src[I] == '\\' && I + 1 != E && isGNUSpecial(Src[I + 1])) 555 ++I; 556 Token.push_back(Src[I]); 557 ++I; 558 } 559 if (I == E) 560 break; 561 continue; 562 } 563 564 // End the token if this is whitespace. 565 if (isWhitespace(Src[I])) { 566 if (!Token.empty()) 567 NewArgv.push_back(Saver.SaveString(Token.c_str())); 568 Token.clear(); 569 continue; 570 } 571 572 // This is a normal character. Append it. 573 Token.push_back(Src[I]); 574 } 575 576 // Append the last token after hitting EOF with no whitespace. 577 if (!Token.empty()) 578 NewArgv.push_back(Saver.SaveString(Token.c_str())); 579 // Mark the end of response files 580 if (MarkEOLs) 581 NewArgv.push_back(nullptr); 582} 583 584/// Backslashes are interpreted in a rather complicated way in the Windows-style 585/// command line, because backslashes are used both to separate path and to 586/// escape double quote. This method consumes runs of backslashes as well as the 587/// following double quote if it's escaped. 588/// 589/// * If an even number of backslashes is followed by a double quote, one 590/// backslash is output for every pair of backslashes, and the last double 591/// quote remains unconsumed. The double quote will later be interpreted as 592/// the start or end of a quoted string in the main loop outside of this 593/// function. 594/// 595/// * If an odd number of backslashes is followed by a double quote, one 596/// backslash is output for every pair of backslashes, and a double quote is 597/// output for the last pair of backslash-double quote. The double quote is 598/// consumed in this case. 599/// 600/// * Otherwise, backslashes are interpreted literally. 601static size_t parseBackslash(StringRef Src, size_t I, SmallString<128> &Token) { 602 size_t E = Src.size(); 603 int BackslashCount = 0; 604 // Skip the backslashes. 605 do { 606 ++I; 607 ++BackslashCount; 608 } while (I != E && Src[I] == '\\'); 609 610 bool FollowedByDoubleQuote = (I != E && Src[I] == '"'); 611 if (FollowedByDoubleQuote) { 612 Token.append(BackslashCount / 2, '\\'); 613 if (BackslashCount % 2 == 0) 614 return I - 1; 615 Token.push_back('"'); 616 return I; 617 } 618 Token.append(BackslashCount, '\\'); 619 return I - 1; 620} 621 622void cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver, 623 SmallVectorImpl<const char *> &NewArgv, 624 bool MarkEOLs) { 625 SmallString<128> Token; 626 627 // This is a small state machine to consume characters until it reaches the 628 // end of the source string. 629 enum { INIT, UNQUOTED, QUOTED } State = INIT; 630 for (size_t I = 0, E = Src.size(); I != E; ++I) { 631 // INIT state indicates that the current input index is at the start of 632 // the string or between tokens. 633 if (State == INIT) { 634 if (isWhitespace(Src[I])) { 635 // Mark the end of lines in response files 636 if (MarkEOLs && Src[I] == '\n') 637 NewArgv.push_back(nullptr); 638 continue; 639 } 640 if (Src[I] == '"') { 641 State = QUOTED; 642 continue; 643 } 644 if (Src[I] == '\\') { 645 I = parseBackslash(Src, I, Token); 646 State = UNQUOTED; 647 continue; 648 } 649 Token.push_back(Src[I]); 650 State = UNQUOTED; 651 continue; 652 } 653 654 // UNQUOTED state means that it's reading a token not quoted by double 655 // quotes. 656 if (State == UNQUOTED) { 657 // Whitespace means the end of the token. 658 if (isWhitespace(Src[I])) { 659 NewArgv.push_back(Saver.SaveString(Token.c_str())); 660 Token.clear(); 661 State = INIT; 662 // Mark the end of lines in response files 663 if (MarkEOLs && Src[I] == '\n') 664 NewArgv.push_back(nullptr); 665 continue; 666 } 667 if (Src[I] == '"') { 668 State = QUOTED; 669 continue; 670 } 671 if (Src[I] == '\\') { 672 I = parseBackslash(Src, I, Token); 673 continue; 674 } 675 Token.push_back(Src[I]); 676 continue; 677 } 678 679 // QUOTED state means that it's reading a token quoted by double quotes. 680 if (State == QUOTED) { 681 if (Src[I] == '"') { 682 State = UNQUOTED; 683 continue; 684 } 685 if (Src[I] == '\\') { 686 I = parseBackslash(Src, I, Token); 687 continue; 688 } 689 Token.push_back(Src[I]); 690 } 691 } 692 // Append the last token after hitting EOF with no whitespace. 693 if (!Token.empty()) 694 NewArgv.push_back(Saver.SaveString(Token.c_str())); 695 // Mark the end of response files 696 if (MarkEOLs) 697 NewArgv.push_back(nullptr); 698} 699 700// It is called byte order marker but the UTF-8 BOM is actually not affected 701// by the host system's endianness. 702static bool hasUTF8ByteOrderMark(ArrayRef<char> S) { 703 return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf'); 704} 705 706static bool ExpandResponseFile(const char *FName, StringSaver &Saver, 707 TokenizerCallback Tokenizer, 708 SmallVectorImpl<const char *> &NewArgv, 709 bool MarkEOLs = false) { 710 ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr = 711 MemoryBuffer::getFile(FName); 712 if (!MemBufOrErr) 713 return false; 714 MemoryBuffer &MemBuf = *MemBufOrErr.get(); 715 StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize()); 716 717 // If we have a UTF-16 byte order mark, convert to UTF-8 for parsing. 718 ArrayRef<char> BufRef(MemBuf.getBufferStart(), MemBuf.getBufferEnd()); 719 std::string UTF8Buf; 720 if (hasUTF16ByteOrderMark(BufRef)) { 721 if (!convertUTF16ToUTF8String(BufRef, UTF8Buf)) 722 return false; 723 Str = StringRef(UTF8Buf); 724 } 725 // If we see UTF-8 BOM sequence at the beginning of a file, we shall remove 726 // these bytes before parsing. 727 // Reference: http://en.wikipedia.org/wiki/UTF-8#Byte_order_mark 728 else if (hasUTF8ByteOrderMark(BufRef)) 729 Str = StringRef(BufRef.data() + 3, BufRef.size() - 3); 730 731 // Tokenize the contents into NewArgv. 732 Tokenizer(Str, Saver, NewArgv, MarkEOLs); 733 734 return true; 735} 736 737/// \brief Expand response files on a command line recursively using the given 738/// StringSaver and tokenization strategy. 739bool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, 740 SmallVectorImpl<const char *> &Argv, 741 bool MarkEOLs) { 742 unsigned RspFiles = 0; 743 bool AllExpanded = true; 744 745 // Don't cache Argv.size() because it can change. 746 for (unsigned I = 0; I != Argv.size();) { 747 const char *Arg = Argv[I]; 748 // Check if it is an EOL marker 749 if (Arg == nullptr) { 750 ++I; 751 continue; 752 } 753 if (Arg[0] != '@') { 754 ++I; 755 continue; 756 } 757 758 // If we have too many response files, leave some unexpanded. This avoids 759 // crashing on self-referential response files. 760 if (RspFiles++ > 20) 761 return false; 762 763 // Replace this response file argument with the tokenization of its 764 // contents. Nested response files are expanded in subsequent iterations. 765 // FIXME: If a nested response file uses a relative path, is it relative to 766 // the cwd of the process or the response file? 767 SmallVector<const char *, 0> ExpandedArgv; 768 if (!ExpandResponseFile(Arg + 1, Saver, Tokenizer, ExpandedArgv, 769 MarkEOLs)) { 770 // We couldn't read this file, so we leave it in the argument stream and 771 // move on. 772 AllExpanded = false; 773 ++I; 774 continue; 775 } 776 Argv.erase(Argv.begin() + I); 777 Argv.insert(Argv.begin() + I, ExpandedArgv.begin(), ExpandedArgv.end()); 778 } 779 return AllExpanded; 780} 781 782namespace { 783class StrDupSaver : public StringSaver { 784 std::vector<char *> Dups; 785 786public: 787 ~StrDupSaver() override { 788 for (std::vector<char *>::iterator I = Dups.begin(), E = Dups.end(); I != E; 789 ++I) { 790 char *Dup = *I; 791 free(Dup); 792 } 793 } 794 const char *SaveString(const char *Str) override { 795 char *Dup = strdup(Str); 796 Dups.push_back(Dup); 797 return Dup; 798 } 799}; 800} 801 802/// ParseEnvironmentOptions - An alternative entry point to the 803/// CommandLine library, which allows you to read the program's name 804/// from the caller (as PROGNAME) and its command-line arguments from 805/// an environment variable (whose name is given in ENVVAR). 806/// 807void cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 808 const char *Overview) { 809 // Check args. 810 assert(progName && "Program name not specified"); 811 assert(envVar && "Environment variable name missing"); 812 813 // Get the environment variable they want us to parse options out of. 814 const char *envValue = getenv(envVar); 815 if (!envValue) 816 return; 817 818 // Get program's "name", which we wouldn't know without the caller 819 // telling us. 820 SmallVector<const char *, 20> newArgv; 821 StrDupSaver Saver; 822 newArgv.push_back(Saver.SaveString(progName)); 823 824 // Parse the value of the environment variable into a "command line" 825 // and hand it off to ParseCommandLineOptions(). 826 TokenizeGNUCommandLine(envValue, Saver, newArgv); 827 int newArgc = static_cast<int>(newArgv.size()); 828 ParseCommandLineOptions(newArgc, &newArgv[0], Overview); 829} 830 831void cl::ParseCommandLineOptions(int argc, const char *const *argv, 832 const char *Overview) { 833 GlobalParser->ParseCommandLineOptions(argc, argv, Overview); 834} 835 836void CommandLineParser::ParseCommandLineOptions(int argc, 837 const char *const *argv, 838 const char *Overview) { 839 assert(hasOptions() && "No options specified!"); 840 841 // Expand response files. 842 SmallVector<const char *, 20> newArgv(argv, argv + argc); 843 StrDupSaver Saver; 844 ExpandResponseFiles(Saver, TokenizeGNUCommandLine, newArgv); 845 argv = &newArgv[0]; 846 argc = static_cast<int>(newArgv.size()); 847 848 // Copy the program name into ProgName, making sure not to overflow it. 849 ProgramName = sys::path::filename(argv[0]); 850 851 ProgramOverview = Overview; 852 bool ErrorParsing = false; 853 854 // Check out the positional arguments to collect information about them. 855 unsigned NumPositionalRequired = 0; 856 857 // Determine whether or not there are an unlimited number of positionals 858 bool HasUnlimitedPositionals = false; 859 860 if (ConsumeAfterOpt) { 861 assert(PositionalOpts.size() > 0 && 862 "Cannot specify cl::ConsumeAfter without a positional argument!"); 863 } 864 if (!PositionalOpts.empty()) { 865 866 // Calculate how many positional values are _required_. 867 bool UnboundedFound = false; 868 for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 869 Option *Opt = PositionalOpts[i]; 870 if (RequiresValue(Opt)) 871 ++NumPositionalRequired; 872 else if (ConsumeAfterOpt) { 873 // ConsumeAfter cannot be combined with "optional" positional options 874 // unless there is only one positional argument... 875 if (PositionalOpts.size() > 1) 876 ErrorParsing |= Opt->error( 877 "error - this positional option will never be matched, " 878 "because it does not Require a value, and a " 879 "cl::ConsumeAfter option is active!"); 880 } else if (UnboundedFound && !Opt->ArgStr[0]) { 881 // This option does not "require" a value... Make sure this option is 882 // not specified after an option that eats all extra arguments, or this 883 // one will never get any! 884 // 885 ErrorParsing |= Opt->error("error - option can never match, because " 886 "another positional argument will match an " 887 "unbounded number of values, and this option" 888 " does not require a value!"); 889 errs() << ProgramName << ": CommandLine Error: Option '" << Opt->ArgStr 890 << "' is all messed up!\n"; 891 errs() << PositionalOpts.size(); 892 } 893 UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 894 } 895 HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 896 } 897 898 // PositionalVals - A vector of "positional" arguments we accumulate into 899 // the process at the end. 900 // 901 SmallVector<std::pair<StringRef, unsigned>, 4> PositionalVals; 902 903 // If the program has named positional arguments, and the name has been run 904 // across, keep track of which positional argument was named. Otherwise put 905 // the positional args into the PositionalVals list... 906 Option *ActivePositionalArg = nullptr; 907 908 // Loop over all of the arguments... processing them. 909 bool DashDashFound = false; // Have we read '--'? 910 for (int i = 1; i < argc; ++i) { 911 Option *Handler = nullptr; 912 Option *NearestHandler = nullptr; 913 std::string NearestHandlerString; 914 StringRef Value; 915 StringRef ArgName = ""; 916 917 // Check to see if this is a positional argument. This argument is 918 // considered to be positional if it doesn't start with '-', if it is "-" 919 // itself, or if we have seen "--" already. 920 // 921 if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 922 // Positional argument! 923 if (ActivePositionalArg) { 924 ProvidePositionalOption(ActivePositionalArg, argv[i], i); 925 continue; // We are done! 926 } 927 928 if (!PositionalOpts.empty()) { 929 PositionalVals.push_back(std::make_pair(argv[i], i)); 930 931 // All of the positional arguments have been fulfulled, give the rest to 932 // the consume after option... if it's specified... 933 // 934 if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) { 935 for (++i; i < argc; ++i) 936 PositionalVals.push_back(std::make_pair(argv[i], i)); 937 break; // Handle outside of the argument processing loop... 938 } 939 940 // Delay processing positional arguments until the end... 941 continue; 942 } 943 } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 944 !DashDashFound) { 945 DashDashFound = true; // This is the mythical "--"? 946 continue; // Don't try to process it as an argument itself. 947 } else if (ActivePositionalArg && 948 (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 949 // If there is a positional argument eating options, check to see if this 950 // option is another positional argument. If so, treat it as an argument, 951 // otherwise feed it to the eating positional. 952 ArgName = argv[i] + 1; 953 // Eat leading dashes. 954 while (!ArgName.empty() && ArgName[0] == '-') 955 ArgName = ArgName.substr(1); 956 957 Handler = LookupOption(ArgName, Value); 958 if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 959 ProvidePositionalOption(ActivePositionalArg, argv[i], i); 960 continue; // We are done! 961 } 962 963 } else { // We start with a '-', must be an argument. 964 ArgName = argv[i] + 1; 965 // Eat leading dashes. 966 while (!ArgName.empty() && ArgName[0] == '-') 967 ArgName = ArgName.substr(1); 968 969 Handler = LookupOption(ArgName, Value); 970 971 // Check to see if this "option" is really a prefixed or grouped argument. 972 if (!Handler) 973 Handler = HandlePrefixedOrGroupedOption(ArgName, Value, ErrorParsing, 974 OptionsMap); 975 976 // Otherwise, look for the closest available option to report to the user 977 // in the upcoming error. 978 if (!Handler && SinkOpts.empty()) 979 NearestHandler = 980 LookupNearestOption(ArgName, OptionsMap, NearestHandlerString); 981 } 982 983 if (!Handler) { 984 if (SinkOpts.empty()) { 985 errs() << ProgramName << ": Unknown command line argument '" << argv[i] 986 << "'. Try: '" << argv[0] << " -help'\n"; 987 988 if (NearestHandler) { 989 // If we know a near match, report it as well. 990 errs() << ProgramName << ": Did you mean '-" << NearestHandlerString 991 << "'?\n"; 992 } 993 994 ErrorParsing = true; 995 } else { 996 for (SmallVectorImpl<Option *>::iterator I = SinkOpts.begin(), 997 E = SinkOpts.end(); 998 I != E; ++I) 999 (*I)->addOccurrence(i, "", argv[i]); 1000 } 1001 continue; 1002 } 1003 1004 // If this is a named positional argument, just remember that it is the 1005 // active one... 1006 if (Handler->getFormattingFlag() == cl::Positional) 1007 ActivePositionalArg = Handler; 1008 else 1009 ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 1010 } 1011 1012 // Check and handle positional arguments now... 1013 if (NumPositionalRequired > PositionalVals.size()) { 1014 errs() << ProgramName 1015 << ": Not enough positional command line arguments specified!\n" 1016 << "Must specify at least " << NumPositionalRequired 1017 << " positional arguments: See: " << argv[0] << " -help\n"; 1018 1019 ErrorParsing = true; 1020 } else if (!HasUnlimitedPositionals && 1021 PositionalVals.size() > PositionalOpts.size()) { 1022 errs() << ProgramName << ": Too many positional arguments specified!\n" 1023 << "Can specify at most " << PositionalOpts.size() 1024 << " positional arguments: See: " << argv[0] << " -help\n"; 1025 ErrorParsing = true; 1026 1027 } else if (!ConsumeAfterOpt) { 1028 // Positional args have already been handled if ConsumeAfter is specified. 1029 unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); 1030 for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 1031 if (RequiresValue(PositionalOpts[i])) { 1032 ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 1033 PositionalVals[ValNo].second); 1034 ValNo++; 1035 --NumPositionalRequired; // We fulfilled our duty... 1036 } 1037 1038 // If we _can_ give this option more arguments, do so now, as long as we 1039 // do not give it values that others need. 'Done' controls whether the 1040 // option even _WANTS_ any more. 1041 // 1042 bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 1043 while (NumVals - ValNo > NumPositionalRequired && !Done) { 1044 switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 1045 case cl::Optional: 1046 Done = true; // Optional arguments want _at most_ one value 1047 // FALL THROUGH 1048 case cl::ZeroOrMore: // Zero or more will take all they can get... 1049 case cl::OneOrMore: // One or more will take all they can get... 1050 ProvidePositionalOption(PositionalOpts[i], 1051 PositionalVals[ValNo].first, 1052 PositionalVals[ValNo].second); 1053 ValNo++; 1054 break; 1055 default: 1056 llvm_unreachable("Internal error, unexpected NumOccurrences flag in " 1057 "positional argument processing!"); 1058 } 1059 } 1060 } 1061 } else { 1062 assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 1063 unsigned ValNo = 0; 1064 for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) 1065 if (RequiresValue(PositionalOpts[j])) { 1066 ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 1067 PositionalVals[ValNo].first, 1068 PositionalVals[ValNo].second); 1069 ValNo++; 1070 } 1071 1072 // Handle the case where there is just one positional option, and it's 1073 // optional. In this case, we want to give JUST THE FIRST option to the 1074 // positional option and keep the rest for the consume after. The above 1075 // loop would have assigned no values to positional options in this case. 1076 // 1077 if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.empty()) { 1078 ErrorParsing |= ProvidePositionalOption(PositionalOpts[0], 1079 PositionalVals[ValNo].first, 1080 PositionalVals[ValNo].second); 1081 ValNo++; 1082 } 1083 1084 // Handle over all of the rest of the arguments to the 1085 // cl::ConsumeAfter command line option... 1086 for (; ValNo != PositionalVals.size(); ++ValNo) 1087 ErrorParsing |= 1088 ProvidePositionalOption(ConsumeAfterOpt, PositionalVals[ValNo].first, 1089 PositionalVals[ValNo].second); 1090 } 1091 1092 // Loop over args and make sure all required args are specified! 1093 for (const auto &Opt : OptionsMap) { 1094 switch (Opt.second->getNumOccurrencesFlag()) { 1095 case Required: 1096 case OneOrMore: 1097 if (Opt.second->getNumOccurrences() == 0) { 1098 Opt.second->error("must be specified at least once!"); 1099 ErrorParsing = true; 1100 } 1101 // Fall through 1102 default: 1103 break; 1104 } 1105 } 1106 1107 // Now that we know if -debug is specified, we can use it. 1108 // Note that if ReadResponseFiles == true, this must be done before the 1109 // memory allocated for the expanded command line is free()d below. 1110 DEBUG(dbgs() << "Args: "; 1111 for (int i = 0; i < argc; ++i) dbgs() << argv[i] << ' '; 1112 dbgs() << '\n';); 1113 1114 // Free all of the memory allocated to the map. Command line options may only 1115 // be processed once! 1116 MoreHelp.clear(); 1117 1118 // If we had an error processing our arguments, don't let the program execute 1119 if (ErrorParsing) 1120 exit(1); 1121} 1122 1123//===----------------------------------------------------------------------===// 1124// Option Base class implementation 1125// 1126 1127bool Option::error(const Twine &Message, StringRef ArgName) { 1128 if (!ArgName.data()) 1129 ArgName = ArgStr; 1130 if (ArgName.empty()) 1131 errs() << HelpStr; // Be nice for positional arguments 1132 else 1133 errs() << GlobalParser->ProgramName << ": for the -" << ArgName; 1134 1135 errs() << " option: " << Message << "\n"; 1136 return true; 1137} 1138 1139bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value, 1140 bool MultiArg) { 1141 if (!MultiArg) 1142 NumOccurrences++; // Increment the number of times we have been seen 1143 1144 switch (getNumOccurrencesFlag()) { 1145 case Optional: 1146 if (NumOccurrences > 1) 1147 return error("may only occur zero or one times!", ArgName); 1148 break; 1149 case Required: 1150 if (NumOccurrences > 1) 1151 return error("must occur exactly one time!", ArgName); 1152 // Fall through 1153 case OneOrMore: 1154 case ZeroOrMore: 1155 case ConsumeAfter: 1156 break; 1157 } 1158 1159 return handleOccurrence(pos, ArgName, Value); 1160} 1161 1162// getValueStr - Get the value description string, using "DefaultMsg" if nothing 1163// has been specified yet. 1164// 1165static const char *getValueStr(const Option &O, const char *DefaultMsg) { 1166 if (O.ValueStr[0] == 0) 1167 return DefaultMsg; 1168 return O.ValueStr; 1169} 1170 1171//===----------------------------------------------------------------------===// 1172// cl::alias class implementation 1173// 1174 1175// Return the width of the option tag for printing... 1176size_t alias::getOptionWidth() const { return std::strlen(ArgStr) + 6; } 1177 1178static void printHelpStr(StringRef HelpStr, size_t Indent, 1179 size_t FirstLineIndentedBy) { 1180 std::pair<StringRef, StringRef> Split = HelpStr.split('\n'); 1181 outs().indent(Indent - FirstLineIndentedBy) << " - " << Split.first << "\n"; 1182 while (!Split.second.empty()) { 1183 Split = Split.second.split('\n'); 1184 outs().indent(Indent) << Split.first << "\n"; 1185 } 1186} 1187 1188// Print out the option for the alias. 1189void alias::printOptionInfo(size_t GlobalWidth) const { 1190 outs() << " -" << ArgStr; 1191 printHelpStr(HelpStr, GlobalWidth, std::strlen(ArgStr) + 6); 1192} 1193 1194//===----------------------------------------------------------------------===// 1195// Parser Implementation code... 1196// 1197 1198// basic_parser implementation 1199// 1200 1201// Return the width of the option tag for printing... 1202size_t basic_parser_impl::getOptionWidth(const Option &O) const { 1203 size_t Len = std::strlen(O.ArgStr); 1204 if (const char *ValName = getValueName()) 1205 Len += std::strlen(getValueStr(O, ValName)) + 3; 1206 1207 return Len + 6; 1208} 1209 1210// printOptionInfo - Print out information about this option. The 1211// to-be-maintained width is specified. 1212// 1213void basic_parser_impl::printOptionInfo(const Option &O, 1214 size_t GlobalWidth) const { 1215 outs() << " -" << O.ArgStr; 1216 1217 if (const char *ValName = getValueName()) 1218 outs() << "=<" << getValueStr(O, ValName) << '>'; 1219 1220 printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O)); 1221} 1222 1223void basic_parser_impl::printOptionName(const Option &O, 1224 size_t GlobalWidth) const { 1225 outs() << " -" << O.ArgStr; 1226 outs().indent(GlobalWidth - std::strlen(O.ArgStr)); 1227} 1228 1229// parser<bool> implementation 1230// 1231bool parser<bool>::parse(Option &O, StringRef ArgName, StringRef Arg, 1232 bool &Value) { 1233 if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 1234 Arg == "1") { 1235 Value = true; 1236 return false; 1237 } 1238 1239 if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 1240 Value = false; 1241 return false; 1242 } 1243 return O.error("'" + Arg + 1244 "' is invalid value for boolean argument! Try 0 or 1"); 1245} 1246 1247// parser<boolOrDefault> implementation 1248// 1249bool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, StringRef Arg, 1250 boolOrDefault &Value) { 1251 if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 1252 Arg == "1") { 1253 Value = BOU_TRUE; 1254 return false; 1255 } 1256 if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 1257 Value = BOU_FALSE; 1258 return false; 1259 } 1260 1261 return O.error("'" + Arg + 1262 "' is invalid value for boolean argument! Try 0 or 1"); 1263} 1264 1265// parser<int> implementation 1266// 1267bool parser<int>::parse(Option &O, StringRef ArgName, StringRef Arg, 1268 int &Value) { 1269 if (Arg.getAsInteger(0, Value)) 1270 return O.error("'" + Arg + "' value invalid for integer argument!"); 1271 return false; 1272} 1273 1274// parser<unsigned> implementation 1275// 1276bool parser<unsigned>::parse(Option &O, StringRef ArgName, StringRef Arg, 1277 unsigned &Value) { 1278 1279 if (Arg.getAsInteger(0, Value)) 1280 return O.error("'" + Arg + "' value invalid for uint argument!"); 1281 return false; 1282} 1283 1284// parser<unsigned long long> implementation 1285// 1286bool parser<unsigned long long>::parse(Option &O, StringRef ArgName, 1287 StringRef Arg, 1288 unsigned long long &Value) { 1289 1290 if (Arg.getAsInteger(0, Value)) 1291 return O.error("'" + Arg + "' value invalid for uint argument!"); 1292 return false; 1293} 1294 1295// parser<double>/parser<float> implementation 1296// 1297static bool parseDouble(Option &O, StringRef Arg, double &Value) { 1298 SmallString<32> TmpStr(Arg.begin(), Arg.end()); 1299 const char *ArgStart = TmpStr.c_str(); 1300 char *End; 1301 Value = strtod(ArgStart, &End); 1302 if (*End != 0) 1303 return O.error("'" + Arg + "' value invalid for floating point argument!"); 1304 return false; 1305} 1306 1307bool parser<double>::parse(Option &O, StringRef ArgName, StringRef Arg, 1308 double &Val) { 1309 return parseDouble(O, Arg, Val); 1310} 1311 1312bool parser<float>::parse(Option &O, StringRef ArgName, StringRef Arg, 1313 float &Val) { 1314 double dVal; 1315 if (parseDouble(O, Arg, dVal)) 1316 return true; 1317 Val = (float)dVal; 1318 return false; 1319} 1320 1321// generic_parser_base implementation 1322// 1323 1324// findOption - Return the option number corresponding to the specified 1325// argument string. If the option is not found, getNumOptions() is returned. 1326// 1327unsigned generic_parser_base::findOption(const char *Name) { 1328 unsigned e = getNumOptions(); 1329 1330 for (unsigned i = 0; i != e; ++i) { 1331 if (strcmp(getOption(i), Name) == 0) 1332 return i; 1333 } 1334 return e; 1335} 1336 1337// Return the width of the option tag for printing... 1338size_t generic_parser_base::getOptionWidth(const Option &O) const { 1339 if (O.hasArgStr()) { 1340 size_t Size = std::strlen(O.ArgStr) + 6; 1341 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 1342 Size = std::max(Size, std::strlen(getOption(i)) + 8); 1343 return Size; 1344 } else { 1345 size_t BaseSize = 0; 1346 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 1347 BaseSize = std::max(BaseSize, std::strlen(getOption(i)) + 8); 1348 return BaseSize; 1349 } 1350} 1351 1352// printOptionInfo - Print out information about this option. The 1353// to-be-maintained width is specified. 1354// 1355void generic_parser_base::printOptionInfo(const Option &O, 1356 size_t GlobalWidth) const { 1357 if (O.hasArgStr()) { 1358 outs() << " -" << O.ArgStr; 1359 printHelpStr(O.HelpStr, GlobalWidth, std::strlen(O.ArgStr) + 6); 1360 1361 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 1362 size_t NumSpaces = GlobalWidth - strlen(getOption(i)) - 8; 1363 outs() << " =" << getOption(i); 1364 outs().indent(NumSpaces) << " - " << getDescription(i) << '\n'; 1365 } 1366 } else { 1367 if (O.HelpStr[0]) 1368 outs() << " " << O.HelpStr << '\n'; 1369 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 1370 const char *Option = getOption(i); 1371 outs() << " -" << Option; 1372 printHelpStr(getDescription(i), GlobalWidth, std::strlen(Option) + 8); 1373 } 1374 } 1375} 1376 1377static const size_t MaxOptWidth = 8; // arbitrary spacing for printOptionDiff 1378 1379// printGenericOptionDiff - Print the value of this option and it's default. 1380// 1381// "Generic" options have each value mapped to a name. 1382void generic_parser_base::printGenericOptionDiff( 1383 const Option &O, const GenericOptionValue &Value, 1384 const GenericOptionValue &Default, size_t GlobalWidth) const { 1385 outs() << " -" << O.ArgStr; 1386 outs().indent(GlobalWidth - std::strlen(O.ArgStr)); 1387 1388 unsigned NumOpts = getNumOptions(); 1389 for (unsigned i = 0; i != NumOpts; ++i) { 1390 if (Value.compare(getOptionValue(i))) 1391 continue; 1392 1393 outs() << "= " << getOption(i); 1394 size_t L = std::strlen(getOption(i)); 1395 size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0; 1396 outs().indent(NumSpaces) << " (default: "; 1397 for (unsigned j = 0; j != NumOpts; ++j) { 1398 if (Default.compare(getOptionValue(j))) 1399 continue; 1400 outs() << getOption(j); 1401 break; 1402 } 1403 outs() << ")\n"; 1404 return; 1405 } 1406 outs() << "= *unknown option value*\n"; 1407} 1408 1409// printOptionDiff - Specializations for printing basic value types. 1410// 1411#define PRINT_OPT_DIFF(T) \ 1412 void parser<T>::printOptionDiff(const Option &O, T V, OptionValue<T> D, \ 1413 size_t GlobalWidth) const { \ 1414 printOptionName(O, GlobalWidth); \ 1415 std::string Str; \ 1416 { \ 1417 raw_string_ostream SS(Str); \ 1418 SS << V; \ 1419 } \ 1420 outs() << "= " << Str; \ 1421 size_t NumSpaces = \ 1422 MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0; \ 1423 outs().indent(NumSpaces) << " (default: "; \ 1424 if (D.hasValue()) \ 1425 outs() << D.getValue(); \ 1426 else \ 1427 outs() << "*no default*"; \ 1428 outs() << ")\n"; \ 1429 } 1430 1431PRINT_OPT_DIFF(bool) 1432PRINT_OPT_DIFF(boolOrDefault) 1433PRINT_OPT_DIFF(int) 1434PRINT_OPT_DIFF(unsigned) 1435PRINT_OPT_DIFF(unsigned long long) 1436PRINT_OPT_DIFF(double) 1437PRINT_OPT_DIFF(float) 1438PRINT_OPT_DIFF(char) 1439 1440void parser<std::string>::printOptionDiff(const Option &O, StringRef V, 1441 OptionValue<std::string> D, 1442 size_t GlobalWidth) const { 1443 printOptionName(O, GlobalWidth); 1444 outs() << "= " << V; 1445 size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0; 1446 outs().indent(NumSpaces) << " (default: "; 1447 if (D.hasValue()) 1448 outs() << D.getValue(); 1449 else 1450 outs() << "*no default*"; 1451 outs() << ")\n"; 1452} 1453 1454// Print a placeholder for options that don't yet support printOptionDiff(). 1455void basic_parser_impl::printOptionNoValue(const Option &O, 1456 size_t GlobalWidth) const { 1457 printOptionName(O, GlobalWidth); 1458 outs() << "= *cannot print option value*\n"; 1459} 1460 1461//===----------------------------------------------------------------------===// 1462// -help and -help-hidden option implementation 1463// 1464 1465static int OptNameCompare(const std::pair<const char *, Option *> *LHS, 1466 const std::pair<const char *, Option *> *RHS) { 1467 return strcmp(LHS->first, RHS->first); 1468} 1469 1470// Copy Options into a vector so we can sort them as we like. 1471static void sortOpts(StringMap<Option *> &OptMap, 1472 SmallVectorImpl<std::pair<const char *, Option *>> &Opts, 1473 bool ShowHidden) { 1474 SmallPtrSet<Option *, 128> OptionSet; // Duplicate option detection. 1475 1476 for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end(); 1477 I != E; ++I) { 1478 // Ignore really-hidden options. 1479 if (I->second->getOptionHiddenFlag() == ReallyHidden) 1480 continue; 1481 1482 // Unless showhidden is set, ignore hidden flags. 1483 if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden) 1484 continue; 1485 1486 // If we've already seen this option, don't add it to the list again. 1487 if (!OptionSet.insert(I->second).second) 1488 continue; 1489 1490 Opts.push_back( 1491 std::pair<const char *, Option *>(I->getKey().data(), I->second)); 1492 } 1493 1494 // Sort the options list alphabetically. 1495 array_pod_sort(Opts.begin(), Opts.end(), OptNameCompare); 1496} 1497 1498namespace { 1499 1500class HelpPrinter { 1501protected: 1502 const bool ShowHidden; 1503 typedef SmallVector<std::pair<const char *, Option *>, 128> 1504 StrOptionPairVector; 1505 // Print the options. Opts is assumed to be alphabetically sorted. 1506 virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) { 1507 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1508 Opts[i].second->printOptionInfo(MaxArgLen); 1509 } 1510 1511public: 1512 explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {} 1513 virtual ~HelpPrinter() {} 1514 1515 // Invoke the printer. 1516 void operator=(bool Value) { 1517 if (!Value) 1518 return; 1519 1520 StrOptionPairVector Opts; 1521 sortOpts(GlobalParser->OptionsMap, Opts, ShowHidden); 1522 1523 if (GlobalParser->ProgramOverview) 1524 outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n"; 1525 1526 outs() << "USAGE: " << GlobalParser->ProgramName << " [options]"; 1527 1528 for (auto Opt : GlobalParser->PositionalOpts) { 1529 if (Opt->ArgStr[0]) 1530 outs() << " --" << Opt->ArgStr; 1531 outs() << " " << Opt->HelpStr; 1532 } 1533 1534 // Print the consume after option info if it exists... 1535 if (GlobalParser->ConsumeAfterOpt) 1536 outs() << " " << GlobalParser->ConsumeAfterOpt->HelpStr; 1537 1538 outs() << "\n\n"; 1539 1540 // Compute the maximum argument length... 1541 size_t MaxArgLen = 0; 1542 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1543 MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1544 1545 outs() << "OPTIONS:\n"; 1546 printOptions(Opts, MaxArgLen); 1547 1548 // Print any extra help the user has declared. 1549 for (auto I : GlobalParser->MoreHelp) 1550 outs() << I; 1551 GlobalParser->MoreHelp.clear(); 1552 1553 // Halt the program since help information was printed 1554 exit(0); 1555 } 1556}; 1557 1558class CategorizedHelpPrinter : public HelpPrinter { 1559public: 1560 explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {} 1561 1562 // Helper function for printOptions(). 1563 // It shall return a negative value if A's name should be lexicographically 1564 // ordered before B's name. It returns a value greater equal zero otherwise. 1565 static int OptionCategoryCompare(OptionCategory *const *A, 1566 OptionCategory *const *B) { 1567 return strcmp((*A)->getName(), (*B)->getName()); 1568 } 1569 1570 // Make sure we inherit our base class's operator=() 1571 using HelpPrinter::operator=; 1572 1573protected: 1574 void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override { 1575 std::vector<OptionCategory *> SortedCategories; 1576 std::map<OptionCategory *, std::vector<Option *>> CategorizedOptions; 1577 1578 // Collect registered option categories into vector in preparation for 1579 // sorting. 1580 for (auto I = GlobalParser->RegisteredOptionCategories.begin(), 1581 E = GlobalParser->RegisteredOptionCategories.end(); 1582 I != E; ++I) { 1583 SortedCategories.push_back(*I); 1584 } 1585 1586 // Sort the different option categories alphabetically. 1587 assert(SortedCategories.size() > 0 && "No option categories registered!"); 1588 array_pod_sort(SortedCategories.begin(), SortedCategories.end(), 1589 OptionCategoryCompare); 1590 1591 // Create map to empty vectors. 1592 for (std::vector<OptionCategory *>::const_iterator 1593 I = SortedCategories.begin(), 1594 E = SortedCategories.end(); 1595 I != E; ++I) 1596 CategorizedOptions[*I] = std::vector<Option *>(); 1597 1598 // Walk through pre-sorted options and assign into categories. 1599 // Because the options are already alphabetically sorted the 1600 // options within categories will also be alphabetically sorted. 1601 for (size_t I = 0, E = Opts.size(); I != E; ++I) { 1602 Option *Opt = Opts[I].second; 1603 assert(CategorizedOptions.count(Opt->Category) > 0 && 1604 "Option has an unregistered category"); 1605 CategorizedOptions[Opt->Category].push_back(Opt); 1606 } 1607 1608 // Now do printing. 1609 for (std::vector<OptionCategory *>::const_iterator 1610 Category = SortedCategories.begin(), 1611 E = SortedCategories.end(); 1612 Category != E; ++Category) { 1613 // Hide empty categories for -help, but show for -help-hidden. 1614 bool IsEmptyCategory = CategorizedOptions[*Category].size() == 0; 1615 if (!ShowHidden && IsEmptyCategory) 1616 continue; 1617 1618 // Print category information. 1619 outs() << "\n"; 1620 outs() << (*Category)->getName() << ":\n"; 1621 1622 // Check if description is set. 1623 if ((*Category)->getDescription() != nullptr) 1624 outs() << (*Category)->getDescription() << "\n\n"; 1625 else 1626 outs() << "\n"; 1627 1628 // When using -help-hidden explicitly state if the category has no 1629 // options associated with it. 1630 if (IsEmptyCategory) { 1631 outs() << " This option category has no options.\n"; 1632 continue; 1633 } 1634 // Loop over the options in the category and print. 1635 for (std::vector<Option *>::const_iterator 1636 Opt = CategorizedOptions[*Category].begin(), 1637 E = CategorizedOptions[*Category].end(); 1638 Opt != E; ++Opt) 1639 (*Opt)->printOptionInfo(MaxArgLen); 1640 } 1641 } 1642}; 1643 1644// This wraps the Uncategorizing and Categorizing printers and decides 1645// at run time which should be invoked. 1646class HelpPrinterWrapper { 1647private: 1648 HelpPrinter &UncategorizedPrinter; 1649 CategorizedHelpPrinter &CategorizedPrinter; 1650 1651public: 1652 explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter, 1653 CategorizedHelpPrinter &CategorizedPrinter) 1654 : UncategorizedPrinter(UncategorizedPrinter), 1655 CategorizedPrinter(CategorizedPrinter) {} 1656 1657 // Invoke the printer. 1658 void operator=(bool Value); 1659}; 1660 1661} // End anonymous namespace 1662 1663// Declare the four HelpPrinter instances that are used to print out help, or 1664// help-hidden as an uncategorized list or in categories. 1665static HelpPrinter UncategorizedNormalPrinter(false); 1666static HelpPrinter UncategorizedHiddenPrinter(true); 1667static CategorizedHelpPrinter CategorizedNormalPrinter(false); 1668static CategorizedHelpPrinter CategorizedHiddenPrinter(true); 1669 1670// Declare HelpPrinter wrappers that will decide whether or not to invoke 1671// a categorizing help printer 1672static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter, 1673 CategorizedNormalPrinter); 1674static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter, 1675 CategorizedHiddenPrinter); 1676 1677// Define a category for generic options that all tools should have. 1678static cl::OptionCategory GenericCategory("Generic Options"); 1679 1680// Define uncategorized help printers. 1681// -help-list is hidden by default because if Option categories are being used 1682// then -help behaves the same as -help-list. 1683static cl::opt<HelpPrinter, true, parser<bool>> HLOp( 1684 "help-list", 1685 cl::desc("Display list of available options (-help-list-hidden for more)"), 1686 cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed, 1687 cl::cat(GenericCategory)); 1688 1689static cl::opt<HelpPrinter, true, parser<bool>> 1690 HLHOp("help-list-hidden", cl::desc("Display list of all available options"), 1691 cl::location(UncategorizedHiddenPrinter), cl::Hidden, 1692 cl::ValueDisallowed, cl::cat(GenericCategory)); 1693 1694// Define uncategorized/categorized help printers. These printers change their 1695// behaviour at runtime depending on whether one or more Option categories have 1696// been declared. 1697static cl::opt<HelpPrinterWrapper, true, parser<bool>> 1698 HOp("help", cl::desc("Display available options (-help-hidden for more)"), 1699 cl::location(WrappedNormalPrinter), cl::ValueDisallowed, 1700 cl::cat(GenericCategory)); 1701 1702static cl::opt<HelpPrinterWrapper, true, parser<bool>> 1703 HHOp("help-hidden", cl::desc("Display all available options"), 1704 cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed, 1705 cl::cat(GenericCategory)); 1706 1707static cl::opt<bool> PrintOptions( 1708 "print-options", 1709 cl::desc("Print non-default options after command line parsing"), 1710 cl::Hidden, cl::init(false), cl::cat(GenericCategory)); 1711 1712static cl::opt<bool> PrintAllOptions( 1713 "print-all-options", 1714 cl::desc("Print all option values after command line parsing"), cl::Hidden, 1715 cl::init(false), cl::cat(GenericCategory)); 1716 1717void HelpPrinterWrapper::operator=(bool Value) { 1718 if (!Value) 1719 return; 1720 1721 // Decide which printer to invoke. If more than one option category is 1722 // registered then it is useful to show the categorized help instead of 1723 // uncategorized help. 1724 if (GlobalParser->RegisteredOptionCategories.size() > 1) { 1725 // unhide -help-list option so user can have uncategorized output if they 1726 // want it. 1727 HLOp.setHiddenFlag(NotHidden); 1728 1729 CategorizedPrinter = true; // Invoke categorized printer 1730 } else 1731 UncategorizedPrinter = true; // Invoke uncategorized printer 1732} 1733 1734// Print the value of each option. 1735void cl::PrintOptionValues() { GlobalParser->printOptionValues(); } 1736 1737void CommandLineParser::printOptionValues() { 1738 if (!PrintOptions && !PrintAllOptions) 1739 return; 1740 1741 SmallVector<std::pair<const char *, Option *>, 128> Opts; 1742 sortOpts(OptionsMap, Opts, /*ShowHidden*/ true); 1743 1744 // Compute the maximum argument length... 1745 size_t MaxArgLen = 0; 1746 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1747 MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1748 1749 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1750 Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions); 1751} 1752 1753static void (*OverrideVersionPrinter)() = nullptr; 1754 1755static std::vector<void (*)()> *ExtraVersionPrinters = nullptr; 1756 1757namespace { 1758class VersionPrinter { 1759public: 1760 void print() { 1761 raw_ostream &OS = outs(); 1762 OS << "LLVM (http://llvm.org/):\n" 1763 << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; 1764#ifdef LLVM_VERSION_INFO 1765 OS << " " << LLVM_VERSION_INFO; 1766#endif 1767 OS << "\n "; 1768#ifndef __OPTIMIZE__ 1769 OS << "DEBUG build"; 1770#else 1771 OS << "Optimized build"; 1772#endif 1773#ifndef NDEBUG 1774 OS << " with assertions"; 1775#endif 1776 std::string CPU = sys::getHostCPUName(); 1777 if (CPU == "generic") 1778 CPU = "(unknown)"; 1779 OS << ".\n" 1780#if (ENABLE_TIMESTAMPS == 1) 1781 << " Built " << __DATE__ << " (" << __TIME__ << ").\n" 1782#endif 1783 << " Default target: " << sys::getDefaultTargetTriple() << '\n' 1784 << " Host CPU: " << CPU << '\n'; 1785 } 1786 void operator=(bool OptionWasSpecified) { 1787 if (!OptionWasSpecified) 1788 return; 1789 1790 if (OverrideVersionPrinter != nullptr) { 1791 (*OverrideVersionPrinter)(); 1792 exit(0); 1793 } 1794 print(); 1795 1796 // Iterate over any registered extra printers and call them to add further 1797 // information. 1798 if (ExtraVersionPrinters != nullptr) { 1799 outs() << '\n'; 1800 for (std::vector<void (*)()>::iterator I = ExtraVersionPrinters->begin(), 1801 E = ExtraVersionPrinters->end(); 1802 I != E; ++I) 1803 (*I)(); 1804 } 1805 1806 exit(0); 1807 } 1808}; 1809} // End anonymous namespace 1810 1811// Define the --version option that prints out the LLVM version for the tool 1812static VersionPrinter VersionPrinterInstance; 1813 1814static cl::opt<VersionPrinter, true, parser<bool>> 1815 VersOp("version", cl::desc("Display the version of this program"), 1816 cl::location(VersionPrinterInstance), cl::ValueDisallowed, 1817 cl::cat(GenericCategory)); 1818 1819// Utility function for printing the help message. 1820void cl::PrintHelpMessage(bool Hidden, bool Categorized) { 1821 // This looks weird, but it actually prints the help message. The Printers are 1822 // types of HelpPrinter and the help gets printed when its operator= is 1823 // invoked. That's because the "normal" usages of the help printer is to be 1824 // assigned true/false depending on whether -help or -help-hidden was given or 1825 // not. Since we're circumventing that we have to make it look like -help or 1826 // -help-hidden were given, so we assign true. 1827 1828 if (!Hidden && !Categorized) 1829 UncategorizedNormalPrinter = true; 1830 else if (!Hidden && Categorized) 1831 CategorizedNormalPrinter = true; 1832 else if (Hidden && !Categorized) 1833 UncategorizedHiddenPrinter = true; 1834 else 1835 CategorizedHiddenPrinter = true; 1836} 1837 1838/// Utility function for printing version number. 1839void cl::PrintVersionMessage() { VersionPrinterInstance.print(); } 1840 1841void cl::SetVersionPrinter(void (*func)()) { OverrideVersionPrinter = func; } 1842 1843void cl::AddExtraVersionPrinter(void (*func)()) { 1844 if (!ExtraVersionPrinters) 1845 ExtraVersionPrinters = new std::vector<void (*)()>; 1846 1847 ExtraVersionPrinters->push_back(func); 1848} 1849 1850StringMap<Option *> &cl::getRegisteredOptions() { 1851 return GlobalParser->OptionsMap; 1852} 1853 1854void cl::HideUnrelatedOptions(cl::OptionCategory &Category) { 1855 for (auto &I : GlobalParser->OptionsMap) { 1856 if (I.second->Category != &Category && 1857 I.second->Category != &GenericCategory) 1858 I.second->setHiddenFlag(cl::ReallyHidden); 1859 } 1860} 1861 1862void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories) { 1863 auto CategoriesBegin = Categories.begin(); 1864 auto CategoriesEnd = Categories.end(); 1865 for (auto &I : GlobalParser->OptionsMap) { 1866 if (std::find(CategoriesBegin, CategoriesEnd, I.second->Category) == 1867 CategoriesEnd && 1868 I.second->Category != &GenericCategory) 1869 I.second->setHiddenFlag(cl::ReallyHidden); 1870 } 1871} 1872 1873void LLVMParseCommandLineOptions(int argc, const char *const *argv, 1874 const char *Overview) { 1875 llvm::cl::ParseCommandLineOptions(argc, argv, Overview); 1876} 1877