X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FCommandLine.cpp;h=e556d76f96580c7e872cd84ae622e69e4404d84d;hb=cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5;hp=84aaeadd43a761fa30034790c51b19344eeccb75;hpb=dd6cb6a43b78732f1a136583ccca4e715bae7d71;p=oota-llvm.git diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp index 84aaeadd43a..e556d76f965 100644 --- a/lib/Support/CommandLine.cpp +++ b/lib/Support/CommandLine.cpp @@ -1,5 +1,12 @@ //===-- CommandLine.cpp - Command line parser implementation --------------===// // +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // 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. @@ -9,72 +16,105 @@ // //===----------------------------------------------------------------------===// -#include "Support/CommandLine.h" +#include "llvm/Config/config.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/Streams.h" +#include "llvm/System/Path.h" #include +#include #include +#include #include -#include - +#include +#include +#include +using namespace llvm; using namespace cl; //===----------------------------------------------------------------------===// -// Basic, shared command line option processing machinery... +// Template instantiations and anchors. // +TEMPLATE_INSTANTIATION(class basic_parser); +TEMPLATE_INSTANTIATION(class basic_parser); +TEMPLATE_INSTANTIATION(class basic_parser); +TEMPLATE_INSTANTIATION(class basic_parser); +TEMPLATE_INSTANTIATION(class basic_parser); +TEMPLATE_INSTANTIATION(class basic_parser); + +TEMPLATE_INSTANTIATION(class opt); +TEMPLATE_INSTANTIATION(class opt); +TEMPLATE_INSTANTIATION(class opt); +TEMPLATE_INSTANTIATION(class opt); + +void Option::anchor() {} +void basic_parser_impl::anchor() {} +void parser::anchor() {} +void parser::anchor() {} +void parser::anchor() {} +void parser::anchor() {} +void parser::anchor() {} +void parser::anchor() {} -// 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 *CommandLineOptions = 0; -static std::map &getOpts() { - if (CommandLineOptions == 0) - CommandLineOptions = new std::map(); - return *CommandLineOptions; -} +//===----------------------------------------------------------------------===// -static Option *getOption(const std::string &Str) { - if (CommandLineOptions == 0) return 0; - std::map::iterator I = CommandLineOptions->find(Str); - return I != CommandLineOptions->end() ? I->second : 0; +// Globals for name and overview of program. Program name is not a string to +// avoid static ctor/dtor issues. +static char ProgramName[80] = ""; +static const char *ProgramOverview = 0; + +// This collects additional help to be printed. +static ManagedStatic > MoreHelp; + +extrahelp::extrahelp(const char *Help) + : morehelp(Help) { + MoreHelp->push_back(Help); } -static std::vector &getPositionalOpts() { - static std::vector Positional; - return Positional; +//===----------------------------------------------------------------------===// +// Basic, shared command line option processing machinery. +// + +static ManagedStatic > Options; +static ManagedStatic > PositionalOptions; + +static Option *getOption(const std::string &Str) { + std::map::iterator I = Options->find(Str); + return I != Options->end() ? I->second : 0; } static void AddArgument(const char *ArgName, Option *Opt) { if (getOption(ArgName)) { - std::cerr << "CommandLine Error: Argument '" << ArgName - << "' defined more than once!\n"; + cerr << ProgramName << ": CommandLine Error: Argument '" + << ArgName << "' defined more than once!\n"; } else { // Add argument to the argument map! - getOpts()[ArgName] = Opt; + (*Options)[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; - } + if (Options->empty()) return; + +#ifndef NDEBUG + // This disgusting HACK is brought to you courtesy of GCC 3.3.2, which ICE's + // If we pass ArgName directly into getOption here. + std::string Tmp = ArgName; + assert(getOption(Tmp) == Opt && "Arg not in map!"); +#endif + Options->erase(ArgName); } -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 (Value == 0) { // No value specified? if (i+1 < argc) { // Steal the next argument, like for '-o filename' Value = argv[++i]; } else { @@ -83,22 +123,28 @@ static inline bool ProvideOption(Option *Handler, const char *ArgName, } break; case ValueDisallowed: - if (*Value != 0) - return Handler->error(" does not allow a value! '" + + if (Value) + 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(); + case ValueOptional: + break; + default: + cerr << ProgramName + << ": Bad ValueMask flag! CommandLine usage error:" + << Handler->getValueExpectedFlag() << "\n"; + abort(); + break; } // Run the handler now! - return Handler->addOccurrence(ArgName, Value); + return Handler->addOccurrence(i, ArgName, Value ? Value : ""); } -static bool ProvidePositionalOption(Option *Handler, std::string &Arg) { - int Dummy; - return ProvideOption(Handler, "", Arg.c_str(), 0, 0, Dummy); +static bool ProvidePositionalOption(Option *Handler, const std::string &Arg, + int i) { + int Dummy = i; + return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy); } @@ -118,7 +164,7 @@ static inline bool isPrefixedOrGrouping(const Option *O) { // static Option *getOptionPred(std::string Name, unsigned &Length, bool (*Pred)(const Option*)) { - + Option *Op = getOption(Name); if (Op && Pred(Op)) { Length = Name.length(); @@ -152,20 +198,131 @@ static bool EatsUnboundedNumberOfValues(const Option *O) { 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 &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 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::iterator i = newArgv.begin(), e = newArgv.end(); + i != e; ++i) + free (*i); +} + +/// LookupOption - Lookup the option specified by the specified option on the +/// command line. If there is a value specified (after an equal sign) return +/// that as well. +static Option *LookupOption(const char *&Arg, const char *&Value) { + while (*Arg == '-') ++Arg; // Eat leading dashes + + const char *ArgEnd = Arg; + while (*ArgEnd && *ArgEnd != '=') + ++ArgEnd; // Scan till end of argument name. + + if (*ArgEnd == '=') // If we have an equals sign... + Value = ArgEnd+1; // Get the value, not the equals + + + if (*Arg == 0) return 0; + + // Look up the option. + std::map &Opts = *Options; + std::map::iterator I = + Opts.find(std::string(Arg, ArgEnd)); + return (I != Opts.end()) ? I->second : 0; +} + void cl::ParseCommandLineOptions(int &argc, char **argv, const char *Overview) { - assert((!getOpts().empty() || !getPositionalOpts().empty()) && + assert((!Options->empty() || !PositionalOptions->empty()) && "No options specified, or ParseCommandLineOptions called more" " than once!"); - ProgramName = argv[0]; // Save this away safe and snug + sys::Path progname(argv[0]); + + // Copy the program name into ProgName, making sure not to overflow it. + std::string ProgName = sys::Path(argv[0]).getLast(); + if (ProgName.size() > 79) ProgName.resize(79); + strcpy(ProgramName, ProgName.c_str()); + ProgramOverview = Overview; bool ErrorParsing = false; - std::map &Opts = getOpts(); - std::vector &PositionalOpts = getPositionalOpts(); + std::map &Opts = *Options; + std::vector &PositionalOpts = *PositionalOptions; // Check out the positional arguments to collect information about them. unsigned NumPositionalRequired = 0; + + // Determine whether or not there are an unlimited number of positionals + bool HasUnlimitedPositionals = false; + Option *ConsumeAfterOpt = 0; if (!PositionalOpts.empty()) { if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { @@ -189,9 +346,10 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, 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) { // 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! + } 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 " @@ -200,68 +358,75 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } UnboundedFound |= EatsUnboundedNumberOfValues(Opt); } + HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; } - // PositionalVals - A vector of "positional" arguments we accumulate into to - // processes at the end... + // PositionalVals - A vector of "positional" arguments we accumulate into + // the process at the end... // - std::vector PositionalVals; + std::vector > 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 *Value = 0; 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 see "--" already. + // itself, or if we have seen "--" already. // if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { // Positional argument! - if (!PositionalOpts.empty()) { - PositionalVals.push_back(argv[i]); + if (ActivePositionalArg) { + ProvidePositionalOption(ActivePositionalArg, argv[i], i); + continue; // We are done! + } else if (!PositionalOpts.empty()) { + PositionalVals.push_back(std::make_pair(argv[i],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 && + if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt != 0) { for (++i; i < argc; ++i) - PositionalVals.push_back(argv[i]); + PositionalVals.push_back(std::make_pair(argv[i],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... + } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && + !DashDashFound) { + DashDashFound = true; // This is the mythical "--"? + continue; // Don't try to process it as an argument itself. + } else if (ActivePositionalArg && + (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { + // If there is a positional argument eating options, check to see if this + // option is another positional argument. If so, treat it as an argument, + // otherwise feed it to the eating positional. 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 iself. + Handler = LookupOption(ArgName, Value); + if (!Handler || Handler->getFormattingFlag() != cl::Positional) { + ProvidePositionalOption(ActivePositionalArg, argv[i], i); + continue; // We are done! } - 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::iterator I = Opts.find(RealName); + } else { // We start with a '-', must be an argument... + ArgName = argv[i]+1; + Handler = LookupOption(ArgName, Value); - if (I == Opts.end() && !*Value && RealName.size() > 1) { - // Check to see if this "option" is really a prefixed or grouped - // argument... - // + // Check to see if this "option" is really a prefixed or grouped argument. + if (Handler == 0) { + std::string RealName(ArgName); + if (RealName.size() > 1) { unsigned Length = 0; Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); @@ -270,57 +435,49 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // 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); + Value = ArgName+Length; + assert(Opts.find(std::string(ArgName, Value)) != Opts.end() && + Opts.find(std::string(ArgName, Value))->second == PGOpt); + Handler = PGOpt; } else if (PGOpt) { - // This must be a grouped option... handle all of them now... + // This must be a grouped option... handle 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); + 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... - // + // 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); + ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), + 0, 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... + PGOpt = getOptionPred(RealName, Length, isGrouping); + } while (PGOpt && Length != RealName.size()); - // If RealName is not empty, that means we did not match one of the - // options! This is an error. - // - I = Opts.end(); + Handler = PGOpt; // Ate all of the options. } - } - - Handler = I != Opts.end() ? I->second : 0; + } } } if (Handler == 0) { - std::cerr << "Unknown command line argument '" << argv[i] << "'. Try: " - << argv[0] << " --help'\n"; + cerr << ProgramName << ": 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) { + if (Value && Handler->getMiscFlags() & CommaSeparated) { std::string Val(Value); std::string::size_type Pos = Val.find(','); @@ -338,23 +495,39 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, Pos = Val.find(','); } } - ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); + + // 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"; + cerr << ProgramName + << ": Not enough positional command line arguments specified!\n" + << "Must specify at least " << NumPositionalRequired + << " positional arguments: See: " << argv[0] << " --help\n"; + + ErrorParsing = true; + } else if (!HasUnlimitedPositionals + && PositionalVals.size() > PositionalOpts.size()) { + cerr << ProgramName + << ": Too many positional arguments specified!\n" + << "Can specify at most " << PositionalOpts.size() + << " 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++]); + ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, + PositionalVals[ValNo].second); + ValNo++; --NumPositionalRequired; // We fulfilled our duty... } @@ -370,7 +543,10 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // 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++]); + ProvidePositionalOption(PositionalOpts[i], + PositionalVals[ValNo].first, + PositionalVals[ValNo].second); + ValNo++; break; default: assert(0 && "Internal error, unexpected NumOccurrences flag in " @@ -382,34 +558,41 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); unsigned ValNo = 0; for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) - if (RequiresValue(PositionalOpts[j])) + if (RequiresValue(PositionalOpts[j])) { ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], - PositionalVals[ValNo++]); + PositionalVals[ValNo].first, + PositionalVals[ValNo].second); + 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()) + if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], - PositionalVals[ValNo++]); - + PositionalVals[ValNo].first, + PositionalVals[ValNo].second); + 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]); + PositionalVals[ValNo].first, + PositionalVals[ValNo].second); } // Loop over args and make sure all required args are specified! - for (std::map::iterator I = Opts.begin(), - E = Opts.end(); I != E; ++I) { + for (std::map::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!"); + I->second->error(" must be specified at least once!"); ErrorParsing = true; } // Fall through @@ -420,9 +603,9 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // Free all of the memory allocated to the map. Command line options may only // be processed once! - delete CommandLineOptions; - CommandLineOptions = 0; + Opts.clear(); PositionalOpts.clear(); + MoreHelp->clear(); // If we had an error processing our arguments, don't let the program execute if (ErrorParsing) exit(1); @@ -435,14 +618,16 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, 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 + cerr << HelpStr; // Be nice for positional arguments else - std::cerr << "-" << ArgName; - std::cerr << " option" << Message << "\n"; + cerr << ProgramName << ": for the -" << ArgName; + + cerr << " option: " << Message << "\n"; return true; } -bool Option::addOccurrence(const char *ArgName, const std::string &Value) { +bool Option::addOccurrence(unsigned pos, const char *ArgName, + const std::string &Value) { NumOccurrences++; // Increment the number of times we have been seen switch (getNumOccurrencesFlag()) { @@ -457,41 +642,42 @@ bool Option::addOccurrence(const char *ArgName, const std::string &Value) { case OneOrMore: case ZeroOrMore: case ConsumeAfter: break; - default: return error(": bad num occurances flag value!"); + default: return error(": bad num occurrences flag value!"); } - return handleOccurrence(ArgName, Value); + return handleOccurrence(pos, ArgName, Value); } // addArgument - Tell the system that this Option subclass will handle all -// occurances of -ArgStr on the command line. +// occurrences of -ArgStr on the command line. // void Option::addArgument(const char *ArgStr) { if (ArgStr[0]) AddArgument(ArgStr, this); - else if (getFormattingFlag() == Positional) - getPositionalOpts().push_back(this); + + if (getFormattingFlag() == Positional) + PositionalOptions->push_back(this); else if (getNumOccurrencesFlag() == ConsumeAfter) { - assert((getPositionalOpts().empty() || - getPositionalOpts().front()->getNumOccurrencesFlag() != ConsumeAfter) - && "Cannot specify more than one option with cl::ConsumeAfter " - "specified!"); - getPositionalOpts().insert(getPositionalOpts().begin(), this); + if (!PositionalOptions->empty() && + PositionalOptions->front()->getNumOccurrencesFlag() == ConsumeAfter) + error("Cannot specify more than one option with cl::ConsumeAfter!"); + PositionalOptions->insert(PositionalOptions->begin(), this); } } void Option::removeArgument(const char *ArgStr) { - if (ArgStr[0]) { + if (ArgStr[0]) RemoveArgument(ArgStr, this); - } else if (getFormattingFlag() == Positional) { + + if (getFormattingFlag() == Positional) { std::vector::iterator I = - std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this); - assert(I != getPositionalOpts().end() && "Arg not registered!"); - getPositionalOpts().erase(I); + std::find(PositionalOptions->begin(), PositionalOptions->end(), this); + assert(I != PositionalOptions->end() && "Arg not registered!"); + PositionalOptions->erase(I); } else if (getNumOccurrencesFlag() == ConsumeAfter) { - assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this && + assert(!PositionalOptions->empty() && (*PositionalOptions)[0] == this && "Arg not registered correctly!"); - getPositionalOpts().erase(getPositionalOpts().begin()); + PositionalOptions->erase(PositionalOptions->begin()); } } @@ -513,11 +699,11 @@ unsigned alias::getOptionWidth() const { return std::strlen(ArgStr)+6; } -// Print out the option for the alias... +// 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"; + cout << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " + << HelpStr << "\n"; } @@ -538,18 +724,18 @@ unsigned basic_parser_impl::getOptionWidth(const Option &O) const { return Len + 6; } -// printOptionInfo - Print out information about this option. The +// 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; + cout << " -" << O.ArgStr; if (const char *ValName = getValueName()) - std::cerr << "=<" << getValueStr(O, ValName) << ">"; + cout << "=<" << getValueStr(O, ValName) << ">"; - std::cerr << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " - << O.HelpStr << "\n"; + cout << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " + << O.HelpStr << "\n"; } @@ -559,7 +745,7 @@ void basic_parser_impl::printOptionInfo(const Option &O, // bool parser::parse(Option &O, const char *ArgName, const std::string &Arg, bool &Value) { - if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || + if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || Arg == "1") { Value = true; } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { @@ -577,7 +763,7 @@ bool parser::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) + if (*End != 0) return O.error(": '" + Arg + "' value invalid for integer argument!"); return false; } @@ -587,9 +773,12 @@ bool parser::parse(Option &O, const char *ArgName, bool parser::parse(Option &O, const char *ArgName, const std::string &Arg, unsigned &Value) { char *End; - long long int V = strtoll(Arg.c_str(), &End, 0); + errno = 0; + unsigned long V = strtoul(Arg.c_str(), &End, 0); Value = (unsigned)V; - if (*End != 0 || V < 0 || Value != V) + if (((V == ULONG_MAX) && (errno == ERANGE)) + || (*End != 0) + || (Value != V)) return O.error(": '" + Arg + "' value invalid for uint argument!"); return false; } @@ -600,7 +789,7 @@ 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) + if (*End != 0) return O.error(": '" +Arg+ "' value invalid for floating point argument!"); return false; } @@ -655,28 +844,28 @@ unsigned generic_parser_base::getOptionWidth(const Option &O) const { } } -// printOptionInfo - Print out information about this option. The +// 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"; + cout << " -" << 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"; + cout << " =" << getOption(i) << std::string(NumSpaces, ' ') + << " - " << getDescription(i) << "\n"; } } else { if (O.HelpStr[0]) - std::cerr << " " << O.HelpStr << "\n"; + cout << " " << 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"; + cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') + << " - " << getDescription(i) << "\n"; } } } @@ -685,6 +874,7 @@ void generic_parser_base::printOptionInfo(const Option &O, //===----------------------------------------------------------------------===// // --help and --help-hidden option implementation // + namespace { class HelpPrinter { @@ -709,71 +899,143 @@ public: if (Value == false) return; // Copy Options into a vector so we can sort them as we like... - std::vector > Options; - copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options)); + std::vector > Opts; + copy(Options->begin(), Options->end(), std::back_inserter(Opts)); // 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()); + Opts.erase(std::remove_if(Opts.begin(), Opts.end(), + std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), + Opts.end()); // Eliminate duplicate entries in table (from enum flags options, f.e.) { // Give OptionSet a scope std::set 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 + for (unsigned i = 0; i != Opts.size(); ++i) + if (OptionSet.count(Opts[i].second) == 0) + OptionSet.insert(Opts[i].second); // Add new entry to set else - Options.erase(Options.begin()+i--); // Erase duplicate + Opts.erase(Opts.begin()+i--); // Erase duplicate } if (ProgramOverview) - std::cerr << "OVERVIEW:" << ProgramOverview << "\n"; + cout << "OVERVIEW:" << ProgramOverview << "\n"; - std::cerr << "USAGE: " << ProgramName << " [options]"; + cout << "USAGE: " << ProgramName << " [options]"; - // Print out the positional options... - std::vector &PosOpts = getPositionalOpts(); + // Print out the positional options. + std::vector &PosOpts = *PositionalOptions; 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) - std::cerr << " " << PosOpts[i]->HelpStr; + for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) { + if (PosOpts[i]->ArgStr[0]) + cout << " --" << PosOpts[i]->ArgStr; + cout << " " << PosOpts[i]->HelpStr; + } // Print the consume after option info if it exists... - if (CAOpt) std::cerr << " " << CAOpt->HelpStr; + if (CAOpt) cout << " " << CAOpt->HelpStr; - std::cerr << "\n\n"; + cout << "\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()); + for (unsigned i = 0, e = Opts.size(); i != e; ++i) + MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); - std::cerr << "OPTIONS:\n"; - for (unsigned i = 0, e = Options.size(); i != e; ++i) - Options[i].second->printOptionInfo(MaxArgLen); + cout << "OPTIONS:\n"; + for (unsigned i = 0, e = Opts.size(); i != e; ++i) + Opts[i].second->printOptionInfo(MaxArgLen); - // Halt the program if help information is printed + // Print any extra help the user has declared. + for (std::vector::iterator I = MoreHelp->begin(), + E = MoreHelp->end(); I != E; ++I) + cout << *I; + MoreHelp->clear(); + + // Halt the program since help information was printed + Options->clear(); // Don't bother making option dtors remove from map. exit(1); } }; - - +} // End anonymous namespace // Define the two HelpPrinter instances that are used to print out help, or // help-hidden... // -HelpPrinter NormalPrinter(false); -HelpPrinter HiddenPrinter(true); +static HelpPrinter NormalPrinter(false); +static HelpPrinter HiddenPrinter(true); -cl::opt > -HOp("help", cl::desc("display available options (--help-hidden for more)"), +static cl::opt > +HOp("help", cl::desc("Display available options (--help-hidden for more)"), cl::location(NormalPrinter), cl::ValueDisallowed); -cl::opt > -HHOp("help-hidden", cl::desc("display all available options"), +static cl::opt > +HHOp("help-hidden", cl::desc("Display all available options"), cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); +static void (*OverrideVersionPrinter)() = 0; + +namespace { +class VersionPrinter { +public: + void print() { + cout << "Low Level Virtual Machine (http://llvm.org/):\n"; + cout << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; +#ifdef LLVM_VERSION_INFO + cout << LLVM_VERSION_INFO; +#endif + cout << "\n "; +#ifndef __OPTIMIZE__ + cout << "DEBUG build"; +#else + cout << "Optimized build"; +#endif +#ifndef NDEBUG + cout << " with assertions"; +#endif + cout << ".\n"; + } + void operator=(bool OptionWasSpecified) { + if (OptionWasSpecified) { + if (OverrideVersionPrinter == 0) { + print(); + Options->clear(); // Don't bother making option dtors remove from map. + exit(1); + } else { + (*OverrideVersionPrinter)(); + exit(1); + } + } + } +}; } // End anonymous namespace + + +// Define the --version option that prints out the LLVM version for the tool +static VersionPrinter VersionPrinterInstance; + +static cl::opt > +VersOp("version", cl::desc("Display the version of this program"), + cl::location(VersionPrinterInstance), cl::ValueDisallowed); + +// Utility function for printing the help message. +void cl::PrintHelpMessage() { + // This looks weird, but it actually prints the help message. The + // NormalPrinter variable is a HelpPrinter and the help gets printed when + // its operator= is invoked. That's because the "normal" usages of the + // help printer is to be assigned true/false depending on whether the + // --help option was given or not. Since we're circumventing that we have + // to make it look like --help was given, so we assign true. + NormalPrinter = true; +} + +/// Utility function for printing version number. +void cl::PrintVersionMessage() { + VersionPrinterInstance.print(); +} + +void cl::SetVersionPrinter(void (*func)()) { + OverrideVersionPrinter = func; +}