X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FCommandLine.cpp;h=2c56e0ffb87eb0fc5e12c06d1f924466a06fd56d;hb=2ec0dbf9616e91952c90ad1c7f7404d9d1ee053c;hp=e349eaa514c425a673f7e30a9db3480ebfbd2b31;hpb=9878d6ae3a535e421f69e0c08e27b259ad1bdbdc;p=oota-llvm.git diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp index e349eaa514c..2c56e0ffb87 100644 --- a/lib/Support/CommandLine.cpp +++ b/lib/Support/CommandLine.cpp @@ -2,8 +2,8 @@ // // 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. // //===----------------------------------------------------------------------===// // @@ -17,7 +17,9 @@ //===----------------------------------------------------------------------===// #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" @@ -29,6 +31,7 @@ #include #include #include +#include using namespace llvm; using namespace cl; @@ -36,6 +39,7 @@ using namespace cl; // 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); @@ -50,6 +54,7 @@ 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() {} @@ -71,17 +76,26 @@ extrahelp::extrahelp(const char *Help) MoreHelp->push_back(Help); } +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. // @@ -89,37 +103,46 @@ void Option::addArgument() { /// 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 (unsigned i = 0, e = OptionNames.size(); i != e; ++i) { + 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[0] << "' defined more than once!\n"; + << 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 (!PositionalOpts.empty() && - PositionalOpts.front()->getNumOccurrencesFlag() == cl::ConsumeAfter) + if (CAOpt) O->error("Cannot specify more than one option with cl::ConsumeAfter!"); - PositionalOpts.insert(PositionalOpts.begin(), O); + 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()); } @@ -129,17 +152,17 @@ static void GetOptionInfo(std::vector &PositionalOpts, 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)); @@ -149,6 +172,9 @@ static Option *LookupOption(const char *&Arg, const char *&Value, 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: @@ -161,6 +187,10 @@ static inline bool ProvideOption(Option *Handler, const char *ArgName, } break; case ValueDisallowed: + 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."); @@ -175,8 +205,35 @@ static inline bool ProvideOption(Option *Handler, const char *ArgName, break; } - // Run the handler now! - return Handler->addOccurrence(i, ArgName, Value ? 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, @@ -200,7 +257,7 @@ 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, +static Option *getOptionPred(std::string Name, size_t &Length, bool (*Pred)(const Option*), std::map &OptionsMap) { @@ -246,7 +303,7 @@ static bool EatsUnboundedNumberOfValues(const Option *O) { 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. @@ -288,7 +345,7 @@ 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"); @@ -306,8 +363,8 @@ void cl::ParseEnvironmentOptions(const char *progName, const char *envVar, // 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); + 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(); @@ -315,31 +372,80 @@ void cl::ParseEnvironmentOptions(const char *progName, const char *envVar, free (*i); } -void cl::ParseCommandLineOptions(int &argc, char **argv, - const char *Overview) { + +/// 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, bool ReadResponseFiles) { // Process all registered options. std::vector PositionalOpts; + std::vector SinkOpts; std::map Opts; - GetOptionInfo(PositionalOpts, Opts); - + GetOptionInfo(PositionalOpts, SinkOpts, Opts); + assert((!Opts.empty() || !PositionalOpts.empty()) && "No options specified!"); - sys::Path progname(argv[0]); + + // 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) { @@ -350,7 +456,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)) @@ -395,6 +501,17 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, 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. @@ -444,7 +561,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, if (Handler == 0) { std::string RealName(ArgName); if (RealName.size() > 1) { - unsigned Length = 0; + size_t Length = 0; Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping, Opts); @@ -487,9 +604,15 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } if (Handler == 0) { - 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; } @@ -528,7 +651,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, << ": 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()) { @@ -540,8 +663,8 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, } 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, PositionalVals[ValNo].second); @@ -575,7 +698,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, @@ -625,6 +748,14 @@ void cl::ParseCommandLineOptions(int &argc, char **argv, 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); } @@ -639,14 +770,16 @@ bool Option::error(std::string Message, const char *ArgName) { cerr << HelpStr; // Be nice for positional arguments else 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 + const std::string &Value, + bool MultiArg) { + if (!MultiArg) + NumOccurrences++; // Increment the number of times we have been seen switch (getNumOccurrencesFlag()) { case Optional: @@ -680,13 +813,13 @@ 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); +void alias::printOptionInfo(size_t GlobalWidth) const { + size_t L = std::strlen(ArgStr); cout << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " << HelpStr << "\n"; } @@ -701,8 +834,8 @@ 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; @@ -713,7 +846,7 @@ unsigned basic_parser_impl::getOptionWidth(const Option &O) const { // to-be-maintained width is specified. // void basic_parser_impl::printOptionInfo(const Option &O, - unsigned GlobalWidth) const { + size_t GlobalWidth) const { cout << " -" << O.ArgStr; if (const char *ValName = getValueName()) @@ -739,6 +872,25 @@ bool parser::parse(Option &O, const char *ArgName, return O.error(": '" + Arg + "' is invalid value for boolean argument! Try 0 or 1"); } + if (IsInvertable && strncmp(ArgName+1, "no-", 3) == 0) + Value = !Value; + 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; } @@ -815,16 +967,16 @@ 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; } } @@ -833,22 +985,22 @@ unsigned generic_parser_base::getOptionWidth(const Option &O) const { // 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); + 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; + size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; cout << " =" << getOption(i) << std::string(NumSpaces, ' ') - << " - " << getDescription(i) << "\n"; + << " - " << getDescription(i) << "\n"; } } else { if (O.HelpStr[0]) cout << " " << O.HelpStr << "\n"; for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { - unsigned L = std::strlen(getOption(i)); + size_t L = std::strlen(getOption(i)); cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') << " - " << getDescription(i) << "\n"; } @@ -863,7 +1015,7 @@ void generic_parser_base::printOptionInfo(const Option &O, namespace { class HelpPrinter { - unsigned MaxArgLen; + size_t MaxArgLen; const Option *EmptyArg; const bool ShowHidden; @@ -876,7 +1028,7 @@ class HelpPrinter { } public: - HelpPrinter(bool showHidden) : ShowHidden(showHidden) { + explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) { EmptyArg = 0; } @@ -885,9 +1037,10 @@ public: // Get all the options. std::vector PositionalOpts; + std::vector SinkOpts; std::map OptMap; - GetOptionInfo(PositionalOpts, OptMap); - + GetOptionInfo(PositionalOpts, SinkOpts, OptMap); + // Copy Options into a vector so we can sort them as we like... std::vector > Opts; copy(OptMap.begin(), OptMap.end(), std::back_inserter(Opts)); @@ -908,17 +1061,17 @@ public: } if (ProgramOverview) - cout << "OVERVIEW:" << ProgramOverview << "\n"; + 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() && + if (!PositionalOpts.empty() && PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) CAOpt = PositionalOpts[0]; - for (unsigned i = CAOpt != 0, e = PositionalOpts.size(); i != e; ++i) { + 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; @@ -931,11 +1084,11 @@ public: // Compute the maximum argument length... MaxArgLen = 0; - for (unsigned i = 0, e = Opts.size(); i != e; ++i) + for (size_t i = 0, e = Opts.size(); i != e; ++i) MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); cout << "OPTIONS:\n"; - for (unsigned i = 0, e = Opts.size(); i != e; ++i) + for (size_t i = 0, e = Opts.size(); i != e; ++i) Opts[i].second->printOptionInfo(MaxArgLen); // Print any extra help the user has declared. @@ -985,6 +1138,7 @@ public: cout << " with assertions"; #endif cout << ".\n"; + cout << " Built " << __DATE__ << "(" << __TIME__ << ").\n"; } void operator=(bool OptionWasSpecified) { if (OptionWasSpecified) {