CommandLine.cpp revision c86e84bcf38a94d0bcd09e76ff127ee636354bc0
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 155c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// ParseCStringVector - Break INPUT up wherever one or more 156c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// whitespace characters are found, and store the resulting tokens in 157c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 158c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// using strdup (), so it is the caller's responsibility to free () 159c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// them later. 16006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 161c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaekestatic void ParseCStringVector (std::vector<char *> &output, 162c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke const char *input) { 163c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Characters which will be treated as token separators: 164c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke static const char *delims = " \v\f\t\r\n"; 165c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 16606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string work (input); 167c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Skip past any delims at head of input string. 168c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t pos = work.find_first_not_of (delims); 169c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If the string consists entirely of delims, then exit early. 170c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (pos == std::string::npos) return; 171c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Otherwise, jump forward to beginning of first word. 17206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (pos); 173c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Find position of first delimiter. 17406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 175c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 176c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke while (!work.empty() && pos != std::string::npos) { 177c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Everything from 0 to POS is the next word to copy. 178c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.substr (0,pos).c_str ())); 179c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Is there another word in the string? 180c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t nextpos = work.find_first_not_of (delims, pos + 1); 181c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (nextpos != std::string::npos) { 182c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Yes? Then remove delims from beginning ... 18306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (work.find_first_not_of (delims, pos + 1)); 184c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // and find the end of the word. 18506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 18606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } else { 187c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // No? (Remainder of string is delims.) End the loop. 18806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = ""; 189c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke pos = std::string::npos; 19006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 19106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 19206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 193c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If `input' ended with non-delim char, then we'll get here with 194c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // the last word of `input' in `work'; copy it now. 195c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!work.empty ()) { 196c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.c_str ())); 19706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 19806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 19906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 20006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 20106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 20206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 20306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 20406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 205c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaekevoid cl::ParseEnvironmentOptions (const char *progName, const char *envVar, 20606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke const char *Overview) { 207c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 20806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke assert (progName && "Program name not specified"); 209c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke assert (envVar && "Environment variable name missing"); 210c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 21106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 212c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke const char *envValue = getenv (envVar); 213c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 21406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 215c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 216c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 217c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 218c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke std::vector<char *> newArgv; 219c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke newArgv.push_back (strdup (progName)); 22006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 22106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 22206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 223c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke ParseCStringVector (newArgv, envValue); 224c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke int newArgc = newArgv.size (); 225c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke ParseCommandLineOptions (newArgc, &newArgv[0], Overview); 226c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 227c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Free all the strdup()ed strings. 228c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke for (std::vector<char *>::iterator i = newArgv.begin (), e = newArgv.end (); 229c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke i != e; ++i) { 230c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke free (*i); 231c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke } 23206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 23306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 234dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnervoid cl::ParseCommandLineOptions(int &argc, char **argv, 2350c0edf8afc35a42b15a24ebb5fa5f3fc674290aeChris Lattner const char *Overview) { 236331de23705a719514e37c211f327379688f81b0dChris Lattner assert((!getOpts().empty() || !getPositionalOpts().empty()) && 237331de23705a719514e37c211f327379688f81b0dChris Lattner "No options specified, or ParseCommandLineOptions called more" 238331de23705a719514e37c211f327379688f81b0dChris Lattner " than once!"); 239dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramName = argv[0]; // Save this away safe and snug 240dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 241dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 242dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 243ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string, Option*> &Opts = getOpts(); 244ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PositionalOpts = getPositionalOpts(); 245331de23705a719514e37c211f327379688f81b0dChris Lattner 246331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 247331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 248331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 249331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 250dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 251331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 252331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 253331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 254331de23705a719514e37c211f327379688f81b0dChris Lattner } 255331de23705a719514e37c211f327379688f81b0dChris Lattner 256331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 257331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 258331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 259331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 260331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 261331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 262331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 263331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 264331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 26554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 26654ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 26754ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 26854ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner Opt->error(" error - this positional option will never be matched, " 26954ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 27054ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 2719cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 2729cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 2739cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 2749cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 275331de23705a719514e37c211f327379688f81b0dChris Lattner // 276331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= Opt->error(" error - option can never match, because " 277331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 278331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 279331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 280331de23705a719514e37c211f327379688f81b0dChris Lattner } 281331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 282331de23705a719514e37c211f327379688f81b0dChris Lattner } 283331de23705a719514e37c211f327379688f81b0dChris Lattner } 284331de23705a719514e37c211f327379688f81b0dChris Lattner 285331de23705a719514e37c211f327379688f81b0dChris Lattner // PositionalVals - A vector of "positional" arguments we accumulate into to 286331de23705a719514e37c211f327379688f81b0dChris Lattner // processes at the end... 287331de23705a719514e37c211f327379688f81b0dChris Lattner // 288ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<std::string> PositionalVals; 289331de23705a719514e37c211f327379688f81b0dChris Lattner 2909cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 2919cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 2929cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 2939cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 2949cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 295dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 296331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 297dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 298dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 299dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *Value = ""; 300dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgName = ""; 301331de23705a719514e37c211f327379688f81b0dChris Lattner 302331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 303331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 3041115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 305331de23705a719514e37c211f327379688f81b0dChris Lattner // 306331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 307331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 3089cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 3099cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ProvidePositionalOption(ActivePositionalArg, argv[i]); 3109cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 3119cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (!PositionalOpts.empty()) { 312331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals.push_back(argv[i]); 313331de23705a719514e37c211f327379688f81b0dChris Lattner 314331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 315331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 316331de23705a719514e37c211f327379688f81b0dChris Lattner // 317d16714b5ed076d0c1d14543098c1e9b90fd92a38Chris Lattner if (PositionalVals.size() >= NumPositionalRequired && 318331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 319331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 320331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals.push_back(argv[i]); 321331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 322331de23705a719514e37c211f327379688f81b0dChris Lattner } 323331de23705a719514e37c211f327379688f81b0dChris Lattner 324331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 325331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 326331de23705a719514e37c211f327379688f81b0dChris Lattner } 327331de23705a719514e37c211f327379688f81b0dChris Lattner } else { // We start with a '-', must be an argument... 328dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 329dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner while (*ArgName == '-') ++ArgName; // Eat leading dashes 330dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 331331de23705a719514e37c211f327379688f81b0dChris Lattner if (*ArgName == 0 && !DashDashFound) { // Is this the mythical "--"? 332331de23705a719514e37c211f327379688f81b0dChris Lattner DashDashFound = true; // Yup, take note of that fact... 333950971dfe6271e85292f73dd6ac105465e4898f7Misha Brukman continue; // Don't try to process it as an argument itself. 334331de23705a719514e37c211f327379688f81b0dChris Lattner } 335331de23705a719514e37c211f327379688f81b0dChris Lattner 336dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgNameEnd = ArgName; 337f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner while (*ArgNameEnd && *ArgNameEnd != '=') 338b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman ++ArgNameEnd; // Scan till end of argument name... 339dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 340dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = ArgNameEnd; 341dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (*Value) // If we have an equals sign... 342b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman ++Value; // Advance to value... 343dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 344dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (*ArgName != 0) { 345b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman std::string RealName(ArgName, ArgNameEnd); 346b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Extract arg name part 347ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string, Option*>::iterator I = Opts.find(RealName); 348331de23705a719514e37c211f327379688f81b0dChris Lattner 349b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman if (I == Opts.end() && !*Value && RealName.size() > 1) { 350331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this "option" is really a prefixed or grouped 351331de23705a719514e37c211f327379688f81b0dChris Lattner // argument... 352331de23705a719514e37c211f327379688f81b0dChris Lattner // 353331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Length = 0; 354331de23705a719514e37c211f327379688f81b0dChris Lattner Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); 355331de23705a719514e37c211f327379688f81b0dChris Lattner 356331de23705a719514e37c211f327379688f81b0dChris Lattner // If the option is a prefixed option, then the value is simply the 357331de23705a719514e37c211f327379688f81b0dChris Lattner // rest of the name... so fall through to later processing, by 358331de23705a719514e37c211f327379688f81b0dChris Lattner // setting up the argument name flags and value fields. 359331de23705a719514e37c211f327379688f81b0dChris Lattner // 360331de23705a719514e37c211f327379688f81b0dChris Lattner if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { 361331de23705a719514e37c211f327379688f81b0dChris Lattner ArgNameEnd = ArgName+Length; 362331de23705a719514e37c211f327379688f81b0dChris Lattner Value = ArgNameEnd; 363ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner I = Opts.find(std::string(ArgName, ArgNameEnd)); 364331de23705a719514e37c211f327379688f81b0dChris Lattner assert(I->second == PGOpt); 365331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (PGOpt) { 366331de23705a719514e37c211f327379688f81b0dChris Lattner // This must be a grouped option... handle all of them now... 367331de23705a719514e37c211f327379688f81b0dChris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 368331de23705a719514e37c211f327379688f81b0dChris Lattner 369331de23705a719514e37c211f327379688f81b0dChris Lattner do { 370331de23705a719514e37c211f327379688f81b0dChris Lattner // Move current arg name out of RealName into RealArgName... 371ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string RealArgName(RealName.begin(),RealName.begin()+Length); 372331de23705a719514e37c211f327379688f81b0dChris Lattner RealName.erase(RealName.begin(), RealName.begin()+Length); 373f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 374b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Because ValueRequired is an invalid flag for grouped arguments, 375b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // we don't need to pass argc/argv in... 376b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // 377331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 378331de23705a719514e37c211f327379688f81b0dChris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 379331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 380b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), "", 381331de23705a719514e37c211f327379688f81b0dChris Lattner 0, 0, Dummy); 382331de23705a719514e37c211f327379688f81b0dChris Lattner 383331de23705a719514e37c211f327379688f81b0dChris Lattner // Get the next grouping option... 384331de23705a719514e37c211f327379688f81b0dChris Lattner if (!RealName.empty()) 385331de23705a719514e37c211f327379688f81b0dChris Lattner PGOpt = getOptionPred(RealName, Length, isGrouping); 386331de23705a719514e37c211f327379688f81b0dChris Lattner } while (!RealName.empty() && PGOpt); 387331de23705a719514e37c211f327379688f81b0dChris Lattner 388331de23705a719514e37c211f327379688f81b0dChris Lattner if (RealName.empty()) // Processed all of the options, move on 389331de23705a719514e37c211f327379688f81b0dChris Lattner continue; // to the next argv[] value... 390331de23705a719514e37c211f327379688f81b0dChris Lattner 391331de23705a719514e37c211f327379688f81b0dChris Lattner // If RealName is not empty, that means we did not match one of the 392331de23705a719514e37c211f327379688f81b0dChris Lattner // options! This is an error. 393331de23705a719514e37c211f327379688f81b0dChris Lattner // 394331de23705a719514e37c211f327379688f81b0dChris Lattner I = Opts.end(); 395331de23705a719514e37c211f327379688f81b0dChris Lattner } 396b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman } 397f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 398331de23705a719514e37c211f327379688f81b0dChris Lattner Handler = I != Opts.end() ? I->second : 0; 399dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 400dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 401dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 402dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 403c86e84bcf38a94d0bcd09e76ff127ee636354bc0Brian Gaeke std::cerr << "Unknown command line argument '" << argv[i] << "'. Try: '" 404ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << argv[0] << " --help'\n"; 405dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ErrorParsing = true; 406dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 407dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 408dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 40972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check to see if this option accepts a comma separated list of values. If 41072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // it does, we have to split up the value into multiple values... 41172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner if (Handler->getMiscFlags() & CommaSeparated) { 41272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string Val(Value); 41372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string::size_type Pos = Val.find(','); 41472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 41572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner while (Pos != std::string::npos) { 41672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Process the portion before the comma... 41772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, 41872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string(Val.begin(), 41972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.begin()+Pos).c_str(), 42072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner argc, argv, i); 42172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Erase the portion before the comma, AND the comma... 42272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.erase(Val.begin(), Val.begin()+Pos+1); 42372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Value += Pos+1; // Increment the original value pointer as well... 42472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 42572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check for another comma... 42672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Pos = Val.find(','); 42772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 42872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 4299cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 4309cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 4319cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 4329cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 4339cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 4349cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner else 4359cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 436331de23705a719514e37c211f327379688f81b0dChris Lattner } 437dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 438331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 439331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 440ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "Not enough positional command line arguments specified!\n" 441ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << "Must specify at least " << NumPositionalRequired 442ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " positional arguments: See: " << argv[0] << " --help\n"; 443331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 444331de23705a719514e37c211f327379688f81b0dChris Lattner 445331de23705a719514e37c211f327379688f81b0dChris Lattner 446331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 447331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional args have already been handled if ConsumeAfter is specified... 448331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0, NumVals = PositionalVals.size(); 449331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) { 450331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 451331de23705a719514e37c211f327379688f81b0dChris Lattner ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); 452331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 453331de23705a719514e37c211f327379688f81b0dChris Lattner } 454331de23705a719514e37c211f327379688f81b0dChris Lattner 455331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 456331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 457331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 458331de23705a719514e37c211f327379688f81b0dChris Lattner // 459dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 460331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 461dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 462331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 463331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 464331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 465331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 466331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 467331de23705a719514e37c211f327379688f81b0dChris Lattner ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); 468331de23705a719514e37c211f327379688f81b0dChris Lattner break; 469331de23705a719514e37c211f327379688f81b0dChris Lattner default: 470dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman assert(0 && "Internal error, unexpected NumOccurrences flag in " 471331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 472331de23705a719514e37c211f327379688f81b0dChris Lattner } 473331de23705a719514e37c211f327379688f81b0dChris Lattner } 474caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 475331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 476331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 477331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 478331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) 479331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[j])) 480faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 481faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner PositionalVals[ValNo++]); 482faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 483faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 484faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 485faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 486faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 487faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 488b490c20b3891717f95804517d47d269bbcf3dc03Chris Lattner if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) 489faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 490faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner PositionalVals[ValNo++]); 491331de23705a719514e37c211f327379688f81b0dChris Lattner 492331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 493331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 494331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 495331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 496331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals[ValNo]); 497dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 498dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 499dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 500ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner for (std::map<std::string, Option*>::iterator I = Opts.begin(), 501b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 502dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 503dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 504dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 505dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 506b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman I->second->error(" must be specified at least once!"); 507f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 508f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 509dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 510dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 511dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 512dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 513dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 514dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 515331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 516331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 517e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner delete CommandLineOptions; 518e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner CommandLineOptions = 0; 519331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 520dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 521dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 522dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 523dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 524dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 525dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 526dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 527dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 528dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 529ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerbool Option::error(std::string Message, const char *ArgName) { 530dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ArgName == 0) ArgName = ArgStr; 531331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgName[0] == 0) 532ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << HelpStr; // Be nice for positional arguments 533331de23705a719514e37c211f327379688f81b0dChris Lattner else 534ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "-" << ArgName; 535ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " option" << Message << "\n"; 536dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 537dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 538dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 539dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukmanbool Option::addOccurrence(const char *ArgName, const std::string &Value) { 540dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman NumOccurrences++; // Increment the number of times we have been seen 541dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 542dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 543dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 544dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 545dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": may only occur zero or one times!", ArgName); 546dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 547dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 548dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 549dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": must occur exactly one time!", ArgName); 550dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 551dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 552caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 553caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 554b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman default: return error(": bad num occurrences flag value!"); 555dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 556dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 557dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return handleOccurrence(ArgName, Value); 558dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 559dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 560331de23705a719514e37c211f327379688f81b0dChris Lattner// addArgument - Tell the system that this Option subclass will handle all 561b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman// occurrences of -ArgStr on the command line. 562331de23705a719514e37c211f327379688f81b0dChris Lattner// 563331de23705a719514e37c211f327379688f81b0dChris Lattnervoid Option::addArgument(const char *ArgStr) { 564331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgStr[0]) 565331de23705a719514e37c211f327379688f81b0dChris Lattner AddArgument(ArgStr, this); 5669cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 5679cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) 568331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().push_back(this); 569dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman else if (getNumOccurrencesFlag() == ConsumeAfter) { 5709cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (!getPositionalOpts().empty() && 5719cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner getPositionalOpts().front()->getNumOccurrencesFlag() == ConsumeAfter) 5729cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner error("Cannot specify more than one option with cl::ConsumeAfter!"); 573331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().insert(getPositionalOpts().begin(), this); 574331de23705a719514e37c211f327379688f81b0dChris Lattner } 575331de23705a719514e37c211f327379688f81b0dChris Lattner} 576331de23705a719514e37c211f327379688f81b0dChris Lattner 577aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnervoid Option::removeArgument(const char *ArgStr) { 5789cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ArgStr[0]) 579e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner RemoveArgument(ArgStr, this); 5809cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 5819cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) { 582ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*>::iterator I = 583aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this); 584aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(I != getPositionalOpts().end() && "Arg not registered!"); 585aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(I); 586dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman } else if (getNumOccurrencesFlag() == ConsumeAfter) { 587aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this && 588aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner "Arg not registered correctly!"); 589aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(getPositionalOpts().begin()); 590aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner } 591aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 592aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 593331de23705a719514e37c211f327379688f81b0dChris Lattner 594331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 595331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 596331de23705a719514e37c211f327379688f81b0dChris Lattner// 597331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 598331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 599331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 600331de23705a719514e37c211f327379688f81b0dChris Lattner} 601331de23705a719514e37c211f327379688f81b0dChris Lattner 602331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 603331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 604331de23705a719514e37c211f327379688f81b0dChris Lattner// 605331de23705a719514e37c211f327379688f81b0dChris Lattner 606dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 607331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned alias::getOptionWidth() const { 608dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 609dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 610dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 611331de23705a719514e37c211f327379688f81b0dChris Lattner// Print out the option for the alias... 612331de23705a719514e37c211f327379688f81b0dChris Lattnervoid alias::printOptionInfo(unsigned GlobalWidth) const { 613dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned L = std::strlen(ArgStr); 614ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " 615ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << HelpStr << "\n"; 616dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 617dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 618dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 619331de23705a719514e37c211f327379688f81b0dChris Lattner 620dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 621331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 622dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 623dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6249b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 6259b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 6269b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6279b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 6289b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerunsigned basic_parser_impl::getOptionWidth(const Option &O) const { 6299b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned Len = std::strlen(O.ArgStr); 6309b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 6319b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 6329b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6339b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 6349b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 6359b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6369b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// printOptionInfo - Print out information about this option. The 6379b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 6389b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 6399b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 6409b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned GlobalWidth) const { 641ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr; 6429b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6439b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 644ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "=<" << getValueStr(O, ValName) << ">"; 6459b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 646ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " 647ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << O.HelpStr << "\n"; 6489b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 6499b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6509b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6519b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6529b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 653331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 654331de23705a719514e37c211f327379688f81b0dChris Lattner// 6559b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<bool>::parse(Option &O, const char *ArgName, 656ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, bool &Value) { 657dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 658dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 659dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 660dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 661dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 662dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 663331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + 664331de23705a719514e37c211f327379688f81b0dChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 665dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 666dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 667dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 668dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 669331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 670dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 6719b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<int>::parse(Option &O, const char *ArgName, 672ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, int &Value) { 673331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 674d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (int)strtol(Arg.c_str(), &End, 0); 675331de23705a719514e37c211f327379688f81b0dChris Lattner if (*End != 0) 676331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + "' value invalid for integer argument!"); 677331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 678dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 679dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 680d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 681d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 682d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattnerbool parser<unsigned>::parse(Option &O, const char *ArgName, 683d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner const std::string &Arg, unsigned &Value) { 684d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner char *End; 685d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner long long int V = strtoll(Arg.c_str(), &End, 0); 686d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (unsigned)V; 687d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner if (*End != 0 || V < 0 || Value != V) 688d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return O.error(": '" + Arg + "' value invalid for uint argument!"); 689d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 690d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 691d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 6929b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 693331de23705a719514e37c211f327379688f81b0dChris Lattner// 694ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic bool parseDouble(Option &O, const std::string &Arg, double &Value) { 695331de23705a719514e37c211f327379688f81b0dChris Lattner const char *ArgStart = Arg.c_str(); 696331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 697331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 698331de23705a719514e37c211f327379688f81b0dChris Lattner if (*End != 0) 699331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" +Arg+ "' value invalid for floating point argument!"); 700dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 701dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 702dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7039b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<double>::parse(Option &O, const char *AN, 7049b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, double &Val) { 7059b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 706dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 707dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7089b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<float>::parse(Option &O, const char *AN, 7099b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, float &Val) { 7109b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 7119b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 7129b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 7139b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 7149b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 715dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 716dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 717dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 718dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 719331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 720dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 721dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 722aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 723aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 724aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 725aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 726aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner unsigned i = 0, e = getNumOptions(); 727ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string N(Name); 728aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 729aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner while (i != e) 730aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner if (getOption(i) == N) 731aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 732aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner else 733aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner ++i; 734aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 735aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 736aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 737aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 738dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 739331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned generic_parser_base::getOptionWidth(const Option &O) const { 740331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 741331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Size = std::strlen(O.ArgStr)+6; 742331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 743331de23705a719514e37c211f327379688f81b0dChris Lattner Size = std::max(Size, (unsigned)std::strlen(getOption(i))+8); 744331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 745331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 746331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned BaseSize = 0; 747331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 748331de23705a719514e37c211f327379688f81b0dChris Lattner BaseSize = std::max(BaseSize, (unsigned)std::strlen(getOption(i))+8); 749331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 750331de23705a719514e37c211f327379688f81b0dChris Lattner } 751dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 752dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 753dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// printOptionInfo - Print out information about this option. The 754dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 755dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 756331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 757331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned GlobalWidth) const { 758331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 759331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(O.ArgStr); 760ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') 761ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << O.HelpStr << "\n"; 762331de23705a719514e37c211f327379688f81b0dChris Lattner 763331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 764331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8; 765ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " =" << getOption(i) << std::string(NumSpaces, ' ') 766ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 767331de23705a719514e37c211f327379688f81b0dChris Lattner } 768331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 769331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 770ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " " << O.HelpStr << "\n"; 771331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 772331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(getOption(i)); 773ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') 774ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 775331de23705a719514e37c211f327379688f81b0dChris Lattner } 776dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 777dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 778dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 779dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 780dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 781331de23705a719514e37c211f327379688f81b0dChris Lattner// --help and --help-hidden option implementation 782dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 783dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 784dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 785331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 786dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned MaxArgLen; 787dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 788dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 789dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 790331de23705a719514e37c211f327379688f81b0dChris Lattner // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. 791ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isHidden(std::pair<std::string, Option *> &OptPair) { 792331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() >= Hidden; 793331de23705a719514e37c211f327379688f81b0dChris Lattner } 794ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isReallyHidden(std::pair<std::string, Option *> &OptPair) { 795331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() == ReallyHidden; 796331de23705a719514e37c211f327379688f81b0dChris Lattner } 797331de23705a719514e37c211f327379688f81b0dChris Lattner 798331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 799331de23705a719514e37c211f327379688f81b0dChris Lattner HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 800331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 801331de23705a719514e37c211f327379688f81b0dChris Lattner } 802331de23705a719514e37c211f327379688f81b0dChris Lattner 803331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 804331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 805331de23705a719514e37c211f327379688f81b0dChris Lattner 806dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Copy Options into a vector so we can sort them as we like... 807ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<std::pair<std::string, Option*> > Options; 808697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options)); 809dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 810dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden 811331de23705a719514e37c211f327379688f81b0dChris Lattner Options.erase(std::remove_if(Options.begin(), Options.end(), 812331de23705a719514e37c211f327379688f81b0dChris Lattner std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), 813b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman Options.end()); 814dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 815dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate duplicate entries in table (from enum flags options, f.e.) 816331de23705a719514e37c211f327379688f81b0dChris Lattner { // Give OptionSet a scope 817331de23705a719514e37c211f327379688f81b0dChris Lattner std::set<Option*> OptionSet; 818331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0; i != Options.size(); ++i) 819331de23705a719514e37c211f327379688f81b0dChris Lattner if (OptionSet.count(Options[i].second) == 0) 820331de23705a719514e37c211f327379688f81b0dChris Lattner OptionSet.insert(Options[i].second); // Add new entry to set 821331de23705a719514e37c211f327379688f81b0dChris Lattner else 822331de23705a719514e37c211f327379688f81b0dChris Lattner Options.erase(Options.begin()+i--); // Erase duplicate 823331de23705a719514e37c211f327379688f81b0dChris Lattner } 824dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 825dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 826ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OVERVIEW:" << ProgramOverview << "\n"; 827dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 828ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "USAGE: " << ProgramName << " [options]"; 829331de23705a719514e37c211f327379688f81b0dChris Lattner 830331de23705a719514e37c211f327379688f81b0dChris Lattner // Print out the positional options... 831ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PosOpts = getPositionalOpts(); 832331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 833dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 834331de23705a719514e37c211f327379688f81b0dChris Lattner CAOpt = PosOpts[0]; 835331de23705a719514e37c211f327379688f81b0dChris Lattner 8369cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) { 8379cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (PosOpts[i]->ArgStr[0]) 8389cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner std::cerr << " --" << PosOpts[i]->ArgStr; 839ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " " << PosOpts[i]->HelpStr; 8409cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 841331de23705a719514e37c211f327379688f81b0dChris Lattner 842331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 843ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner if (CAOpt) std::cerr << " " << CAOpt->HelpStr; 844331de23705a719514e37c211f327379688f81b0dChris Lattner 845ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "\n\n"; 846dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 847dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 848dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 849331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 850331de23705a719514e37c211f327379688f81b0dChris Lattner MaxArgLen = std::max(MaxArgLen, Options[i].second->getOptionWidth()); 851dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 852ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OPTIONS:\n"; 853331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 854331de23705a719514e37c211f327379688f81b0dChris Lattner Options[i].second->printOptionInfo(MaxArgLen); 855dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 856331de23705a719514e37c211f327379688f81b0dChris Lattner // Halt the program if help information is printed 857331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 858dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 859331de23705a719514e37c211f327379688f81b0dChris Lattner}; 860dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 861dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 862dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 863331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 864331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 865331de23705a719514e37c211f327379688f81b0dChris Lattner// 866331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter NormalPrinter(false); 867331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter HiddenPrinter(true); 868331de23705a719514e37c211f327379688f81b0dChris Lattner 869331de23705a719514e37c211f327379688f81b0dChris Lattnercl::opt<HelpPrinter, true, parser<bool> > 870331de23705a719514e37c211f327379688f81b0dChris LattnerHOp("help", cl::desc("display available options (--help-hidden for more)"), 8719b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 872dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 873331de23705a719514e37c211f327379688f81b0dChris Lattnercl::opt<HelpPrinter, true, parser<bool> > 874331de23705a719514e37c211f327379688f81b0dChris LattnerHHOp("help-hidden", cl::desc("display all available options"), 8759b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 876dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 877dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} // End anonymous namespace 878