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