#ifndef LLVM_SUPPORT_COMMANDLINE_H
#define LLVM_SUPPORT_COMMANDLINE_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/Compiler.h"
#include <cassert>
#include <climits>
#include <cstdarg>
#include <utility>
#include <vector>
namespace llvm {
namespace cl {
void ParseCommandLineOptions(int argc, const char *const *argv,
const char *Overview = nullptr);
void ParseEnvironmentOptions(const char *progName, const char *envvar,
const char *Overview = nullptr);
void SetVersionPrinter(void (*func)());
void AddExtraVersionPrinter(void (*func)());
void PrintOptionValues();
class Option;
void AddLiteralOption(Option &O, const char *Name);
enum NumOccurrencesFlag { Optional = 0x00, ZeroOrMore = 0x01, Required = 0x02, OneOrMore = 0x03,
ConsumeAfter = 0x04
};
enum ValueExpected { ValueOptional = 0x01, ValueRequired = 0x02, ValueDisallowed = 0x03 };
enum OptionHidden { NotHidden = 0x00, Hidden = 0x01, ReallyHidden = 0x02 };
enum FormattingFlags {
NormalFormatting = 0x00, Positional = 0x01, Prefix = 0x02, Grouping = 0x03 };
enum MiscFlags { CommaSeparated = 0x01, PositionalEatsArgs = 0x02, Sink = 0x04 };
class OptionCategory {
private:
const char *const Name;
const char *const Description;
void registerCategory();
public:
OptionCategory(const char *const Name,
const char *const Description = nullptr)
: Name(Name), Description(Description) {
registerCategory();
}
const char *getName() const { return Name; }
const char *getDescription() const { return Description; }
};
extern OptionCategory GeneralCategory;
class alias;
class Option {
friend class alias;
virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) = 0;
virtual enum ValueExpected getValueExpectedFlagDefault() const {
return ValueOptional;
}
virtual void anchor();
int NumOccurrences; unsigned Occurrences : 3; unsigned Value : 2;
unsigned HiddenFlag : 2; unsigned Formatting : 2; unsigned Misc : 3;
unsigned Position; unsigned AdditionalVals;
public:
const char *ArgStr; const char *HelpStr; const char *ValueStr; OptionCategory *Category; bool FullyInitialized;
inline enum NumOccurrencesFlag getNumOccurrencesFlag() const {
return (enum NumOccurrencesFlag)Occurrences;
}
inline enum ValueExpected getValueExpectedFlag() const {
return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
}
inline enum OptionHidden getOptionHiddenFlag() const {
return (enum OptionHidden)HiddenFlag;
}
inline enum FormattingFlags getFormattingFlag() const {
return (enum FormattingFlags)Formatting;
}
inline unsigned getMiscFlags() const { return Misc; }
inline unsigned getPosition() const { return Position; }
inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
bool hasArgStr() const { return ArgStr[0] != 0; }
void setArgStr(const char *S);
void setDescription(const char *S) { HelpStr = S; }
void setValueStr(const char *S) { ValueStr = S; }
void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }
void setMiscFlag(enum MiscFlags M) { Misc |= M; }
void setPosition(unsigned pos) { Position = pos; }
void setCategory(OptionCategory &C) { Category = &C; }
protected:
explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
enum OptionHidden Hidden)
: NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0), Position(0),
AdditionalVals(0), ArgStr(""), HelpStr(""), ValueStr(""),
Category(&GeneralCategory), FullyInitialized(false) {}
inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
public:
void addArgument();
void removeArgument();
virtual size_t getOptionWidth() const = 0;
virtual void printOptionInfo(size_t GlobalWidth) const = 0;
virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
virtual void getExtraOptionNames(SmallVectorImpl<const char *> &) {}
virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
bool MultiArg = false);
bool error(const Twine &Message, StringRef ArgName = StringRef());
public:
inline int getNumOccurrences() const { return NumOccurrences; }
virtual ~Option() {}
};
struct desc {
const char *Desc;
desc(const char *Str) : Desc(Str) {}
void apply(Option &O) const { O.setDescription(Desc); }
};
struct value_desc {
const char *Desc;
value_desc(const char *Str) : Desc(Str) {}
void apply(Option &O) const { O.setValueStr(Desc); }
};
template <class Ty> struct initializer {
const Ty &Init;
initializer(const Ty &Val) : Init(Val) {}
template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
};
template <class Ty> initializer<Ty> init(const Ty &Val) {
return initializer<Ty>(Val);
}
template <class Ty> struct LocationClass {
Ty &Loc;
LocationClass(Ty &L) : Loc(L) {}
template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
};
template <class Ty> LocationClass<Ty> location(Ty &L) {
return LocationClass<Ty>(L);
}
struct cat {
OptionCategory &Category;
cat(OptionCategory &c) : Category(c) {}
template <class Opt> void apply(Opt &O) const { O.setCategory(Category); }
};
struct GenericOptionValue {
virtual ~GenericOptionValue() {}
virtual bool compare(const GenericOptionValue &V) const = 0;
private:
virtual void anchor();
};
template <class DataType> struct OptionValue;
template <class DataType, bool isClass>
struct OptionValueBase : public GenericOptionValue {
typedef OptionValue<DataType> WrapperType;
bool hasValue() const { return false; }
const DataType &getValue() const { llvm_unreachable("no default value"); }
template <class DT> void setValue(const DT & ) {}
bool compare(const DataType & ) const { return false; }
bool compare(const GenericOptionValue & ) const override {
return false;
}
};
template <class DataType> class OptionValueCopy : public GenericOptionValue {
DataType Value;
bool Valid;
public:
OptionValueCopy() : Valid(false) {}
bool hasValue() const { return Valid; }
const DataType &getValue() const {
assert(Valid && "invalid option value");
return Value;
}
void setValue(const DataType &V) {
Valid = true;
Value = V;
}
bool compare(const DataType &V) const { return Valid && (Value != V); }
bool compare(const GenericOptionValue &V) const override {
const OptionValueCopy<DataType> &VC =
static_cast<const OptionValueCopy<DataType> &>(V);
if (!VC.hasValue())
return false;
return compare(VC.getValue());
}
};
template <class DataType>
struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
typedef DataType WrapperType;
};
template <class DataType>
struct OptionValue : OptionValueBase<DataType, std::is_class<DataType>::value> {
OptionValue() {}
OptionValue(const DataType &V) { this->setValue(V); }
template <class DT> OptionValue<DataType> &operator=(const DT &V) {
this->setValue(V);
return *this;
}
};
enum boolOrDefault { BOU_UNSET, BOU_TRUE, BOU_FALSE };
template <>
struct OptionValue<cl::boolOrDefault> : OptionValueCopy<cl::boolOrDefault> {
typedef cl::boolOrDefault WrapperType;
OptionValue() {}
OptionValue(const cl::boolOrDefault &V) { this->setValue(V); }
OptionValue<cl::boolOrDefault> &operator=(const cl::boolOrDefault &V) {
setValue(V);
return *this;
}
private:
void anchor() override;
};
template <> struct OptionValue<std::string> : OptionValueCopy<std::string> {
typedef StringRef WrapperType;
OptionValue() {}
OptionValue(const std::string &V) { this->setValue(V); }
OptionValue<std::string> &operator=(const std::string &V) {
setValue(V);
return *this;
}
private:
void anchor() override;
};
#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, int(ENUMVAL), DESC
#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, int(ENUMVAL), DESC
#define clEnumValEnd (reinterpret_cast<void *>(0))
template <class DataType> class ValuesClass {
SmallVector<std::pair<const char *, std::pair<int, const char *>>, 4> Values;
void processValues(va_list Vals);
public:
ValuesClass(const char *EnumName, DataType Val, const char *Desc,
va_list ValueArgs) {
Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
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, std::make_pair(EnumVal, EnumDesc)));
}
}
template <class Opt> void apply(Opt &O) const {
for (size_t i = 0, e = Values.size(); i != e; ++i)
O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
Values[i].second.second);
}
};
template <class DataType>
ValuesClass<DataType> LLVM_END_WITH_NULL
values(const char *Arg, DataType Val, const char *Desc, ...) {
va_list ValueArgs;
va_start(ValueArgs, Desc);
ValuesClass<DataType> Vals(Arg, Val, Desc, ValueArgs);
va_end(ValueArgs);
return Vals;
}
class generic_parser_base {
protected:
class GenericOptionInfo {
public:
GenericOptionInfo(const char *name, const char *helpStr)
: Name(name), HelpStr(helpStr) {}
const char *Name;
const char *HelpStr;
};
public:
generic_parser_base(Option &O) : Owner(O) {}
virtual ~generic_parser_base() {}
virtual unsigned getNumOptions() const = 0;
virtual const char *getOption(unsigned N) const = 0;
virtual const char *getDescription(unsigned N) const = 0;
virtual size_t getOptionWidth(const Option &O) const;
virtual const GenericOptionValue &getOptionValue(unsigned N) const = 0;
virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const;
void printGenericOptionDiff(const Option &O, const GenericOptionValue &V,
const GenericOptionValue &Default,
size_t GlobalWidth) const;
template <class AnyOptionValue>
void printOptionDiff(const Option &O, const AnyOptionValue &V,
const AnyOptionValue &Default,
size_t GlobalWidth) const {
printGenericOptionDiff(O, V, Default, GlobalWidth);
}
void initialize() {}
void getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) {
if (!Owner.hasArgStr())
for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
OptionNames.push_back(getOption(i));
}
enum ValueExpected getValueExpectedFlagDefault() const {
if (Owner.hasArgStr())
return ValueRequired;
else
return ValueDisallowed;
}
unsigned findOption(const char *Name);
protected:
Option &Owner;
};
template <class DataType> class parser : public generic_parser_base {
protected:
class OptionInfo : public GenericOptionInfo {
public:
OptionInfo(const char *name, DataType v, const char *helpStr)
: GenericOptionInfo(name, helpStr), V(v) {}
OptionValue<DataType> V;
};
SmallVector<OptionInfo, 8> Values;
public:
parser(Option &O) : generic_parser_base(O) {}
typedef DataType parser_data_type;
unsigned getNumOptions() const override { return unsigned(Values.size()); }
const char *getOption(unsigned N) const override { return Values[N].Name; }
const char *getDescription(unsigned N) const override {
return Values[N].HelpStr;
}
const GenericOptionValue &getOptionValue(unsigned N) const override {
return Values[N].V;
}
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
StringRef ArgVal;
if (Owner.hasArgStr())
ArgVal = Arg;
else
ArgVal = ArgName;
for (size_t i = 0, e = Values.size(); i != e; ++i)
if (Values[i].Name == ArgVal) {
V = Values[i].V.getValue();
return false;
}
return O.error("Cannot find option named '" + ArgVal + "'!");
}
template <class DT>
void addLiteralOption(const char *Name, const DT &V, const char *HelpStr) {
assert(findOption(Name) == Values.size() && "Option already exists!");
OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
Values.push_back(X);
AddLiteralOption(Owner, Name);
}
void removeLiteralOption(const char *Name) {
unsigned N = findOption(Name);
assert(N != Values.size() && "Option not found!");
Values.erase(Values.begin() + N);
}
};
class basic_parser_impl { public:
basic_parser_impl(Option &O) {}
virtual ~basic_parser_impl() {}
enum ValueExpected getValueExpectedFlagDefault() const {
return ValueRequired;
}
void getExtraOptionNames(SmallVectorImpl<const char *> &) {}
void initialize() {}
size_t getOptionWidth(const Option &O) const;
void printOptionInfo(const Option &O, size_t GlobalWidth) const;
void printOptionNoValue(const Option &O, size_t GlobalWidth) const;
virtual const char *getValueName() const { return "value"; }
virtual void anchor();
protected:
void printOptionName(const Option &O, size_t GlobalWidth) const;
};
template <class DataType> class basic_parser : public basic_parser_impl {
public:
basic_parser(Option &O) : basic_parser_impl(O) {}
typedef DataType parser_data_type;
typedef OptionValue<DataType> OptVal;
};
template <> class parser<bool> : public basic_parser<bool> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
void initialize() {}
enum ValueExpected getValueExpectedFlagDefault() const {
return ValueOptional;
}
const char *getValueName() const override { return nullptr; }
void printOptionDiff(const Option &O, bool V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<bool>);
template <> class parser<boolOrDefault> : public basic_parser<boolOrDefault> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
enum ValueExpected getValueExpectedFlagDefault() const {
return ValueOptional;
}
const char *getValueName() const override { return nullptr; }
void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>);
template <> class parser<int> : public basic_parser<int> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
const char *getValueName() const override { return "int"; }
void printOptionDiff(const Option &O, int V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<int>);
template <> class parser<unsigned> : public basic_parser<unsigned> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
const char *getValueName() const override { return "uint"; }
void printOptionDiff(const Option &O, unsigned V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned>);
template <>
class parser<unsigned long long> : public basic_parser<unsigned long long> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef ArgName, StringRef Arg,
unsigned long long &Val);
const char *getValueName() const override { return "uint"; }
void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>);
template <> class parser<double> : public basic_parser<double> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
const char *getValueName() const override { return "number"; }
void printOptionDiff(const Option &O, double V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<double>);
template <> class parser<float> : public basic_parser<float> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
const char *getValueName() const override { return "number"; }
void printOptionDiff(const Option &O, float V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<float>);
template <> class parser<std::string> : public basic_parser<std::string> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
Value = Arg.str();
return false;
}
const char *getValueName() const override { return "string"; }
void printOptionDiff(const Option &O, StringRef V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<std::string>);
template <> class parser<char> : public basic_parser<char> {
public:
parser(Option &O) : basic_parser(O) {}
bool parse(Option &, StringRef, StringRef Arg, char &Value) {
Value = Arg[0];
return false;
}
const char *getValueName() const override { return "char"; }
void printOptionDiff(const Option &O, char V, OptVal Default,
size_t GlobalWidth) const;
void anchor() override;
};
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<char>);
template <class ParserClass, class DT>
void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,
const OptionValue<DT> &Default, size_t GlobalWidth) {
OptionValue<DT> OV = V;
P.printOptionDiff(O, OV, Default, GlobalWidth);
}
template <class ParserDT, class ValDT> struct OptionDiffPrinter {
void print(const Option &O, const parser<ParserDT> P, const ValDT & ,
const OptionValue<ValDT> & , size_t GlobalWidth) {
P.printOptionNoValue(O, GlobalWidth);
}
};
template <class DT> struct OptionDiffPrinter<DT, DT> {
void print(const Option &O, const parser<DT> P, const DT &V,
const OptionValue<DT> &Default, size_t GlobalWidth) {
P.printOptionDiff(O, V, Default, GlobalWidth);
}
};
template <class ParserClass, class ValDT>
void printOptionDiff(
const Option &O,
const basic_parser<typename ParserClass::parser_data_type> &P,
const ValDT &V, const OptionValue<ValDT> &Default, size_t GlobalWidth) {
OptionDiffPrinter<typename ParserClass::parser_data_type, ValDT> printer;
printer.print(O, static_cast<const ParserClass &>(P), V, Default,
GlobalWidth);
}
template <class Mod> struct applicator {
template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
};
template <unsigned n> struct applicator<char[n]> {
template <class Opt> static void opt(const char *Str, Opt &O) {
O.setArgStr(Str);
}
};
template <unsigned n> struct applicator<const char[n]> {
template <class Opt> static void opt(const char *Str, Opt &O) {
O.setArgStr(Str);
}
};
template <> struct applicator<const char *> {
template <class Opt> static void opt(const char *Str, Opt &O) {
O.setArgStr(Str);
}
};
template <> struct applicator<NumOccurrencesFlag> {
static void opt(NumOccurrencesFlag N, Option &O) {
O.setNumOccurrencesFlag(N);
}
};
template <> struct applicator<ValueExpected> {
static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
};
template <> struct applicator<OptionHidden> {
static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
};
template <> struct applicator<FormattingFlags> {
static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
};
template <> struct applicator<MiscFlags> {
static void opt(MiscFlags MF, Option &O) { O.setMiscFlag(MF); }
};
template <class Mod, class Opt> void apply(const Mod &M, Opt *O) {
applicator<Mod>::opt(M, *O);
}
template <class DataType, bool ExternalStorage, bool isClass>
class opt_storage {
DataType *Location; OptionValue<DataType> Default;
void check_location() const {
assert(Location && "cl::location(...) not specified for a command "
"line option with external storage, "
"or cl::init specified before cl::location()!!");
}
public:
opt_storage() : Location(nullptr) {}
bool setLocation(Option &O, DataType &L) {
if (Location)
return O.error("cl::location(x) specified more than once!");
Location = &L;
Default = L;
return false;
}
template <class T> void setValue(const T &V, bool initial = false) {
check_location();
*Location = V;
if (initial)
Default = V;
}
DataType &getValue() {
check_location();
return *Location;
}
const DataType &getValue() const {
check_location();
return *Location;
}
operator DataType() const { return this->getValue(); }
const OptionValue<DataType> &getDefault() const { return Default; }
};
template <class DataType>
class opt_storage<DataType, false, true> : public DataType {
public:
OptionValue<DataType> Default;
template <class T> void setValue(const T &V, bool initial = false) {
DataType::operator=(V);
if (initial)
Default = V;
}
DataType &getValue() { return *this; }
const DataType &getValue() const { return *this; }
const OptionValue<DataType> &getDefault() const { return Default; }
};
template <class DataType> class opt_storage<DataType, false, false> {
public:
DataType Value;
OptionValue<DataType> Default;
opt_storage() : Value(DataType()), Default(DataType()) {}
template <class T> void setValue(const T &V, bool initial = false) {
Value = V;
if (initial)
Default = V;
}
DataType &getValue() { return Value; }
DataType getValue() const { return Value; }
const OptionValue<DataType> &getDefault() const { return Default; }
operator DataType() const { return getValue(); }
DataType operator->() const { return Value; }
};
template <class DataType, bool ExternalStorage = false,
class ParserClass = parser<DataType>>
class opt : public Option,
public opt_storage<DataType, ExternalStorage,
std::is_class<DataType>::value> {
ParserClass Parser;
bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; this->setValue(Val);
this->setPosition(pos);
return false;
}
enum ValueExpected getValueExpectedFlagDefault() const override {
return Parser.getValueExpectedFlagDefault();
}
void
getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
return Parser.getExtraOptionNames(OptionNames);
}
size_t getOptionWidth() const override {
return Parser.getOptionWidth(*this);
}
void printOptionInfo(size_t GlobalWidth) const override {
Parser.printOptionInfo(*this, GlobalWidth);
}
void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
}
void done() {
addArgument();
Parser.initialize();
}
opt(const opt &) LLVM_DELETED_FUNCTION;
opt &operator=(const opt &) LLVM_DELETED_FUNCTION;
public:
void setInitialValue(const DataType &V) { this->setValue(V, true); }
ParserClass &getParser() { return Parser; }
template <class T> DataType &operator=(const T &Val) {
this->setValue(Val);
return this->getValue();
}
template <class M0t>
explicit opt(const M0t &M0)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
done();
}
template <class M0t, class M1t>
opt(const M0t &M0, const M1t &M1)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
done();
}
template <class M0t, class M1t, class M2t>
opt(const M0t &M0, const M1t &M1, const M2t &M2)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t>
opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t>
opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t>
opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4,
const M5t &M5)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
class M6t>
opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4,
const M5t &M5, const M6t &M6)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
apply(M6, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
class M6t, class M7t>
opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4,
const M5t &M5, const M6t &M6, const M7t &M7)
: Option(Optional, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
apply(M6, this);
apply(M7, this);
done();
}
};
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>);
template <class DataType, class StorageClass> class list_storage {
StorageClass *Location;
public:
list_storage() : Location(0) {}
bool setLocation(Option &O, StorageClass &L) {
if (Location)
return O.error("cl::location(x) specified more than once!");
Location = &L;
return false;
}
template <class T> void addValue(const T &V) {
assert(Location != 0 && "cl::location(...) not specified for a command "
"line option with external storage!");
Location->push_back(V);
}
};
template <class DataType>
class list_storage<DataType, bool> : public std::vector<DataType> {
public:
template <class T> void addValue(const T &V) {
std::vector<DataType>::push_back(V);
}
};
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;
enum ValueExpected getValueExpectedFlagDefault() const override {
return Parser.getValueExpectedFlagDefault();
}
void
getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
return Parser.getExtraOptionNames(OptionNames);
}
bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; list_storage<DataType, Storage>::addValue(Val);
setPosition(pos);
Positions.push_back(pos);
return false;
}
size_t getOptionWidth() const override {
return Parser.getOptionWidth(*this);
}
void printOptionInfo(size_t GlobalWidth) const override {
Parser.printOptionInfo(*this, GlobalWidth);
}
void printOptionValue(size_t , bool ) const override {
}
void done() {
addArgument();
Parser.initialize();
}
list(const list &) LLVM_DELETED_FUNCTION;
list &operator=(const list &) LLVM_DELETED_FUNCTION;
public:
ParserClass &getParser() { return Parser; }
unsigned getPosition(unsigned optnum) const {
assert(optnum < this->size() && "Invalid option index");
return Positions[optnum];
}
void setNumAdditionalVals(unsigned n) { Option::setNumAdditionalVals(n); }
template <class M0t>
explicit list(const M0t &M0)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
done();
}
template <class M0t, class M1t>
list(const M0t &M0, const M1t &M1)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
done();
}
template <class M0t, class M1t, class M2t>
list(const M0t &M0, const M1t &M1, const M2t &M2)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t>
list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t>
list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t>
list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4, const M5t &M5)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
class M6t>
list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4, const M5t &M5, const M6t &M6)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
apply(M6, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
class M6t, class M7t>
list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4, const M5t &M5, const M6t &M6, const M7t &M7)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
apply(M6, this);
apply(M7, this);
done();
}
};
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);
}
};
template <class DataType, class StorageClass> class bits_storage {
unsigned *Location;
template <class T> static unsigned Bit(const T &V) {
unsigned BitPos = reinterpret_cast<unsigned>(V);
assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
"enum exceeds width of bit vector!");
return 1 << BitPos;
}
public:
bits_storage() : Location(nullptr) {}
bool setLocation(Option &O, unsigned &L) {
if (Location)
return O.error("cl::location(x) specified more than once!");
Location = &L;
return false;
}
template <class T> void addValue(const T &V) {
assert(Location != 0 && "cl::location(...) not specified for a command "
"line option with external storage!");
*Location |= Bit(V);
}
unsigned getBits() { return *Location; }
template <class T> bool isSet(const T &V) {
return (*Location & Bit(V)) != 0;
}
};
template <class DataType> class bits_storage<DataType, bool> {
unsigned Bits;
template <class T> static unsigned Bit(const T &V) {
unsigned BitPos = (unsigned)V;
assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
"enum exceeds width of bit vector!");
return 1 << BitPos;
}
public:
template <class T> void addValue(const T &V) { Bits |= Bit(V); }
unsigned getBits() { return Bits; }
template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
};
template <class DataType, class Storage = bool,
class ParserClass = parser<DataType>>
class bits : public Option, public bits_storage<DataType, Storage> {
std::vector<unsigned> Positions;
ParserClass Parser;
enum ValueExpected getValueExpectedFlagDefault() const override {
return Parser.getValueExpectedFlagDefault();
}
void
getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
return Parser.getExtraOptionNames(OptionNames);
}
bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; this->addValue(Val);
setPosition(pos);
Positions.push_back(pos);
return false;
}
size_t getOptionWidth() const override {
return Parser.getOptionWidth(*this);
}
void printOptionInfo(size_t GlobalWidth) const override {
Parser.printOptionInfo(*this, GlobalWidth);
}
void printOptionValue(size_t , bool ) const override {
}
void done() {
addArgument();
Parser.initialize();
}
bits(const bits &) LLVM_DELETED_FUNCTION;
bits &operator=(const bits &) LLVM_DELETED_FUNCTION;
public:
ParserClass &getParser() { return Parser; }
unsigned getPosition(unsigned optnum) const {
assert(optnum < this->size() && "Invalid option index");
return Positions[optnum];
}
template <class M0t>
explicit bits(const M0t &M0)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
done();
}
template <class M0t, class M1t>
bits(const M0t &M0, const M1t &M1)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
done();
}
template <class M0t, class M1t, class M2t>
bits(const M0t &M0, const M1t &M1, const M2t &M2)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t>
bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t>
bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t>
bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4, const M5t &M5)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
class M6t>
bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4, const M5t &M5, const M6t &M6)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
apply(M6, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
class M6t, class M7t>
bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
const M4t &M4, const M5t &M5, const M6t &M6, const M7t &M7)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
apply(M4, this);
apply(M5, this);
apply(M6, this);
apply(M7, this);
done();
}
};
class alias : public Option {
Option *AliasFor;
bool handleOccurrence(unsigned pos, StringRef ,
StringRef Arg) override {
return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
}
bool addOccurrence(unsigned pos, StringRef , StringRef Value,
bool MultiArg = false) override {
return AliasFor->addOccurrence(pos, AliasFor->ArgStr, Value, MultiArg);
}
size_t getOptionWidth() const override;
void printOptionInfo(size_t GlobalWidth) const override;
void printOptionValue(size_t , bool ) const override {
}
ValueExpected getValueExpectedFlagDefault() const override {
return AliasFor->getValueExpectedFlag();
}
void done() {
if (!hasArgStr())
error("cl::alias must have argument name specified!");
if (!AliasFor)
error("cl::alias must have an cl::aliasopt(option) specified!");
addArgument();
}
alias(const alias &) LLVM_DELETED_FUNCTION;
alias &operator=(const alias &) LLVM_DELETED_FUNCTION;
public:
void setAliasFor(Option &O) {
if (AliasFor)
error("cl::alias must only have one cl::aliasopt(...) specified!");
AliasFor = &O;
}
template <class M0t>
explicit alias(const M0t &M0)
: Option(Optional, Hidden), AliasFor(nullptr) {
apply(M0, this);
done();
}
template <class M0t, class M1t>
alias(const M0t &M0, const M1t &M1)
: Option(Optional, Hidden), AliasFor(nullptr) {
apply(M0, this);
apply(M1, this);
done();
}
template <class M0t, class M1t, class M2t>
alias(const M0t &M0, const M1t &M1, const M2t &M2)
: Option(Optional, Hidden), AliasFor(nullptr) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
done();
}
template <class M0t, class M1t, class M2t, class M3t>
alias(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
: Option(Optional, Hidden), AliasFor(nullptr) {
apply(M0, this);
apply(M1, this);
apply(M2, this);
apply(M3, this);
done();
}
};
struct aliasopt {
Option &Opt;
explicit aliasopt(Option &O) : Opt(O) {}
void apply(alias &A) const { A.setAliasFor(Opt); }
};
struct extrahelp {
const char *morehelp;
explicit extrahelp(const char *help);
};
void PrintVersionMessage();
void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
StringMap<Option *> &getRegisteredOptions();
class StringSaver {
virtual void anchor();
public:
virtual const char *SaveString(const char *Str) = 0;
virtual ~StringSaver(){}; };
void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
SmallVectorImpl<const char *> &NewArgv,
bool MarkEOLs = false);
void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
SmallVectorImpl<const char *> &NewArgv,
bool MarkEOLs = false);
typedef void (*TokenizerCallback)(StringRef Source, StringSaver &Saver,
SmallVectorImpl<const char *> &NewArgv,
bool MarkEOLs);
bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
SmallVectorImpl<const char *> &Argv,
bool MarkEOLs = false);
void HideUnrelatedOptions(cl::OptionCategory &Category);
void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories);
}
}
#endif