X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FCommandLine.cpp;h=4922560200a02ced8acfb9827b1dbeb355620861;hb=058a024eb7265239d527680b0a448cdb48102a46;hp=549f42c4e3be7080081d3a8c99fb533f2cfcfd40;hpb=697954c15da58bd8b186dbafdedd8b06db770201;p=oota-llvm.git diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp index 549f42c4e3b..4922560200a 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 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,48 +16,172 @@ // //===----------------------------------------------------------------------===// -#include "Support/CommandLine.h" -#include "Support/STLExtras.h" -#include +#include "llvm/Config/config.h" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/MemoryBuffer.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 +#include +using namespace llvm; using namespace cl; -using std::map; -using std::pair; -using std::vector; -using std::string; -using std::cerr; - -// Return the global command line option vector. Making it a function scoped -// static ensures that it will be initialized correctly before its first use. + +//===----------------------------------------------------------------------===// +// Template instantiations and anchors. // -static map &getOpts() { - static map CommandLineOptions; - return CommandLineOptions; +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 basic_parser); +TEMPLATE_INSTANTIATION(class basic_parser); + +TEMPLATE_INSTANTIATION(class opt); +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() {} +void parser::anchor() {} +void parser::anchor() {} + +//===----------------------------------------------------------------------===// + +// 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 void AddArgument(const string &ArgName, Option *Opt) { - if (getOpts().find(ArgName) != getOpts().end()) { - cerr << "CommandLine Error: Argument '" << ArgName - << "' specified more than once!\n"; - } else { - // Add argument to the argument map! - getOpts().insert(std::make_pair(ArgName, Opt)); +static bool OptionListChanged = false; + +// MarkOptionsChanged - Internal helper function. +void cl::MarkOptionsChanged() { + OptionListChanged = true; +} + +/// RegisteredOptionList - This is the list of the command line options that +/// have statically constructed themselves. +static Option *RegisteredOptionList = 0; + +void Option::addArgument() { + assert(NextRegistered == 0 && "argument multiply registered!"); + + NextRegistered = RegisteredOptionList; + RegisteredOptionList = this; + MarkOptionsChanged(); +} + + +//===----------------------------------------------------------------------===// +// Basic, shared command line option processing machinery. +// + +/// GetOptionInfo - Scan the list of registered options, turning them into data +/// structures that are easier to handle. +static void GetOptionInfo(std::vector &PositionalOpts, + std::vector &SinkOpts, + std::map &OptionsMap) { + std::vector OptionNames; + Option *CAOpt = 0; // The ConsumeAfter option if it exists. + for (Option *O = RegisteredOptionList; O; O = O->getNextRegisteredOption()) { + // If this option wants to handle multiple option names, get the full set. + // This handles enum options like "-O1 -O2" etc. + O->getExtraOptionNames(OptionNames); + if (O->ArgStr[0]) + OptionNames.push_back(O->ArgStr); + + // Handle named options. + for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { + // Add argument to the argument map! + if (!OptionsMap.insert(std::pair(OptionNames[i], + O)).second) { + cerr << ProgramName << ": CommandLine Error: Argument '" + << OptionNames[i] << "' defined more than once!\n"; + } + } + + OptionNames.clear(); + + // Remember information about positional options. + if (O->getFormattingFlag() == cl::Positional) + PositionalOpts.push_back(O); + else if (O->getMiscFlags() & cl::Sink) // Remember sink options + SinkOpts.push_back(O); + else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { + if (CAOpt) + O->error("Cannot specify more than one option with cl::ConsumeAfter!"); + CAOpt = O; + } } + + if (CAOpt) + PositionalOpts.push_back(CAOpt); + + // Make sure that they are in order of registration not backwards. + std::reverse(PositionalOpts.begin(), PositionalOpts.end()); } -static const char *ProgramName = 0; -static const char *ProgramOverview = 0; + +/// 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, + std::map &OptionsMap) { + 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::iterator I = + OptionsMap.find(std::string(Arg, ArgEnd)); + return I != OptionsMap.end() ? I->second : 0; +} static inline bool ProvideOption(Option *Handler, const char *ArgName, const char *Value, int argc, char **argv, int &i) { + // Is this a multi-argument option? + unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); + // 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 { @@ -59,137 +190,553 @@ static inline bool ProvideOption(Option *Handler, const char *ArgName, } break; case ValueDisallowed: - if (*Value != 0) - return Handler->error(" does not allow a value! '" + - string(Value) + "' specified."); + if (NumAdditionalVals > 0) + return Handler->error(": multi-valued option specified" + " with ValueDisallowed modifier!"); + + if (Value) + return Handler->error(" does not allow a value! '" + + std::string(Value) + "' specified."); + break; + case ValueOptional: + break; + default: + cerr << ProgramName + << ": Bad ValueMask flag! CommandLine usage error:" + << Handler->getValueExpectedFlag() << "\n"; + abort(); break; - case ValueOptional: break; - default: cerr << "Bad ValueMask flag! CommandLine usage error:" - << Handler->getValueExpectedFlag() << "\n"; abort(); } - // Run the handler now! - return Handler->addOccurance(ArgName, Value); + // If this isn't a multi-arg option, just run the handler. + if (NumAdditionalVals == 0) { + return Handler->addOccurrence(i, ArgName, Value ? Value : ""); + } + // If it is, run the handle several times. + else { + bool MultiArg = false; + + if (Value) { + if (Handler->addOccurrence(i, ArgName, Value, MultiArg)) + return true; + --NumAdditionalVals; + MultiArg = true; + } + + while (NumAdditionalVals > 0) { + + if (i+1 < argc) { + Value = argv[++i]; + } else { + return Handler->error(": not enough values!"); + } + if (Handler->addOccurrence(i, ArgName, Value, MultiArg)) + return true; + MultiArg = true; + --NumAdditionalVals; + } + return false; + } +} + +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); } -// ValueGroupedArgs - Return true if the specified string is valid as a group -// of single letter arguments stuck together like the 'ls -la' case. + +// 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 inline bool ValidGroupedArgs(string Args) { - for (unsigned i = 0; i < Args.size(); ++i) { - map::iterator I = getOpts().find(string(1, Args[i])); - if (I == getOpts().end()) return false; // Make sure option exists +static Option *getOptionPred(std::string Name, size_t &Length, + bool (*Pred)(const Option*), + std::map &OptionsMap) { + + std::map::iterator OMI = OptionsMap.find(Name); + if (OMI != OptionsMap.end() && Pred(OMI->second)) { + Length = Name.length(); + return OMI->second; + } - // Grouped arguments have no value specified, make sure that if this option - // exists that it can accept no argument. - // - switch (I->second->getValueExpectedFlag()) { - case ValueDisallowed: - case ValueOptional: break; - default: return false; + if (Name.size() == 1) return 0; + do { + Name.erase(Name.end()-1, Name.end()); // Chop off the last character... + OMI = OptionsMap.find(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 ((OMI == OptionsMap.end() || !Pred(OMI->second)) && Name.size() > 1); + + if (OMI != OptionsMap.end() && Pred(OMI->second)) { + Length = Name.length(); + return OMI->second; // 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 &output, + const char *input) { + // Characters which will be treated as token separators: + static const char *const 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; } } - return true; + // 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, bool ReadResponseFiles) { + // 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 = static_cast(newArgv.size()); + ParseCommandLineOptions(newArgc, &newArgv[0], Overview, ReadResponseFiles); + + // Free all the strdup()ed strings. + for (std::vector::iterator i = newArgv.begin(), e = newArgv.end(); + i != e; ++i) + free (*i); +} + + +/// ExpandResponseFiles - Copy the contents of argv into newArgv, +/// substituting the contents of the response files for the arguments +/// of type @file. +static void ExpandResponseFiles(int argc, char** argv, + std::vector& newArgv) { + for (int i = 1; i != argc; ++i) { + char* arg = argv[i]; + + if (arg[0] == '@') { + + sys::PathWithStatus respFile(++arg); + + // Check that the response file is not empty (mmap'ing empty + // files can be problematic). + const sys::FileStatus *FileStat = respFile.getFileStatus(); + if (FileStat && FileStat->getSize() != 0) { + + // Mmap the response file into memory. + OwningPtr + respFilePtr(MemoryBuffer::getFile(respFile.c_str())); + + // If we could open the file, parse its contents, otherwise + // pass the @file option verbatim. + + // TODO: we should also support recursive loading of response files, + // since this is how gcc behaves. (From their man page: "The file may + // itself contain additional @file options; any such options will be + // processed recursively.") + + if (respFilePtr != 0) { + ParseCStringVector(newArgv, respFilePtr->getBufferStart()); + continue; + } + } + } + newArgv.push_back(strdup(arg)); + } } -void cl::ParseCommandLineOptions(int &argc, char **argv, - const char *Overview = 0, int Flags = 0) { - ProgramName = argv[0]; // Save this away safe and snug +void cl::ParseCommandLineOptions(int argc, char **argv, + const char *Overview, bool ReadResponseFiles) { + // Process all registered options. + std::vector PositionalOpts; + std::vector SinkOpts; + std::map Opts; + GetOptionInfo(PositionalOpts, SinkOpts, Opts); + + assert((!Opts.empty() || !PositionalOpts.empty()) && + "No options specified!"); + + // Expand response files. + std::vector newArgv; + if (ReadResponseFiles) { + newArgv.push_back(strdup(argv[0])); + ExpandResponseFiles(argc, argv, newArgv); + argv = &newArgv[0]; + argc = static_cast(newArgv.size()); + } + + // 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; + // 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) { + 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 (size_t 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); + } + HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; + } + + // PositionalVals - A vector of "positional" arguments we accumulate into + // the process at the end... + // + 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 = ""; - if (argv[i][0] != '-') { // Unnamed argument? - map::iterator I = getOpts().find(""); - Handler = I != getOpts().end() ? I->second : 0; - Value = argv[i]; - } else { // We start with a - or --, eat dashes + + // If the option list changed, this means that some command line + // option has just been registered or deregistered. This can occur in + // response to things like -load, etc. If this happens, rescan the options. + if (OptionListChanged) { + PositionalOpts.clear(); + SinkOpts.clear(); + Opts.clear(); + GetOptionInfo(PositionalOpts, SinkOpts, Opts); + OptionListChanged = false; + } + + // 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], 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 && + ConsumeAfterOpt != 0) { + for (++i; i < argc; ++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 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; + Handler = LookupOption(ArgName, Value, Opts); + if (!Handler || Handler->getFormattingFlag() != cl::Positional) { + ProvidePositionalOption(ActivePositionalArg, argv[i], i); + continue; // We are done! + } + + } else { // We start with a '-', must be an argument... ArgName = argv[i]+1; - while (*ArgName == '-') ++ArgName; // Eat leading dashes - - 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) { - string RealName(ArgName, ArgNameEnd); - // Extract arg name part - map::iterator I = getOpts().find(RealName); - - if (I == getOpts().end() && !*Value && RealName.size() > 1) { - // If grouping of single letter arguments is enabled, see if this is a - // legal grouping... - // - if (!(Flags & DisableSingleLetterArgGrouping) && - ValidGroupedArgs(RealName)) { - - for (unsigned i = 0; i < RealName.size(); ++i) { - char ArgName[2] = { 0, 0 }; int Dummy; - ArgName[0] = RealName[i]; - I = getOpts().find(ArgName); - assert(I != getOpts().end() && "ValidGroupedArgs failed!"); - - // Because ValueRequired is an invalid flag for grouped arguments, - // we don't need to pass argc/argv in... - // - ErrorParsing |= ProvideOption(I->second, ArgName, "", - 0, 0, Dummy); - } - continue; - } else if (Flags & EnableSingleLetterArgValue) { - // Check to see if the first letter is a single letter argument that - // have a value that is equal to the rest of the string. If this - // is the case, recognize it now. (Example: -lfoo for a linker) - // - I = getOpts().find(string(1, RealName[0])); - if (I != getOpts().end()) { - // If we are successful, fall through to later processing, by - // setting up the argument name flags and value fields. - // - ArgNameEnd = ArgName+1; - Value = ArgNameEnd; - } - } - } - - - Handler = I != getOpts().end() ? I->second : 0; + Handler = LookupOption(ArgName, Value, Opts); + + // Check to see if this "option" is really a prefixed or grouped argument. + if (Handler == 0) { + std::string RealName(ArgName); + if (RealName.size() > 1) { + size_t Length = 0; + Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping, + Opts); + + // 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) { + 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 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, 0, Dummy); + + // Get the next grouping option... + PGOpt = getOptionPred(RealName, Length, isGrouping, Opts); + } while (PGOpt && Length != RealName.size()); + + Handler = PGOpt; // Ate all of the options. + } + } } } if (Handler == 0) { - cerr << "Unknown command line argument '" << argv[i] << "'. Try: " - << argv[0] << " --help'\n"; - ErrorParsing = true; + if (SinkOpts.empty()) { + cerr << ProgramName << ": Unknown command line argument '" + << argv[i] << "'. Try: '" << argv[0] << " --help'\n"; + ErrorParsing = true; + } else { + for (std::vector::iterator I = SinkOpts.begin(), + E = SinkOpts.end(); I != E ; ++I) + (*I)->addOccurrence(i, "", argv[i]); + } continue; } - ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); + // 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 (Value && 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); + } - // If this option should consume all arguments that come after it... - if (Handler->getNumOccurancesFlag() == ConsumeAfter) { - for (++i; i < argc; ++i) - ErrorParsing |= ProvideOption(Handler, ArgName, argv[i], argc, argv, i); + // Check and handle positional arguments now... + if (NumPositionalRequired > PositionalVals.size()) { + 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 = static_cast(PositionalVals.size()); + for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { + if (RequiresValue(PositionalOpts[i])) { + ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, + PositionalVals[ValNo].second); + 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].first, + PositionalVals[ValNo].second); + ValNo++; + break; + default: + assert(0 && "Internal error, unexpected NumOccurrences flag in " + "positional argument processing!"); + } + } } + } else { + assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); + unsigned ValNo = 0; + for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) + if (RequiresValue(PositionalOpts[j])) { + ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], + 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()) { + ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], + 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].first, + PositionalVals[ValNo].second); } // Loop over args and make sure all required args are specified! - for (map::iterator I = getOpts().begin(), - E = getOpts().end(); I != E; ++I) { - switch (I->second->getNumOccurancesFlag()) { + for (std::map::iterator I = Opts.begin(), + E = Opts.end(); I != E; ++I) { + switch (I->second->getNumOccurrencesFlag()) { case Required: case OneOrMore: - if (I->second->getNumOccurances() == 0) { - I->second->error(" must be specified at least once!"); + if (I->second->getNumOccurrences() == 0) { + I->second->error(" must be specified at least once!"); ErrorParsing = true; } // Fall through @@ -198,9 +745,19 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } } - // Free all of the memory allocated to the vector. Command line options may - // only be processed once! - getOpts().clear(); + // Free all of the memory allocated to the map. Command line options may only + // be processed once! + Opts.clear(); + PositionalOpts.clear(); + MoreHelp->clear(); + + // Free the memory allocated by ExpandResponseFiles. + if (ReadResponseFiles) { + // Free all the strdup()ed strings. + for (std::vector::iterator i = newArgv.begin(), e = newArgv.end(); + i != e; ++i) + free (*i); + } // If we had an error processing our arguments, don't let the program execute if (ErrorParsing) exit(1); @@ -209,298 +766,419 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, //===----------------------------------------------------------------------===// // Option Base class implementation // -Option::Option(const char *argStr, const char *helpStr, int flags) - : NumOccurances(0), Flags(flags), ArgStr(argStr), HelpStr(helpStr) { - AddArgument(ArgStr, this); -} -bool Option::error(string Message, const char *ArgName = 0) { +bool Option::error(std::string Message, const char *ArgName) { if (ArgName == 0) ArgName = ArgStr; - cerr << "-" << ArgName << " option" << Message << "\n"; + if (ArgName[0] == 0) + cerr << HelpStr; // Be nice for positional arguments + else + cerr << ProgramName << ": for the -" << ArgName; + + cerr << " option: " << Message << "\n"; return true; } -bool Option::addOccurance(const char *ArgName, const string &Value) { - NumOccurances++; // Increment the number of times we have been seen +bool Option::addOccurrence(unsigned pos, const char *ArgName, + const std::string &Value, + bool MultiArg) { + if (!MultiArg) + NumOccurrences++; // Increment the number of times we have been seen - switch (getNumOccurancesFlag()) { + switch (getNumOccurrencesFlag()) { case Optional: - if (NumOccurances > 1) + if (NumOccurrences > 1) return error(": may only occur zero or one times!", ArgName); break; case Required: - if (NumOccurances > 1) + 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 occurances flag value!"); + default: return error(": bad num occurrences flag value!"); } - return handleOccurance(ArgName, Value); + return handleOccurrence(pos, ArgName, Value); } + +// 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 Option::getOptionWidth() const { +size_t alias::getOptionWidth() const { return std::strlen(ArgStr)+6; } -void Option::printOptionInfo(unsigned GlobalWidth) const { - unsigned L = std::strlen(ArgStr); - if (L == 0) return; // Don't print the empty arg like this! - cerr << " -" << ArgStr << string(GlobalWidth-L-6, ' ') << " - " +// Print out the option for the alias. +void alias::printOptionInfo(size_t GlobalWidth) const { + size_t L = std::strlen(ArgStr); + cout << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " << HelpStr << "\n"; } + //===----------------------------------------------------------------------===// -// Boolean/flag command line option implementation +// Parser Implementation code... +// + +// basic_parser implementation // -bool Flag::handleOccurance(const char *ArgName, const string &Arg) { - if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || +// Return the width of the option tag for printing... +size_t basic_parser_impl::getOptionWidth(const Option &O) const { + size_t 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, + size_t GlobalWidth) const { + cout << " -" << O.ArgStr; + + if (const char *ValName = getValueName()) + cout << "=<" << getValueStr(O, ValName) << ">"; + + cout << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " + << O.HelpStr << "\n"; +} + + + + +// parser implementation +// +bool parser::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 error(": '" + Arg + - "' is invalid value for boolean argument! Try 0 or 1"); + return O.error(": '" + Arg + + "' is invalid value for boolean argument! Try 0 or 1"); } - return false; } -//===----------------------------------------------------------------------===// -// Integer valued command line option implementation +// parser implementation // -bool Int::handleOccurance(const char *ArgName, const string &Arg) { - const char *ArgStart = Arg.c_str(); - char *End; - Value = (int)strtol(ArgStart, &End, 0); - if (*End != 0) - return error(": '" + Arg + "' value invalid for integer argument!"); - return false; +bool parser::parse(Option &O, const char *ArgName, + const std::string &Arg, boolOrDefault &Value) { + if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || + Arg == "1") { + Value = BOU_TRUE; + } else if (Arg == "false" || Arg == "FALSE" + || Arg == "False" || Arg == "0") { + Value = BOU_FALSE; + } else { + return O.error(": '" + Arg + + "' is invalid value for boolean argument! Try 0 or 1"); + } + return false; } -//===----------------------------------------------------------------------===// -// String valued command line option implementation +// parser implementation // -bool String::handleOccurance(const char *ArgName, const string &Arg) { - *this = Arg; +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) + return O.error(": '" + Arg + "' value invalid for integer argument!"); return false; } -//===----------------------------------------------------------------------===// -// StringList valued command line option implementation +// parser implementation // -bool StringList::handleOccurance(const char *ArgName, const string &Arg) { - push_back(Arg); +bool parser::parse(Option &O, const char *ArgName, + const std::string &Arg, unsigned &Value) { + char *End; + errno = 0; + unsigned long V = strtoul(Arg.c_str(), &End, 0); + Value = (unsigned)V; + if (((V == ULONG_MAX) && (errno == ERANGE)) + || (*End != 0) + || (Value != V)) + return O.error(": '" + Arg + "' value invalid for uint argument!"); return false; } -//===----------------------------------------------------------------------===// -// Enum valued command line option implementation +// parser/parser implementation // -void EnumBase::processValues(va_list Vals) { - while (const char *EnumName = va_arg(Vals, const char *)) { - int EnumVal = va_arg(Vals, int); - const char *EnumDesc = va_arg(Vals, const char *); - ValueMap.push_back(std::make_pair(EnumName, // Add value to value map - std::make_pair(EnumVal, EnumDesc))); - } -} - -// registerArgs - notify the system about these new arguments -void EnumBase::registerArgs() { - for (unsigned i = 0; i < ValueMap.size(); ++i) - AddArgument(ValueMap[i].first, this); +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; } -const char *EnumBase::getArgName(int ID) const { - for (unsigned i = 0; i < ValueMap.size(); ++i) - if (ID == ValueMap[i].second.first) return ValueMap[i].first; - return ""; -} -const char *EnumBase::getArgDescription(int ID) const { - for (unsigned i = 0; i < ValueMap.size(); ++i) - if (ID == ValueMap[i].second.first) return ValueMap[i].second.second; - return ""; +bool parser::parse(Option &O, const char *AN, + const std::string &Arg, double &Val) { + return parseDouble(O, Arg, Val); } - - -bool EnumValueBase::handleOccurance(const char *ArgName, const string &Arg) { - unsigned i; - for (i = 0; i < ValueMap.size(); ++i) - if (ValueMap[i].first == Arg) break; - if (i == ValueMap.size()) - return error(": unrecognized alternative '"+Arg+"'!"); - Value = ValueMap[i].second.first; +bool parser::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; } -// Return the width of the option tag for printing... -unsigned EnumValueBase::getOptionWidth() const { - unsigned BaseSize = Option::getOptionWidth(); - for (unsigned i = 0; i < ValueMap.size(); ++i) - BaseSize = std::max(BaseSize, std::strlen(ValueMap[i].first)+8); - return BaseSize; -} -// printOptionInfo - Print out information about this option. The -// to-be-maintained width is specified. -// -void EnumValueBase::printOptionInfo(unsigned GlobalWidth) const { - Option::printOptionInfo(GlobalWidth); - for (unsigned i = 0; i < ValueMap.size(); ++i) { - unsigned NumSpaces = GlobalWidth-strlen(ValueMap[i].first)-8; - cerr << " =" << ValueMap[i].first << string(NumSpaces, ' ') << " - " - << ValueMap[i].second.second; - - if (i == 0) cerr << " (default)"; - cerr << "\n"; - } -} -//===----------------------------------------------------------------------===// -// Enum flags command line option implementation +// generic_parser_base implementation // -bool EnumFlagsBase::handleOccurance(const char *ArgName, const string &Arg) { - return EnumValueBase::handleOccurance("", ArgName); -} - -unsigned EnumFlagsBase::getOptionWidth() const { - unsigned BaseSize = 0; - for (unsigned i = 0; i < ValueMap.size(); ++i) - BaseSize = std::max(BaseSize, std::strlen(ValueMap[i].first)+6); - return BaseSize; -} - -void EnumFlagsBase::printOptionInfo(unsigned GlobalWidth) const { - for (unsigned i = 0; i < ValueMap.size(); ++i) { - unsigned L = std::strlen(ValueMap[i].first); - cerr << " -" << ValueMap[i].first << string(GlobalWidth-L-6, ' ') << " - " - << ValueMap[i].second.second; - if (i == 0) cerr << " (default)"; - cerr << "\n"; - } -} - - -//===----------------------------------------------------------------------===// -// Enum list command line option implementation +// findOption - Return the option number corresponding to the specified +// argument string. If the option is not found, getNumOptions() is returned. // - -bool EnumListBase::handleOccurance(const char *ArgName, const string &Arg) { - unsigned i; - for (i = 0; i < ValueMap.size(); ++i) - if (ValueMap[i].first == string(ArgName)) break; - if (i == ValueMap.size()) - return error(": CommandLine INTERNAL ERROR", ArgName); - Values.push_back(ValueMap[i].second.first); - return false; +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 EnumListBase::getOptionWidth() const { - unsigned BaseSize = 0; - for (unsigned i = 0; i < ValueMap.size(); ++i) - BaseSize = std::max(BaseSize, std::strlen(ValueMap[i].first)+6); - return BaseSize; +size_t generic_parser_base::getOptionWidth(const Option &O) const { + if (O.hasArgStr()) { + size_t Size = std::strlen(O.ArgStr)+6; + for (unsigned i = 0, e = getNumOptions(); i != e; ++i) + Size = std::max(Size, std::strlen(getOption(i))+8); + return Size; + } else { + size_t BaseSize = 0; + for (unsigned i = 0, e = getNumOptions(); i != e; ++i) + BaseSize = std::max(BaseSize, std::strlen(getOption(i))+8); + return BaseSize; + } } - -// printOptionInfo - Print out information about this option. The +// printOptionInfo - Print out information about this option. The // to-be-maintained width is specified. // -void EnumListBase::printOptionInfo(unsigned GlobalWidth) const { - for (unsigned i = 0; i < ValueMap.size(); ++i) { - unsigned L = std::strlen(ValueMap[i].first); - cerr << " -" << ValueMap[i].first << string(GlobalWidth-L-6, ' ') << " - " - << ValueMap[i].second.second << "\n"; +void generic_parser_base::printOptionInfo(const Option &O, + size_t GlobalWidth) const { + if (O.hasArgStr()) { + size_t L = std::strlen(O.ArgStr); + cout << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') + << " - " << O.HelpStr << "\n"; + + for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { + size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; + cout << " =" << getOption(i) << std::string(NumSpaces, ' ') + << " - " << getDescription(i) << "\n"; + } + } else { + if (O.HelpStr[0]) + cout << " " << O.HelpStr << "\n"; + for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { + size_t L = std::strlen(getOption(i)); + cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') + << " - " << getDescription(i) << "\n"; + } } } //===----------------------------------------------------------------------===// -// Help option... always automatically provided. +// --help and --help-hidden option implementation // -namespace { -// isHidden/isReallyHidden - Predicates to be used to filter down arg lists. -inline bool isHidden(pair &OptPair) { - return OptPair.second->getOptionHiddenFlag() >= Hidden; -} -inline bool isReallyHidden(pair &OptPair) { - return OptPair.second->getOptionHiddenFlag() == ReallyHidden; -} +namespace { -class Help : public Option { - unsigned MaxArgLen; +class HelpPrinter { + size_t MaxArgLen; const Option *EmptyArg; const bool ShowHidden; - virtual bool handleOccurance(const char *ArgName, const string &Arg) { + // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. + inline static bool isHidden(std::pair &OptPair) { + return OptPair.second->getOptionHiddenFlag() >= Hidden; + } + inline static bool isReallyHidden(std::pair &OptPair) { + return OptPair.second->getOptionHiddenFlag() == ReallyHidden; + } + +public: + explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) { + EmptyArg = 0; + } + + void operator=(bool Value) { + if (Value == false) return; + + // Get all the options. + std::vector PositionalOpts; + std::vector SinkOpts; + std::map OptMap; + GetOptionInfo(PositionalOpts, SinkOpts, OptMap); + // Copy Options into a vector so we can sort them as we like... - vector > Options; - copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options)); + std::vector > Opts; + copy(OptMap.begin(), OptMap.end(), std::back_inserter(Opts)); // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden - Options.erase(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.) - std::set OptionSet; - for (unsigned i = 0; i < Options.size(); ) - if (OptionSet.count(Options[i].second) == 0) - OptionSet.insert(Options[i++].second); // Add to set - else - Options.erase(Options.begin()+i); // Erase duplicate - + { // Give OptionSet a scope + std::set OptionSet; + 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 + Opts.erase(Opts.begin()+i--); // Erase duplicate + } if (ProgramOverview) - cerr << "OVERVIEW:" << ProgramOverview << "\n"; - // TODO: Sort options by some criteria + cout << "OVERVIEW: " << ProgramOverview << "\n"; + + cout << "USAGE: " << ProgramName << " [options]"; + + // Print out the positional options. + Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... + if (!PositionalOpts.empty() && + PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) + CAOpt = PositionalOpts[0]; + + for (size_t i = CAOpt != 0, e = PositionalOpts.size(); i != e; ++i) { + if (PositionalOpts[i]->ArgStr[0]) + cout << " --" << PositionalOpts[i]->ArgStr; + cout << " " << PositionalOpts[i]->HelpStr; + } + + // Print the consume after option info if it exists... + if (CAOpt) cout << " " << CAOpt->HelpStr; - cerr << "USAGE: " << ProgramName << " [options]\n\n"; - // TODO: print usage nicer + cout << "\n\n"; // Compute the maximum argument length... MaxArgLen = 0; - for_each(Options.begin(), Options.end(), - bind_obj(this, &Help::getMaxArgLen)); + for (size_t i = 0, e = Opts.size(); i != e; ++i) + MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); - cerr << "OPTIONS:\n"; - for_each(Options.begin(), Options.end(), - bind_obj(this, &Help::printOption)); + cout << "OPTIONS:\n"; + for (size_t i = 0, e = Opts.size(); i != e; ++i) + Opts[i].second->printOptionInfo(MaxArgLen); - return true; // Displaying help is cause to terminate the program - } + // 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(); - void getMaxArgLen(pair OptPair) { - const Option *Opt = OptPair.second; - if (Opt->ArgStr[0] == 0) EmptyArg = Opt; // Capture the empty arg if exists - MaxArgLen = std::max(MaxArgLen, Opt->getOptionWidth()); + // Halt the program since help information was printed + exit(1); } +}; +} // End anonymous namespace - void printOption(pair OptPair) { - const Option *Opt = OptPair.second; - Opt->printOptionInfo(MaxArgLen); - } +// Define the two HelpPrinter instances that are used to print out help, or +// help-hidden... +// +static HelpPrinter NormalPrinter(false); +static HelpPrinter HiddenPrinter(true); + +static cl::opt > +HOp("help", cl::desc("Display available options (--help-hidden for more)"), + cl::location(NormalPrinter), cl::ValueDisallowed); +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: - inline Help(const char *ArgVal, const char *HelpVal, bool showHidden) - : Option(ArgVal, HelpVal, showHidden ? Hidden : 0), ShowHidden(showHidden) { - EmptyArg = 0; + 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"; + cout << " Built " << __DATE__ << "(" << __TIME__ << ").\n"; + } + void operator=(bool OptionWasSpecified) { + if (OptionWasSpecified) { + if (OverrideVersionPrinter == 0) { + print(); + exit(1); + } else { + (*OverrideVersionPrinter)(); + exit(1); + } + } } }; +} // End anonymous namespace -Help HelpOp("help", "display available options" - " (--help-hidden for more)", false); -Help HelpHiddenOpt("help-hidden", "display all available options", true); -} // 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; +}