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