#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Compiler.h"
#include "llvm/ADT/SmallVector.h"
+#include <cassert>
+#include <climits>
+#include <cstdarg>
#include <string>
-#include <vector>
#include <utility>
-#include <cstdarg>
-#include <cassert>
+#include <vector>
namespace llvm {
int NumOccurrences; // The number of times specified
int Flags; // Flags for the argument
unsigned Position; // Position of last occurrence of the option
+ unsigned AdditionalVals;// Greater than 0 for multi-valued option.
Option *NextRegistered; // Singly linked list of registered options.
public:
const char *ArgStr; // The argument string itself (ex: "help", "o")
return Flags & MiscMask;
}
inline unsigned getPosition() const { return Position; }
+ inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
// hasArgStr - Return true if the argstr != ""
bool hasArgStr() const { return ArgStr[0] != 0; }
protected:
explicit Option(unsigned DefaultFlags)
: NumOccurrences(0), Flags(DefaultFlags | NormalFormatting), Position(0),
- NextRegistered(0), ArgStr(""), HelpStr(""), ValueStr("") {
+ AdditionalVals(0), NextRegistered(0),
+ ArgStr(""), HelpStr(""), ValueStr("") {
assert(getNumOccurrencesFlag() != 0 &&
getOptionHiddenFlag() != 0 && "Not all default flags specified!");
}
+ inline void setNumAdditionalVals(unsigned n)
+ { AdditionalVals = n; }
public:
// addArgument - Register this argument with the commandline system.
//
Option *getNextRegisteredOption() const { return NextRegistered; }
// Return the width of the option tag for printing...
- virtual unsigned getOptionWidth() const = 0;
+ virtual size_t getOptionWidth() const = 0;
// printOptionInfo - Print out information about this option. The
// to-be-maintained width is specified.
//
- virtual void printOptionInfo(unsigned GlobalWidth) const = 0;
+ virtual void printOptionInfo(size_t GlobalWidth) const = 0;
- virtual void getExtraOptionNames(std::vector<const char*> &OptionNames) {}
+ virtual void getExtraOptionNames(std::vector<const char*> &) {}
// addOccurrence - Wrapper around handleOccurrence that enforces Flags
//
bool addOccurrence(unsigned pos, const char *ArgName,
- const std::string &Value);
+ const std::string &Value, bool MultiArg = false);
// Prints option name followed by message. Always returns true.
bool error(std::string Message, const char *ArgName = 0);
Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
// Process the varargs portion of the values...
- while (const char *EnumName = va_arg(ValueArgs, const char *)) {
+ while (const char *enumName = va_arg(ValueArgs, const char *)) {
DataType EnumVal = static_cast<DataType>(va_arg(ValueArgs, int));
const char *EnumDesc = va_arg(ValueArgs, const char *);
- Values.push_back(std::make_pair(EnumName, // Add value to value map
+ Values.push_back(std::make_pair(enumName, // Add value to value map
std::make_pair(EnumVal, EnumDesc)));
}
}
template<class Opt>
void apply(Opt &O) const {
- for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ for (unsigned i = 0, e = static_cast<unsigned>(Values.size());
+ i != e; ++i)
O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
Values[i].second.second);
}
virtual const char *getDescription(unsigned N) const = 0;
// Return the width of the option tag for printing...
- virtual unsigned getOptionWidth(const Option &O) const;
+ virtual size_t getOptionWidth(const Option &O) const;
// printOptionInfo - Print out information about this option. The
// to-be-maintained width is specified.
//
- virtual void printOptionInfo(const Option &O, unsigned GlobalWidth) const;
+ virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const;
void initialize(Option &O) {
// All of the modifiers for the option have been processed by now, so the
else
ArgVal = ArgName;
- for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ for (unsigned i = 0, e = static_cast<unsigned>(Values.size());
+ i != e; ++i)
if (ArgVal == Values[i].first) {
V = Values[i].second.first;
return false;
return ValueRequired;
}
- void getExtraOptionNames(std::vector<const char*> &OptionNames) {}
+ void getExtraOptionNames(std::vector<const char*> &) {}
- void initialize(Option &O) {}
+ void initialize(Option &) {}
// Return the width of the option tag for printing...
- unsigned getOptionWidth(const Option &O) const;
+ size_t getOptionWidth(const Option &O) const;
// printOptionInfo - Print out information about this option. The
// to-be-maintained width is specified.
//
- void printOptionInfo(const Option &O, unsigned GlobalWidth) const;
+ void printOptionInfo(const Option &O, size_t GlobalWidth) const;
// getValueName - Overload in subclass to provide a better default value.
virtual const char *getValueName() const { return "value"; }
//
template<>
class parser<bool> : public basic_parser<bool> {
+ const char *ArgStr;
public:
+
// parse - Return true on error.
bool parse(Option &O, const char *ArgName, const std::string &Arg, bool &Val);
+ template <class Opt>
+ void initialize(Opt &O) {
+ ArgStr = O.ArgStr;
+ }
+
enum ValueExpected getValueExpectedFlagDefault() const {
return ValueOptional;
}
class parser<std::string> : public basic_parser<std::string> {
public:
// parse - Return true on error.
- bool parse(Option &O, const char *AN, const std::string &Arg,
+ bool parse(Option &, const char *, const std::string &Arg,
std::string &Value) {
Value = Arg;
return false;
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<std::string>);
+//--------------------------------------------------
+// parser<char>
+//
+template<>
+class parser<char> : public basic_parser<char> {
+public:
+ // parse - Return true on error.
+ bool parse(Option &, const char *, const std::string &Arg,
+ char &Value) {
+ Value = Arg[0];
+ return false;
+ }
+
+ // getValueName - Overload in subclass to provide a better default value.
+ virtual const char *getValueName() const { return "char"; }
+
+ // An out-of-line virtual method to provide a 'home' for this class.
+ virtual void anchor();
+};
+
+EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<char>);
+
//===----------------------------------------------------------------------===//
// applicator class - This class is used because we must use partial
// specialization to handle literal string arguments specially (const char* does
class opt_storage {
DataType *Location; // Where to store the object...
- void check() {
+ void check() const {
assert(Location != 0 && "cl::location(...) not specified for a command "
"line option with external storage, "
"or cl::init specified before cl::location()!!");
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
- setValue(Val);
- setPosition(pos);
+ this->setValue(Val);
+ this->setPosition(pos);
return false;
}
}
// Forward printing stuff to the parser...
- virtual unsigned getOptionWidth() const {return Parser.getOptionWidth(*this);}
- virtual void printOptionInfo(unsigned GlobalWidth) const {
+ virtual size_t getOptionWidth() const {return Parser.getOptionWidth(*this);}
+ virtual void printOptionInfo(size_t GlobalWidth) const {
Parser.printOptionInfo(*this, GlobalWidth);
}
EXTERN_TEMPLATE_INSTANTIATION(class opt<unsigned>);
EXTERN_TEMPLATE_INSTANTIATION(class opt<int>);
EXTERN_TEMPLATE_INSTANTIATION(class opt<std::string>);
+EXTERN_TEMPLATE_INSTANTIATION(class opt<char>);
EXTERN_TEMPLATE_INSTANTIATION(class opt<bool>);
//===----------------------------------------------------------------------===//
}
// Forward printing stuff to the parser...
- virtual unsigned getOptionWidth() const {return Parser.getOptionWidth(*this);}
- virtual void printOptionInfo(unsigned GlobalWidth) const {
+ virtual size_t getOptionWidth() const {return Parser.getOptionWidth(*this);}
+ virtual void printOptionInfo(size_t GlobalWidth) const {
Parser.printOptionInfo(*this, GlobalWidth);
}
return Positions[optnum];
}
+ void setNumAdditionalVals(unsigned n) {
+ Option::setNumAdditionalVals(n);
+ }
+
// One option...
template<class M0t>
explicit list(const M0t &M0) : Option(ZeroOrMore | NotHidden) {
}
};
+// multi_val - Modifier to set the number of additional values.
+struct multi_val {
+ unsigned AdditionalVals;
+ explicit multi_val(unsigned N) : AdditionalVals(N) {}
+
+ template <typename D, typename S, typename P>
+ void apply(list<D, S, P> &L) const { L.setNumAdditionalVals(AdditionalVals); }
+};
+
+
//===----------------------------------------------------------------------===//
// bits_storage class
template<class T>
static unsigned Bit(const T &V) {
unsigned BitPos = reinterpret_cast<unsigned>(V);
- assert(BitPos < sizeof(unsigned) * 8 &&
+ assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
"enum exceeds width of bit vector!");
return 1 << BitPos;
}
template<class T>
static unsigned Bit(const T &V) {
unsigned BitPos = reinterpret_cast<unsigned>(V);
- assert(BitPos < sizeof(unsigned) * 8 &&
+ assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
"enum exceeds width of bit vector!");
return 1 << BitPos;
}
}
// Forward printing stuff to the parser...
- virtual unsigned getOptionWidth() const {return Parser.getOptionWidth(*this);}
- virtual void printOptionInfo(unsigned GlobalWidth) const {
+ virtual size_t getOptionWidth() const {return Parser.getOptionWidth(*this);}
+ virtual void printOptionInfo(size_t GlobalWidth) const {
Parser.printOptionInfo(*this, GlobalWidth);
}
class alias : public Option {
Option *AliasFor;
- virtual bool handleOccurrence(unsigned pos, const char *ArgName,
+ virtual bool handleOccurrence(unsigned pos, const char * /*ArgName*/,
const std::string &Arg) {
return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
}
// Handle printing stuff...
- virtual unsigned getOptionWidth() const;
- virtual void printOptionInfo(unsigned GlobalWidth) const;
+ virtual size_t getOptionWidth() const;
+ virtual void printOptionInfo(size_t GlobalWidth) const;
void done() {
if (!hasArgStr())
projects / oota-llvm.git / blobdiff