CommandLine.cpp revision 06b06c5f00acffdab8c59e3dc5baca3eacca172a
1dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===-- CommandLine.cpp - Command line parser implementation --------------===// 2dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 3dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// This class implements a command line argument processor that is useful when 4dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// creating a tool. It provides a simple, minimalistic interface that is easily 5dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// extensible and supports nonlocal (library) command line options. 6dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 703fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// Note that rather than trying to figure out what this code does, you could try 803fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// reading the library documentation located in docs/CommandLine.html 903fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// 10dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 11dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 12cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/CommandLine.h" 13dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <algorithm> 14dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <map> 15dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <set> 16697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner#include <iostream> 177f1576f0424542d6162c1cedc14629e4cbc3e80aChris Lattner 18dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 19dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 20331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 21331de23705a719514e37c211f327379688f81b0dChris Lattner// Basic, shared command line option processing machinery... 22331de23705a719514e37c211f327379688f81b0dChris Lattner// 23331de23705a719514e37c211f327379688f81b0dChris Lattner 24dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the global command line option vector. Making it a function scoped 25f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// static ensures that it will be initialized correctly before its first use. 26dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 27ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::map<std::string, Option*> *CommandLineOptions = 0; 28ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::map<std::string, Option*> &getOpts() { 29ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner if (CommandLineOptions == 0) 30ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner CommandLineOptions = new std::map<std::string,Option*>(); 31e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return *CommandLineOptions; 32e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 33e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 34ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic Option *getOption(const std::string &Str) { 35e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (CommandLineOptions == 0) return 0; 36ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string,Option*>::iterator I = CommandLineOptions->find(Str); 37e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return I != CommandLineOptions->end() ? I->second : 0; 38dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 39dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 40ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::vector<Option*> &getPositionalOpts() { 41ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner static std::vector<Option*> Positional; 42331de23705a719514e37c211f327379688f81b0dChris Lattner return Positional; 43331de23705a719514e37c211f327379688f81b0dChris Lattner} 44331de23705a719514e37c211f327379688f81b0dChris Lattner 45e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void AddArgument(const char *ArgName, Option *Opt) { 46e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (getOption(ArgName)) { 47ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "CommandLine Error: Argument '" << ArgName 48ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << "' defined more than once!\n"; 49dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 50f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner // Add argument to the argument map! 51e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner getOpts()[ArgName] = Opt; 52e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 53e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 54e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 55e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// RemoveArgument - It's possible that the argument is no longer in the map if 56e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// options have already been processed and the map has been deleted! 57e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// 58e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void RemoveArgument(const char *ArgName, Option *Opt) { 59e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (CommandLineOptions == 0) return; 60e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner assert(getOption(ArgName) == Opt && "Arg not in map!"); 61e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner CommandLineOptions->erase(ArgName); 62e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (CommandLineOptions->empty()) { 63e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner delete CommandLineOptions; 64e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner CommandLineOptions = 0; 65dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 66dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 67dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 68dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerstatic const char *ProgramName = 0; 69dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerstatic const char *ProgramOverview = 0; 70dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 71caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattnerstatic inline bool ProvideOption(Option *Handler, const char *ArgName, 72caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner const char *Value, int argc, char **argv, 73caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner int &i) { 74caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 75caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 76caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 77caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (Value == 0 || *Value == 0) { // No value specified? 78caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (i+1 < argc) { // Steal the next argument, like for '-o filename' 79caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner Value = argv[++i]; 80caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } else { 81caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner return Handler->error(" requires a value!"); 82caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 83caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 84caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 85caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 86caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (*Value != 0) 87caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner return Handler->error(" does not allow a value! '" + 88ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string(Value) + "' specified."); 89caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 90caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueOptional: break; 91ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner default: std::cerr << "Bad ValueMask flag! CommandLine usage error:" 92ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << Handler->getValueExpectedFlag() << "\n"; abort(); 93caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 94caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 95caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Run the handler now! 96dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return Handler->addOccurrence(ArgName, Value); 97caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 98caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 999cf3d4770230238f2f395514bf04e0e64352d261Chris Lattnerstatic bool ProvidePositionalOption(Option *Handler, const std::string &Arg) { 100331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 1019cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy); 102331de23705a719514e37c211f327379688f81b0dChris Lattner} 103331de23705a719514e37c211f327379688f81b0dChris Lattner 104331de23705a719514e37c211f327379688f81b0dChris Lattner 105331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 106331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 107331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 108331de23705a719514e37c211f327379688f81b0dChris Lattner} 109331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 110331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 111331de23705a719514e37c211f327379688f81b0dChris Lattner} 112331de23705a719514e37c211f327379688f81b0dChris Lattner 113331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 114331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 115331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 116331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 117331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 118f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 119331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic Option *getOptionPred(std::string Name, unsigned &Length, 120331de23705a719514e37c211f327379688f81b0dChris Lattner bool (*Pred)(const Option*)) { 121331de23705a719514e37c211f327379688f81b0dChris Lattner 122e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Option *Op = getOption(Name); 123e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 124331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 125e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; 126331de23705a719514e37c211f327379688f81b0dChris Lattner } 127f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 128331de23705a719514e37c211f327379688f81b0dChris Lattner if (Name.size() == 1) return 0; 129331de23705a719514e37c211f327379688f81b0dChris Lattner do { 130331de23705a719514e37c211f327379688f81b0dChris Lattner Name.erase(Name.end()-1, Name.end()); // Chop off the last character... 131e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Op = getOption(Name); 132331de23705a719514e37c211f327379688f81b0dChris Lattner 133331de23705a719514e37c211f327379688f81b0dChris Lattner // Loop while we haven't found an option and Name still has at least two 134331de23705a719514e37c211f327379688f81b0dChris Lattner // characters in it (so that the next iteration will not be the empty 135331de23705a719514e37c211f327379688f81b0dChris Lattner // string... 136e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } while ((Op == 0 || !Pred(Op)) && Name.size() > 1); 137331de23705a719514e37c211f327379688f81b0dChris Lattner 138e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 139331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 140e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; // Found one! 141f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 142331de23705a719514e37c211f327379688f81b0dChris Lattner return 0; // No option found! 143331de23705a719514e37c211f327379688f81b0dChris Lattner} 144f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 145331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 146dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 147dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 148331de23705a719514e37c211f327379688f81b0dChris Lattner} 149331de23705a719514e37c211f327379688f81b0dChris Lattner 150331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 151dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 152dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 153f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 154caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 15506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseStringVector - Break INPUT up wherever one or more characters 15606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from DELIMS are found, and store the resulting tokens in OUTPUT. 15706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 15806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaekestatic void ParseStringVector (std::vector<std::string> &output, 15906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string &input, const char *delims) { 16006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string work (input); 16106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke int pos = work.find_first_not_of (delims); 16206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke if (pos == -1) return; 16306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (pos); 16406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 16506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke while (!work.empty() && pos != -1) { 16606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke if (pos == -1) break; 16706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke output.push_back (work.substr (0,pos)); 16806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke int nextpos = work.find_first_not_of (delims, pos + 1); 16906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke if (nextpos != -1) { 17006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (work.find_first_not_of (delims, pos + 1)); 17106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 17206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } else { 17306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = ""; 17406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = -1; 17506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 17606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 17706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke if (!work.empty ()) { 17806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke output.push_back (work); 17906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 18006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 18106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 18206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseCStringVector - Same effect as ParseStringVector, but the 18306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// resulting output vector contains dynamically-allocated pointers to 18406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// char, instead of standard C++ strings. 18506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 18606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaekestatic void ParseCStringVector (std::vector<char *> &output, 18706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string &input, const char *delims) { 18806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::vector<std::string> work; 18906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke ParseStringVector (work, input, delims); 19006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke for (std::vector<std::string>::iterator i = work.begin(), e = work.end(); 19106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke i != e; ++i) { 19206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke output.push_back (strdup (i->c_str ())); 19306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 19406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 19506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 19606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 19706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 19806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 19906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 20006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 20106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaekevoid cl::ParseEnvironmentOptions (char *progName, char *envvar, 20206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke const char *Overview) { 20306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get program's "name", which we wouldn't know without the caller 20406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // telling us. 20506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke assert (progName && "Program name not specified"); 20606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke static std::vector<char *> newargv; // Maybe making it "static" is a hack. 20706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke int newargc; 20806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke newargv.push_back (progName); 20906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 21006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 21106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke assert (envvar && "Environment variable name missing"); 21206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke char *envvalue = getenv (envvar); 21306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke if (envvalue == NULL) { 21406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Env var not set --> act like there are no more command line 21506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // arguments. 21606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke newargc = newargv.size (); 21706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke ParseCommandLineOptions (newargc, &newargv[0], Overview); 21806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 21906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 22006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string envvaluestr (envvalue); 22106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 22206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 22306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 22406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke ParseCStringVector (newargv, envvaluestr, " \v\f\t\r\n"); 22506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke newargc = newargv.size (); 22606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke ParseCommandLineOptions (newargc, &newargv[0], Overview); 22706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 22806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 229dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnervoid cl::ParseCommandLineOptions(int &argc, char **argv, 2300c0edf8afc35a42b15a24ebb5fa5f3fc674290aeChris Lattner const char *Overview) { 231331de23705a719514e37c211f327379688f81b0dChris Lattner assert((!getOpts().empty() || !getPositionalOpts().empty()) && 232331de23705a719514e37c211f327379688f81b0dChris Lattner "No options specified, or ParseCommandLineOptions called more" 233331de23705a719514e37c211f327379688f81b0dChris Lattner " than once!"); 234dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramName = argv[0]; // Save this away safe and snug 235dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 236dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 237dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 238ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string, Option*> &Opts = getOpts(); 239ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PositionalOpts = getPositionalOpts(); 240331de23705a719514e37c211f327379688f81b0dChris Lattner 241331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 242331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 243331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 244331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 245dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 246331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 247331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 248331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 249331de23705a719514e37c211f327379688f81b0dChris Lattner } 250331de23705a719514e37c211f327379688f81b0dChris Lattner 251331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 252331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 253331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 254331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 255331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 256331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 257331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 258331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 259331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 26054ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 26154ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 26254ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 26354ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner Opt->error(" error - this positional option will never be matched, " 26454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 26554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 2669cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 2679cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 2689cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 2699cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 270331de23705a719514e37c211f327379688f81b0dChris Lattner // 271331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= Opt->error(" error - option can never match, because " 272331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 273331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 274331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 275331de23705a719514e37c211f327379688f81b0dChris Lattner } 276331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 277331de23705a719514e37c211f327379688f81b0dChris Lattner } 278331de23705a719514e37c211f327379688f81b0dChris Lattner } 279331de23705a719514e37c211f327379688f81b0dChris Lattner 280331de23705a719514e37c211f327379688f81b0dChris Lattner // PositionalVals - A vector of "positional" arguments we accumulate into to 281331de23705a719514e37c211f327379688f81b0dChris Lattner // processes at the end... 282331de23705a719514e37c211f327379688f81b0dChris Lattner // 283ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<std::string> PositionalVals; 284331de23705a719514e37c211f327379688f81b0dChris Lattner 2859cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 2869cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 2879cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 2889cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 2899cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 290dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 291331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 292dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 293dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 294dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *Value = ""; 295dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgName = ""; 296331de23705a719514e37c211f327379688f81b0dChris Lattner 297331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 298331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 2991115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 300331de23705a719514e37c211f327379688f81b0dChris Lattner // 301331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 302331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 3039cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 3049cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ProvidePositionalOption(ActivePositionalArg, argv[i]); 3059cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 3069cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (!PositionalOpts.empty()) { 307331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals.push_back(argv[i]); 308331de23705a719514e37c211f327379688f81b0dChris Lattner 309331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 310331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 311331de23705a719514e37c211f327379688f81b0dChris Lattner // 312d16714b5ed076d0c1d14543098c1e9b90fd92a38Chris Lattner if (PositionalVals.size() >= NumPositionalRequired && 313331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 314331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 315331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals.push_back(argv[i]); 316331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 317331de23705a719514e37c211f327379688f81b0dChris Lattner } 318331de23705a719514e37c211f327379688f81b0dChris Lattner 319331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 320331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 321331de23705a719514e37c211f327379688f81b0dChris Lattner } 322331de23705a719514e37c211f327379688f81b0dChris Lattner } else { // We start with a '-', must be an argument... 323dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 324dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner while (*ArgName == '-') ++ArgName; // Eat leading dashes 325dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 326331de23705a719514e37c211f327379688f81b0dChris Lattner if (*ArgName == 0 && !DashDashFound) { // Is this the mythical "--"? 327331de23705a719514e37c211f327379688f81b0dChris Lattner DashDashFound = true; // Yup, take note of that fact... 328331de23705a719514e37c211f327379688f81b0dChris Lattner continue; // Don't try to process it as an argument iself. 329331de23705a719514e37c211f327379688f81b0dChris Lattner } 330331de23705a719514e37c211f327379688f81b0dChris Lattner 331dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgNameEnd = ArgName; 332f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner while (*ArgNameEnd && *ArgNameEnd != '=') 333b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman ++ArgNameEnd; // Scan till end of argument name... 334dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 335dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = ArgNameEnd; 336dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (*Value) // If we have an equals sign... 337b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman ++Value; // Advance to value... 338dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 339dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (*ArgName != 0) { 340b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman std::string RealName(ArgName, ArgNameEnd); 341b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Extract arg name part 342ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string, Option*>::iterator I = Opts.find(RealName); 343331de23705a719514e37c211f327379688f81b0dChris Lattner 344b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman if (I == Opts.end() && !*Value && RealName.size() > 1) { 345331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this "option" is really a prefixed or grouped 346331de23705a719514e37c211f327379688f81b0dChris Lattner // argument... 347331de23705a719514e37c211f327379688f81b0dChris Lattner // 348331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Length = 0; 349331de23705a719514e37c211f327379688f81b0dChris Lattner Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); 350331de23705a719514e37c211f327379688f81b0dChris Lattner 351331de23705a719514e37c211f327379688f81b0dChris Lattner // If the option is a prefixed option, then the value is simply the 352331de23705a719514e37c211f327379688f81b0dChris Lattner // rest of the name... so fall through to later processing, by 353331de23705a719514e37c211f327379688f81b0dChris Lattner // setting up the argument name flags and value fields. 354331de23705a719514e37c211f327379688f81b0dChris Lattner // 355331de23705a719514e37c211f327379688f81b0dChris Lattner if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { 356331de23705a719514e37c211f327379688f81b0dChris Lattner ArgNameEnd = ArgName+Length; 357331de23705a719514e37c211f327379688f81b0dChris Lattner Value = ArgNameEnd; 358ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner I = Opts.find(std::string(ArgName, ArgNameEnd)); 359331de23705a719514e37c211f327379688f81b0dChris Lattner assert(I->second == PGOpt); 360331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (PGOpt) { 361331de23705a719514e37c211f327379688f81b0dChris Lattner // This must be a grouped option... handle all of them now... 362331de23705a719514e37c211f327379688f81b0dChris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 363331de23705a719514e37c211f327379688f81b0dChris Lattner 364331de23705a719514e37c211f327379688f81b0dChris Lattner do { 365331de23705a719514e37c211f327379688f81b0dChris Lattner // Move current arg name out of RealName into RealArgName... 366ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string RealArgName(RealName.begin(),RealName.begin()+Length); 367331de23705a719514e37c211f327379688f81b0dChris Lattner RealName.erase(RealName.begin(), RealName.begin()+Length); 368f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 369b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Because ValueRequired is an invalid flag for grouped arguments, 370b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // we don't need to pass argc/argv in... 371b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // 372331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 373331de23705a719514e37c211f327379688f81b0dChris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 374331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 375b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), "", 376331de23705a719514e37c211f327379688f81b0dChris Lattner 0, 0, Dummy); 377331de23705a719514e37c211f327379688f81b0dChris Lattner 378331de23705a719514e37c211f327379688f81b0dChris Lattner // Get the next grouping option... 379331de23705a719514e37c211f327379688f81b0dChris Lattner if (!RealName.empty()) 380331de23705a719514e37c211f327379688f81b0dChris Lattner PGOpt = getOptionPred(RealName, Length, isGrouping); 381331de23705a719514e37c211f327379688f81b0dChris Lattner } while (!RealName.empty() && PGOpt); 382331de23705a719514e37c211f327379688f81b0dChris Lattner 383331de23705a719514e37c211f327379688f81b0dChris Lattner if (RealName.empty()) // Processed all of the options, move on 384331de23705a719514e37c211f327379688f81b0dChris Lattner continue; // to the next argv[] value... 385331de23705a719514e37c211f327379688f81b0dChris Lattner 386331de23705a719514e37c211f327379688f81b0dChris Lattner // If RealName is not empty, that means we did not match one of the 387331de23705a719514e37c211f327379688f81b0dChris Lattner // options! This is an error. 388331de23705a719514e37c211f327379688f81b0dChris Lattner // 389331de23705a719514e37c211f327379688f81b0dChris Lattner I = Opts.end(); 390331de23705a719514e37c211f327379688f81b0dChris Lattner } 391b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman } 392f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 393331de23705a719514e37c211f327379688f81b0dChris Lattner Handler = I != Opts.end() ? I->second : 0; 394dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 395dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 396dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 397dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 398ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "Unknown command line argument '" << argv[i] << "'. Try: " 399ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << argv[0] << " --help'\n"; 400dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ErrorParsing = true; 401dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 402dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 403dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 40472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check to see if this option accepts a comma separated list of values. If 40572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // it does, we have to split up the value into multiple values... 40672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner if (Handler->getMiscFlags() & CommaSeparated) { 40772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string Val(Value); 40872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string::size_type Pos = Val.find(','); 40972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 41072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner while (Pos != std::string::npos) { 41172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Process the portion before the comma... 41272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, 41372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string(Val.begin(), 41472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.begin()+Pos).c_str(), 41572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner argc, argv, i); 41672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Erase the portion before the comma, AND the comma... 41772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.erase(Val.begin(), Val.begin()+Pos+1); 41872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Value += Pos+1; // Increment the original value pointer as well... 41972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 42072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check for another comma... 42172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Pos = Val.find(','); 42272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 42372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 4249cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 4259cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 4269cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 4279cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 4289cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 4299cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner else 4309cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 431331de23705a719514e37c211f327379688f81b0dChris Lattner } 432dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 433331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 434331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 435ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "Not enough positional command line arguments specified!\n" 436ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << "Must specify at least " << NumPositionalRequired 437ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " positional arguments: See: " << argv[0] << " --help\n"; 438331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 439331de23705a719514e37c211f327379688f81b0dChris Lattner 440331de23705a719514e37c211f327379688f81b0dChris Lattner 441331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 442331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional args have already been handled if ConsumeAfter is specified... 443331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0, NumVals = PositionalVals.size(); 444331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) { 445331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 446331de23705a719514e37c211f327379688f81b0dChris Lattner ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); 447331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 448331de23705a719514e37c211f327379688f81b0dChris Lattner } 449331de23705a719514e37c211f327379688f81b0dChris Lattner 450331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 451331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 452331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 453331de23705a719514e37c211f327379688f81b0dChris Lattner // 454dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 455331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 456dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 457331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 458331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 459331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 460331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 461331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 462331de23705a719514e37c211f327379688f81b0dChris Lattner ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); 463331de23705a719514e37c211f327379688f81b0dChris Lattner break; 464331de23705a719514e37c211f327379688f81b0dChris Lattner default: 465dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman assert(0 && "Internal error, unexpected NumOccurrences flag in " 466331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 467331de23705a719514e37c211f327379688f81b0dChris Lattner } 468331de23705a719514e37c211f327379688f81b0dChris Lattner } 469caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 470331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 471331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 472331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 473331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) 474331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[j])) 475faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 476faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner PositionalVals[ValNo++]); 477faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 478faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 479faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 480faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 481faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 482faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 483b490c20b3891717f95804517d47d269bbcf3dc03Chris Lattner if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) 484faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 485faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner PositionalVals[ValNo++]); 486331de23705a719514e37c211f327379688f81b0dChris Lattner 487331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 488331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 489331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 490331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 491331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals[ValNo]); 492dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 493dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 494dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 495ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner for (std::map<std::string, Option*>::iterator I = Opts.begin(), 496b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 497dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 498dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 499dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 500dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 501b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman I->second->error(" must be specified at least once!"); 502f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 503f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 504dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 505dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 506dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 507dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 508dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 509dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 510331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 511331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 512e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner delete CommandLineOptions; 513e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner CommandLineOptions = 0; 514331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 515dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 516dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 517dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 518dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 519dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 520dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 521dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 522dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 523dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 524ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerbool Option::error(std::string Message, const char *ArgName) { 525dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ArgName == 0) ArgName = ArgStr; 526331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgName[0] == 0) 527ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << HelpStr; // Be nice for positional arguments 528331de23705a719514e37c211f327379688f81b0dChris Lattner else 529ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "-" << ArgName; 530ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " option" << Message << "\n"; 531dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 532dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 533dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 534dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukmanbool Option::addOccurrence(const char *ArgName, const std::string &Value) { 535dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman NumOccurrences++; // Increment the number of times we have been seen 536dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 537dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 538dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 539dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 540dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": may only occur zero or one times!", ArgName); 541dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 542dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 543dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 544dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": must occur exactly one time!", ArgName); 545dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 546dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 547caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 548caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 549b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman default: return error(": bad num occurrences flag value!"); 550dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 551dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 552dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return handleOccurrence(ArgName, Value); 553dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 554dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 555331de23705a719514e37c211f327379688f81b0dChris Lattner// addArgument - Tell the system that this Option subclass will handle all 556b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman// occurrences of -ArgStr on the command line. 557331de23705a719514e37c211f327379688f81b0dChris Lattner// 558331de23705a719514e37c211f327379688f81b0dChris Lattnervoid Option::addArgument(const char *ArgStr) { 559331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgStr[0]) 560331de23705a719514e37c211f327379688f81b0dChris Lattner AddArgument(ArgStr, this); 5619cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 5629cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) 563331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().push_back(this); 564dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman else if (getNumOccurrencesFlag() == ConsumeAfter) { 5659cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (!getPositionalOpts().empty() && 5669cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner getPositionalOpts().front()->getNumOccurrencesFlag() == ConsumeAfter) 5679cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner error("Cannot specify more than one option with cl::ConsumeAfter!"); 568331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().insert(getPositionalOpts().begin(), this); 569331de23705a719514e37c211f327379688f81b0dChris Lattner } 570331de23705a719514e37c211f327379688f81b0dChris Lattner} 571331de23705a719514e37c211f327379688f81b0dChris Lattner 572aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnervoid Option::removeArgument(const char *ArgStr) { 5739cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ArgStr[0]) 574e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner RemoveArgument(ArgStr, this); 5759cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 5769cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) { 577ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*>::iterator I = 578aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this); 579aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(I != getPositionalOpts().end() && "Arg not registered!"); 580aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(I); 581dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman } else if (getNumOccurrencesFlag() == ConsumeAfter) { 582aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this && 583aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner "Arg not registered correctly!"); 584aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(getPositionalOpts().begin()); 585aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner } 586aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 587aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 588331de23705a719514e37c211f327379688f81b0dChris Lattner 589331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 590331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 591331de23705a719514e37c211f327379688f81b0dChris Lattner// 592331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 593331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 594331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 595331de23705a719514e37c211f327379688f81b0dChris Lattner} 596331de23705a719514e37c211f327379688f81b0dChris Lattner 597331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 598331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 599331de23705a719514e37c211f327379688f81b0dChris Lattner// 600331de23705a719514e37c211f327379688f81b0dChris Lattner 601dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 602331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned alias::getOptionWidth() const { 603dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 604dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 605dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 606331de23705a719514e37c211f327379688f81b0dChris Lattner// Print out the option for the alias... 607331de23705a719514e37c211f327379688f81b0dChris Lattnervoid alias::printOptionInfo(unsigned GlobalWidth) const { 608dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned L = std::strlen(ArgStr); 609ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " 610ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << HelpStr << "\n"; 611dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 612dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 613dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 614331de23705a719514e37c211f327379688f81b0dChris Lattner 615dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 616331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 617dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 618dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6199b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 6209b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 6219b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6229b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 6239b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerunsigned basic_parser_impl::getOptionWidth(const Option &O) const { 6249b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned Len = std::strlen(O.ArgStr); 6259b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 6269b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 6279b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6289b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 6299b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 6309b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6319b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// printOptionInfo - Print out information about this option. The 6329b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 6339b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 6349b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 6359b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned GlobalWidth) const { 636ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr; 6379b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6389b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 639ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "=<" << getValueStr(O, ValName) << ">"; 6409b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 641ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " 642ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << O.HelpStr << "\n"; 6439b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 6449b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6459b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6469b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6479b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 648331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 649331de23705a719514e37c211f327379688f81b0dChris Lattner// 6509b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<bool>::parse(Option &O, const char *ArgName, 651ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, bool &Value) { 652dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 653dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 654dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 655dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 656dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 657dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 658331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + 659331de23705a719514e37c211f327379688f81b0dChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 660dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 661dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 662dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 663dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 664331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 665dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 6669b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<int>::parse(Option &O, const char *ArgName, 667ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, int &Value) { 668331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 669d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (int)strtol(Arg.c_str(), &End, 0); 670331de23705a719514e37c211f327379688f81b0dChris Lattner if (*End != 0) 671331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + "' value invalid for integer argument!"); 672331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 673dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 674dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 675d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 676d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 677d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattnerbool parser<unsigned>::parse(Option &O, const char *ArgName, 678d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner const std::string &Arg, unsigned &Value) { 679d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner char *End; 680d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner long long int V = strtoll(Arg.c_str(), &End, 0); 681d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (unsigned)V; 682d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner if (*End != 0 || V < 0 || Value != V) 683d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return O.error(": '" + Arg + "' value invalid for uint argument!"); 684d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 685d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 686d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 6879b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 688331de23705a719514e37c211f327379688f81b0dChris Lattner// 689ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic bool parseDouble(Option &O, const std::string &Arg, double &Value) { 690331de23705a719514e37c211f327379688f81b0dChris Lattner const char *ArgStart = Arg.c_str(); 691331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 692331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 693331de23705a719514e37c211f327379688f81b0dChris Lattner if (*End != 0) 694331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" +Arg+ "' value invalid for floating point argument!"); 695dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 696dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 697dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6989b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<double>::parse(Option &O, const char *AN, 6999b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, double &Val) { 7009b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 701dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 702dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7039b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<float>::parse(Option &O, const char *AN, 7049b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, float &Val) { 7059b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 7069b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 7079b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 7089b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 7099b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 710dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 711dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 712dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 713dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 714331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 715dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 716dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 717aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 718aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 719aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 720aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 721aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner unsigned i = 0, e = getNumOptions(); 722ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string N(Name); 723aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 724aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner while (i != e) 725aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner if (getOption(i) == N) 726aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 727aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner else 728aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner ++i; 729aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 730aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 731aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 732aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 733dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 734331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned generic_parser_base::getOptionWidth(const Option &O) const { 735331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 736331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Size = std::strlen(O.ArgStr)+6; 737331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 738331de23705a719514e37c211f327379688f81b0dChris Lattner Size = std::max(Size, (unsigned)std::strlen(getOption(i))+8); 739331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 740331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 741331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned BaseSize = 0; 742331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 743331de23705a719514e37c211f327379688f81b0dChris Lattner BaseSize = std::max(BaseSize, (unsigned)std::strlen(getOption(i))+8); 744331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 745331de23705a719514e37c211f327379688f81b0dChris Lattner } 746dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 747dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 748dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// printOptionInfo - Print out information about this option. The 749dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 750dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 751331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 752331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned GlobalWidth) const { 753331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 754331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(O.ArgStr); 755ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') 756ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << O.HelpStr << "\n"; 757331de23705a719514e37c211f327379688f81b0dChris Lattner 758331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 759331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8; 760ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " =" << getOption(i) << std::string(NumSpaces, ' ') 761ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 762331de23705a719514e37c211f327379688f81b0dChris Lattner } 763331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 764331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 765ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " " << O.HelpStr << "\n"; 766331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 767331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(getOption(i)); 768ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') 769ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 770331de23705a719514e37c211f327379688f81b0dChris Lattner } 771dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 772dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 773dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 774dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 775dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 776331de23705a719514e37c211f327379688f81b0dChris Lattner// --help and --help-hidden option implementation 777dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 778dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 779dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 780331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 781dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned MaxArgLen; 782dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 783dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 784dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 785331de23705a719514e37c211f327379688f81b0dChris Lattner // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. 786ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isHidden(std::pair<std::string, Option *> &OptPair) { 787331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() >= Hidden; 788331de23705a719514e37c211f327379688f81b0dChris Lattner } 789ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isReallyHidden(std::pair<std::string, Option *> &OptPair) { 790331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() == ReallyHidden; 791331de23705a719514e37c211f327379688f81b0dChris Lattner } 792331de23705a719514e37c211f327379688f81b0dChris Lattner 793331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 794331de23705a719514e37c211f327379688f81b0dChris Lattner HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 795331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 796331de23705a719514e37c211f327379688f81b0dChris Lattner } 797331de23705a719514e37c211f327379688f81b0dChris Lattner 798331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 799331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 800331de23705a719514e37c211f327379688f81b0dChris Lattner 801dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Copy Options into a vector so we can sort them as we like... 802ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<std::pair<std::string, Option*> > Options; 803697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options)); 804dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 805dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden 806331de23705a719514e37c211f327379688f81b0dChris Lattner Options.erase(std::remove_if(Options.begin(), Options.end(), 807331de23705a719514e37c211f327379688f81b0dChris Lattner std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), 808b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman Options.end()); 809dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 810dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate duplicate entries in table (from enum flags options, f.e.) 811331de23705a719514e37c211f327379688f81b0dChris Lattner { // Give OptionSet a scope 812331de23705a719514e37c211f327379688f81b0dChris Lattner std::set<Option*> OptionSet; 813331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0; i != Options.size(); ++i) 814331de23705a719514e37c211f327379688f81b0dChris Lattner if (OptionSet.count(Options[i].second) == 0) 815331de23705a719514e37c211f327379688f81b0dChris Lattner OptionSet.insert(Options[i].second); // Add new entry to set 816331de23705a719514e37c211f327379688f81b0dChris Lattner else 817331de23705a719514e37c211f327379688f81b0dChris Lattner Options.erase(Options.begin()+i--); // Erase duplicate 818331de23705a719514e37c211f327379688f81b0dChris Lattner } 819dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 820dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 821ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OVERVIEW:" << ProgramOverview << "\n"; 822dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 823ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "USAGE: " << ProgramName << " [options]"; 824331de23705a719514e37c211f327379688f81b0dChris Lattner 825331de23705a719514e37c211f327379688f81b0dChris Lattner // Print out the positional options... 826ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PosOpts = getPositionalOpts(); 827331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 828dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 829331de23705a719514e37c211f327379688f81b0dChris Lattner CAOpt = PosOpts[0]; 830331de23705a719514e37c211f327379688f81b0dChris Lattner 8319cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) { 8329cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (PosOpts[i]->ArgStr[0]) 8339cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner std::cerr << " --" << PosOpts[i]->ArgStr; 834ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " " << PosOpts[i]->HelpStr; 8359cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 836331de23705a719514e37c211f327379688f81b0dChris Lattner 837331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 838ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner if (CAOpt) std::cerr << " " << CAOpt->HelpStr; 839331de23705a719514e37c211f327379688f81b0dChris Lattner 840ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "\n\n"; 841dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 842dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 843dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 844331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 845331de23705a719514e37c211f327379688f81b0dChris Lattner MaxArgLen = std::max(MaxArgLen, Options[i].second->getOptionWidth()); 846dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 847ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OPTIONS:\n"; 848331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 849331de23705a719514e37c211f327379688f81b0dChris Lattner Options[i].second->printOptionInfo(MaxArgLen); 850dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 851331de23705a719514e37c211f327379688f81b0dChris Lattner // Halt the program if help information is printed 852331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 853dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 854331de23705a719514e37c211f327379688f81b0dChris Lattner}; 855dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 856dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 857dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 858331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 859331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 860331de23705a719514e37c211f327379688f81b0dChris Lattner// 861331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter NormalPrinter(false); 862331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter HiddenPrinter(true); 863331de23705a719514e37c211f327379688f81b0dChris Lattner 864331de23705a719514e37c211f327379688f81b0dChris Lattnercl::opt<HelpPrinter, true, parser<bool> > 865331de23705a719514e37c211f327379688f81b0dChris LattnerHOp("help", cl::desc("display available options (--help-hidden for more)"), 8669b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 867dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 868331de23705a719514e37c211f327379688f81b0dChris Lattnercl::opt<HelpPrinter, true, parser<bool> > 869331de23705a719514e37c211f327379688f81b0dChris LattnerHHOp("help-hidden", cl::desc("display all available options"), 8709b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 871dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 872dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} // End anonymous namespace 873