#include <utility>
#include <cstdarg>
#include "boost/type_traits/object_traits.hpp"
-#include <assert.h>
/// cl Namespace - This namespace contains all of the command line option
/// processing machinery. It is intentionally a short name to make qualified
// Flags permitted to be passed to command line arguments
//
-enum NumOccurances { // Flags for the number of occurances allowed...
- Optional = 0x01, // Zero or One occurance
- ZeroOrMore = 0x02, // Zero or more occurances allowed
- Required = 0x03, // One occurance required
- OneOrMore = 0x04, // One or more occurances required
+enum NumOccurrences { // 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
+ OneOrMore = 0x04, // One or more occurrences required
// ConsumeAfter - Indicates that this option is fed anything that follows the
// last positional argument required by the application (it is an error if
//
ConsumeAfter = 0x05,
- OccurancesMask = 0x07,
+ OccurrencesMask = 0x07,
};
enum ValueExpected { // Is a value required for the option?
friend void cl::ParseCommandLineOptions(int &, char **, const char *, int);
friend class alias;
- // handleOccurances - Overriden by subclasses to handle the value passed into
+ // handleOccurrences - Overriden by subclasses to handle the value passed into
// an argument. Should return true if there was an error processing the
// argument and the program should exit.
//
- virtual bool handleOccurance(const char *ArgName, const std::string &Arg) = 0;
+ virtual bool handleOccurrence(const char *ArgName, const std::string &Arg) = 0;
- virtual enum NumOccurances getNumOccurancesFlagDefault() const {
+ virtual enum NumOccurrences getNumOccurrencesFlagDefault() const {
return Optional;
}
virtual enum ValueExpected getValueExpectedFlagDefault() const {
return NormalFormatting;
}
- int NumOccurances; // The number of times specified
+ int NumOccurrences; // The number of times specified
int Flags; // Flags for the argument
public:
const char *ArgStr; // The argument string itself (ex: "help", "o")
const char *HelpStr; // The descriptive text message for --help
const char *ValueStr; // String describing what the value of this option is
- inline enum NumOccurances getNumOccurancesFlag() const {
- int NO = Flags & OccurancesMask;
- return NO ? (enum NumOccurances)NO : getNumOccurancesFlagDefault();
+ inline enum NumOccurrences getNumOccurrencesFlag() const {
+ int NO = Flags & OccurrencesMask;
+ return NO ? (enum NumOccurrences)NO : getNumOccurrencesFlagDefault();
}
inline enum ValueExpected getValueExpectedFlag() const {
int VE = Flags & ValueMask;
Flags |= Flag;
}
- void setNumOccurancesFlag(enum NumOccurances Val) {
- setFlag(Val, OccurancesMask);
+ void setNumOccurrencesFlag(enum NumOccurrences Val) {
+ setFlag(Val, OccurrencesMask);
}
void setValueExpectedFlag(enum ValueExpected Val) { setFlag(Val, ValueMask); }
void setHiddenFlag(enum OptionHidden Val) { setFlag(Val, HiddenMask); }
void setFormattingFlag(enum FormattingFlags V) { setFlag(V, FormattingMask); }
void setMiscFlag(enum MiscFlags M) { setFlag(M, M); }
protected:
- Option() : NumOccurances(0), Flags(0),
+ Option() : NumOccurrences(0), Flags(0),
ArgStr(""), HelpStr(""), ValueStr("") {}
public:
// addArgument - Tell the system that this Option subclass will handle all
- // occurances of -ArgStr on the command line.
+ // occurrences of -ArgStr on the command line.
//
void addArgument(const char *ArgStr);
void removeArgument(const char *ArgStr);
//
virtual void printOptionInfo(unsigned GlobalWidth) const = 0;
- // addOccurance - Wrapper around handleOccurance that enforces Flags
+ // addOccurrence - Wrapper around handleOccurrence that enforces Flags
//
- bool addOccurance(const char *ArgName, const std::string &Value);
+ bool addOccurrence(const char *ArgName, const std::string &Value);
// Prints option name followed by message. Always returns true.
bool error(std::string Message, const char *ArgName = 0);
public:
- inline int getNumOccurances() const { return NumOccurances; }
+ inline int getNumOccurrences() const { return NumOccurrences; }
virtual ~Option() {}
};
// In which case, the value is required. Otherwise if an arg str has not
// been specified, we are of the form:
//
- // -O2 or O2 or -la (where -l and -a are seperate options)
+ // -O2 or O2 or -la (where -l and -a are separate options)
//
// If this is the case, we cannot allow a value.
//
};
+//--------------------------------------------------
+// parser<unsigned>
+//
+template<>
+struct parser<unsigned> : public basic_parser<unsigned> {
+
+ // parse - Return true on error.
+ bool parse(Option &O, const char *ArgName, const std::string &Arg,
+ unsigned &Val);
+
+ // getValueName - Overload in subclass to provide a better default value.
+ virtual const char *getValueName() const { return "uint"; }
+};
+
+
//--------------------------------------------------
// parser<double>
//
static void opt(const char *Str, Opt &O) { O.setArgStr(Str); }
};
-template<> struct applicator<NumOccurances> {
- static void opt(NumOccurances NO, Option &O) { O.setNumOccurancesFlag(NO); }
+template<> struct applicator<NumOccurrences> {
+ static void opt(NumOccurrences NO, Option &O) { O.setNumOccurrencesFlag(NO); }
};
template<> struct applicator<ValueExpected> {
static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
::boost::is_class<DataType>::value> {
ParserClass Parser;
- virtual bool handleOccurance(const char *ArgName, const std::string &Arg) {
+ virtual bool handleOccurrence(const char *ArgName, const std::string &Arg) {
typename ParserClass::parser_data_type Val;
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
class list : public Option, public list_storage<DataType, Storage> {
ParserClass Parser;
- virtual enum NumOccurances getNumOccurancesFlagDefault() const {
+ virtual enum NumOccurrences getNumOccurrencesFlagDefault() const {
return ZeroOrMore;
}
virtual enum ValueExpected getValueExpectedFlagDefault() const {
return Parser.getValueExpectedFlagDefault();
}
- virtual bool handleOccurance(const char *ArgName, const std::string &Arg) {
+ virtual bool handleOccurrence(const char *ArgName, const std::string &Arg) {
typename ParserClass::parser_data_type Val;
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse Error!
class alias : public Option {
Option *AliasFor;
- virtual bool handleOccurance(const char *ArgName, const std::string &Arg) {
- return AliasFor->handleOccurance(AliasFor->ArgStr, Arg);
+ virtual bool handleOccurrence(const char *ArgName, const std::string &Arg) {
+ return AliasFor->handleOccurrence(AliasFor->ArgStr, Arg);
}
// Aliases default to be hidden...
virtual enum OptionHidden getOptionHiddenFlagDefault() const {return Hidden;}
projects / oota-llvm.git / blobdiff