CommandLine.cpp revision 249423
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> 36using namespace llvm; 37using namespace cl; 38 39//===----------------------------------------------------------------------===// 40// Template instantiations and anchors. 41// 42namespace llvm { namespace cl { 43TEMPLATE_INSTANTIATION(class basic_parser<bool>); 44TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>); 45TEMPLATE_INSTANTIATION(class basic_parser<int>); 46TEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 47TEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>); 48TEMPLATE_INSTANTIATION(class basic_parser<double>); 49TEMPLATE_INSTANTIATION(class basic_parser<float>); 50TEMPLATE_INSTANTIATION(class basic_parser<std::string>); 51TEMPLATE_INSTANTIATION(class basic_parser<char>); 52 53TEMPLATE_INSTANTIATION(class opt<unsigned>); 54TEMPLATE_INSTANTIATION(class opt<int>); 55TEMPLATE_INSTANTIATION(class opt<std::string>); 56TEMPLATE_INSTANTIATION(class opt<char>); 57TEMPLATE_INSTANTIATION(class opt<bool>); 58} } // end namespace llvm::cl 59 60void GenericOptionValue::anchor() {} 61void OptionValue<boolOrDefault>::anchor() {} 62void OptionValue<std::string>::anchor() {} 63void Option::anchor() {} 64void basic_parser_impl::anchor() {} 65void parser<bool>::anchor() {} 66void parser<boolOrDefault>::anchor() {} 67void parser<int>::anchor() {} 68void parser<unsigned>::anchor() {} 69void parser<unsigned long long>::anchor() {} 70void parser<double>::anchor() {} 71void parser<float>::anchor() {} 72void parser<std::string>::anchor() {} 73void 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. 79static char ProgramName[80] = "<premain>"; 80static const char *ProgramOverview = 0; 81 82// This collects additional help to be printed. 83static ManagedStatic<std::vector<const char*> > MoreHelp; 84 85extrahelp::extrahelp(const char *Help) 86 : morehelp(Help) { 87 MoreHelp->push_back(Help); 88} 89 90static bool OptionListChanged = false; 91 92// MarkOptionsChanged - Internal helper function. 93void cl::MarkOptionsChanged() { 94 OptionListChanged = true; 95} 96 97/// RegisteredOptionList - This is the list of the command line options that 98/// have statically constructed themselves. 99static Option *RegisteredOptionList = 0; 100 101void 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. 116static 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. 162static 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. 191static 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. 235static 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=). 268static 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 324static 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... 331static inline bool isGrouping(const Option *O) { 332 return O->getFormattingFlag() == cl::Grouping; 333} 334static 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// 344static 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. 369static 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 416static bool RequiresValue(const Option *O) { 417 return O->getNumOccurrencesFlag() == cl::Required || 418 O->getNumOccurrencesFlag() == cl::OneOrMore; 419} 420 421static 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/// 432static 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/// 466void 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. 498static 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 531void 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 853bool 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 864bool 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// 890static 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... 900size_t alias::getOptionWidth() const { 901 return std::strlen(ArgStr)+6; 902} 903 904// Print out the option for the alias. 905void 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... 919size_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// 930void 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 940void 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// 949bool 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// 967bool 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// 985bool 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// 994bool 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// 1004bool 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// 1014static 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 1024bool parser<double>::parse(Option &O, StringRef ArgName, 1025 StringRef Arg, double &Val) { 1026 return parseDouble(O, Arg, Val); 1027} 1028 1029bool 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// 1046unsigned 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... 1058size_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// 1075void 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 1098static 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. 1103void generic_parser_base:: 1104printGenericOptionDiff(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 1153PRINT_OPT_DIFF(bool) 1154PRINT_OPT_DIFF(boolOrDefault) 1155PRINT_OPT_DIFF(int) 1156PRINT_OPT_DIFF(unsigned) 1157PRINT_OPT_DIFF(unsigned long long) 1158PRINT_OPT_DIFF(double) 1159PRINT_OPT_DIFF(float) 1160PRINT_OPT_DIFF(char) 1161 1162void parser<std::string>:: 1163printOptionDiff(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(). 1177void basic_parser_impl:: 1178printOptionNoValue(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 1187static 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. 1194static void 1195sortOpts(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 1222namespace { 1223 1224class HelpPrinter { 1225 const bool ShowHidden; 1226 1227public: 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// 1288static HelpPrinter NormalPrinter(false); 1289static HelpPrinter HiddenPrinter(true); 1290 1291static cl::opt<HelpPrinter, true, parser<bool> > 1292HOp("help", cl::desc("Display available options (-help-hidden for more)"), 1293 cl::location(NormalPrinter), cl::ValueDisallowed); 1294 1295static cl::opt<HelpPrinter, true, parser<bool> > 1296HHOp("help-hidden", cl::desc("Display all available options"), 1297 cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 1298 1299static cl::opt<bool> 1300PrintOptions("print-options", 1301 cl::desc("Print non-default options after command line parsing"), 1302 cl::Hidden, cl::init(false)); 1303 1304static cl::opt<bool> 1305PrintAllOptions("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. 1310void 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 1331static void (*OverrideVersionPrinter)() = 0; 1332 1333static std::vector<void (*)()>* ExtraVersionPrinters = 0; 1334 1335namespace { 1336class VersionPrinter { 1337public: 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 1389static VersionPrinter VersionPrinterInstance; 1390 1391static cl::opt<VersionPrinter, true, parser<bool> > 1392VersOp("version", cl::desc("Display the version of this program"), 1393 cl::location(VersionPrinterInstance), cl::ValueDisallowed); 1394 1395// Utility function for printing the help message. 1396void 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. 1407void cl::PrintVersionMessage() { 1408 VersionPrinterInstance.print(); 1409} 1410 1411void cl::SetVersionPrinter(void (*func)()) { 1412 OverrideVersionPrinter = func; 1413} 1414 1415void cl::AddExtraVersionPrinter(void (*func)()) { 1416 if (ExtraVersionPrinters == 0) 1417 ExtraVersionPrinters = new std::vector<void (*)()>; 1418 1419 ExtraVersionPrinters->push_back(func); 1420} 1421