20 #ifndef LLVM_SUPPORT_COMMANDLINE_H
21 #define LLVM_SUPPORT_COMMANDLINE_H
36 #include <initializer_list>
38 #include <type_traits>
55 bool IgnoreErrors =
false);
62 const char *Overview =
"");
167 void registerCategory();
172 : Name(Name), Description(Description) {
197 : Name(Name), Description(Description) {
204 explicit operator bool()
const;
235 virtual enum ValueExpected getValueExpectedFlagDefault()
const {
240 virtual void anchor();
245 unsigned Occurrences : 3;
249 unsigned HiddenFlag : 2;
250 unsigned Formatting : 2;
253 unsigned AdditionalVals;
316 : NumOccurrences(0), Occurrences(OccurrencesFlag),
Value(0),
351 bool MultiArg =
false);
357 inline void reset() { NumOccurrences = 0; }
392 template <
class Opt>
void apply(Opt &O)
const { O.setInitialValue(
Init); }
408 template <
class Opt>
void apply(Opt &O)
const { O.setLocation(O,
Loc); }
431 template <
class Opt>
void apply(Opt &O)
const { O.addSubCommand(
Sub); }
448 virtual void anchor();
455 template <
class DataType,
bool isClass>
493 assert(Valid &&
"invalid option value");
514 template <
class DataType>
526 template <
class DataType>
557 void anchor()
override;
574 void anchor()
override;
588 #define clEnumVal(ENUMVAL, DESC) \
589 llvm::cl::OptionEnumValue { #ENUMVAL, int(ENUMVAL), DESC }
590 #define clEnumValN(ENUMVAL, FLAGNAME, DESC) \
591 llvm::cl::OptionEnumValue { FLAGNAME, int(ENUMVAL), DESC }
606 template <
class Opt>
void apply(Opt &O)
const {
607 for (
auto Value : Values)
636 : Name(name),
HelpStr(helpStr) {}
670 size_t GlobalWidth)
const;
676 template <
class AnyOptionValue>
678 const AnyOptionValue &Default,
679 size_t GlobalWidth)
const {
761 for (
size_t i = 0, e =
Values.size();
i != e; ++
i)
762 if (
Values[
i].Name == ArgVal) {
767 return O.
error(
"Cannot find option named '" + ArgVal +
"'!");
775 OptionInfo
X(Name, static_cast<DataType>(V), HelpStr);
863 size_t GlobalWidth)
const;
866 void anchor()
override;
869 extern template class basic_parser<bool>;
889 size_t GlobalWidth)
const;
892 void anchor()
override;
895 extern template class basic_parser<boolOrDefault>;
911 size_t GlobalWidth)
const;
914 void anchor()
override;
917 extern template class basic_parser<int>;
933 size_t GlobalWidth)
const;
936 void anchor()
override;
939 extern template class basic_parser<unsigned>;
952 unsigned long long &Val);
958 size_t GlobalWidth)
const;
961 void anchor()
override;
964 extern template class basic_parser<unsigned long long>;
980 size_t GlobalWidth)
const;
983 void anchor()
override;
986 extern template class basic_parser<double>;
1002 size_t GlobalWidth)
const;
1005 void anchor()
override;
1008 extern template class basic_parser<float>;
1027 size_t GlobalWidth)
const;
1030 void anchor()
override;
1033 extern template class basic_parser<std::string>;
1052 size_t GlobalWidth)
const;
1055 void anchor()
override;
1058 extern template class basic_parser<char>;
1067 template <
class ParserClass,
class DT>
1079 P.printOptionNoValue(O, GlobalWidth);
1094 template <
class ParserClass,
class ValDT>
1101 printer.
print(O, static_cast<const ParserClass &>(P), V, Default,
1112 template <
class Opt>
static void opt(
const Mod &M, Opt &O) { M.apply(O); }
1155 template <
class Opt,
class Mod,
class... Mods>
1156 void apply(Opt *O,
const Mod &M,
const Mods &... Ms) {
1161 template <
class Opt,
class Mod>
void apply(Opt *O,
const Mod &M) {
1172 template <
class DataType,
bool ExternalStorage,
bool isClass>
1177 void check_location()
const {
1178 assert(Location &&
"cl::location(...) not specified for a command "
1179 "line option with external storage, "
1180 "or cl::init specified before cl::location()!!");
1188 return O.
error(
"cl::location(x) specified more than once!");
1194 template <
class T>
void setValue(
const T &V,
bool initial =
false) {
1219 template <
class DataType>
1224 template <
class T>
void setValue(
const T &V,
bool initial =
false) {
1225 DataType::operator=(V);
1249 template <
class T>
void setValue(
const T &V,
bool initial =
false) {
1268 template <
class DataType,
bool ExternalStorage =
false,
1269 class ParserClass = parser<DataType>>
1272 std::is_class<DataType>::value> {
1277 typename ParserClass::parser_data_type Val =
1278 typename ParserClass::parser_data_type();
1279 if (Parser.parse(*
this, ArgName, Arg, Val))
1286 enum ValueExpected getValueExpectedFlagDefault()
const override {
1287 return Parser.getValueExpectedFlagDefault();
1290 return Parser.getExtraOptionNames(OptionNames);
1294 size_t getOptionWidth()
const override {
1295 return Parser.getOptionWidth(*
this);
1297 void printOptionInfo(
size_t GlobalWidth)
const override {
1298 Parser.printOptionInfo(*
this, GlobalWidth);
1301 void printOptionValue(
size_t GlobalWidth,
bool Force)
const override {
1303 cl::printOptionDiff<ParserClass>(*
this, Parser, this->
getValue(),
1310 Parser.initialize();
1315 opt(
const opt &) =
delete;
1328 template <
class... Mods>
1329 explicit opt(
const Mods &... Ms)
1336 extern template class opt<unsigned>;
1337 extern template class opt<int>;
1338 extern template class opt<std::string>;
1339 extern template class opt<char>;
1340 extern template class opt<bool>;
1357 return O.
error(
"cl::location(x) specified more than once!");
1363 assert(Location != 0 &&
"cl::location(...) not specified for a command "
1364 "line option with external storage!");
1365 Location->push_back(V);
1378 std::vector<DataType> Storage;
1381 typedef typename std::vector<DataType>::iterator
iterator;
1383 iterator
begin() {
return Storage.begin(); }
1384 iterator
end() {
return Storage.end(); }
1387 const_iterator
begin()
const {
return Storage.begin(); }
1388 const_iterator
end()
const {
return Storage.end(); }
1390 typedef typename std::vector<DataType>::size_type
size_type;
1391 size_type
size()
const {
return Storage.size(); }
1393 bool empty()
const {
return Storage.empty(); }
1398 typedef typename std::vector<DataType>::reference
reference;
1401 const_reference
operator[](size_type pos)
const {
return Storage[pos]; }
1403 iterator
erase(const_iterator pos) {
return Storage.erase(pos); }
1404 iterator
erase(const_iterator first, const_iterator last) {
1405 return Storage.erase(first, last);
1408 iterator
erase(iterator pos) {
return Storage.erase(pos); }
1409 iterator
erase(iterator first, iterator last) {
1410 return Storage.erase(first, last);
1414 return Storage.insert(pos, value);
1417 return Storage.insert(pos, value);
1421 return Storage.insert(pos, value);
1424 return Storage.insert(pos, value);
1427 reference
front() {
return Storage.front(); }
1428 const_reference
front()
const {
return Storage.front(); }
1430 operator std::vector<DataType>&() {
return Storage; }
1433 const std::vector<DataType> *
operator&()
const {
return &Storage; }
1435 template <
class T>
void addValue(
const T &V) { Storage.push_back(V); }
1442 class ParserClass = parser<DataType>>
1444 std::vector<unsigned> Positions;
1447 enum ValueExpected getValueExpectedFlagDefault()
const override {
1448 return Parser.getValueExpectedFlagDefault();
1451 return Parser.getExtraOptionNames(OptionNames);
1456 typename ParserClass::parser_data_type Val =
1457 typename ParserClass::parser_data_type();
1458 if (Parser.parse(*
this, ArgName, Arg, Val))
1462 Positions.push_back(pos);
1467 size_t getOptionWidth()
const override {
1468 return Parser.getOptionWidth(*
this);
1470 void printOptionInfo(
size_t GlobalWidth)
const override {
1471 Parser.printOptionInfo(*
this, GlobalWidth);
1475 void printOptionValue(
size_t ,
bool )
const override {
1480 Parser.initialize();
1491 assert(optnum < this->size() &&
"Invalid option index");
1492 return Positions[optnum];
1497 template <
class... Mods>
1510 template <
typename D,
typename S,
typename P>
1524 unsigned *Location =
nullptr;
1526 template <
class T>
static unsigned Bit(
const T &V) {
1527 unsigned BitPos =
reinterpret_cast<unsigned>(V);
1528 assert(BitPos <
sizeof(
unsigned) * CHAR_BIT &&
1529 "enum exceeds width of bit vector!");
1538 return O.
error(
"cl::location(x) specified more than once!");
1544 assert(Location != 0 &&
"cl::location(...) not specified for a command "
1545 "line option with external storage!");
1546 *Location |= Bit(V);
1552 return (*Location & Bit(V)) != 0;
1562 template <
class T>
static unsigned Bit(
const T &V) {
1564 assert(BitPos <
sizeof(
unsigned) * CHAR_BIT &&
1565 "enum exceeds width of bit vector!");
1574 template <
class T>
bool isSet(
const T &V) {
return (
Bits & Bit(V)) != 0; }
1581 class ParserClass = parser<DataType>>
1583 std::vector<unsigned> Positions;
1586 enum ValueExpected getValueExpectedFlagDefault()
const override {
1587 return Parser.getValueExpectedFlagDefault();
1590 return Parser.getExtraOptionNames(OptionNames);
1595 typename ParserClass::parser_data_type Val =
1596 typename ParserClass::parser_data_type();
1597 if (Parser.parse(*
this, ArgName, Arg, Val))
1601 Positions.push_back(pos);
1606 size_t getOptionWidth()
const override {
1607 return Parser.getOptionWidth(*
this);
1609 void printOptionInfo(
size_t GlobalWidth)
const override {
1610 Parser.printOptionInfo(*
this, GlobalWidth);
1614 void printOptionValue(
size_t ,
bool )
const override {
1619 Parser.initialize();
1630 assert(optnum < this->size() &&
"Invalid option index");
1631 return Positions[optnum];
1634 template <
class... Mods>
1649 bool handleOccurrence(
unsigned pos,
StringRef ,
1651 return AliasFor->handleOccurrence(pos, AliasFor->
ArgStr, Arg);
1655 bool MultiArg =
false)
override {
1660 size_t getOptionWidth()
const override;
1661 void printOptionInfo(
size_t GlobalWidth)
const override;
1664 void printOptionValue(
size_t ,
bool )
const override {
1667 ValueExpected getValueExpectedFlagDefault()
const override {
1673 error(
"cl::alias must have argument name specified!");
1675 error(
"cl::alias must have an cl::aliasopt(option) specified!");
1687 error(
"cl::alias must only have one cl::aliasopt(...) specified!");
1691 template <
class... Mods>
1802 bool MarkEOLs =
false);
1817 bool MarkEOLs =
false);
1843 bool MarkEOLs =
false,
bool RelativeNames =
false);
1879 #endif // LLVM_SUPPORT_COMMANDLINE_H
iterator erase(const_iterator pos)
void addValue(const T &V)
bool isPositional() const
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)
StringRef getName() const
void(* TokenizerCallback)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs)
String tokenization function type.
ParserClass & getParser()
void ResetCommandLineParser()
Reset the command line parser back to its initial state.
OptionValue< std::string > & operator=(const std::string &V)
virtual StringRef getValueName() const
OptionCategory GeneralCategory
OptionValue< cl::boolOrDefault > & operator=(const cl::boolOrDefault &V)
void push_back(const DataType &value)
bool parse(Option &, StringRef, StringRef Arg, char &Value)
const GenericOptionValue & getOptionValue(unsigned N) const override
OptionValue(const DataType &V)
DataType parser_data_type
opt & operator=(const opt &)=delete
enum ValueExpected getValueExpectedFlagDefault() const
void setArgStr(StringRef S)
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
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
void setValueStr(StringRef S)
OptionValue< DataType > Default
void setValue(const T &V, bool initial=false)
void ResetAllOptionOccurrences()
Reset all command line options to a state that looks as if they have never appeared on the command li...
OptionValue< DataType > WrapperType
void printOptionName(const Option &O, size_t GlobalWidth) const
iterator insert(iterator pos, const DataType &value)
void unregisterSubCommand()
void addValue(const T &V)
void ParseEnvironmentOptions(const char *progName, const char *envvar, const char *Overview="")
ParseEnvironmentOptions - An alternative entry point to the CommandLine library, which allows you to ...
SmallVector< Option *, 4 > SinkOpts
void SetVersionPrinter(void(*func)())
===------------------------------------------------------------------—===// SetVersionPrinter - Overr...
virtual size_t getOptionWidth() const =0
COFF::SymbolStorageClass StorageClass
list & operator=(const list &)=delete
GenericOptionInfo(StringRef name, StringRef helpStr)
bool compare(const GenericOptionValue &V) const override
StringRef getValueName() const override
static void opt(OptionHidden OH, Option &O)
bool parse(Option &, StringRef, StringRef Arg, std::string &Value)
StringRef getValueName() const override
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 getExtraOptionNames(SmallVectorImpl< StringRef > &OptionNames)
enum ValueExpected getValueExpectedFlagDefault() const
virtual void printOptionInfo(size_t GlobalWidth) const =0
StringRef getValueName() const override
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
ParserClass & getParser()
void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
virtual ~generic_parser_base()=default
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
void getExtraOptionNames(SmallVectorImpl< StringRef > &)
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
static void opt(StringRef Str, Opt &O)
OptionValue(const cl::boolOrDefault &V)
StringRef getValueName() const override
void AddExtraVersionPrinter(void(*func)())
===------------------------------------------------------------------—===// AddExtraVersionPrinter - ...
const DataType & getValue() const
SmallVector< Option *, 4 > PositionalOpts
bool isConsumeAfter() const
const_iterator begin() const
StringRef getValueName() const override
iterator erase(iterator first, iterator last)
virtual StringRef getDescription(unsigned N) const =0
StringRef getValueName() const override
bits & operator=(const bits &)=delete
int getNumOccurrences() const
Function Alias Analysis false
alias(const alias &)=delete
StringRef getValueName() const override
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
ParserClass & getParser()
bool ParseCommandLineOptions(int argc, const char *const *argv, StringRef Overview="", bool IgnoreErrors=false)
reference operator[](size_type pos)
ManagedStatic< SubCommand > AllSubCommands
bool setLocation(Option &O, DataType &L)
StringMap< Option * > OptionsMap
ManagedStatic< SubCommand > TopLevelSubCommand
ValuesClass values(OptsTy...Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
static void opt(const Mod &M, Opt &O)
~GenericOptionValue()=default
initializer< Ty > init(const Ty &Val)
StringRef getName() const
StringMap< Option * > & getRegisteredOptions(SubCommand &Sub=*TopLevelSubCommand)
Use this to get a StringMap to all registered named options (e.g.
size_t getOptionWidth(const Option &O) const
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V)
void setNumOccurrencesFlag(enum NumOccurrencesFlag Val)
SubCommand(StringRef Name, StringRef Description="")
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...
value_desc(StringRef Str)
void registerSubCommand()
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.
bits(const bits &)=delete
bool any_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly...
virtual unsigned getNumOptions() const =0
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
OptionCategory * Category
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)
virtual StringRef getOption(unsigned N) const =0
unsigned getPosition(unsigned optnum) const
void setValue(const DataType &V)
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
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
Value(Type *Ty, unsigned scid)
const_reference front() const
void setCategory(OptionCategory &C)
iterator insert(const_iterator pos, DataType &&value)
std::vector< DataType > * operator&()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool setLocation(Option &O, unsigned &L)
cl::boolOrDefault WrapperType
void removeLiteralOption(StringRef Name)
removeLiteralOption - Remove the specified option.
DataType getValue() const
~OptionValueBase()=default
void printOptionNoValue(const Option &O, size_t GlobalWidth) const
const_reference operator[](size_type pos) const
generic_parser_base(Option &O)
virtual ~Option()=default
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
void setFormattingFlag(enum FormattingFlags V)
enum FormattingFlags getFormattingFlag() const
~OptionValueCopy()=default
std::vector< DataType >::iterator iterator
OptionValue(const std::string &V)
OptionValue< DataType > OptVal
void setInitialValue(const DataType &V)
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 setDescription(StringRef S)
static ManagedStatic< CodeViewErrorCategory > Category
StringRef getValueName() const override
basic_parser_impl(Option &)
void setValue(const T &V, bool initial=false)
CHAIN = SC CHAIN, Imm128 - System call.
void setAliasFor(Option &O)
bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &Argv, bool MarkEOLs=false, bool RelativeNames=false)
Expand response files on a command line recursively using the given StringSaver and tokenization stra...
OptionInfo(StringRef name, DataType v, StringRef helpStr)
void setNumAdditionalVals(unsigned n)
virtual size_t getOptionWidth(const Option &O) const
OptionValueCopy()=default
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
const DataType & getValue() const
A range adaptor for a pair of iterators.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
bool isInAllSubCommands() const
std::vector< DataType >::size_type size_type
void AddLiteralOption(Option &O, StringRef Name)
Adds a new option for parsing and provides the option it refers to.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr)
addLiteralOption - Add an entry to the mapping table.
void HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub=*TopLevelSubCommand)
Mark all options not part of this category as cl::ReallyHidden.
unsigned getNumAdditionalVals() const
ValuesClass(std::initializer_list< OptionEnumValue > Options)
static void opt(StringRef Str, Opt &O)
iterator erase(const_iterator first, const_iterator last)
enum ValueExpected getValueExpectedFlag() const
Saves strings in the inheritor's stable storage and returns a StringRef with a stable character point...
StringRef getValueName() const override
std::vector< DataType >::const_reference const_reference
static void opt(MiscFlags MF, Option &O)
virtual void getExtraOptionNames(SmallVectorImpl< StringRef > &)
void removeArgument()
Unregisters this option from the CommandLine system.
void setMiscFlag(enum MiscFlags M)
list(const list &)=delete
OptionCategory(StringRef const Name, StringRef const Description="")
static void opt(ValueExpected VE, Option &O)
SmallPtrSet< SubCommand *, 4 > Subs
void setValue(const DT &)
bool compare(const GenericOptionValue &) const override
DataType & operator=(const T &Val)
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)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef getDescription() const
void apply(Option &O) const
LLVM Value Representation.
StringRef getOption(unsigned N) const override
alias & operator=(const alias &)=delete
unsigned getPosition(unsigned optnum) const
StringRef getDescription(unsigned N) const override
OptionValue< DataType > & operator=(const DT &V)
void addSubCommand(SubCommand &S)
bool error(const Twine &Message, StringRef ArgName=StringRef())
StringRef - Represent a constant reference to a string, i.e.
GenericOptionValue & operator=(const GenericOptionValue &)=default
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
bool compare(const DataType &) const
std::vector< DataType >::const_iterator const_iterator
unsigned getPosition() const
const DataType & getValue() const
unsigned findOption(StringRef Name)
~basic_parser_impl()=default
static void opt(StringRef Str, Opt &O)
iterator_range< typename SmallPtrSet< SubCommand *, 4 >::iterator > getRegisteredSubcommands()
Use this to get all registered SubCommands from the provided parser.
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
void addValue(const T &V)
OptionValue< DataType > Default
StringRef getDescription() const
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