-//===- Support/CommandLine.h - Flexible Command line parser ------*- C++ -*--=//
+//===- Support/CommandLine.h - Flexible Command line parser -----*- C++ -*-===//
+//
+// 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
// creating a tool. It provides a simple, minimalistic interface that is easily
#include <vector>
#include <utility>
#include <cstdarg>
+#include <cassert>
#include "boost/type_traits/object_traits.hpp"
-#include <assert.h>
-
+namespace llvm {
/// cl Namespace - This namespace contains all of the command line option
/// processing machinery. It is intentionally a short name to make qualified
/// usage concise.
//===----------------------------------------------------------------------===//
// ParseCommandLineOptions - Command line option processing entry point.
//
-void cl::ParseCommandLineOptions(int &argc, char **argv,
- const char *Overview = 0);
+void ParseCommandLineOptions(int &argc, char **argv,
+ const char *Overview = 0);
+
+//===----------------------------------------------------------------------===//
+// ParseEnvironmentOptions - Environment variable option processing alternate
+// entry point.
+//
+void ParseEnvironmentOptions(const char *progName, const char *envvar,
+ const char *Overview = 0);
//===----------------------------------------------------------------------===//
// 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 ? static_cast<enum NumOccurrences>(NO)
+ : getNumOccurrencesFlagDefault();
}
inline enum ValueExpected getValueExpectedFlag() const {
int VE = Flags & ValueMask;
- return VE ? (enum ValueExpected)VE : getValueExpectedFlagDefault();
+ return VE ? static_cast<enum ValueExpected>(VE)
+ : getValueExpectedFlagDefault();
}
inline enum OptionHidden getOptionHiddenFlag() const {
int OH = Flags & HiddenMask;
- return OH ? (enum OptionHidden)OH : getOptionHiddenFlagDefault();
+ return OH ? static_cast<enum OptionHidden>(OH)
+ : getOptionHiddenFlagDefault();
}
inline enum FormattingFlags getFormattingFlag() const {
int OH = Flags & FormattingMask;
- return OH ? (enum FormattingFlags)OH : getFormattingFlagDefault();
+ return OH ? static_cast<enum FormattingFlags>(OH)
+ : getFormattingFlagDefault();
}
inline unsigned getMiscFlags() const {
return Flags & MiscMask;
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() {}
};
// Process the varargs portion of the values...
while (const char *EnumName = va_arg(ValueArgs, const char *)) {
- DataType EnumVal = (DataType)va_arg(ValueArgs, int);
+ 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
std::make_pair(EnumVal, EnumDesc)));
// 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.
//
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((DataType)V,HelpStr)));
+ Values.push_back(std::make_pair(Name,
+ std::make_pair(static_cast<DataType>(V),HelpStr)));
}
// removeLiteralOption - Remove the specified option.
};
+//--------------------------------------------------
+// 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); }
void check() {
assert(Location != 0 && "cl::location(...) not specified for a command "
- "line option with external storage!");
+ "line option with external storage, "
+ "or cl::init specified before cl::location()!!");
}
public:
opt_storage() : Location(0) {}
::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!
}
public:
// setInitialValue - Used by the cl::init modifier...
- void setInitialValue(const DataType &V) { setValue(V); }
+ void setInitialValue(const DataType &V) { this->setValue(V); }
ParserClass &getParser() { return Parser; }
- operator DataType() const { return getValue(); }
+ operator DataType() const { return this->getValue(); }
template<class T>
- DataType &operator=(const T &Val) { setValue(Val); return getValue(); }
+ DataType &operator=(const T &Val) {
+ this->setValue(Val);
+ return this->getValue();
+ }
// One option...
template<class M0t>
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;}
} // End namespace cl
+} // End namespace llvm
+
#endif