contrib/llvm/lib/Support/CommandLine.cpp

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