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