20 #ifndef LLVM_SUPPORT_COMMANDLINE_H
21 #define LLVM_SUPPORT_COMMANDLINE_H
36 class BumpPtrStringSaver;
48 const char *Overview =
nullptr);
55 const char *Overview =
nullptr);
157 const char *
const Name;
158 const char *
const Description;
159 void registerCategory();
163 const char *
const Description =
nullptr)
164 : Name(Name), Description(Description) {
185 virtual bool handleOccurrence(
unsigned pos,
StringRef ArgName,
188 virtual enum ValueExpected getValueExpectedFlagDefault()
const {
193 virtual void anchor();
198 unsigned Occurrences : 3;
202 unsigned HiddenFlag : 2;
203 unsigned Formatting : 2;
206 unsigned AdditionalVals;
251 : NumOccurrences(0), Occurrences(OccurrencesFlag),
Value(0),
284 bool MultiArg =
false);
322 template <
class Opt>
void apply(Opt &O)
const { O.setInitialValue(
Init); }
337 template <
class Opt>
void apply(Opt &O)
const { O.setLocation(O,
Loc); }
367 virtual void anchor();
374 template <
class DataType,
bool isClass>
412 assert(Valid &&
"invalid option value");
433 template <
class DataType>
445 template <
class DataType>
474 void anchor()
override;
490 void anchor()
override;
496 #define clEnumVal(ENUMVAL, DESC) #ENUMVAL, int(ENUMVAL), DESC
497 #define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, int(ENUMVAL), DESC
498 #define clEnumValEnd (reinterpret_cast<void *>(0))
510 void processValues(va_list Vals);
516 Values.
push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
519 while (
const char *enumName = va_arg(ValueArgs,
const char *)) {
521 const char *EnumDesc = va_arg(ValueArgs,
const char *);
522 Values.
push_back(std::make_pair(enumName,
523 std::make_pair(EnumVal, EnumDesc)));
527 template <
class Opt>
void apply(Opt &O)
const {
528 for (
size_t i = 0, e = Values.
size(); i != e; ++i)
529 O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
530 Values[i].second.second);
534 template <
class DataType>
538 va_start(ValueArgs, Desc);
561 : Name(name),
HelpStr(helpStr) {}
577 virtual const char *
getOption(
unsigned N)
const = 0;
594 size_t GlobalWidth)
const;
600 template <
class AnyOptionValue>
603 size_t GlobalWidth)
const {
685 for (
size_t i = 0, e =
Values.size(); i != e; ++i)
686 if (
Values[i].Name == ArgVal) {
687 V =
Values[i].V.getValue();
691 return O.
error(
"Cannot find option named '" + ArgVal +
"'!");
699 OptionInfo
X(Name, static_cast<DataType>(V), HelpStr);
708 assert(N !=
Values.size() &&
"Option not found!");
787 size_t GlobalWidth)
const;
790 void anchor()
override;
793 extern template class basic_parser<bool>;
813 size_t GlobalWidth)
const;
816 void anchor()
override;
819 extern template class basic_parser<boolOrDefault>;
835 size_t GlobalWidth)
const;
838 void anchor()
override;
841 extern template class basic_parser<int>;
857 size_t GlobalWidth)
const;
860 void anchor()
override;
863 extern template class basic_parser<unsigned>;
876 unsigned long long &Val);
882 size_t GlobalWidth)
const;
885 void anchor()
override;
888 extern template class basic_parser<unsigned long long>;
904 size_t GlobalWidth)
const;
907 void anchor()
override;
910 extern template class basic_parser<double>;
926 size_t GlobalWidth)
const;
929 void anchor()
override;
932 extern template class basic_parser<float>;
951 size_t GlobalWidth)
const;
954 void anchor()
override;
957 extern template class basic_parser<std::string>;
976 size_t GlobalWidth)
const;
979 void anchor()
override;
982 extern template class basic_parser<char>;
991 template <
class ParserClass,
class DT>
1003 P.printOptionNoValue(O, GlobalWidth);
1018 template <
class ParserClass,
class ValDT>
1025 printer.
print(O, static_cast<const ParserClass &>(P), V, Default,
1036 template <
class Opt>
static void opt(
const Mod &M, Opt &O) { M.apply(O); }
1041 template <
class Opt>
static void opt(
const char *Str, Opt &O) {
1046 template <
class Opt>
static void opt(
const char *Str, Opt &O) {
1051 template <
class Opt>
static void opt(
const char *Str, Opt &O) {
1075 template <
class Opt,
class Mod,
class... Mods>
1076 void apply(Opt *O,
const Mod &M,
const Mods &... Ms) {
1081 template <
class Opt,
class Mod>
void apply(Opt *O,
const Mod &M) {
1092 template <
class DataType,
bool ExternalStorage,
bool isClass>
1097 void check_location()
const {
1098 assert(Location &&
"cl::location(...) not specified for a command "
1099 "line option with external storage, "
1100 "or cl::init specified before cl::location()!!");
1108 return O.
error(
"cl::location(x) specified more than once!");
1114 template <
class T>
void setValue(
const T &V,
bool initial =
false) {
1139 template <
class DataType>
1144 template <
class T>
void setValue(
const T &V,
bool initial =
false) {
1145 DataType::operator=(V);
1169 template <
class T>
void setValue(
const T &V,
bool initial =
false) {
1188 template <
class DataType,
bool ExternalStorage =
false,
1189 class ParserClass = parser<DataType>>
1192 std::is_class<DataType>::value> {
1195 bool handleOccurrence(
unsigned pos,
StringRef ArgName,
1197 typename ParserClass::parser_data_type Val =
1198 typename ParserClass::parser_data_type();
1199 if (Parser.parse(*
this, ArgName, Arg, Val))
1206 enum ValueExpected getValueExpectedFlagDefault()
const override {
1207 return Parser.getValueExpectedFlagDefault();
1211 return Parser.getExtraOptionNames(OptionNames);
1215 size_t getOptionWidth()
const override {
1216 return Parser.getOptionWidth(*
this);
1218 void printOptionInfo(
size_t GlobalWidth)
const override {
1219 Parser.printOptionInfo(*
this, GlobalWidth);
1222 void printOptionValue(
size_t GlobalWidth,
bool Force)
const override {
1224 cl::printOptionDiff<ParserClass>(*
this, Parser, this->
getValue(),
1231 Parser.initialize();
1235 opt(
const opt &) =
delete;
1236 opt &operator=(
const opt &) =
delete;
1249 template <
class... Mods>
1250 explicit opt(
const Mods &... Ms)
1257 extern template class opt<unsigned>;
1258 extern template class opt<int>;
1259 extern template class opt<std::string>;
1260 extern template class opt<char>;
1261 extern template class opt<bool>;
1278 return O.
error(
"cl::location(x) specified more than once!");
1284 assert(Location != 0 &&
"cl::location(...) not specified for a command "
1285 "line option with external storage!");
1286 Location->push_back(V);
1299 std::vector<DataType> Storage;
1302 typedef typename std::vector<DataType>::iterator
iterator;
1304 iterator
begin() {
return Storage.begin(); }
1305 iterator
end() {
return Storage.end(); }
1308 const_iterator
begin()
const {
return Storage.begin(); }
1309 const_iterator
end()
const {
return Storage.end(); }
1311 typedef typename std::vector<DataType>::size_type
size_type;
1312 size_type
size()
const {
return Storage.size(); }
1314 bool empty()
const {
return Storage.empty(); }
1319 typedef typename std::vector<DataType>::reference
reference;
1322 const_reference
operator[](size_type pos)
const {
return Storage[pos]; }
1324 iterator
erase(const_iterator pos) {
return Storage.erase(pos); }
1325 iterator
erase(const_iterator first, const_iterator last) {
1326 return Storage.erase(first, last);
1329 iterator
erase(iterator pos) {
return Storage.erase(pos); }
1330 iterator
erase(iterator first, iterator last) {
1331 return Storage.erase(first, last);
1335 return Storage.insert(pos, value);
1338 return Storage.insert(pos, value);
1342 return Storage.insert(pos, value);
1345 return Storage.insert(pos, value);
1348 reference
front() {
return Storage.front(); }
1349 const_reference
front()
const {
return Storage.front(); }
1351 operator std::vector<DataType>&() {
return Storage; }
1354 const std::vector<DataType> *
operator&()
const {
return &Storage; }
1356 template <
class T>
void addValue(
const T &V) { Storage.push_back(V); }
1363 class ParserClass = parser<DataType>>
1365 std::vector<unsigned> Positions;
1368 enum ValueExpected getValueExpectedFlagDefault()
const override {
1369 return Parser.getValueExpectedFlagDefault();
1373 return Parser.getExtraOptionNames(OptionNames);
1376 bool handleOccurrence(
unsigned pos,
StringRef ArgName,
1378 typename ParserClass::parser_data_type Val =
1379 typename ParserClass::parser_data_type();
1380 if (Parser.parse(*
this, ArgName, Arg, Val))
1384 Positions.push_back(pos);
1389 size_t getOptionWidth()
const override {
1390 return Parser.getOptionWidth(*
this);
1392 void printOptionInfo(
size_t GlobalWidth)
const override {
1393 Parser.printOptionInfo(*
this, GlobalWidth);
1397 void printOptionValue(
size_t ,
bool )
const override {
1402 Parser.initialize();
1407 list &operator=(
const list &) =
delete;
1413 assert(optnum < this->
size() &&
"Invalid option index");
1414 return Positions[optnum];
1419 template <
class... Mods>
1432 template <
typename D,
typename S,
typename P>
1448 template <
class T>
static unsigned Bit(
const T &V) {
1449 unsigned BitPos =
reinterpret_cast<unsigned>(V);
1450 assert(BitPos <
sizeof(
unsigned) * CHAR_BIT &&
1451 "enum exceeds width of bit vector!");
1460 return O.
error(
"cl::location(x) specified more than once!");
1466 assert(Location != 0 &&
"cl::location(...) not specified for a command "
1467 "line option with external storage!");
1468 *Location |= Bit(V);
1474 return (*Location & Bit(V)) != 0;
1484 template <
class T>
static unsigned Bit(
const T &V) {
1486 assert(BitPos <
sizeof(
unsigned) * CHAR_BIT &&
1487 "enum exceeds width of bit vector!");
1496 template <
class T>
bool isSet(
const T &V) {
return (
Bits & Bit(V)) != 0; }
1503 class ParserClass = parser<DataType>>
1505 std::vector<unsigned> Positions;
1508 enum ValueExpected getValueExpectedFlagDefault()
const override {
1509 return Parser.getValueExpectedFlagDefault();
1513 return Parser.getExtraOptionNames(OptionNames);
1516 bool handleOccurrence(
unsigned pos,
StringRef ArgName,
1518 typename ParserClass::parser_data_type Val =
1519 typename ParserClass::parser_data_type();
1520 if (Parser.parse(*
this, ArgName, Arg, Val))
1524 Positions.push_back(pos);
1529 size_t getOptionWidth()
const override {
1530 return Parser.getOptionWidth(*
this);
1532 void printOptionInfo(
size_t GlobalWidth)
const override {
1533 Parser.printOptionInfo(*
this, GlobalWidth);
1537 void printOptionValue(
size_t ,
bool )
const override {
1542 Parser.initialize();
1547 bits &operator=(
const bits &) =
delete;
1553 assert(optnum < this->
size() &&
"Invalid option index");
1554 return Positions[optnum];
1557 template <
class... Mods>
1571 bool handleOccurrence(
unsigned pos,
StringRef ,
1573 return AliasFor->handleOccurrence(pos, AliasFor->
ArgStr, Arg);
1576 bool MultiArg =
false)
override {
1580 size_t getOptionWidth()
const override;
1581 void printOptionInfo(
size_t GlobalWidth)
const override;
1584 void printOptionValue(
size_t ,
bool )
const override {
1587 ValueExpected getValueExpectedFlagDefault()
const override {
1593 error(
"cl::alias must have argument name specified!");
1595 error(
"cl::alias must have an cl::aliasopt(option) specified!");
1606 error(
"cl::alias must only have one cl::aliasopt(...) specified!");
1610 template <
class... Mods>
1696 bool MarkEOLs =
false);
1711 bool MarkEOLs =
false);
1735 bool MarkEOLs =
false);
const char * getName() const
iterator erase(const_iterator pos)
void addValue(const T &V)
ValuesClass< DataType > LLVM_END_WITH_NULL values(const char *Arg, DataType Val, const char *Desc,...)
void setValue(const T &V, bool initial=false)
void push_back(const T &Elt)
SmallVector< OptionInfo, 8 > Values
void print(const Option &O, const parser< DT > &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
void(* TokenizerCallback)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs)
String tokenization function type.
ParserClass & getParser()
const char * getValueName() const override
OptionValue< std::string > & operator=(const std::string &V)
OptionCategory GeneralCategory
OptionValue< cl::boolOrDefault > & operator=(const cl::boolOrDefault &V)
StringMap< Option * > & getRegisteredOptions()
Use this to get a StringMap to all registered named options (e.g.
void push_back(const DataType &value)
void ParseEnvironmentOptions(const char *progName, const char *envvar, const char *Overview=nullptr)
ParseEnvironmentOptions - An alternative entry point to the CommandLine library, which allows you to ...
bool parse(Option &, StringRef, StringRef Arg, char &Value)
const GenericOptionValue & getOptionValue(unsigned N) const override
OptionValue(const DataType &V)
static void opt(const char *Str, Opt &O)
DataType parser_data_type
static void opt(const char *Str, Opt &O)
OptionCategory(const char *const Name, const char *const Description=nullptr)
enum ValueExpected getValueExpectedFlagDefault() const
virtual const GenericOptionValue & getOptionValue(unsigned N) const =0
unsigned getNumOptions() const override
void PrintVersionMessage()
Utility function for printing version number.
void print(const Option &O, const parser< ParserDT > &P, const ValDT &, const OptionValue< ValDT > &, size_t GlobalWidth)
GenericOptionValue()=default
bool compare(const DataType &V) const
OptionValue< DataType > Default
void setValue(const T &V, bool initial=false)
OptionValue< DataType > WrapperType
unsigned findOption(const char *Name)
void printOptionName(const Option &O, size_t GlobalWidth) const
std::string str() const
str - Get the contents as an std::string.
iterator insert(iterator pos, const DataType &value)
void addValue(const T &V)
ValuesClass(const char *EnumName, DataType Val, const char *Desc, va_list ValueArgs)
const char * getValueName() const override
void SetVersionPrinter(void(*func)())
===------------------------------------------------------------------—===// SetVersionPrinter - Overr...
virtual size_t getOptionWidth() const =0
void removeLiteralOption(const char *Name)
removeLiteralOption - Remove the specified option.
COFF::SymbolStorageClass StorageClass
bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &Argv, bool MarkEOLs=false)
Expand response files on a command line recursively using the given StringSaver and tokenization stra...
bool compare(const GenericOptionValue &V) const override
static void opt(OptionHidden OH, Option &O)
bool parse(Option &, StringRef, StringRef Arg, std::string &Value)
virtual void printOptionValue(size_t GlobalWidth, bool Force) const =0
virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const
Option(enum NumOccurrencesFlag OccurrencesFlag, enum OptionHidden Hidden)
void setDescription(const char *S)
enum ValueExpected getValueExpectedFlagDefault() const
virtual void printOptionInfo(size_t GlobalWidth) const =0
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
std::vector< DataType >::reference reference
void setNumAdditionalVals(unsigned n)
const OptionValue< DataType > & getDefault() const
const char * getValueName() const override
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
ParserClass & getParser()
void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
const OptionValue< DataType > & getDefault() const
void apply(list< D, S, P > &L) const
void push_back(DataType &&value)
OptionValue< DataType > V
const OptionValue< DataType > & getDefault() const
virtual bool compare(const GenericOptionValue &V) const =0
virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value, bool MultiArg=false)
void printOptionInfo(const Option &O, size_t GlobalWidth) const
OptionValue(const cl::boolOrDefault &V)
void setValueStr(const char *S)
void AddExtraVersionPrinter(void(*func)())
===------------------------------------------------------------------—===// AddExtraVersionPrinter - ...
const DataType & getValue() const
const_iterator begin() const
iterator erase(iterator first, iterator last)
int getNumOccurrences() const
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
iterator insert(iterator pos, DataType &&value)
OptionValueCopy & operator=(const OptionValueCopy &)=default
const char * getOption(unsigned N) const override
ParserClass & getParser()
reference operator[](size_type pos)
bool setLocation(Option &O, DataType &L)
void HideUnrelatedOptions(cl::OptionCategory &Category)
Mark all options not part of this category as cl::ReallyHidden.
static void opt(const Mod &M, Opt &O)
~GenericOptionValue()=default
initializer< Ty > init(const Ty &Val)
const char * getDescription() const
size_t getOptionWidth(const Option &O) const
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V)
void setNumOccurrencesFlag(enum NumOccurrencesFlag Val)
const char * getValueName() const override
enum NumOccurrencesFlag getNumOccurrencesFlag() const
void PrintHelpMessage(bool Hidden=false, bool Categorized=false)
This function just prints the help message, exactly the same way as if the -help or -help-hidden opti...
bool setLocation(Option &O, StorageClass &L)
DataType parser_data_type
void setHiddenFlag(enum OptionHidden Val)
void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes a Windows command line which may contain quotes and escaped quotes.
virtual unsigned getNumOptions() const =0
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
OptionCategory * Category
const char * getValueName() const override
const std::vector< DataType > * operator&() const
const_iterator end() const
void apply(Option &O) const
void addValue(const T &V)
enum OptionHidden getOptionHiddenFlag() const
void setPosition(unsigned pos)
const char * getValueName() const override
unsigned getPosition(unsigned optnum) const
const char * getValueName() const override
void setValue(const DataType &V)
void apply(Opt *O, const Mod &M, const Mods &...Ms)
void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes a command line that can contain escapes and quotes.
void printGenericOptionDiff(const Option &O, const GenericOptionValue &V, const GenericOptionValue &Default, size_t GlobalWidth) const
GenericOptionInfo(const char *name, const char *helpStr)
#define LLVM_END_WITH_NULL
const_reference front() const
void setCategory(OptionCategory &C)
iterator insert(const_iterator pos, DataType &&value)
std::vector< DataType > * operator&()
bool setLocation(Option &O, unsigned &L)
static void opt(const char *Str, Opt &O)
cl::boolOrDefault WrapperType
DataType getValue() const
~OptionValueBase()=default
OptionInfo(const char *name, DataType v, const char *helpStr)
void printOptionNoValue(const Option &O, size_t GlobalWidth) const
const_reference operator[](size_type pos) const
generic_parser_base(Option &O)
void setFormattingFlag(enum FormattingFlags V)
enum FormattingFlags getFormattingFlag() const
~OptionValueCopy()=default
virtual const char * getOption(unsigned N) const =0
std::vector< DataType >::iterator iterator
OptionValue(const std::string &V)
OptionValue< DataType > OptVal
void setInitialValue(const DataType &V)
void getExtraOptionNames(SmallVectorImpl< const char * > &OptionNames)
void setValueExpectedFlag(enum ValueExpected Val)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
DataType operator->() const
void setValue(const T &V, bool initial=false)
void setAliasFor(Option &O)
void setNumAdditionalVals(unsigned n)
virtual void getExtraOptionNames(SmallVectorImpl< const char * > &)
virtual size_t getOptionWidth(const Option &O) const
const DataType & getValue() const
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
void ParseCommandLineOptions(int argc, const char *const *argv, const char *Overview=nullptr)
std::vector< DataType >::size_type size_type
basic_parser_impl(Option &O)
unsigned getNumAdditionalVals() const
iterator erase(const_iterator first, const_iterator last)
enum ValueExpected getValueExpectedFlag() const
Saves strings in the inheritor's stable storage and returns a stable raw character pointer...
std::vector< DataType >::const_reference const_reference
const char * getValueName() const override
static void opt(MiscFlags MF, Option &O)
void removeArgument()
Unregisters this option from the CommandLine system.
const char * getValueName() const override
void setMiscFlag(enum MiscFlags M)
void setArgStr(const char *S)
static void opt(ValueExpected VE, Option &O)
void setValue(const DT &)
virtual const char * getValueName() const
bool compare(const GenericOptionValue &) const override
virtual const char * getDescription(unsigned N) const =0
DataType & operator=(const T &Val)
virtual ~generic_parser_base()
iterator erase(iterator pos)
iterator insert(const_iterator pos, const DataType &value)
const DataType & getValue() const
int compare(DigitsT LDigits, int16_t LScale, DigitsT RDigits, int16_t RScale)
Compare two scaled numbers.
static void opt(NumOccurrencesFlag N, Option &O)
void apply(Option &O) const
value_desc(const char *Str)
LLVM Value Representation.
unsigned getPosition(unsigned optnum) const
OptionValue< DataType > & operator=(const DT &V)
void AddLiteralOption(Option &O, const char *Name)
Adds a new option for parsing and provides the option it refers to.
void addLiteralOption(const char *Name, const DT &V, const char *HelpStr)
addLiteralOption - Add an entry to the mapping table.
void getExtraOptionNames(SmallVectorImpl< const char * > &)
bool error(const Twine &Message, StringRef ArgName=StringRef())
C - The default llvm calling convention, compatible with C.
StringRef - Represent a constant reference to a string, i.e.
GenericOptionValue & operator=(const GenericOptionValue &)=default
bool compare(const DataType &) const
std::vector< DataType >::const_iterator const_iterator
unsigned getPosition() const
const DataType & getValue() const
~basic_parser_impl()=default
void addValue(const T &V)
OptionValue< DataType > Default
void apply(alias &A) const
LocationClass< Ty > location(Ty &L)
unsigned getMiscFlags() const
void printOptionDiff(const Option &O, const AnyOptionValue &V, const AnyOptionValue &Default, size_t GlobalWidth) const
initializer(const Ty &Val)
OptionCategory & Category
const char * getDescription(unsigned N) const override