-//===- Support/CommandLine.h - Flexible Command line parser ------*- C++ -*--=//
+//===- llvm/Support/CommandLine.h - Command line handler --------*- 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
#ifndef LLVM_SUPPORT_COMMANDLINE_H
#define LLVM_SUPPORT_COMMANDLINE_H
+#include "llvm/Support/type_traits.h"
#include <string>
#include <vector>
#include <utility>
#include <cstdarg>
-#include "boost/type_traits/object_traits.hpp"
+#include <cassert>
-#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
//===----------------------------------------------------------------------===//
// 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?
Positional = 0x080, // Is a positional argument, no '-' required
Prefix = 0x100, // Can this option directly prefix its value?
Grouping = 0x180, // Can this option group with other options?
- FormattingMask = 0x180,
+ FormattingMask = 0x180, // Union of the above flags.
};
-enum MiscFlags { // Miscellaneous flags to adjust argument
- CommaSeparated = 0x200, // Should this cl::list split between commas?
- MiscMask = 0x200,
+enum MiscFlags { // Miscellaneous flags to adjust argument
+ CommaSeparated = 0x200, // Should this cl::list split between commas?
+ PositionalEatsArgs = 0x400, // Should this positional cl::list eat -args?
+ MiscMask = 0x600, // Union of the above flags.
};
//
class alias;
class Option {
- friend void cl::ParseCommandLineOptions(int &, char **, const char *, int);
+ friend void cl::ParseCommandLineOptions(int &, char **, const char *);
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(unsigned pos, 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
+ unsigned Position; // Position of last occurrence of the option
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;
}
+ inline unsigned getPosition() const { return Position; }
// hasArgStr - Return true if the argstr != ""
bool hasArgStr() const { return ArgStr[0] != 0; }
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); }
+ void setPosition(unsigned pos) { Position = pos; }
protected:
- Option() : NumOccurances(0), Flags(0),
+ Option() : NumOccurrences(0), Flags(0), Position(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(unsigned pos, 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() {}
};
void apply(Option &O) const { O.setValueStr(Desc); }
};
-
// init - Specify a default (initial) value for the command line argument, if
// the default constructor for the argument type does not give you what you
// want. This is only valid on "opt" arguments, not on "list" arguments.
//
#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, (int)ENUMVAL, DESC
#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, (int)ENUMVAL, DESC
+#define clEnumValEnd ((void*)0)
// values - For custom data types, allow specifying a group of values together
// as the values that go into the mapping that the option handler uses. Note
// 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.
//
}
// parse - Return true on error.
- bool parse(Option &O, const char *ArgName, const std::string &Arg,
+ bool parse(Option &O, const char *ArgName, const std::string &Arg,
DataType &V) {
std::string ArgVal;
if (hasArgStr)
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.
//
void printOptionInfo(const Option &O, unsigned GlobalWidth) const;
-
// getValueName - Overload in subclass to provide a better default value.
virtual const char *getValueName() const { return "value"; }
};
};
+//--------------------------------------------------
+// parser<unsigned>
+//
+template<>
+struct parser<unsigned> : public basic_parser<unsigned> {
+
+ // parse - Return true on error.
+ bool parse(Option &O, const char *AN, 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>
//
template<>
struct parser<std::string> : public basic_parser<std::string> {
// parse - Return true on error.
- bool parse(Option &O, const char *ArgName, const std::string &Arg,
+ bool parse(Option &O, const char *AN, const std::string &Arg,
std::string &Value) {
Value = Arg;
return false;
virtual const char *getValueName() const { return "string"; }
};
-
-
//===----------------------------------------------------------------------===//
// applicator class - This class is used because we must use partial
// specialization to handle literal string arguments specially (const char* does
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) {}
void setValue(const T &V) { Value = V; }
DataType &getValue() { return Value; }
DataType getValue() const { return Value; }
+
+ // If the datatype is a pointer, support -> on it.
+ DataType operator->() const { return Value; }
};
class ParserClass = parser<DataType> >
class opt : public Option,
public opt_storage<DataType, ExternalStorage,
- ::boost::is_class<DataType>::value> {
+ is_class<DataType>::value> {
ParserClass Parser;
- virtual bool handleOccurance(const char *ArgName, const std::string &Arg) {
+ virtual bool handleOccurrence(unsigned pos, const char *ArgName,
+ const std::string &Arg) {
typename ParserClass::parser_data_type Val;
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
setValue(Val);
+ setPosition(pos);
return false;
}
}
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>
template <class DataType, class Storage = bool,
class ParserClass = parser<DataType> >
class list : public Option, public list_storage<DataType, Storage> {
+ std::vector<unsigned> Positions;
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(unsigned pos, const char *ArgName,
+ const std::string &Arg) {
typename ParserClass::parser_data_type Val;
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse Error!
addValue(Val);
+ setPosition(pos);
+ Positions.push_back(pos);
return false;
}
public:
ParserClass &getParser() { return Parser; }
+ unsigned getPosition(unsigned optnum) {
+ assert(optnum < this->size() && "Invalid option index");
+ return Positions[optnum];
+ }
+
// One option...
template<class M0t>
list(const M0t &M0) {
}
};
-
-
//===----------------------------------------------------------------------===//
// Aliased command line option (alias this name to a preexisting name)
//
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(unsigned pos, const char *ArgName,
+ const std::string &Arg) {
+ return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
}
// Aliases default to be hidden...
virtual enum OptionHidden getOptionHiddenFlagDefault() const {return Hidden;}
} // End namespace cl
+} // End namespace llvm
+
#endif
projects / oota-llvm.git / blobdiff