#define LLVM_SUPPORT_COMMANDLINE_H
#include "llvm/Support/type_traits.h"
-#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Compiler.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/Twine.h"
#include <cassert>
#include <climits>
#include <cstdarg>
-#include <string>
#include <utility>
#include <vector>
// Flags permitted to be passed to command line arguments
//
-enum NumOccurrences { // Flags for the number of occurrences allowed
+enum NumOccurrencesFlag { // Flags for the number of occurrences allowed
Optional = 0x01, // Zero or One occurrence
ZeroOrMore = 0x02, // Zero or more occurrences allowed
Required = 0x03, // One occurrence required
};
enum OptionHidden { // Control whether -help shows this option
- NotHidden = 0x20, // Option included in --help & --help-hidden
- Hidden = 0x40, // -help doesn't, but --help-hidden does
- ReallyHidden = 0x60, // Neither --help nor --help-hidden show this arg
+ NotHidden = 0x20, // Option included in -help & -help-hidden
+ Hidden = 0x40, // -help doesn't, but -help-hidden does
+ ReallyHidden = 0x60, // Neither -help nor -help-hidden show this arg
HiddenMask = 0x60
};
// an argument. Should return true if there was an error processing the
// argument and the program should exit.
//
- virtual bool handleOccurrence(unsigned pos, const char *ArgName,
- const std::string &Arg) = 0;
+ virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
+ StringRef Arg) = 0;
virtual enum ValueExpected getValueExpectedFlagDefault() const {
return ValueOptional;
Option *NextRegistered; // Singly linked list of registered options.
public:
const char *ArgStr; // The argument string itself (ex: "help", "o")
- const char *HelpStr; // The descriptive text message for --help
+ const char *HelpStr; // The descriptive text message for -help
const char *ValueStr; // String describing what the value of this option is
- inline enum NumOccurrences getNumOccurrencesFlag() const {
- return static_cast<enum NumOccurrences>(Flags & OccurrencesMask);
+ inline enum NumOccurrencesFlag getNumOccurrencesFlag() const {
+ return static_cast<enum NumOccurrencesFlag>(Flags & OccurrencesMask);
}
inline enum ValueExpected getValueExpectedFlag() const {
int VE = Flags & ValueMask;
Flags |= Flag;
}
- void setNumOccurrencesFlag(enum NumOccurrences Val) {
+ void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) {
setFlag(Val, OccurrencesMask);
}
void setValueExpectedFlag(enum ValueExpected Val) { setFlag(Val, ValueMask); }
getOptionHiddenFlag() != 0 && "Not all default flags specified!");
}
- inline void setNumAdditionalVals(unsigned n)
- { AdditionalVals = n; }
+ inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
public:
// addArgument - Register this argument with the commandline system.
//
//
virtual void printOptionInfo(size_t GlobalWidth) const = 0;
- virtual void getExtraOptionNames(std::vector<const char*> &) {}
+ virtual void getExtraOptionNames(SmallVectorImpl<const char*> &) {}
- // addOccurrence - Wrapper around handleOccurrence that enforces Flags
+ // addOccurrence - Wrapper around handleOccurrence that enforces Flags.
//
- bool addOccurrence(unsigned pos, const char *ArgName,
- const std::string &Value, bool MultiArg = false);
+ bool addOccurrence(unsigned pos, StringRef ArgName,
+ StringRef Value, bool MultiArg = false);
// Prints option name followed by message. Always returns true.
- bool error(std::string Message, const char *ArgName = 0);
+ bool error(const Twine &Message, StringRef ArgName = StringRef());
public:
inline int getNumOccurrences() const { return NumOccurrences; }
// command line option parsers...
//
-// desc - Modifier to set the description shown in the --help output...
+// desc - Modifier to set the description shown in the -help output...
struct desc {
const char *Desc;
desc(const char *Str) : Desc(Str) {}
void apply(Option &O) const { O.setDescription(Desc); }
};
-// value_desc - Modifier to set the value description shown in the --help
+// value_desc - Modifier to set the value description shown in the -help
// output...
struct value_desc {
const char *Desc;
hasArgStr = O.hasArgStr();
}
- void getExtraOptionNames(std::vector<const char*> &OptionNames) {
+ void getExtraOptionNames(SmallVectorImpl<const char*> &OptionNames) {
// If there has been no argstr specified, that means that we need to add an
// argument for every possible option. This ensures that our options are
// vectored to us.
// Default parser implementation - This implementation depends on having a
// mapping of recognized options to values of some sort. In addition to this,
// each entry in the mapping also tracks a help message that is printed with the
-// command line option for --help. Because this is a simple mapping parser, the
+// command line option for -help. Because this is a simple mapping parser, the
// data type can be any unsupported type.
//
template <class DataType>
class parser : public generic_parser_base {
protected:
- SmallVector<std::pair<const char *,
- std::pair<DataType, const char *> >, 8> Values;
+ class OptionInfo {
+ public:
+ OptionInfo(const char *name, DataType v, const char *helpStr) :
+ Name(name), V(v), HelpStr(helpStr) {}
+ const char *Name;
+ DataType V;
+ const char *HelpStr;
+ };
+ SmallVector<OptionInfo, 8> Values;
public:
typedef DataType parser_data_type;
// Implement virtual functions needed by generic_parser_base
unsigned getNumOptions() const { return unsigned(Values.size()); }
- const char *getOption(unsigned N) const { return Values[N].first; }
+ const char *getOption(unsigned N) const { return Values[N].Name; }
const char *getDescription(unsigned N) const {
- return Values[N].second.second;
+ return Values[N].HelpStr;
}
// parse - Return true on error.
- bool parse(Option &O, const char *ArgName, const std::string &Arg,
- DataType &V) {
- std::string ArgVal;
+ bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
+ StringRef ArgVal;
if (hasArgStr)
ArgVal = Arg;
else
for (unsigned i = 0, e = static_cast<unsigned>(Values.size());
i != e; ++i)
- if (ArgVal == Values[i].first) {
- V = Values[i].second.first;
+ if (Values[i].Name == ArgVal) {
+ V = Values[i].V;
return false;
}
- return O.error(": Cannot find option named '" + ArgVal + "'!");
+ return O.error("Cannot find option named '" + ArgVal + "'!");
}
/// addLiteralOption - Add an entry to the mapping table.
template <class DT>
void addLiteralOption(const char *Name, const DT &V, const char *HelpStr) {
assert(findOption(Name) == Values.size() && "Option already exists!");
- Values.push_back(std::make_pair(Name,
- std::make_pair(static_cast<DataType>(V),HelpStr)));
+ OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
+ Values.push_back(X);
MarkOptionsChanged();
}
//--------------------------------------------------
// basic_parser - Super class of parsers to provide boilerplate code
//
-struct basic_parser_impl { // non-template implementation of basic_parser<t>
+class basic_parser_impl { // non-template implementation of basic_parser<t>
+public:
virtual ~basic_parser_impl() {}
enum ValueExpected getValueExpectedFlagDefault() const {
return ValueRequired;
}
- void getExtraOptionNames(std::vector<const char*> &) {}
+ void getExtraOptionNames(SmallVectorImpl<const char*> &) {}
void initialize(Option &) {}
// a typedef for the provided data type.
//
template<class DataType>
-struct basic_parser : public basic_parser_impl {
+class basic_parser : public basic_parser_impl {
+public:
typedef DataType parser_data_type;
};
public:
// parse - Return true on error.
- bool parse(Option &O, const char *ArgName, const std::string &Arg, bool &Val);
+ bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
template <class Opt>
void initialize(Opt &O) {
class parser<boolOrDefault> : public basic_parser<boolOrDefault> {
public:
// parse - Return true on error.
- bool parse(Option &O, const char *ArgName, const std::string &Arg,
- boolOrDefault &Val);
+ bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
enum ValueExpected getValueExpectedFlagDefault() const {
return ValueOptional;
class parser<int> : public basic_parser<int> {
public:
// parse - Return true on error.
- bool parse(Option &O, const char *ArgName, const std::string &Arg, int &Val);
+ bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
// getValueName - Overload in subclass to provide a better default value.
virtual const char *getValueName() const { return "int"; }
class parser<unsigned> : public basic_parser<unsigned> {
public:
// parse - Return true on error.
- bool parse(Option &O, const char *AN, const std::string &Arg, unsigned &Val);
+ bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
// getValueName - Overload in subclass to provide a better default value.
virtual const char *getValueName() const { return "uint"; }
class parser<double> : public basic_parser<double> {
public:
// parse - Return true on error.
- bool parse(Option &O, const char *AN, const std::string &Arg, double &Val);
+ bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
// getValueName - Overload in subclass to provide a better default value.
virtual const char *getValueName() const { return "number"; }
class parser<float> : public basic_parser<float> {
public:
// parse - Return true on error.
- bool parse(Option &O, const char *AN, const std::string &Arg, float &Val);
+ bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
// getValueName - Overload in subclass to provide a better default value.
virtual const char *getValueName() const { return "number"; }
class parser<std::string> : public basic_parser<std::string> {
public:
// parse - Return true on error.
- bool parse(Option &, const char *, const std::string &Arg,
- std::string &Value) {
- Value = Arg;
+ bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
+ Value = Arg.str();
return false;
}
class parser<char> : public basic_parser<char> {
public:
// parse - Return true on error.
- bool parse(Option &, const char *, const std::string &Arg,
- char &Value) {
+ bool parse(Option &, StringRef, StringRef Arg, char &Value) {
Value = Arg[0];
return false;
}
static void opt(const char *Str, Opt &O) { O.setArgStr(Str); }
};
-template<> struct applicator<NumOccurrences> {
- static void opt(NumOccurrences NO, Option &O) { O.setNumOccurrencesFlag(NO); }
+template<> struct applicator<NumOccurrencesFlag> {
+ static void opt(NumOccurrencesFlag NO, Option &O) {
+ O.setNumOccurrencesFlag(NO);
+ }
};
template<> struct applicator<ValueExpected> {
static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
bool setLocation(Option &O, DataType &L) {
if (Location)
- return O.error(": cl::location(x) specified more than once!");
+ return O.error("cl::location(x) specified more than once!");
Location = &L;
return false;
}
DataType &getValue() { check(); return *Location; }
const DataType &getValue() const { check(); return *Location; }
+
+ operator DataType() const { return this->getValue(); }
};
DataType &getValue() { return Value; }
DataType getValue() const { return Value; }
+ operator DataType() const { return getValue(); }
+
// If the datatype is a pointer, support -> on it.
DataType operator->() const { return Value; }
};
is_class<DataType>::value> {
ParserClass Parser;
- virtual bool handleOccurrence(unsigned pos, const char *ArgName,
- const std::string &Arg) {
+ virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
+ StringRef Arg) {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
virtual enum ValueExpected getValueExpectedFlagDefault() const {
return Parser.getValueExpectedFlagDefault();
}
- virtual void getExtraOptionNames(std::vector<const char*> &OptionNames) {
+ virtual void getExtraOptionNames(SmallVectorImpl<const char*> &OptionNames) {
return Parser.getExtraOptionNames(OptionNames);
}
ParserClass &getParser() { return Parser; }
- operator DataType() const { return this->getValue(); }
-
template<class T>
DataType &operator=(const T &Val) {
this->setValue(Val);
bool setLocation(Option &O, StorageClass &L) {
if (Location)
- return O.error(": cl::location(x) specified more than once!");
+ return O.error("cl::location(x) specified more than once!");
Location = &L;
return false;
}
class list_storage<DataType, bool> : public std::vector<DataType> {
public:
template<class T>
- void addValue(const T &V) { push_back(V); }
+ void addValue(const T &V) { std::vector<DataType>::push_back(V); }
};
virtual enum ValueExpected getValueExpectedFlagDefault() const {
return Parser.getValueExpectedFlagDefault();
}
- virtual void getExtraOptionNames(std::vector<const char*> &OptionNames) {
+ virtual void getExtraOptionNames(SmallVectorImpl<const char*> &OptionNames) {
return Parser.getExtraOptionNames(OptionNames);
}
- virtual bool handleOccurrence(unsigned pos, const char *ArgName,
- const std::string &Arg) {
+ virtual bool handleOccurrence(unsigned pos, StringRef ArgName, StringRef Arg){
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse Error!
- addValue(Val);
+ list_storage<DataType, Storage>::addValue(Val);
setPosition(pos);
Positions.push_back(pos);
return false;
bool setLocation(Option &O, unsigned &L) {
if (Location)
- return O.error(": cl::location(x) specified more than once!");
+ return O.error("cl::location(x) specified more than once!");
Location = &L;
return false;
}
template<class T>
static unsigned Bit(const T &V) {
- unsigned BitPos = reinterpret_cast<unsigned>(V);
+ unsigned BitPos = (unsigned)V;
assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
"enum exceeds width of bit vector!");
return 1 << BitPos;
virtual enum ValueExpected getValueExpectedFlagDefault() const {
return Parser.getValueExpectedFlagDefault();
}
- virtual void getExtraOptionNames(std::vector<const char*> &OptionNames) {
+ virtual void getExtraOptionNames(SmallVectorImpl<const char*> &OptionNames) {
return Parser.getExtraOptionNames(OptionNames);
}
- virtual bool handleOccurrence(unsigned pos, const char *ArgName,
- const std::string &Arg) {
+ virtual bool handleOccurrence(unsigned pos, StringRef ArgName, StringRef Arg){
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
class alias : public Option {
Option *AliasFor;
- virtual bool handleOccurrence(unsigned pos, const char * /*ArgName*/,
- const std::string &Arg) {
+ virtual bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
+ StringRef Arg) {
return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
}
// Handle printing stuff...
void done() {
if (!hasArgStr())
- error(": cl::alias must have argument name specified!");
+ error("cl::alias must have argument name specified!");
if (AliasFor == 0)
- error(": cl::alias must have an cl::aliasopt(option) specified!");
+ error("cl::alias must have an cl::aliasopt(option) specified!");
addArgument();
}
public:
void setAliasFor(Option &O) {
if (AliasFor)
- error(": cl::alias must only have one cl::aliasopt(...) specified!");
+ error("cl::alias must only have one cl::aliasopt(...) specified!");
AliasFor = &O;
}
// extrahelp - provide additional help at the end of the normal help
// output. All occurrences of cl::extrahelp will be accumulated and
-// printed to std::cerr at the end of the regular help, just before
+// printed to stderr at the end of the regular help, just before
// exit is called.
struct extrahelp {
const char * morehelp;
void PrintVersionMessage();
// This function just prints the help message, exactly the same way as if the
-// --help option had been given on the command line.
+// -help option had been given on the command line.
// NOTE: THIS FUNCTION TERMINATES THE PROGRAM!
void PrintHelpMessage();
projects / oota-llvm.git / blobdiff