//===-- CommandLine.cpp - Command line parser implementation --------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This class implements a command line argument processor that is useful when
#include "llvm/Config/config.h"
#include "llvm/Support/CommandLine.h"
#include <algorithm>
+#include <functional>
#include <map>
#include <set>
#include <iostream>
static void AddArgument(const char *ArgName, Option *Opt) {
if (getOption(ArgName)) {
- std::cerr << ProgramName << ": CommandLine Error: Argument '"
+ std::cerr << ProgramName << ": CommandLine Error: Argument '"
<< ArgName << "' defined more than once!\n";
} else {
// Add argument to the argument map!
// RemoveArgument - It's possible that the argument is no longer in the map if
// options have already been processed and the map has been deleted!
-//
+//
static void RemoveArgument(const char *ArgName, Option *Opt) {
if(getOpts().empty()) return;
// 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 {
}
break;
case ValueDisallowed:
- if (*Value != 0)
- return Handler->error(" does not allow a value! '" +
+ if (Value)
+ return Handler->error(" does not allow a value! '" +
std::string(Value) + "' specified.");
break;
- case ValueOptional:
+ case ValueOptional:
break;
- default:
- std::cerr << ProgramName
- << ": Bad ValueMask flag! CommandLine usage error:"
- << Handler->getValueExpectedFlag() << "\n";
+ default:
+ std::cerr << ProgramName
+ << ": Bad ValueMask flag! CommandLine usage error:"
+ << Handler->getValueExpectedFlag() << "\n";
abort();
break;
}
// Run the handler now!
- return Handler->addOccurrence(i, ArgName, Value);
+ return Handler->addOccurrence(i, ArgName, Value ? Value : "");
}
-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);
//
static Option *getOptionPred(std::string Name, unsigned &Length,
bool (*Pred)(const Option*)) {
-
+
Option *Op = getOption(Name);
if (Op && Pred(Op)) {
Length = Name.length();
// 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)
/// 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...
+ ++ArgEnd; // Scan till end of argument name.
+
+ if (*ArgEnd == '=') // If we have an equals sign...
+ Value = ArgEnd+1; // Get the value, not the equals
+
- Value = ArgEnd;
- if (*Value) // If we have an equals sign...
- ++Value; // Advance to value...
-
if (*Arg == 0) return 0;
// Look up the option.
// 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) {
}
UnboundedFound |= EatsUnboundedNumberOfValues(Opt);
}
+ HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt;
}
// PositionalVals - A vector of "positional" arguments we accumulate into
bool DashDashFound = false; // Have we read '--'?
for (int i = 1; i < argc; ++i) {
Option *Handler = 0;
- const char *Value = "";
+ const char *Value = 0;
const char *ArgName = "";
// Check to see if this is a positional argument. This argument is
// 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));
if (RealName.size() > 1) {
unsigned Length = 0;
Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping);
-
+
// If the option is a prefixed option, then the value is simply the
// rest of the name... so fall through to later processing, by
// setting up the argument name flags and value fields.
} 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...
//
"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);
} while (PGOpt && Length != RealName.size());
-
+
Handler = PGOpt; // Ate all of the options.
}
}
// 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(',');
// 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
+ 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;
-
+ } else if (!HasUnlimitedPositionals
+ && PositionalVals.size() > PositionalOpts.size()) {
+ std::cerr << ProgramName
+ << ": Too many positional arguments specified!\n"
+ << "Can specify at most " << PositionalOpts.size()
+ << " positional arguments: See: " << argv[0] << " --help\n";
+ ErrorParsing = true;
} else if (ConsumeAfterOpt == 0) {
// Positional args have already been handled if ConsumeAfter is specified...
unsigned ValNo = 0, NumVals = PositionalVals.size();
for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) {
if (RequiresValue(PositionalOpts[i])) {
- ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
+ ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
PositionalVals[ValNo].second);
ValNo++;
--NumPositionalRequired; // We fulfilled our duty...
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)
}
// Loop over args and make sure all required args are specified!
- for (std::map<std::string, Option*>::iterator I = Opts.begin(),
+ for (std::map<std::string, Option*>::iterator I = Opts.begin(),
E = Opts.end(); I != E; ++I) {
switch (I->second->getNumOccurrencesFlag()) {
case Required:
return true;
}
-bool Option::addOccurrence(unsigned pos, const char *ArgName, const std::string &Value) {
+bool Option::addOccurrence(unsigned pos, const char *ArgName,
+ const std::string &Value) {
NumOccurrences++; // Increment the number of times we have been seen
switch (getNumOccurrencesFlag()) {
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,
//
bool parser<bool>::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") {
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;
}
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;
}
}
}
-// 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,
}
} else {
if (O.HelpStr[0])
- std::cerr << " " << O.HelpStr << "\n";
+ std::cerr << " " << O.HelpStr << "\n";
for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
unsigned L = std::strlen(getOption(i));
std::cerr << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ')
copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options));
// Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden
- Options.erase(std::remove_if(Options.begin(), Options.end(),
+ Options.erase(std::remove_if(Options.begin(), Options.end(),
std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)),
Options.end());
MoreHelp().clear();
// Halt the program since help information was printed
+ getOpts().clear(); // Don't bother making option dtors remove from map.
exit(1);
}
};
public:
void operator=(bool OptionWasSpecified) {
if (OptionWasSpecified) {
- std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") "
- << PACKAGE_VERSION << " (see http://llvm.cs.uiuc.edu/)\n";
+ std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") "
+ << PACKAGE_VERSION << " (see http://llvm.org/)";
+#ifndef NDEBUG
+ std::cerr << " DEBUG BUILD\n";
+#else
+ std::cerr << "\n";
+#endif
+ getOpts().clear(); // Don't bother making option dtors remove from map.
exit(1);
}
}
HelpPrinter NormalPrinter(false);
HelpPrinter HiddenPrinter(true);
-cl::opt<HelpPrinter, true, parser<bool> >
-HOp("help", cl::desc("display available options (--help-hidden for more)"),
+cl::opt<HelpPrinter, true, parser<bool> >
+HOp("help", cl::desc("Display available options (--help-hidden for more)"),
cl::location(NormalPrinter), cl::ValueDisallowed);
cl::opt<HelpPrinter, true, parser<bool> >
-HHOp("help-hidden", cl::desc("display all available options"),
+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<VersionPrinter, true, parser<bool> >
-VersOp("version", cl::desc("display the version"),
+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;
projects / oota-llvm.git / blobdiff