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/OwningPtr.h" 21 #include "llvm/ADT/SmallPtrSet.h" 22 #include "llvm/ADT/SmallString.h" 23 #include "llvm/ADT/StringMap.h" 24 #include "llvm/ADT/Twine.h" 25 #include "llvm/Config/config.h" 26 #include "llvm/Support/Debug.h" 27 #include "llvm/Support/ErrorHandling.h" 28 #include "llvm/Support/Host.h" 29 #include "llvm/Support/ManagedStatic.h" 30 #include "llvm/Support/MemoryBuffer.h" 31 #include "llvm/Support/Path.h" 32 #include "llvm/Support/raw_ostream.h" 33 #include "llvm/Support/system_error.h" 34 #include <cerrno> 35 #include <cstdlib> 36 using namespace llvm; 37 using namespace cl; 38 39 //===----------------------------------------------------------------------===// 40 // Template instantiations and anchors. 41 // 42 namespace llvm { namespace cl { 43 TEMPLATE_INSTANTIATION(class basic_parser<bool>); 44 TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>); 45 TEMPLATE_INSTANTIATION(class basic_parser<int>); 46 TEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 47 TEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>); 48 TEMPLATE_INSTANTIATION(class basic_parser<double>); 49 TEMPLATE_INSTANTIATION(class basic_parser<float>); 50 TEMPLATE_INSTANTIATION(class basic_parser<std::string>); 51 TEMPLATE_INSTANTIATION(class basic_parser<char>); 52 53 TEMPLATE_INSTANTIATION(class opt<unsigned>); 54 TEMPLATE_INSTANTIATION(class opt<int>); 55 TEMPLATE_INSTANTIATION(class opt<std::string>); 56 TEMPLATE_INSTANTIATION(class opt<char>); 57 TEMPLATE_INSTANTIATION(class opt<bool>); 58 } } // end namespace llvm::cl 59 60 void GenericOptionValue::anchor() {} 61 void OptionValue<boolOrDefault>::anchor() {} 62 void OptionValue<std::string>::anchor() {} 63 void Option::anchor() {} 64 void basic_parser_impl::anchor() {} 65 void parser<bool>::anchor() {} 66 void parser<boolOrDefault>::anchor() {} 67 void parser<int>::anchor() {} 68 void parser<unsigned>::anchor() {} 69 void parser<unsigned long long>::anchor() {} 70 void parser<double>::anchor() {} 71 void parser<float>::anchor() {} 72 void parser<std::string>::anchor() {} 73 void parser<char>::anchor() {} 74 75 //===----------------------------------------------------------------------===// 76 77 // Globals for name and overview of program. Program name is not a string to 78 // avoid static ctor/dtor issues. 79 static char ProgramName[80] = "<premain>"; 80 static const char *ProgramOverview = 0; 81 82 // This collects additional help to be printed. 83 static ManagedStatic<std::vector<const char*> > MoreHelp; 84 85 extrahelp::extrahelp(const char *Help) 86 : morehelp(Help) { 87 MoreHelp->push_back(Help); 88 } 89 90 static bool OptionListChanged = false; 91 92 // MarkOptionsChanged - Internal helper function. 93 void cl::MarkOptionsChanged() { 94 OptionListChanged = true; 95 } 96 97 /// RegisteredOptionList - This is the list of the command line options that 98 /// have statically constructed themselves. 99 static Option *RegisteredOptionList = 0; 100 101 void Option::addArgument() { 102 assert(NextRegistered == 0 && "argument multiply registered!"); 103 104 NextRegistered = RegisteredOptionList; 105 RegisteredOptionList = this; 106 MarkOptionsChanged(); 107 } 108 109 110 //===----------------------------------------------------------------------===// 111 // Basic, shared command line option processing machinery. 112 // 113 114 /// GetOptionInfo - Scan the list of registered options, turning them into data 115 /// structures that are easier to handle. 116 static void GetOptionInfo(SmallVectorImpl<Option*> &PositionalOpts, 117 SmallVectorImpl<Option*> &SinkOpts, 118 StringMap<Option*> &OptionsMap) { 119 SmallVector<const char*, 16> OptionNames; 120 Option *CAOpt = 0; // The ConsumeAfter option if it exists. 121 for (Option *O = RegisteredOptionList; O; O = O->getNextRegisteredOption()) { 122 // If this option wants to handle multiple option names, get the full set. 123 // This handles enum options like "-O1 -O2" etc. 124 O->getExtraOptionNames(OptionNames); 125 if (O->ArgStr[0]) 126 OptionNames.push_back(O->ArgStr); 127 128 // Handle named options. 129 for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 130 // Add argument to the argument map! 131 if (OptionsMap.GetOrCreateValue(OptionNames[i], O).second != O) { 132 errs() << ProgramName << ": CommandLine Error: Argument '" 133 << OptionNames[i] << "' defined more than once!\n"; 134 } 135 } 136 137 OptionNames.clear(); 138 139 // Remember information about positional options. 140 if (O->getFormattingFlag() == cl::Positional) 141 PositionalOpts.push_back(O); 142 else if (O->getMiscFlags() & cl::Sink) // Remember sink options 143 SinkOpts.push_back(O); 144 else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { 145 if (CAOpt) 146 O->error("Cannot specify more than one option with cl::ConsumeAfter!"); 147 CAOpt = O; 148 } 149 } 150 151 if (CAOpt) 152 PositionalOpts.push_back(CAOpt); 153 154 // Make sure that they are in order of registration not backwards. 155 std::reverse(PositionalOpts.begin(), PositionalOpts.end()); 156 } 157 158 159 /// LookupOption - Lookup the option specified by the specified option on the 160 /// command line. If there is a value specified (after an equal sign) return 161 /// that as well. This assumes that leading dashes have already been stripped. 162 static Option *LookupOption(StringRef &Arg, StringRef &Value, 163 const StringMap<Option*> &OptionsMap) { 164 // Reject all dashes. 165 if (Arg.empty()) return 0; 166 167 size_t EqualPos = Arg.find('='); 168 169 // If we have an equals sign, remember the value. 170 if (EqualPos == StringRef::npos) { 171 // Look up the option. 172 StringMap<Option*>::const_iterator I = OptionsMap.find(Arg); 173 return I != OptionsMap.end() ? I->second : 0; 174 } 175 176 // If the argument before the = is a valid option name, we match. If not, 177 // return Arg unmolested. 178 StringMap<Option*>::const_iterator I = 179 OptionsMap.find(Arg.substr(0, EqualPos)); 180 if (I == OptionsMap.end()) return 0; 181 182 Value = Arg.substr(EqualPos+1); 183 Arg = Arg.substr(0, EqualPos); 184 return I->second; 185 } 186 187 /// LookupNearestOption - Lookup the closest match to the option specified by 188 /// the specified option on the command line. If there is a value specified 189 /// (after an equal sign) return that as well. This assumes that leading dashes 190 /// have already been stripped. 191 static Option *LookupNearestOption(StringRef Arg, 192 const StringMap<Option*> &OptionsMap, 193 std::string &NearestString) { 194 // Reject all dashes. 195 if (Arg.empty()) return 0; 196 197 // Split on any equal sign. 198 std::pair<StringRef, StringRef> SplitArg = Arg.split('='); 199 StringRef &LHS = SplitArg.first; // LHS == Arg when no '=' is present. 200 StringRef &RHS = SplitArg.second; 201 202 // Find the closest match. 203 Option *Best = 0; 204 unsigned BestDistance = 0; 205 for (StringMap<Option*>::const_iterator it = OptionsMap.begin(), 206 ie = OptionsMap.end(); it != ie; ++it) { 207 Option *O = it->second; 208 SmallVector<const char*, 16> OptionNames; 209 O->getExtraOptionNames(OptionNames); 210 if (O->ArgStr[0]) 211 OptionNames.push_back(O->ArgStr); 212 213 bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed; 214 StringRef Flag = PermitValue ? LHS : Arg; 215 for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 216 StringRef Name = OptionNames[i]; 217 unsigned Distance = StringRef(Name).edit_distance( 218 Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance); 219 if (!Best || Distance < BestDistance) { 220 Best = O; 221 BestDistance = Distance; 222 if (RHS.empty() || !PermitValue) 223 NearestString = OptionNames[i]; 224 else 225 NearestString = std::string(OptionNames[i]) + "=" + RHS.str(); 226 } 227 } 228 } 229 230 return Best; 231 } 232 233 /// CommaSeparateAndAddOccurence - A wrapper around Handler->addOccurence() that 234 /// does special handling of cl::CommaSeparated options. 235 static bool CommaSeparateAndAddOccurence(Option *Handler, unsigned pos, 236 StringRef ArgName, 237 StringRef Value, bool MultiArg = false) 238 { 239 // Check to see if this option accepts a comma separated list of values. If 240 // it does, we have to split up the value into multiple values. 241 if (Handler->getMiscFlags() & CommaSeparated) { 242 StringRef Val(Value); 243 StringRef::size_type Pos = Val.find(','); 244 245 while (Pos != StringRef::npos) { 246 // Process the portion before the comma. 247 if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg)) 248 return true; 249 // Erase the portion before the comma, AND the comma. 250 Val = Val.substr(Pos+1); 251 Value.substr(Pos+1); // Increment the original value pointer as well. 252 // Check for another comma. 253 Pos = Val.find(','); 254 } 255 256 Value = Val; 257 } 258 259 if (Handler->addOccurrence(pos, ArgName, Value, MultiArg)) 260 return true; 261 262 return false; 263 } 264 265 /// ProvideOption - For Value, this differentiates between an empty value ("") 266 /// and a null value (StringRef()). The later is accepted for arguments that 267 /// don't allow a value (-foo) the former is rejected (-foo=). 268 static inline bool ProvideOption(Option *Handler, StringRef ArgName, 269 StringRef Value, int argc, 270 const char *const *argv, int &i) { 271 // Is this a multi-argument option? 272 unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); 273 274 // Enforce value requirements 275 switch (Handler->getValueExpectedFlag()) { 276 case ValueRequired: 277 if (Value.data() == 0) { // No value specified? 278 if (i+1 >= argc) 279 return Handler->error("requires a value!"); 280 // Steal the next argument, like for '-o filename' 281 Value = argv[++i]; 282 } 283 break; 284 case ValueDisallowed: 285 if (NumAdditionalVals > 0) 286 return Handler->error("multi-valued option specified" 287 " with ValueDisallowed modifier!"); 288 289 if (Value.data()) 290 return Handler->error("does not allow a value! '" + 291 Twine(Value) + "' specified."); 292 break; 293 case ValueOptional: 294 break; 295 } 296 297 // If this isn't a multi-arg option, just run the handler. 298 if (NumAdditionalVals == 0) 299 return CommaSeparateAndAddOccurence(Handler, i, ArgName, Value); 300 301 // If it is, run the handle several times. 302 bool MultiArg = false; 303 304 if (Value.data()) { 305 if (CommaSeparateAndAddOccurence(Handler, i, ArgName, Value, MultiArg)) 306 return true; 307 --NumAdditionalVals; 308 MultiArg = true; 309 } 310 311 while (NumAdditionalVals > 0) { 312 if (i+1 >= argc) 313 return Handler->error("not enough values!"); 314 Value = argv[++i]; 315 316 if (CommaSeparateAndAddOccurence(Handler, i, ArgName, Value, MultiArg)) 317 return true; 318 MultiArg = true; 319 --NumAdditionalVals; 320 } 321 return false; 322 } 323 324 static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) { 325 int Dummy = i; 326 return ProvideOption(Handler, Handler->ArgStr, Arg, 0, 0, Dummy); 327 } 328 329 330 // Option predicates... 331 static inline bool isGrouping(const Option *O) { 332 return O->getFormattingFlag() == cl::Grouping; 333 } 334 static inline bool isPrefixedOrGrouping(const Option *O) { 335 return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 336 } 337 338 // getOptionPred - Check to see if there are any options that satisfy the 339 // specified predicate with names that are the prefixes in Name. This is 340 // checked by progressively stripping characters off of the name, checking to 341 // see if there options that satisfy the predicate. If we find one, return it, 342 // otherwise return null. 343 // 344 static Option *getOptionPred(StringRef Name, size_t &Length, 345 bool (*Pred)(const Option*), 346 const StringMap<Option*> &OptionsMap) { 347 348 StringMap<Option*>::const_iterator OMI = OptionsMap.find(Name); 349 350 // Loop while we haven't found an option and Name still has at least two 351 // characters in it (so that the next iteration will not be the empty 352 // string. 353 while (OMI == OptionsMap.end() && Name.size() > 1) { 354 Name = Name.substr(0, Name.size()-1); // Chop off the last character. 355 OMI = OptionsMap.find(Name); 356 } 357 358 if (OMI != OptionsMap.end() && Pred(OMI->second)) { 359 Length = Name.size(); 360 return OMI->second; // Found one! 361 } 362 return 0; // No option found! 363 } 364 365 /// HandlePrefixedOrGroupedOption - The specified argument string (which started 366 /// with at least one '-') does not fully match an available option. Check to 367 /// see if this is a prefix or grouped option. If so, split arg into output an 368 /// Arg/Value pair and return the Option to parse it with. 369 static Option *HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value, 370 bool &ErrorParsing, 371 const StringMap<Option*> &OptionsMap) { 372 if (Arg.size() == 1) return 0; 373 374 // Do the lookup! 375 size_t Length = 0; 376 Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap); 377 if (PGOpt == 0) return 0; 378 379 // If the option is a prefixed option, then the value is simply the 380 // rest of the name... so fall through to later processing, by 381 // setting up the argument name flags and value fields. 382 if (PGOpt->getFormattingFlag() == cl::Prefix) { 383 Value = Arg.substr(Length); 384 Arg = Arg.substr(0, Length); 385 assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt); 386 return PGOpt; 387 } 388 389 // This must be a grouped option... handle them now. Grouping options can't 390 // have values. 391 assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 392 393 do { 394 // Move current arg name out of Arg into OneArgName. 395 StringRef OneArgName = Arg.substr(0, Length); 396 Arg = Arg.substr(Length); 397 398 // Because ValueRequired is an invalid flag for grouped arguments, 399 // we don't need to pass argc/argv in. 400 assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 401 "Option can not be cl::Grouping AND cl::ValueRequired!"); 402 int Dummy = 0; 403 ErrorParsing |= ProvideOption(PGOpt, OneArgName, 404 StringRef(), 0, 0, Dummy); 405 406 // Get the next grouping option. 407 PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap); 408 } while (PGOpt && Length != Arg.size()); 409 410 // Return the last option with Arg cut down to just the last one. 411 return PGOpt; 412 } 413 414 415 416 static bool RequiresValue(const Option *O) { 417 return O->getNumOccurrencesFlag() == cl::Required || 418 O->getNumOccurrencesFlag() == cl::OneOrMore; 419 } 420 421 static bool EatsUnboundedNumberOfValues(const Option *O) { 422 return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 423 O->getNumOccurrencesFlag() == cl::OneOrMore; 424 } 425 426 /// ParseCStringVector - Break INPUT up wherever one or more 427 /// whitespace characters are found, and store the resulting tokens in 428 /// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 429 /// using strdup(), so it is the caller's responsibility to free() 430 /// them later. 431 /// 432 static void ParseCStringVector(std::vector<char *> &OutputVector, 433 const char *Input) { 434 // Characters which will be treated as token separators: 435 StringRef Delims = " \v\f\t\r\n"; 436 437 StringRef WorkStr(Input); 438 while (!WorkStr.empty()) { 439 // If the first character is a delimiter, strip them off. 440 if (Delims.find(WorkStr[0]) != StringRef::npos) { 441 size_t Pos = WorkStr.find_first_not_of(Delims); 442 if (Pos == StringRef::npos) Pos = WorkStr.size(); 443 WorkStr = WorkStr.substr(Pos); 444 continue; 445 } 446 447 // Find position of first delimiter. 448 size_t Pos = WorkStr.find_first_of(Delims); 449 if (Pos == StringRef::npos) Pos = WorkStr.size(); 450 451 // Everything from 0 to Pos is the next word to copy. 452 char *NewStr = (char*)malloc(Pos+1); 453 memcpy(NewStr, WorkStr.data(), Pos); 454 NewStr[Pos] = 0; 455 OutputVector.push_back(NewStr); 456 457 WorkStr = WorkStr.substr(Pos); 458 } 459 } 460 461 /// ParseEnvironmentOptions - An alternative entry point to the 462 /// CommandLine library, which allows you to read the program's name 463 /// from the caller (as PROGNAME) and its command-line arguments from 464 /// an environment variable (whose name is given in ENVVAR). 465 /// 466 void cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 467 const char *Overview) { 468 // Check args. 469 assert(progName && "Program name not specified"); 470 assert(envVar && "Environment variable name missing"); 471 472 // Get the environment variable they want us to parse options out of. 473 const char *envValue = getenv(envVar); 474 if (!envValue) 475 return; 476 477 // Get program's "name", which we wouldn't know without the caller 478 // telling us. 479 std::vector<char*> newArgv; 480 newArgv.push_back(strdup(progName)); 481 482 // Parse the value of the environment variable into a "command line" 483 // and hand it off to ParseCommandLineOptions(). 484 ParseCStringVector(newArgv, envValue); 485 int newArgc = static_cast<int>(newArgv.size()); 486 ParseCommandLineOptions(newArgc, &newArgv[0], Overview); 487 488 // Free all the strdup()ed strings. 489 for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 490 i != e; ++i) 491 free(*i); 492 } 493 494 495 /// ExpandResponseFiles - Copy the contents of argv into newArgv, 496 /// substituting the contents of the response files for the arguments 497 /// of type @file. 498 static void ExpandResponseFiles(unsigned argc, const char*const* argv, 499 std::vector<char*>& newArgv) { 500 for (unsigned i = 1; i != argc; ++i) { 501 const char *arg = argv[i]; 502 503 if (arg[0] == '@') { 504 sys::PathWithStatus respFile(++arg); 505 506 // Check that the response file is not empty (mmap'ing empty 507 // files can be problematic). 508 const sys::FileStatus *FileStat = respFile.getFileStatus(); 509 if (FileStat && FileStat->getSize() != 0) { 510 511 // If we could open the file, parse its contents, otherwise 512 // pass the @file option verbatim. 513 514 // TODO: we should also support recursive loading of response files, 515 // since this is how gcc behaves. (From their man page: "The file may 516 // itself contain additional @file options; any such options will be 517 // processed recursively.") 518 519 // Mmap the response file into memory. 520 OwningPtr<MemoryBuffer> respFilePtr; 521 if (!MemoryBuffer::getFile(respFile.c_str(), respFilePtr)) { 522 ParseCStringVector(newArgv, respFilePtr->getBufferStart()); 523 continue; 524 } 525 } 526 } 527 newArgv.push_back(strdup(arg)); 528 } 529 } 530 531 void cl::ParseCommandLineOptions(int argc, const char * const *argv, 532 const char *Overview) { 533 // Process all registered options. 534 SmallVector<Option*, 4> PositionalOpts; 535 SmallVector<Option*, 4> SinkOpts; 536 StringMap<Option*> Opts; 537 GetOptionInfo(PositionalOpts, SinkOpts, Opts); 538 539 assert((!Opts.empty() || !PositionalOpts.empty()) && 540 "No options specified!"); 541 542 // Expand response files. 543 std::vector<char*> newArgv; 544 newArgv.push_back(strdup(argv[0])); 545 ExpandResponseFiles(argc, argv, newArgv); 546 argv = &newArgv[0]; 547 argc = static_cast<int>(newArgv.size()); 548 549 // Copy the program name into ProgName, making sure not to overflow it. 550 std::string ProgName = sys::path::filename(argv[0]); 551 size_t Len = std::min(ProgName.size(), size_t(79)); 552 memcpy(ProgramName, ProgName.data(), Len); 553 ProgramName[Len] = '\0'; 554 555 ProgramOverview = Overview; 556 bool ErrorParsing = false; 557 558 // Check out the positional arguments to collect information about them. 559 unsigned NumPositionalRequired = 0; 560 561 // Determine whether or not there are an unlimited number of positionals 562 bool HasUnlimitedPositionals = false; 563 564 Option *ConsumeAfterOpt = 0; 565 if (!PositionalOpts.empty()) { 566 if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 567 assert(PositionalOpts.size() > 1 && 568 "Cannot specify cl::ConsumeAfter without a positional argument!"); 569 ConsumeAfterOpt = PositionalOpts[0]; 570 } 571 572 // Calculate how many positional values are _required_. 573 bool UnboundedFound = false; 574 for (size_t i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 575 i != e; ++i) { 576 Option *Opt = PositionalOpts[i]; 577 if (RequiresValue(Opt)) 578 ++NumPositionalRequired; 579 else if (ConsumeAfterOpt) { 580 // ConsumeAfter cannot be combined with "optional" positional options 581 // unless there is only one positional argument... 582 if (PositionalOpts.size() > 2) 583 ErrorParsing |= 584 Opt->error("error - this positional option will never be matched, " 585 "because it does not Require a value, and a " 586 "cl::ConsumeAfter option is active!"); 587 } else if (UnboundedFound && !Opt->ArgStr[0]) { 588 // This option does not "require" a value... Make sure this option is 589 // not specified after an option that eats all extra arguments, or this 590 // one will never get any! 591 // 592 ErrorParsing |= Opt->error("error - option can never match, because " 593 "another positional argument will match an " 594 "unbounded number of values, and this option" 595 " does not require a value!"); 596 } 597 UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 598 } 599 HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 600 } 601 602 // PositionalVals - A vector of "positional" arguments we accumulate into 603 // the process at the end. 604 // 605 SmallVector<std::pair<StringRef,unsigned>, 4> PositionalVals; 606 607 // If the program has named positional arguments, and the name has been run 608 // across, keep track of which positional argument was named. Otherwise put 609 // the positional args into the PositionalVals list... 610 Option *ActivePositionalArg = 0; 611 612 // Loop over all of the arguments... processing them. 613 bool DashDashFound = false; // Have we read '--'? 614 for (int i = 1; i < argc; ++i) { 615 Option *Handler = 0; 616 Option *NearestHandler = 0; 617 std::string NearestHandlerString; 618 StringRef Value; 619 StringRef ArgName = ""; 620 621 // If the option list changed, this means that some command line 622 // option has just been registered or deregistered. This can occur in 623 // response to things like -load, etc. If this happens, rescan the options. 624 if (OptionListChanged) { 625 PositionalOpts.clear(); 626 SinkOpts.clear(); 627 Opts.clear(); 628 GetOptionInfo(PositionalOpts, SinkOpts, Opts); 629 OptionListChanged = false; 630 } 631 632 // Check to see if this is a positional argument. This argument is 633 // considered to be positional if it doesn't start with '-', if it is "-" 634 // itself, or if we have seen "--" already. 635 // 636 if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 637 // Positional argument! 638 if (ActivePositionalArg) { 639 ProvidePositionalOption(ActivePositionalArg, argv[i], i); 640 continue; // We are done! 641 } 642 643 if (!PositionalOpts.empty()) { 644 PositionalVals.push_back(std::make_pair(argv[i],i)); 645 646 // All of the positional arguments have been fulfulled, give the rest to 647 // the consume after option... if it's specified... 648 // 649 if (PositionalVals.size() >= NumPositionalRequired && 650 ConsumeAfterOpt != 0) { 651 for (++i; i < argc; ++i) 652 PositionalVals.push_back(std::make_pair(argv[i],i)); 653 break; // Handle outside of the argument processing loop... 654 } 655 656 // Delay processing positional arguments until the end... 657 continue; 658 } 659 } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 660 !DashDashFound) { 661 DashDashFound = true; // This is the mythical "--"? 662 continue; // Don't try to process it as an argument itself. 663 } else if (ActivePositionalArg && 664 (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 665 // If there is a positional argument eating options, check to see if this 666 // option is another positional argument. If so, treat it as an argument, 667 // otherwise feed it to the eating positional. 668 ArgName = argv[i]+1; 669 // Eat leading dashes. 670 while (!ArgName.empty() && ArgName[0] == '-') 671 ArgName = ArgName.substr(1); 672 673 Handler = LookupOption(ArgName, Value, Opts); 674 if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 675 ProvidePositionalOption(ActivePositionalArg, argv[i], i); 676 continue; // We are done! 677 } 678 679 } else { // We start with a '-', must be an argument. 680 ArgName = argv[i]+1; 681 // Eat leading dashes. 682 while (!ArgName.empty() && ArgName[0] == '-') 683 ArgName = ArgName.substr(1); 684 685 Handler = LookupOption(ArgName, Value, Opts); 686 687 // Check to see if this "option" is really a prefixed or grouped argument. 688 if (Handler == 0) 689 Handler = HandlePrefixedOrGroupedOption(ArgName, Value, 690 ErrorParsing, Opts); 691 692 // Otherwise, look for the closest available option to report to the user 693 // in the upcoming error. 694 if (Handler == 0 && SinkOpts.empty()) 695 NearestHandler = LookupNearestOption(ArgName, Opts, 696 NearestHandlerString); 697 } 698 699 if (Handler == 0) { 700 if (SinkOpts.empty()) { 701 errs() << ProgramName << ": Unknown command line argument '" 702 << argv[i] << "'. Try: '" << argv[0] << " -help'\n"; 703 704 if (NearestHandler) { 705 // If we know a near match, report it as well. 706 errs() << ProgramName << ": Did you mean '-" 707 << NearestHandlerString << "'?\n"; 708 } 709 710 ErrorParsing = true; 711 } else { 712 for (SmallVectorImpl<Option*>::iterator I = SinkOpts.begin(), 713 E = SinkOpts.end(); I != E ; ++I) 714 (*I)->addOccurrence(i, "", argv[i]); 715 } 716 continue; 717 } 718 719 // If this is a named positional argument, just remember that it is the 720 // active one... 721 if (Handler->getFormattingFlag() == cl::Positional) 722 ActivePositionalArg = Handler; 723 else 724 ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 725 } 726 727 // Check and handle positional arguments now... 728 if (NumPositionalRequired > PositionalVals.size()) { 729 errs() << ProgramName 730 << ": Not enough positional command line arguments specified!\n" 731 << "Must specify at least " << NumPositionalRequired 732 << " positional arguments: See: " << argv[0] << " -help\n"; 733 734 ErrorParsing = true; 735 } else if (!HasUnlimitedPositionals && 736 PositionalVals.size() > PositionalOpts.size()) { 737 errs() << ProgramName 738 << ": Too many positional arguments specified!\n" 739 << "Can specify at most " << PositionalOpts.size() 740 << " positional arguments: See: " << argv[0] << " -help\n"; 741 ErrorParsing = true; 742 743 } else if (ConsumeAfterOpt == 0) { 744 // Positional args have already been handled if ConsumeAfter is specified. 745 unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); 746 for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 747 if (RequiresValue(PositionalOpts[i])) { 748 ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 749 PositionalVals[ValNo].second); 750 ValNo++; 751 --NumPositionalRequired; // We fulfilled our duty... 752 } 753 754 // If we _can_ give this option more arguments, do so now, as long as we 755 // do not give it values that others need. 'Done' controls whether the 756 // option even _WANTS_ any more. 757 // 758 bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 759 while (NumVals-ValNo > NumPositionalRequired && !Done) { 760 switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 761 case cl::Optional: 762 Done = true; // Optional arguments want _at most_ one value 763 // FALL THROUGH 764 case cl::ZeroOrMore: // Zero or more will take all they can get... 765 case cl::OneOrMore: // One or more will take all they can get... 766 ProvidePositionalOption(PositionalOpts[i], 767 PositionalVals[ValNo].first, 768 PositionalVals[ValNo].second); 769 ValNo++; 770 break; 771 default: 772 llvm_unreachable("Internal error, unexpected NumOccurrences flag in " 773 "positional argument processing!"); 774 } 775 } 776 } 777 } else { 778 assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 779 unsigned ValNo = 0; 780 for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) 781 if (RequiresValue(PositionalOpts[j])) { 782 ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 783 PositionalVals[ValNo].first, 784 PositionalVals[ValNo].second); 785 ValNo++; 786 } 787 788 // Handle the case where there is just one positional option, and it's 789 // optional. In this case, we want to give JUST THE FIRST option to the 790 // positional option and keep the rest for the consume after. The above 791 // loop would have assigned no values to positional options in this case. 792 // 793 if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { 794 ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 795 PositionalVals[ValNo].first, 796 PositionalVals[ValNo].second); 797 ValNo++; 798 } 799 800 // Handle over all of the rest of the arguments to the 801 // cl::ConsumeAfter command line option... 802 for (; ValNo != PositionalVals.size(); ++ValNo) 803 ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 804 PositionalVals[ValNo].first, 805 PositionalVals[ValNo].second); 806 } 807 808 // Loop over args and make sure all required args are specified! 809 for (StringMap<Option*>::iterator I = Opts.begin(), 810 E = Opts.end(); I != E; ++I) { 811 switch (I->second->getNumOccurrencesFlag()) { 812 case Required: 813 case OneOrMore: 814 if (I->second->getNumOccurrences() == 0) { 815 I->second->error("must be specified at least once!"); 816 ErrorParsing = true; 817 } 818 // Fall through 819 default: 820 break; 821 } 822 } 823 824 // Now that we know if -debug is specified, we can use it. 825 // Note that if ReadResponseFiles == true, this must be done before the 826 // memory allocated for the expanded command line is free()d below. 827 DEBUG(dbgs() << "Args: "; 828 for (int i = 0; i < argc; ++i) 829 dbgs() << argv[i] << ' '; 830 dbgs() << '\n'; 831 ); 832 833 // Free all of the memory allocated to the map. Command line options may only 834 // be processed once! 835 Opts.clear(); 836 PositionalOpts.clear(); 837 MoreHelp->clear(); 838 839 // Free the memory allocated by ExpandResponseFiles. 840 // Free all the strdup()ed strings. 841 for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 842 i != e; ++i) 843 free(*i); 844 845 // If we had an error processing our arguments, don't let the program execute 846 if (ErrorParsing) exit(1); 847 } 848 849 //===----------------------------------------------------------------------===// 850 // Option Base class implementation 851 // 852 853 bool Option::error(const Twine &Message, StringRef ArgName) { 854 if (ArgName.data() == 0) ArgName = ArgStr; 855 if (ArgName.empty()) 856 errs() << HelpStr; // Be nice for positional arguments 857 else 858 errs() << ProgramName << ": for the -" << ArgName; 859 860 errs() << " option: " << Message << "\n"; 861 return true; 862 } 863 864 bool Option::addOccurrence(unsigned pos, StringRef ArgName, 865 StringRef Value, bool MultiArg) { 866 if (!MultiArg) 867 NumOccurrences++; // Increment the number of times we have been seen 868 869 switch (getNumOccurrencesFlag()) { 870 case Optional: 871 if (NumOccurrences > 1) 872 return error("may only occur zero or one times!", ArgName); 873 break; 874 case Required: 875 if (NumOccurrences > 1) 876 return error("must occur exactly one time!", ArgName); 877 // Fall through 878 case OneOrMore: 879 case ZeroOrMore: 880 case ConsumeAfter: break; 881 } 882 883 return handleOccurrence(pos, ArgName, Value); 884 } 885 886 887 // getValueStr - Get the value description string, using "DefaultMsg" if nothing 888 // has been specified yet. 889 // 890 static const char *getValueStr(const Option &O, const char *DefaultMsg) { 891 if (O.ValueStr[0] == 0) return DefaultMsg; 892 return O.ValueStr; 893 } 894 895 //===----------------------------------------------------------------------===// 896 // cl::alias class implementation 897 // 898 899 // Return the width of the option tag for printing... 900 size_t alias::getOptionWidth() const { 901 return std::strlen(ArgStr)+6; 902 } 903 904 // Print out the option for the alias. 905 void alias::printOptionInfo(size_t GlobalWidth) const { 906 size_t L = std::strlen(ArgStr); 907 outs() << " -" << ArgStr; 908 outs().indent(GlobalWidth-L-6) << " - " << HelpStr << "\n"; 909 } 910 911 //===----------------------------------------------------------------------===// 912 // Parser Implementation code... 913 // 914 915 // basic_parser implementation 916 // 917 918 // Return the width of the option tag for printing... 919 size_t basic_parser_impl::getOptionWidth(const Option &O) const { 920 size_t Len = std::strlen(O.ArgStr); 921 if (const char *ValName = getValueName()) 922 Len += std::strlen(getValueStr(O, ValName))+3; 923 924 return Len + 6; 925 } 926 927 // printOptionInfo - Print out information about this option. The 928 // to-be-maintained width is specified. 929 // 930 void basic_parser_impl::printOptionInfo(const Option &O, 931 size_t GlobalWidth) const { 932 outs() << " -" << O.ArgStr; 933 934 if (const char *ValName = getValueName()) 935 outs() << "=<" << getValueStr(O, ValName) << '>'; 936 937 outs().indent(GlobalWidth-getOptionWidth(O)) << " - " << O.HelpStr << '\n'; 938 } 939 940 void basic_parser_impl::printOptionName(const Option &O, 941 size_t GlobalWidth) const { 942 outs() << " -" << O.ArgStr; 943 outs().indent(GlobalWidth-std::strlen(O.ArgStr)); 944 } 945 946 947 // parser<bool> implementation 948 // 949 bool parser<bool>::parse(Option &O, StringRef ArgName, 950 StringRef Arg, bool &Value) { 951 if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 952 Arg == "1") { 953 Value = true; 954 return false; 955 } 956 957 if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 958 Value = false; 959 return false; 960 } 961 return O.error("'" + Arg + 962 "' is invalid value for boolean argument! Try 0 or 1"); 963 } 964 965 // parser<boolOrDefault> implementation 966 // 967 bool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, 968 StringRef Arg, boolOrDefault &Value) { 969 if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 970 Arg == "1") { 971 Value = BOU_TRUE; 972 return false; 973 } 974 if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 975 Value = BOU_FALSE; 976 return false; 977 } 978 979 return O.error("'" + Arg + 980 "' is invalid value for boolean argument! Try 0 or 1"); 981 } 982 983 // parser<int> implementation 984 // 985 bool parser<int>::parse(Option &O, StringRef ArgName, 986 StringRef Arg, int &Value) { 987 if (Arg.getAsInteger(0, Value)) 988 return O.error("'" + Arg + "' value invalid for integer argument!"); 989 return false; 990 } 991 992 // parser<unsigned> implementation 993 // 994 bool parser<unsigned>::parse(Option &O, StringRef ArgName, 995 StringRef Arg, unsigned &Value) { 996 997 if (Arg.getAsInteger(0, Value)) 998 return O.error("'" + Arg + "' value invalid for uint argument!"); 999 return false; 1000 } 1001 1002 // parser<unsigned long long> implementation 1003 // 1004 bool parser<unsigned long long>::parse(Option &O, StringRef ArgName, 1005 StringRef Arg, unsigned long long &Value){ 1006 1007 if (Arg.getAsInteger(0, Value)) 1008 return O.error("'" + Arg + "' value invalid for uint argument!"); 1009 return false; 1010 } 1011 1012 // parser<double>/parser<float> implementation 1013 // 1014 static bool parseDouble(Option &O, StringRef Arg, double &Value) { 1015 SmallString<32> TmpStr(Arg.begin(), Arg.end()); 1016 const char *ArgStart = TmpStr.c_str(); 1017 char *End; 1018 Value = strtod(ArgStart, &End); 1019 if (*End != 0) 1020 return O.error("'" + Arg + "' value invalid for floating point argument!"); 1021 return false; 1022 } 1023 1024 bool parser<double>::parse(Option &O, StringRef ArgName, 1025 StringRef Arg, double &Val) { 1026 return parseDouble(O, Arg, Val); 1027 } 1028 1029 bool parser<float>::parse(Option &O, StringRef ArgName, 1030 StringRef Arg, float &Val) { 1031 double dVal; 1032 if (parseDouble(O, Arg, dVal)) 1033 return true; 1034 Val = (float)dVal; 1035 return false; 1036 } 1037 1038 1039 1040 // generic_parser_base implementation 1041 // 1042 1043 // findOption - Return the option number corresponding to the specified 1044 // argument string. If the option is not found, getNumOptions() is returned. 1045 // 1046 unsigned generic_parser_base::findOption(const char *Name) { 1047 unsigned e = getNumOptions(); 1048 1049 for (unsigned i = 0; i != e; ++i) { 1050 if (strcmp(getOption(i), Name) == 0) 1051 return i; 1052 } 1053 return e; 1054 } 1055 1056 1057 // Return the width of the option tag for printing... 1058 size_t generic_parser_base::getOptionWidth(const Option &O) const { 1059 if (O.hasArgStr()) { 1060 size_t Size = std::strlen(O.ArgStr)+6; 1061 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 1062 Size = std::max(Size, std::strlen(getOption(i))+8); 1063 return Size; 1064 } else { 1065 size_t BaseSize = 0; 1066 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 1067 BaseSize = std::max(BaseSize, std::strlen(getOption(i))+8); 1068 return BaseSize; 1069 } 1070 } 1071 1072 // printOptionInfo - Print out information about this option. The 1073 // to-be-maintained width is specified. 1074 // 1075 void generic_parser_base::printOptionInfo(const Option &O, 1076 size_t GlobalWidth) const { 1077 if (O.hasArgStr()) { 1078 size_t L = std::strlen(O.ArgStr); 1079 outs() << " -" << O.ArgStr; 1080 outs().indent(GlobalWidth-L-6) << " - " << O.HelpStr << '\n'; 1081 1082 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 1083 size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; 1084 outs() << " =" << getOption(i); 1085 outs().indent(NumSpaces) << " - " << getDescription(i) << '\n'; 1086 } 1087 } else { 1088 if (O.HelpStr[0]) 1089 outs() << " " << O.HelpStr << '\n'; 1090 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 1091 size_t L = std::strlen(getOption(i)); 1092 outs() << " -" << getOption(i); 1093 outs().indent(GlobalWidth-L-8) << " - " << getDescription(i) << '\n'; 1094 } 1095 } 1096 } 1097 1098 static const size_t MaxOptWidth = 8; // arbitrary spacing for printOptionDiff 1099 1100 // printGenericOptionDiff - Print the value of this option and it's default. 1101 // 1102 // "Generic" options have each value mapped to a name. 1103 void generic_parser_base:: 1104 printGenericOptionDiff(const Option &O, const GenericOptionValue &Value, 1105 const GenericOptionValue &Default, 1106 size_t GlobalWidth) const { 1107 outs() << " -" << O.ArgStr; 1108 outs().indent(GlobalWidth-std::strlen(O.ArgStr)); 1109 1110 unsigned NumOpts = getNumOptions(); 1111 for (unsigned i = 0; i != NumOpts; ++i) { 1112 if (Value.compare(getOptionValue(i))) 1113 continue; 1114 1115 outs() << "= " << getOption(i); 1116 size_t L = std::strlen(getOption(i)); 1117 size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0; 1118 outs().indent(NumSpaces) << " (default: "; 1119 for (unsigned j = 0; j != NumOpts; ++j) { 1120 if (Default.compare(getOptionValue(j))) 1121 continue; 1122 outs() << getOption(j); 1123 break; 1124 } 1125 outs() << ")\n"; 1126 return; 1127 } 1128 outs() << "= *unknown option value*\n"; 1129 } 1130 1131 // printOptionDiff - Specializations for printing basic value types. 1132 // 1133 #define PRINT_OPT_DIFF(T) \ 1134 void parser<T>:: \ 1135 printOptionDiff(const Option &O, T V, OptionValue<T> D, \ 1136 size_t GlobalWidth) const { \ 1137 printOptionName(O, GlobalWidth); \ 1138 std::string Str; \ 1139 { \ 1140 raw_string_ostream SS(Str); \ 1141 SS << V; \ 1142 } \ 1143 outs() << "= " << Str; \ 1144 size_t NumSpaces = MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0;\ 1145 outs().indent(NumSpaces) << " (default: "; \ 1146 if (D.hasValue()) \ 1147 outs() << D.getValue(); \ 1148 else \ 1149 outs() << "*no default*"; \ 1150 outs() << ")\n"; \ 1151 } \ 1152 1153 PRINT_OPT_DIFF(bool) 1154 PRINT_OPT_DIFF(boolOrDefault) 1155 PRINT_OPT_DIFF(int) 1156 PRINT_OPT_DIFF(unsigned) 1157 PRINT_OPT_DIFF(unsigned long long) 1158 PRINT_OPT_DIFF(double) 1159 PRINT_OPT_DIFF(float) 1160 PRINT_OPT_DIFF(char) 1161 1162 void parser<std::string>:: 1163 printOptionDiff(const Option &O, StringRef V, OptionValue<std::string> D, 1164 size_t GlobalWidth) const { 1165 printOptionName(O, GlobalWidth); 1166 outs() << "= " << V; 1167 size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0; 1168 outs().indent(NumSpaces) << " (default: "; 1169 if (D.hasValue()) 1170 outs() << D.getValue(); 1171 else 1172 outs() << "*no default*"; 1173 outs() << ")\n"; 1174 } 1175 1176 // Print a placeholder for options that don't yet support printOptionDiff(). 1177 void basic_parser_impl:: 1178 printOptionNoValue(const Option &O, size_t GlobalWidth) const { 1179 printOptionName(O, GlobalWidth); 1180 outs() << "= *cannot print option value*\n"; 1181 } 1182 1183 //===----------------------------------------------------------------------===// 1184 // -help and -help-hidden option implementation 1185 // 1186 1187 static int OptNameCompare(const void *LHS, const void *RHS) { 1188 typedef std::pair<const char *, Option*> pair_ty; 1189 1190 return strcmp(((const pair_ty*)LHS)->first, ((const pair_ty*)RHS)->first); 1191 } 1192 1193 // Copy Options into a vector so we can sort them as we like. 1194 static void 1195 sortOpts(StringMap<Option*> &OptMap, 1196 SmallVectorImpl< std::pair<const char *, Option*> > &Opts, 1197 bool ShowHidden) { 1198 SmallPtrSet<Option*, 128> OptionSet; // Duplicate option detection. 1199 1200 for (StringMap<Option*>::iterator I = OptMap.begin(), E = OptMap.end(); 1201 I != E; ++I) { 1202 // Ignore really-hidden options. 1203 if (I->second->getOptionHiddenFlag() == ReallyHidden) 1204 continue; 1205 1206 // Unless showhidden is set, ignore hidden flags. 1207 if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden) 1208 continue; 1209 1210 // If we've already seen this option, don't add it to the list again. 1211 if (!OptionSet.insert(I->second)) 1212 continue; 1213 1214 Opts.push_back(std::pair<const char *, Option*>(I->getKey().data(), 1215 I->second)); 1216 } 1217 1218 // Sort the options list alphabetically. 1219 qsort(Opts.data(), Opts.size(), sizeof(Opts[0]), OptNameCompare); 1220 } 1221 1222 namespace { 1223 1224 class HelpPrinter { 1225 const bool ShowHidden; 1226 1227 public: 1228 explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {} 1229 1230 void operator=(bool Value) { 1231 if (Value == false) return; 1232 1233 // Get all the options. 1234 SmallVector<Option*, 4> PositionalOpts; 1235 SmallVector<Option*, 4> SinkOpts; 1236 StringMap<Option*> OptMap; 1237 GetOptionInfo(PositionalOpts, SinkOpts, OptMap); 1238 1239 SmallVector<std::pair<const char *, Option*>, 128> Opts; 1240 sortOpts(OptMap, Opts, ShowHidden); 1241 1242 if (ProgramOverview) 1243 outs() << "OVERVIEW: " << ProgramOverview << "\n"; 1244 1245 outs() << "USAGE: " << ProgramName << " [options]"; 1246 1247 // Print out the positional options. 1248 Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 1249 if (!PositionalOpts.empty() && 1250 PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 1251 CAOpt = PositionalOpts[0]; 1252 1253 for (size_t i = CAOpt != 0, e = PositionalOpts.size(); i != e; ++i) { 1254 if (PositionalOpts[i]->ArgStr[0]) 1255 outs() << " --" << PositionalOpts[i]->ArgStr; 1256 outs() << " " << PositionalOpts[i]->HelpStr; 1257 } 1258 1259 // Print the consume after option info if it exists... 1260 if (CAOpt) outs() << " " << CAOpt->HelpStr; 1261 1262 outs() << "\n\n"; 1263 1264 // Compute the maximum argument length... 1265 size_t MaxArgLen = 0; 1266 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1267 MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1268 1269 outs() << "OPTIONS:\n"; 1270 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1271 Opts[i].second->printOptionInfo(MaxArgLen); 1272 1273 // Print any extra help the user has declared. 1274 for (std::vector<const char *>::iterator I = MoreHelp->begin(), 1275 E = MoreHelp->end(); I != E; ++I) 1276 outs() << *I; 1277 MoreHelp->clear(); 1278 1279 // Halt the program since help information was printed 1280 exit(1); 1281 } 1282 }; 1283 } // End anonymous namespace 1284 1285 // Define the two HelpPrinter instances that are used to print out help, or 1286 // help-hidden... 1287 // 1288 static HelpPrinter NormalPrinter(false); 1289 static HelpPrinter HiddenPrinter(true); 1290 1291 static cl::opt<HelpPrinter, true, parser<bool> > 1292 HOp("help", cl::desc("Display available options (-help-hidden for more)"), 1293 cl::location(NormalPrinter), cl::ValueDisallowed); 1294 1295 static cl::opt<HelpPrinter, true, parser<bool> > 1296 HHOp("help-hidden", cl::desc("Display all available options"), 1297 cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 1298 1299 static cl::opt<bool> 1300 PrintOptions("print-options", 1301 cl::desc("Print non-default options after command line parsing"), 1302 cl::Hidden, cl::init(false)); 1303 1304 static cl::opt<bool> 1305 PrintAllOptions("print-all-options", 1306 cl::desc("Print all option values after command line parsing"), 1307 cl::Hidden, cl::init(false)); 1308 1309 // Print the value of each option. 1310 void cl::PrintOptionValues() { 1311 if (!PrintOptions && !PrintAllOptions) return; 1312 1313 // Get all the options. 1314 SmallVector<Option*, 4> PositionalOpts; 1315 SmallVector<Option*, 4> SinkOpts; 1316 StringMap<Option*> OptMap; 1317 GetOptionInfo(PositionalOpts, SinkOpts, OptMap); 1318 1319 SmallVector<std::pair<const char *, Option*>, 128> Opts; 1320 sortOpts(OptMap, Opts, /*ShowHidden*/true); 1321 1322 // Compute the maximum argument length... 1323 size_t MaxArgLen = 0; 1324 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1325 MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1326 1327 for (size_t i = 0, e = Opts.size(); i != e; ++i) 1328 Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions); 1329 } 1330 1331 static void (*OverrideVersionPrinter)() = 0; 1332 1333 static std::vector<void (*)()>* ExtraVersionPrinters = 0; 1334 1335 namespace { 1336 class VersionPrinter { 1337 public: 1338 void print() { 1339 raw_ostream &OS = outs(); 1340 OS << "LLVM (http://llvm.org/):\n" 1341 << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; 1342 #ifdef LLVM_VERSION_INFO 1343 OS << LLVM_VERSION_INFO; 1344 #endif 1345 OS << "\n "; 1346 #ifndef __OPTIMIZE__ 1347 OS << "DEBUG build"; 1348 #else 1349 OS << "Optimized build"; 1350 #endif 1351 #ifndef NDEBUG 1352 OS << " with assertions"; 1353 #endif 1354 std::string CPU = sys::getHostCPUName(); 1355 if (CPU == "generic") CPU = "(unknown)"; 1356 OS << ".\n" 1357 #if (ENABLE_TIMESTAMPS == 1) 1358 << " Built " << __DATE__ << " (" << __TIME__ << ").\n" 1359 #endif 1360 << " Default target: " << sys::getDefaultTargetTriple() << '\n' 1361 << " Host CPU: " << CPU << '\n'; 1362 } 1363 void operator=(bool OptionWasSpecified) { 1364 if (!OptionWasSpecified) return; 1365 1366 if (OverrideVersionPrinter != 0) { 1367 (*OverrideVersionPrinter)(); 1368 exit(1); 1369 } 1370 print(); 1371 1372 // Iterate over any registered extra printers and call them to add further 1373 // information. 1374 if (ExtraVersionPrinters != 0) { 1375 outs() << '\n'; 1376 for (std::vector<void (*)()>::iterator I = ExtraVersionPrinters->begin(), 1377 E = ExtraVersionPrinters->end(); 1378 I != E; ++I) 1379 (*I)(); 1380 } 1381 1382 exit(1); 1383 } 1384 }; 1385 } // End anonymous namespace 1386 1387 1388 // Define the --version option that prints out the LLVM version for the tool 1389 static VersionPrinter VersionPrinterInstance; 1390 1391 static cl::opt<VersionPrinter, true, parser<bool> > 1392 VersOp("version", cl::desc("Display the version of this program"), 1393 cl::location(VersionPrinterInstance), cl::ValueDisallowed); 1394 1395 // Utility function for printing the help message. 1396 void cl::PrintHelpMessage() { 1397 // This looks weird, but it actually prints the help message. The 1398 // NormalPrinter variable is a HelpPrinter and the help gets printed when 1399 // its operator= is invoked. That's because the "normal" usages of the 1400 // help printer is to be assigned true/false depending on whether the 1401 // -help option was given or not. Since we're circumventing that we have 1402 // to make it look like -help was given, so we assign true. 1403 NormalPrinter = true; 1404 } 1405 1406 /// Utility function for printing version number. 1407 void cl::PrintVersionMessage() { 1408 VersionPrinterInstance.print(); 1409 } 1410 1411 void cl::SetVersionPrinter(void (*func)()) { 1412 OverrideVersionPrinter = func; 1413 } 1414 1415 void cl::AddExtraVersionPrinter(void (*func)()) { 1416 if (ExtraVersionPrinters == 0) 1417 ExtraVersionPrinters = new std::vector<void (*)()>; 1418 1419 ExtraVersionPrinters->push_back(func); 1420 } 1421