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