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