X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FCommandLine.cpp;h=4922560200a02ced8acfb9827b1dbeb355620861;hb=e07715cfba5528dfa368b25d484602ca2b0e1892;hp=5abeb8d2ef19fdc2797da2baee991b44a929fba7;hpb=c540ebbc1b7c2f6a92a968b4d36137a7332cea32;p=oota-llvm.git diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp index 5abeb8d2ef1..4922560200a 100644 --- a/lib/Support/CommandLine.cpp +++ b/lib/Support/CommandLine.cpp @@ -1,10 +1,10 @@ //===-- 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 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 @@ -17,85 +17,171 @@ //===----------------------------------------------------------------------===// #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; -// Globals for name and overview of program -static const char *ProgramName = ""; +//===----------------------------------------------------------------------===// +// 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 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 std::vector &MoreHelp() { - static std::vector moreHelp; - return moreHelp; -} +static ManagedStatic > MoreHelp; -extrahelp::extrahelp(const char* Help) +extrahelp::extrahelp(const char *Help) : morehelp(Help) { - MoreHelp().push_back(Help); + MoreHelp->push_back(Help); } -//===----------------------------------------------------------------------===// -// Basic, shared command line option processing machinery... -// +static bool OptionListChanged = false; -// 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 &getOpts() { - static std::map CommandLineOptions; - return CommandLineOptions; +// MarkOptionsChanged - Internal helper function. +void cl::MarkOptionsChanged() { + OptionListChanged = true; } -static Option *getOption(const std::string &Str) { - std::map::iterator I = getOpts().find(Str); - return I != getOpts().end() ? I->second : 0; -} +/// RegisteredOptionList - This is the list of the command line options that +/// have statically constructed themselves. +static Option *RegisteredOptionList = 0; -static std::vector &getPositionalOpts() { - static std::vector Positional; - return Positional; +void Option::addArgument() { + assert(NextRegistered == 0 && "argument multiply registered!"); + + NextRegistered = RegisteredOptionList; + RegisteredOptionList = this; + MarkOptionsChanged(); } -static void AddArgument(const char *ArgName, Option *Opt) { - if (getOption(ArgName)) { - std::cerr << ProgramName << ": CommandLine Error: Argument '" - << ArgName << "' defined more than once!\n"; - } else { - // Add argument to the argument map! - getOpts()[ArgName] = Opt; + +//===----------------------------------------------------------------------===// +// 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()); } -// 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) { -#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 - getOpts().erase(ArgName); + +/// 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 { @@ -104,25 +190,56 @@ static inline bool ProvideOption(Option *Handler, const char *ArgName, } break; case ValueDisallowed: - if (*Value != 0) - return Handler->error(" does not allow a value! '" + + 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: + case ValueOptional: break; - default: - std::cerr << ProgramName - << ": Bad ValueMask flag! CommandLine usage error:" - << Handler->getValueExpectedFlag() << "\n"; + default: + cerr << ProgramName + << ": Bad ValueMask flag! CommandLine usage error:" + << Handler->getValueExpectedFlag() << "\n"; abort(); break; } - // Run the handler now! - return Handler->addOccurrence(i, 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, +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); @@ -143,28 +260,29 @@ static inline bool isPrefixedOrGrouping(const Option *O) { // 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)) { +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 Op; + return OMI->second; } if (Name.size() == 1) return 0; do { Name.erase(Name.end()-1, Name.end()); // Chop off the last character... - Op = getOption(Name); + 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 ((Op == 0 || !Pred(Op)) && Name.size() > 1); + } while ((OMI == OptionsMap.end() || !Pred(OMI->second)) && Name.size() > 1); - if (Op && Pred(Op)) { + if (OMI != OptionsMap.end() && Pred(OMI->second)) { Length = Name.length(); - return Op; // Found one! + return OMI->second; // Found one! } return 0; // No option found! } @@ -185,10 +303,10 @@ static bool EatsUnboundedNumberOfValues(const Option *O) { /// using strdup (), so it is the caller's responsibility to free () /// them later. /// -static void ParseCStringVector (std::vector &output, - const char *input) { +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"; + static const char *const delims = " \v\f\t\r\n"; std::string work (input); // Skip past any delims at head of input string. @@ -230,71 +348,107 @@ static void ParseCStringVector (std::vector &output, /// an environment variable (whose name is given in ENVVAR). /// void cl::ParseEnvironmentOptions(const char *progName, const char *envVar, - const char *Overview) { + 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); + 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)); + 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); + 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) { + 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... - Value = ArgEnd; - if (*Value) // If we have an equals sign... - ++Value; // Advance to value... - - if (*Arg == 0) return 0; +/// 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]; - // Look up the option. - std::map &Opts = getOpts(); - std::map::iterator I = - Opts.find(std::string(Arg, ArgEnd)); - return (I != Opts.end()) ? I->second : 0; + 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) { - assert((!getOpts().empty() || !getPositionalOpts().empty()) && - "No options specified, or ParseCommandLineOptions called more" - " than once!"); - 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; - std::map &Opts = getOpts(); - std::vector &PositionalOpts = getPositionalOpts(); - // 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) { @@ -305,7 +459,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // Calculate how many positional values are _required_. bool UnboundedFound = false; - for (unsigned i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); + for (size_t i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); i != e; ++i) { Option *Opt = PositionalOpts[i]; if (RequiresValue(Opt)) @@ -330,6 +484,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } UnboundedFound |= EatsUnboundedNumberOfValues(Opt); } + HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; } // PositionalVals - A vector of "positional" arguments we accumulate into @@ -346,9 +501,20 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, 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 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. @@ -364,7 +530,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // 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(std::make_pair(argv[i],i)); @@ -384,7 +550,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // 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); + Handler = LookupOption(ArgName, Value, Opts); if (!Handler || Handler->getFormattingFlag() != cl::Positional) { ProvidePositionalOption(ActivePositionalArg, argv[i], i); continue; // We are done! @@ -392,15 +558,16 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } else { // We start with a '-', must be an argument... ArgName = argv[i]+1; - Handler = LookupOption(ArgName, Value); + Handler = LookupOption(ArgName, Value, Opts); // Check to see if this "option" is really a prefixed or grouped argument. - if (Handler == 0 && *Value == 0) { + if (Handler == 0) { std::string RealName(ArgName); if (RealName.size() > 1) { - unsigned Length = 0; - Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); - + 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. @@ -413,13 +580,13 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } 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... // @@ -427,12 +594,12 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, "Option can not be cl::Grouping AND cl::ValueRequired!"); int Dummy; ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), - "", 0, 0, Dummy); - + 0, 0, 0, Dummy); + // Get the next grouping option... - PGOpt = getOptionPred(RealName, Length, isGrouping); + PGOpt = getOptionPred(RealName, Length, isGrouping, Opts); } while (PGOpt && Length != RealName.size()); - + Handler = PGOpt; // Ate all of the options. } } @@ -440,15 +607,21 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } if (Handler == 0) { - std::cerr << ProgramName << ": 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; } // 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(','); @@ -471,25 +644,32 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // active one... if (Handler->getFormattingFlag() == cl::Positional) ActivePositionalArg = Handler; - else + else ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); } // Check and handle positional arguments now... if (NumPositionalRequired > PositionalVals.size()) { - std::cerr << ProgramName - << ": Not enough positional command line arguments specified!\n" - << "Must specify at least " << NumPositionalRequired - << " positional arguments: See: " << argv[0] << " --help\n"; - ErrorParsing = true; + 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) { + 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, + ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, PositionalVals[ValNo].second); ValNo++; --NumPositionalRequired; // We fulfilled our duty... @@ -521,7 +701,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } else { assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); unsigned ValNo = 0; - for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) + for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) if (RequiresValue(PositionalOpts[j])) { ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], PositionalVals[ValNo].first, @@ -540,7 +720,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, 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) @@ -550,7 +730,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } // Loop over args and make sure all required args are specified! - for (std::map::iterator I = Opts.begin(), + for (std::map::iterator I = Opts.begin(), E = Opts.end(); I != E; ++I) { switch (I->second->getNumOccurrencesFlag()) { case Required: @@ -567,9 +747,17 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, // Free all of the memory allocated to the map. Command line options may only // be processed once! - getOpts().clear(); + Opts.clear(); PositionalOpts.clear(); - MoreHelp().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); @@ -582,15 +770,19 @@ 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 << ProgramName << ": for the -" << ArgName; - std::cerr << " option: " << Message << "\n"; + cerr << ProgramName << ": for the -" << ArgName; + + cerr << " option: " << Message << "\n"; return true; } -bool Option::addOccurrence(unsigned pos, const char *ArgName, const std::string &Value) { - NumOccurrences++; // 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 (getNumOccurrencesFlag()) { case Optional: @@ -610,39 +802,6 @@ bool Option::addOccurrence(unsigned pos, const char *ArgName, const std::string return handleOccurrence(pos, 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::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. @@ -657,15 +816,15 @@ static const char *getValueStr(const Option &O, const char *DefaultMsg) { // // Return the width of the option tag for printing... -unsigned alias::getOptionWidth() const { +size_t 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"; +// 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"; } @@ -678,26 +837,26 @@ void alias::printOptionInfo(unsigned GlobalWidth) const { // // Return the width of the option tag for printing... -unsigned basic_parser_impl::getOptionWidth(const Option &O) const { - unsigned Len = std::strlen(O.ArgStr); +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 +// 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; + size_t GlobalWidth) const { + 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"; } @@ -707,7 +866,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") { @@ -719,13 +878,30 @@ bool parser::parse(Option &O, const char *ArgName, return false; } +// parser implementation +// +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; +} + // parser implementation // 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; } @@ -751,7 +927,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; } @@ -792,42 +968,42 @@ unsigned generic_parser_base::findOption(const char *Name) { // Return the width of the option tag for printing... -unsigned generic_parser_base::getOptionWidth(const Option &O) const { +size_t generic_parser_base::getOptionWidth(const Option &O) const { if (O.hasArgStr()) { - unsigned Size = std::strlen(O.ArgStr)+6; + size_t 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); + Size = std::max(Size, std::strlen(getOption(i))+8); return Size; } else { - unsigned BaseSize = 0; + size_t BaseSize = 0; for (unsigned i = 0, e = getNumOptions(); i != e; ++i) - BaseSize = std::max(BaseSize, (unsigned)std::strlen(getOption(i))+8); + 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 generic_parser_base::printOptionInfo(const Option &O, - unsigned GlobalWidth) const { + size_t GlobalWidth) const { if (O.hasArgStr()) { - unsigned L = std::strlen(O.ArgStr); - std::cerr << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') - << " - " << O.HelpStr << "\n"; + 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) { - unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8; - std::cerr << " =" << getOption(i) << std::string(NumSpaces, ' ') - << " - " << getDescription(i) << "\n"; + size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; + 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"; + size_t L = std::strlen(getOption(i)); + cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') + << " - " << getDescription(i) << "\n"; } } } @@ -840,7 +1016,7 @@ void generic_parser_base::printOptionInfo(const Option &O, namespace { class HelpPrinter { - unsigned MaxArgLen; + size_t MaxArgLen; const Option *EmptyArg; const bool ShowHidden; @@ -853,116 +1029,156 @@ class HelpPrinter { } public: - HelpPrinter(bool showHidden) : ShowHidden(showHidden) { + 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... - std::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(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. 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; + 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) 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 (size_t 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 (size_t i = 0, e = Opts.size(); i != e; ++i) + Opts[i].second->printOptionInfo(MaxArgLen); // Print any extra help the user has declared. - for (std::vector::iterator I = MoreHelp().begin(), - E = MoreHelp().end(); I != E; ++I) - std::cerr << *I; - MoreHelp().clear(); + 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 exit(1); } }; +} // End anonymous namespace + +// 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: + 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) { - std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") " - << PACKAGE_VERSION << " (see http://llvm.cs.uiuc.edu/)\n"; - exit(1); + if (OverrideVersionPrinter == 0) { + print(); + exit(1); + } else { + (*OverrideVersionPrinter)(); + 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); - -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"), - cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); - // Define the --version option that prints out the LLVM version for the tool -VersionPrinter VersionPrinterInstance; -cl::opt > -VersOp("version", cl::desc("display the version"), - cl::location(VersionPrinterInstance), cl::ValueDisallowed); - +static VersionPrinter VersionPrinterInstance; -} // End anonymous namespace +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 + // 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 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; +}