diff options
Diffstat (limited to 'support/lib/Support/CommandLine.cpp')
| -rw-r--r-- | support/lib/Support/CommandLine.cpp | 877 |
1 files changed, 0 insertions, 877 deletions
diff --git a/support/lib/Support/CommandLine.cpp b/support/lib/Support/CommandLine.cpp deleted file mode 100644 index c0be0ecb34..0000000000 --- a/support/lib/Support/CommandLine.cpp +++ /dev/null @@ -1,877 +0,0 @@ -//===-- CommandLine.cpp - Command line parser implementation --------------===// -// -// This class implements a command line argument processor that is useful when -// creating a tool. It provides a simple, minimalistic interface that is easily -// extensible and supports nonlocal (library) command line options. -// -// Note that rather than trying to figure out what this code does, you could try -// reading the library documentation located in docs/CommandLine.html -// -//===----------------------------------------------------------------------===// - -#include "Support/CommandLine.h" -#include <algorithm> -#include <map> -#include <set> -#include <iostream> - -using namespace cl; - -//===----------------------------------------------------------------------===// -// Basic, shared command line option processing machinery... -// - -// Return the global command line option vector. Making it a function scoped -// static ensures that it will be initialized correctly before its first use. -// -static std::map<std::string, Option*> *CommandLineOptions = 0; -static std::map<std::string, Option*> &getOpts() { - if (CommandLineOptions == 0) - CommandLineOptions = new std::map<std::string,Option*>(); - return *CommandLineOptions; -} - -static Option *getOption(const std::string &Str) { - if (CommandLineOptions == 0) return 0; - std::map<std::string,Option*>::iterator I = CommandLineOptions->find(Str); - return I != CommandLineOptions->end() ? I->second : 0; -} - -static std::vector<Option*> &getPositionalOpts() { - static std::vector<Option*> Positional; - return Positional; -} - -static void AddArgument(const char *ArgName, Option *Opt) { - if (getOption(ArgName)) { - std::cerr << "CommandLine Error: Argument '" << ArgName - << "' defined more than once!\n"; - } else { - // Add argument to the argument map! - getOpts()[ArgName] = Opt; - } -} - -// RemoveArgument - It's possible that the argument is no longer in the map if -// options have already been processed and the map has been deleted! -// -static void RemoveArgument(const char *ArgName, Option *Opt) { - if (CommandLineOptions == 0) return; - assert(getOption(ArgName) == Opt && "Arg not in map!"); - CommandLineOptions->erase(ArgName); - if (CommandLineOptions->empty()) { - delete CommandLineOptions; - CommandLineOptions = 0; - } -} - -static const char *ProgramName = 0; -static const char *ProgramOverview = 0; - -static inline bool ProvideOption(Option *Handler, const char *ArgName, - const char *Value, int argc, char **argv, - int &i) { - // Enforce value requirements - switch (Handler->getValueExpectedFlag()) { - case ValueRequired: - if (Value == 0 || *Value == 0) { // No value specified? - if (i+1 < argc) { // Steal the next argument, like for '-o filename' - Value = argv[++i]; - } else { - return Handler->error(" requires a value!"); - } - } - break; - case ValueDisallowed: - if (*Value != 0) - return Handler->error(" does not allow a value! '" + - std::string(Value) + "' specified."); - break; - case ValueOptional: break; - default: std::cerr << "Bad ValueMask flag! CommandLine usage error:" - << Handler->getValueExpectedFlag() << "\n"; abort(); - } - - // Run the handler now! - return Handler->addOccurrence(ArgName, Value); -} - -static bool ProvidePositionalOption(Option *Handler, const std::string &Arg) { - int Dummy; - return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy); -} - - -// Option predicates... -static inline bool isGrouping(const Option *O) { - return O->getFormattingFlag() == cl::Grouping; -} -static inline bool isPrefixedOrGrouping(const Option *O) { - return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; -} - -// getOptionPred - Check to see if there are any options that satisfy the -// specified predicate with names that are the prefixes in Name. This is -// checked by progressively stripping characters off of the name, checking to -// see if there options that satisfy the predicate. If we find one, return it, -// otherwise return null. -// -static Option *getOptionPred(std::string Name, unsigned &Length, - bool (*Pred)(const Option*)) { - - Option *Op = getOption(Name); - if (Op && Pred(Op)) { - Length = Name.length(); - return Op; - } - - if (Name.size() == 1) return 0; - do { - Name.erase(Name.end()-1, Name.end()); // Chop off the last character... - Op = getOption(Name); - - // Loop while we haven't found an option and Name still has at least two - // characters in it (so that the next iteration will not be the empty - // string... - } while ((Op == 0 || !Pred(Op)) && Name.size() > 1); - - if (Op && Pred(Op)) { - Length = Name.length(); - return Op; // Found one! - } - return 0; // No option found! -} - -static bool RequiresValue(const Option *O) { - return O->getNumOccurrencesFlag() == cl::Required || - O->getNumOccurrencesFlag() == cl::OneOrMore; -} - -static bool EatsUnboundedNumberOfValues(const Option *O) { - return O->getNumOccurrencesFlag() == cl::ZeroOrMore || - O->getNumOccurrencesFlag() == cl::OneOrMore; -} - -/// ParseCStringVector - Break INPUT up wherever one or more -/// whitespace characters are found, and store the resulting tokens in -/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated -/// using strdup (), so it is the caller's responsibility to free () -/// them later. -/// -static void ParseCStringVector (std::vector<char *> &output, - const char *input) { - // Characters which will be treated as token separators: - static const char *delims = " \v\f\t\r\n"; - - std::string work (input); - // Skip past any delims at head of input string. - size_t pos = work.find_first_not_of (delims); - // If the string consists entirely of delims, then exit early. - if (pos == std::string::npos) return; - // Otherwise, jump forward to beginning of first word. - work = work.substr (pos); - // Find position of first delimiter. - pos = work.find_first_of (delims); - - while (!work.empty() && pos != std::string::npos) { - // Everything from 0 to POS is the next word to copy. - output.push_back (strdup (work.substr (0,pos).c_str ())); - // Is there another word in the string? - size_t nextpos = work.find_first_not_of (delims, pos + 1); - if (nextpos != std::string::npos) { - // Yes? Then remove delims from beginning ... - work = work.substr (work.find_first_not_of (delims, pos + 1)); - // and find the end of the word. - pos = work.find_first_of (delims); - } else { - // No? (Remainder of string is delims.) End the loop. - work = ""; - pos = std::string::npos; - } - } - - // If `input' ended with non-delim char, then we'll get here with - // the last word of `input' in `work'; copy it now. - if (!work.empty ()) { - output.push_back (strdup (work.c_str ())); - } -} - -/// ParseEnvironmentOptions - An alternative entry point to the -/// CommandLine library, which allows you to read the program's name -/// from the caller (as PROGNAME) and its command-line arguments from -/// an environment variable (whose name is given in ENVVAR). -/// -void cl::ParseEnvironmentOptions (const char *progName, const char *envVar, - const char *Overview) { - // Check args. - assert (progName && "Program name not specified"); - assert (envVar && "Environment variable name missing"); - - // Get the environment variable they want us to parse options out of. - const char *envValue = getenv (envVar); - if (!envValue) - return; - - // Get program's "name", which we wouldn't know without the caller - // telling us. - std::vector<char *> newArgv; - newArgv.push_back (strdup (progName)); - - // Parse the value of the environment variable into a "command line" - // and hand it off to ParseCommandLineOptions(). - ParseCStringVector (newArgv, envValue); - int newArgc = newArgv.size (); - ParseCommandLineOptions (newArgc, &newArgv[0], Overview); - - // Free all the strdup()ed strings. - for (std::vector<char *>::iterator i = newArgv.begin (), e = newArgv.end (); - i != e; ++i) { - free (*i); - } -} - -void cl::ParseCommandLineOptions(int &argc, char **argv, - const char *Overview) { - assert((!getOpts().empty() || !getPositionalOpts().empty()) && - "No options specified, or ParseCommandLineOptions called more" - " than once!"); - ProgramName = argv[0]; // Save this away safe and snug - ProgramOverview = Overview; - bool ErrorParsing = false; - - std::map<std::string, Option*> &Opts = getOpts(); - std::vector<Option*> &PositionalOpts = getPositionalOpts(); - - // Check out the positional arguments to collect information about them. - unsigned NumPositionalRequired = 0; - Option *ConsumeAfterOpt = 0; - if (!PositionalOpts.empty()) { - if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { - assert(PositionalOpts.size() > 1 && - "Cannot specify cl::ConsumeAfter without a positional argument!"); - ConsumeAfterOpt = PositionalOpts[0]; - } - - // Calculate how many positional values are _required_. - bool UnboundedFound = false; - for (unsigned i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); - i != e; ++i) { - Option *Opt = PositionalOpts[i]; - if (RequiresValue(Opt)) - ++NumPositionalRequired; - else if (ConsumeAfterOpt) { - // ConsumeAfter cannot be combined with "optional" positional options - // unless there is only one positional argument... - if (PositionalOpts.size() > 2) - ErrorParsing |= - Opt->error(" error - this positional option will never be matched, " - "because it does not Require a value, and a " - "cl::ConsumeAfter option is active!"); - } else if (UnboundedFound && !Opt->ArgStr[0]) { - // This option does not "require" a value... Make sure this option is - // not specified after an option that eats all extra arguments, or this - // one will never get any! - // - ErrorParsing |= Opt->error(" error - option can never match, because " - "another positional argument will match an " - "unbounded number of values, and this option" - " does not require a value!"); - } - UnboundedFound |= EatsUnboundedNumberOfValues(Opt); - } - } - - // PositionalVals - A vector of "positional" arguments we accumulate into to - // processes at the end... - // - std::vector<std::string> PositionalVals; - - // If the program has named positional arguments, and the name has been run - // across, keep track of which positional argument was named. Otherwise put - // the positional args into the PositionalVals list... - Option *ActivePositionalArg = 0; - - // Loop over all of the arguments... processing them. - bool DashDashFound = false; // Have we read '--'? - for (int i = 1; i < argc; ++i) { - Option *Handler = 0; - const char *Value = ""; - const char *ArgName = ""; - - // Check to see if this is a positional argument. This argument is - // considered to be positional if it doesn't start with '-', if it is "-" - // itself, or if we have seen "--" already. - // - if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { - // Positional argument! - if (ActivePositionalArg) { - ProvidePositionalOption(ActivePositionalArg, argv[i]); - continue; // We are done! - } else if (!PositionalOpts.empty()) { - PositionalVals.push_back(argv[i]); - - // All of the positional arguments have been fulfulled, give the rest to - // the consume after option... if it's specified... - // - if (PositionalVals.size() >= NumPositionalRequired && - ConsumeAfterOpt != 0) { - for (++i; i < argc; ++i) - PositionalVals.push_back(argv[i]); - break; // Handle outside of the argument processing loop... - } - - // Delay processing positional arguments until the end... - continue; - } - } else { // We start with a '-', must be an argument... - ArgName = argv[i]+1; - while (*ArgName == '-') ++ArgName; // Eat leading dashes - - if (*ArgName == 0 && !DashDashFound) { // Is this the mythical "--"? - DashDashFound = true; // Yup, take note of that fact... - continue; // Don't try to process it as an argument itself. - } - - const char *ArgNameEnd = ArgName; - while (*ArgNameEnd && *ArgNameEnd != '=') - ++ArgNameEnd; // Scan till end of argument name... - - Value = ArgNameEnd; - if (*Value) // If we have an equals sign... - ++Value; // Advance to value... - - if (*ArgName != 0) { - std::string RealName(ArgName, ArgNameEnd); - // Extract arg name part - std::map<std::string, Option*>::iterator I = Opts.find(RealName); - - if (I == Opts.end() && !*Value && RealName.size() > 1) { - // Check to see if this "option" is really a prefixed or grouped - // argument... - // - unsigned Length = 0; - Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); - - // If the option is a prefixed option, then the value is simply the - // rest of the name... so fall through to later processing, by - // setting up the argument name flags and value fields. - // - if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { - ArgNameEnd = ArgName+Length; - Value = ArgNameEnd; - I = Opts.find(std::string(ArgName, ArgNameEnd)); - assert(I->second == PGOpt); - } else if (PGOpt) { - // This must be a grouped option... handle all of them now... - assert(isGrouping(PGOpt) && "Broken getOptionPred!"); - - do { - // Move current arg name out of RealName into RealArgName... - std::string RealArgName(RealName.begin(),RealName.begin()+Length); - RealName.erase(RealName.begin(), RealName.begin()+Length); - - // Because ValueRequired is an invalid flag for grouped arguments, - // we don't need to pass argc/argv in... - // - assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && - "Option can not be cl::Grouping AND cl::ValueRequired!"); - int Dummy; - ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), "", - 0, 0, Dummy); - - // Get the next grouping option... - if (!RealName.empty()) - PGOpt = getOptionPred(RealName, Length, isGrouping); - } while (!RealName.empty() && PGOpt); - - if (RealName.empty()) // Processed all of the options, move on - continue; // to the next argv[] value... - - // If RealName is not empty, that means we did not match one of the - // options! This is an error. - // - I = Opts.end(); - } - } - - Handler = I != Opts.end() ? I->second : 0; - } - } - - if (Handler == 0) { - std::cerr << "Unknown command line argument '" << argv[i] << "'. Try: '" - << argv[0] << " --help'\n"; - ErrorParsing = true; - continue; - } - - // Check to see if this option accepts a comma separated list of values. If - // it does, we have to split up the value into multiple values... - if (Handler->getMiscFlags() & CommaSeparated) { - std::string Val(Value); - std::string::size_type Pos = Val.find(','); - - while (Pos != std::string::npos) { - // Process the portion before the comma... - ErrorParsing |= ProvideOption(Handler, ArgName, - std::string(Val.begin(), - Val.begin()+Pos).c_str(), - argc, argv, i); - // Erase the portion before the comma, AND the comma... - Val.erase(Val.begin(), Val.begin()+Pos+1); - Value += Pos+1; // Increment the original value pointer as well... - - // Check for another comma... - Pos = Val.find(','); - } - } - - // If this is a named positional argument, just remember that it is the - // active one... - if (Handler->getFormattingFlag() == cl::Positional) - ActivePositionalArg = Handler; - else - ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); - } - - // Check and handle positional arguments now... - if (NumPositionalRequired > PositionalVals.size()) { - std::cerr << "Not enough positional command line arguments specified!\n" - << "Must specify at least " << NumPositionalRequired - << " positional arguments: See: " << argv[0] << " --help\n"; - ErrorParsing = true; - - - } else if (ConsumeAfterOpt == 0) { - // Positional args have already been handled if ConsumeAfter is specified... - unsigned ValNo = 0, NumVals = PositionalVals.size(); - for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) { - if (RequiresValue(PositionalOpts[i])) { - ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); - --NumPositionalRequired; // We fulfilled our duty... - } - - // If we _can_ give this option more arguments, do so now, as long as we - // do not give it values that others need. 'Done' controls whether the - // option even _WANTS_ any more. - // - bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; - while (NumVals-ValNo > NumPositionalRequired && !Done) { - switch (PositionalOpts[i]->getNumOccurrencesFlag()) { - case cl::Optional: - Done = true; // Optional arguments want _at most_ one value - // FALL THROUGH - case cl::ZeroOrMore: // Zero or more will take all they can get... - case cl::OneOrMore: // One or more will take all they can get... - ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); - break; - default: - assert(0 && "Internal error, unexpected NumOccurrences flag in " - "positional argument processing!"); - } - } - } - } else { - assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); - unsigned ValNo = 0; - for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) - if (RequiresValue(PositionalOpts[j])) - ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], - PositionalVals[ValNo++]); - - // Handle the case where there is just one positional option, and it's - // optional. In this case, we want to give JUST THE FIRST option to the - // positional option and keep the rest for the consume after. The above - // loop would have assigned no values to positional options in this case. - // - if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) - ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], - PositionalVals[ValNo++]); - - // Handle over all of the rest of the arguments to the - // cl::ConsumeAfter command line option... - for (; ValNo != PositionalVals.size(); ++ValNo) - ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, - PositionalVals[ValNo]); - } - - // Loop over args and make sure all required args are specified! - for (std::map<std::string, Option*>::iterator I = Opts.begin(), - E = Opts.end(); I != E; ++I) { - switch (I->second->getNumOccurrencesFlag()) { - case Required: - case OneOrMore: - if (I->second->getNumOccurrences() == 0) { - I->second->error(" must be specified at least once!"); - ErrorParsing = true; - } - // Fall through - default: - break; - } - } - - // Free all of the memory allocated to the map. Command line options may only - // be processed once! - delete CommandLineOptions; - CommandLineOptions = 0; - PositionalOpts.clear(); - - // If we had an error processing our arguments, don't let the program execute - if (ErrorParsing) exit(1); -} - -//===----------------------------------------------------------------------===// -// Option Base class implementation -// - -bool Option::error(std::string Message, const char *ArgName) { - if (ArgName == 0) ArgName = ArgStr; - if (ArgName[0] == 0) - std::cerr << HelpStr; // Be nice for positional arguments - else - std::cerr << "-" << ArgName; - std::cerr << " option" << Message << "\n"; - return true; -} - -bool Option::addOccurrence(const char *ArgName, const std::string &Value) { - NumOccurrences++; // Increment the number of times we have been seen - - switch (getNumOccurrencesFlag()) { - case Optional: - if (NumOccurrences > 1) - return error(": may only occur zero or one times!", ArgName); - break; - case Required: - if (NumOccurrences > 1) - return error(": must occur exactly one time!", ArgName); - // Fall through - case OneOrMore: - case ZeroOrMore: - case ConsumeAfter: break; - default: return error(": bad num occurrences flag value!"); - } - - return handleOccurrence(ArgName, Value); -} - -// addArgument - Tell the system that this Option subclass will handle all -// occurrences of -ArgStr on the command line. -// -void Option::addArgument(const char *ArgStr) { - if (ArgStr[0]) - AddArgument(ArgStr, this); - - if (getFormattingFlag() == Positional) - getPositionalOpts().push_back(this); - else if (getNumOccurrencesFlag() == ConsumeAfter) { - if (!getPositionalOpts().empty() && - getPositionalOpts().front()->getNumOccurrencesFlag() == ConsumeAfter) - error("Cannot specify more than one option with cl::ConsumeAfter!"); - getPositionalOpts().insert(getPositionalOpts().begin(), this); - } -} - -void Option::removeArgument(const char *ArgStr) { - if (ArgStr[0]) - RemoveArgument(ArgStr, this); - - if (getFormattingFlag() == Positional) { - std::vector<Option*>::iterator I = - std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this); - assert(I != getPositionalOpts().end() && "Arg not registered!"); - getPositionalOpts().erase(I); - } else if (getNumOccurrencesFlag() == ConsumeAfter) { - assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this && - "Arg not registered correctly!"); - getPositionalOpts().erase(getPositionalOpts().begin()); - } -} - - -// getValueStr - Get the value description string, using "DefaultMsg" if nothing -// has been specified yet. -// -static const char *getValueStr(const Option &O, const char *DefaultMsg) { - if (O.ValueStr[0] == 0) return DefaultMsg; - return O.ValueStr; -} - -//===----------------------------------------------------------------------===// -// cl::alias class implementation -// - -// Return the width of the option tag for printing... -unsigned alias::getOptionWidth() const { - return std::strlen(ArgStr)+6; -} - -// Print out the option for the alias... -void alias::printOptionInfo(unsigned GlobalWidth) const { - unsigned L = std::strlen(ArgStr); - std::cerr << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " - << HelpStr << "\n"; -} - - - -//===----------------------------------------------------------------------===// -// Parser Implementation code... -// - -// basic_parser implementation -// - -// Return the width of the option tag for printing... -unsigned basic_parser_impl::getOptionWidth(const Option &O) const { - unsigned Len = std::strlen(O.ArgStr); - if (const char *ValName = getValueName()) - Len += std::strlen(getValueStr(O, ValName))+3; - - return Len + 6; -} - -// printOptionInfo - Print out information about this option. The -// to-be-maintained width is specified. -// -void basic_parser_impl::printOptionInfo(const Option &O, - unsigned GlobalWidth) const { - std::cerr << " -" << O.ArgStr; - - if (const char *ValName = getValueName()) - std::cerr << "=<" << getValueStr(O, ValName) << ">"; - - std::cerr << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " - << O.HelpStr << "\n"; -} - - - - -// parser<bool> implementation -// -bool parser<bool>::parse(Option &O, const char *ArgName, - const std::string &Arg, bool &Value) { - if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || - Arg == "1") { - Value = true; - } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { - Value = false; - } else { - return O.error(": '" + Arg + - "' is invalid value for boolean argument! Try 0 or 1"); - } - return false; -} - -// parser<int> implementation -// -bool parser<int>::parse(Option &O, const char *ArgName, - const std::string &Arg, int &Value) { - char *End; - Value = (int)strtol(Arg.c_str(), &End, 0); - if (*End != 0) - return O.error(": '" + Arg + "' value invalid for integer argument!"); - return false; -} - -// parser<unsigned> implementation -// -bool parser<unsigned>::parse(Option &O, const char *ArgName, - const std::string &Arg, unsigned &Value) { - char *End; - long long int V = strtoll(Arg.c_str(), &End, 0); - Value = (unsigned)V; - if (*End != 0 || V < 0 || Value != V) - return O.error(": '" + Arg + "' value invalid for uint argument!"); - return false; -} - -// parser<double>/parser<float> implementation -// -static bool parseDouble(Option &O, const std::string &Arg, double &Value) { - const char *ArgStart = Arg.c_str(); - char *End; - Value = strtod(ArgStart, &End); - if (*End != 0) - return O.error(": '" +Arg+ "' value invalid for floating point argument!"); - return false; -} - -bool parser<double>::parse(Option &O, const char *AN, - const std::string &Arg, double &Val) { - return parseDouble(O, Arg, Val); -} - -bool parser<float>::parse(Option &O, const char *AN, - const std::string &Arg, float &Val) { - double dVal; - if (parseDouble(O, Arg, dVal)) - return true; - Val = (float)dVal; - return false; -} - - - -// generic_parser_base implementation -// - -// findOption - Return the option number corresponding to the specified -// argument string. If the option is not found, getNumOptions() is returned. -// -unsigned generic_parser_base::findOption(const char *Name) { - unsigned i = 0, e = getNumOptions(); - std::string N(Name); - - while (i != e) - if (getOption(i) == N) - return i; - else - ++i; - return e; -} - - -// Return the width of the option tag for printing... -unsigned generic_parser_base::getOptionWidth(const Option &O) const { - if (O.hasArgStr()) { - unsigned Size = std::strlen(O.ArgStr)+6; - for (unsigned i = 0, e = getNumOptions(); i != e; ++i) - Size = std::max(Size, (unsigned)std::strlen(getOption(i))+8); - return Size; - } else { - unsigned BaseSize = 0; - for (unsigned i = 0, e = getNumOptions(); i != e; ++i) - BaseSize = std::max(BaseSize, (unsigned)std::strlen(getOption(i))+8); - return BaseSize; - } -} - -// printOptionInfo - Print out information about this option. The -// to-be-maintained width is specified. -// -void generic_parser_base::printOptionInfo(const Option &O, - unsigned GlobalWidth) const { - if (O.hasArgStr()) { - unsigned L = std::strlen(O.ArgStr); - std::cerr << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') - << " - " << O.HelpStr << "\n"; - - for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { - unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8; - std::cerr << " =" << getOption(i) << std::string(NumSpaces, ' ') - << " - " << getDescription(i) << "\n"; - } - } else { - if (O.HelpStr[0]) - std::cerr << " " << O.HelpStr << "\n"; - for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { - unsigned L = std::strlen(getOption(i)); - std::cerr << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') - << " - " << getDescription(i) << "\n"; - } - } -} - - -//===----------------------------------------------------------------------===// -// --help and --help-hidden option implementation -// -namespace { - -class HelpPrinter { - unsigned MaxArgLen; - const Option *EmptyArg; - const bool ShowHidden; - - // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. - inline static bool isHidden(std::pair<std::string, Option *> &OptPair) { - return OptPair.second->getOptionHiddenFlag() >= Hidden; - } - inline static bool isReallyHidden(std::pair<std::string, Option *> &OptPair) { - return OptPair.second->getOptionHiddenFlag() == ReallyHidden; - } - -public: - HelpPrinter(bool showHidden) : ShowHidden(showHidden) { - EmptyArg = 0; - } - - void operator=(bool Value) { - if (Value == false) return; - - // Copy Options into a vector so we can sort them as we like... - std::vector<std::pair<std::string, Option*> > Options; - copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options)); - - // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden - Options.erase(std::remove_if(Options.begin(), Options.end(), - std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), - Options.end()); - - // Eliminate duplicate entries in table (from enum flags options, f.e.) - { // Give OptionSet a scope - std::set<Option*> OptionSet; - for (unsigned i = 0; i != Options.size(); ++i) - if (OptionSet.count(Options[i].second) == 0) - OptionSet.insert(Options[i].second); // Add new entry to set - else - Options.erase(Options.begin()+i--); // Erase duplicate - } - - if (ProgramOverview) - std::cerr << "OVERVIEW:" << ProgramOverview << "\n"; - - std::cerr << "USAGE: " << ProgramName << " [options]"; - - // Print out the positional options... - std::vector<Option*> &PosOpts = getPositionalOpts(); - Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... - if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) - CAOpt = PosOpts[0]; - - for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) { - if (PosOpts[i]->ArgStr[0]) - std::cerr << " --" << PosOpts[i]->ArgStr; - std::cerr << " " << PosOpts[i]->HelpStr; - } - - // Print the consume after option info if it exists... - if (CAOpt) std::cerr << " " << CAOpt->HelpStr; - - std::cerr << "\n\n"; - - // Compute the maximum argument length... - MaxArgLen = 0; - for (unsigned i = 0, e = Options.size(); i != e; ++i) - MaxArgLen = std::max(MaxArgLen, Options[i].second->getOptionWidth()); - - std::cerr << "OPTIONS:\n"; - for (unsigned i = 0, e = Options.size(); i != e; ++i) - Options[i].second->printOptionInfo(MaxArgLen); - - // Halt the program if help information is printed - exit(1); - } -}; - - - -// Define the two HelpPrinter instances that are used to print out help, or -// help-hidden... -// -HelpPrinter NormalPrinter(false); -HelpPrinter HiddenPrinter(true); - -cl::opt<HelpPrinter, true, parser<bool> > -HOp("help", cl::desc("display available options (--help-hidden for more)"), - cl::location(NormalPrinter), cl::ValueDisallowed); - -cl::opt<HelpPrinter, true, parser<bool> > -HHOp("help-hidden", cl::desc("display all available options"), - cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); - -} // End anonymous namespace |