LLVM 19.0.0git
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
llvm::cl Namespace Reference

This namespace contains all of the command line option processing machinery. More...

Namespaces

namespace  detail
 

Classes

class  alias
 
struct  aliasopt
 
struct  applicator
 
struct  applicator< char[n]>
 
struct  applicator< const char[n]>
 
struct  applicator< FormattingFlags >
 
struct  applicator< MiscFlags >
 
struct  applicator< NumOccurrencesFlag >
 
struct  applicator< OptionHidden >
 
struct  applicator< StringRef >
 
struct  applicator< ValueExpected >
 
class  basic_parser
 
class  basic_parser_impl
 
class  bits
 
class  bits_storage
 
class  bits_storage< DataType, bool >
 
struct  cat
 
struct  cb
 
struct  desc
 
class  ExpansionContext
 Contains options that control response file expansion. More...
 
struct  extrahelp
 
class  generic_parser_base
 
struct  GenericOptionValue
 
struct  initializer
 
class  list
 
struct  list_initializer
 
class  list_storage
 
class  list_storage< DataType, bool >
 
struct  LocationClass
 
struct  multi_val
 
class  opt
 
class  opt_storage
 
class  opt_storage< DataType, false, false >
 
class  opt_storage< DataType, false, true >
 
class  Option
 
class  OptionCategory
 
struct  OptionDiffPrinter
 
struct  OptionDiffPrinter< DT, DT >
 
struct  OptionEnumValue
 
struct  OptionValue
 
struct  OptionValue< cl::boolOrDefault >
 
struct  OptionValue< std::string >
 
struct  OptionValueBase
 
struct  OptionValueBase< DataType, false >
 
class  OptionValueCopy
 
class  parser
 
class  parser< bool >
 
class  parser< boolOrDefault >
 
class  parser< char >
 
class  parser< double >
 
class  parser< float >
 
class  parser< int >
 
class  parser< long >
 
class  parser< long long >
 
class  parser< std::string >
 
class  parser< unsigned >
 
class  parser< unsigned long >
 
class  parser< unsigned long long >
 
struct  sub
 
class  SubCommand
 
class  SubCommandGroup
 
struct  value_desc
 
class  ValuesClass
 

Typedefs

using VersionPrinterTy = std::function< void(raw_ostream &)>
 
using TokenizerCallback = void(*)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs)
 String tokenization function type.
 

Enumerations

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 , AlwaysPrefix = 0x03 }
 
enum  MiscFlags {
  CommaSeparated = 0x01 , PositionalEatsArgs = 0x02 , Sink = 0x04 , Grouping = 0x08 ,
  DefaultOption = 0x10
}
 
enum  boolOrDefault { BOU_UNSET , BOU_TRUE , BOU_FALSE }
 

Functions

bool ParseCommandLineOptions (int argc, const char *const *argv, StringRef Overview="", raw_ostream *Errs=nullptr, const char *EnvVar=nullptr, bool LongOptionsUseDoubleDash=false)
 
void SetVersionPrinter (VersionPrinterTy func)
 ===------------------------------------------------------------------—===// Override the default (LLVM specific) version printer used to print out the version when –version is given on the command line.
 
void AddExtraVersionPrinter (VersionPrinterTy func)
 ===------------------------------------------------------------------—===// Add an extra printer to use in addition to the default one.
 
void PrintOptionValues ()
 
void AddLiteralOption (Option &O, StringRef Name)
 Adds a new option for parsing and provides the option it refers to.
 
OptionCategorygetGeneralCategory ()
 
template<class Ty >
initializer< Ty > init (const Ty &Val)
 
template<class Ty >
list_initializer< Ty > list_init (ArrayRef< Ty > Vals)
 
template<class Ty >
LocationClass< Ty > location (Ty &L)
 
template<typename F >
cb< typename detail::callback_traits< F >::result_type, typename detail::callback_traits< F >::arg_type > callback (F CB)
 
template<typename... OptsTy>
ValuesClass values (OptsTy... Options)
 Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to the ValuesClass constructor.
 
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)
 
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)
 
template<class Opt , class Mod , class... Mods>
void apply (Opt *O, const Mod &M, const Mods &... Ms)
 
template<class Opt , class Mod >
void apply (Opt *O, const Mod &M)
 
void PrintVersionMessage ()
 Utility function for printing version number.
 
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 option had been given on the command line.
 
StringMap< Option * > & getRegisteredOptions (SubCommand &Sub=SubCommand::getTopLevel())
 Use this to get a StringMap to all registered named options (e.g.
 
iterator_range< typename SmallPtrSet< SubCommand *, 4 >::iterator > getRegisteredSubcommands ()
 Use this to get all registered SubCommands from the provided parser.
 
void TokenizeGNUCommandLine (StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
 Tokenizes a command line that can contain escapes and quotes.
 
void TokenizeWindowsCommandLine (StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
 Tokenizes a string of Windows command line arguments, which may contain quotes and escaped quotes.
 
void TokenizeWindowsCommandLineNoCopy (StringRef Source, StringSaver &Saver, SmallVectorImpl< StringRef > &NewArgv)
 Tokenizes a Windows command line while attempting to avoid copies.
 
void TokenizeWindowsCommandLineFull (StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
 Tokenizes a Windows full command line, including command name at the start.
 
void tokenizeConfigFile (StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
 Tokenizes content of configuration file.
 
bool expandResponseFiles (int Argc, const char *const *Argv, const char *EnvVar, SmallVectorImpl< const char * > &NewArgv)
 A convenience helper which concatenates the options specified by the environment variable EnvVar and command line options, then expands response files recursively.
 
bool ExpandResponseFiles (StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &Argv)
 A convenience helper which supports the typical use case of expansion function call.
 
bool expandResponseFiles (int Argc, const char *const *Argv, const char *EnvVar, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv)
 A convenience helper which concatenates the options specified by the environment variable EnvVar and command line options, then expands response files recursively.
 
void HideUnrelatedOptions (cl::OptionCategory &Category, SubCommand &Sub=SubCommand::getTopLevel())
 Mark all options not part of this category as cl::ReallyHidden.
 
void HideUnrelatedOptions (ArrayRef< const cl::OptionCategory * > Categories, SubCommand &Sub=SubCommand::getTopLevel())
 Mark all options not part of the categories as cl::ReallyHidden.
 
void ResetAllOptionOccurrences ()
 Reset all command line options to a state that looks as if they have never appeared on the command line.
 
void ResetCommandLineParser ()
 Reset the command line parser back to its initial state.
 
bool ProvidePositionalOption (Option *Handler, StringRef Arg, int i)
 Parses Arg into the option handler Handler.
 

Variables

ManagedStatic< SubCommandTopLevelSubCommand
 
ManagedStatic< SubCommandAllSubCommands
 

Detailed Description

This namespace contains all of the command line option processing machinery.

It is intentionally a short name to make qualified usage concise.

Typedef Documentation

◆ TokenizerCallback

using llvm::cl::TokenizerCallback = typedef void (*)(StringRef Source, StringSaver &Saver, SmallVectorImpl<const char *> &NewArgv, bool MarkEOLs)

String tokenization function type.

Should be compatible with either Windows or Unix command line tokenizers.

Definition at line 2125 of file CommandLine.h.

◆ VersionPrinterTy

using llvm::cl::VersionPrinterTy = typedef std::function<void(raw_ostream &)>

Definition at line 76 of file CommandLine.h.

Enumeration Type Documentation

◆ boolOrDefault

Enumerator
BOU_UNSET 
BOU_TRUE 
BOU_FALSE 

Definition at line 644 of file CommandLine.h.

◆ FormattingFlags

Enumerator
NormalFormatting 
Positional 
Prefix 
AlwaysPrefix 

Definition at line 156 of file CommandLine.h.

◆ MiscFlags

Enumerator
CommaSeparated 
PositionalEatsArgs 
Sink 
Grouping 
DefaultOption 

Definition at line 163 of file CommandLine.h.

◆ NumOccurrencesFlag

Enumerator
Optional 
ZeroOrMore 
Required 
OneOrMore 
ConsumeAfter 

Definition at line 113 of file CommandLine.h.

◆ OptionHidden

Enumerator
NotHidden 
Hidden 
ReallyHidden 

Definition at line 136 of file CommandLine.h.

◆ ValueExpected

Enumerator
ValueOptional 
ValueRequired 
ValueDisallowed 

Definition at line 129 of file CommandLine.h.

Function Documentation

◆ AddExtraVersionPrinter()

void llvm::cl::AddExtraVersionPrinter ( VersionPrinterTy  func)

===------------------------------------------------------------------—===// Add an extra printer to use in addition to the default one.

This can be called multiple times, and each time it adds a new function to the list which will be called after the basic LLVM version printing is complete. Each can then add additional information specific to the tool.

Definition at line 2755 of file CommandLine.cpp.

References CommonOptions.

◆ AddLiteralOption()

void llvm::cl::AddLiteralOption ( Option O,
StringRef  Name 
)

Adds a new option for parsing and provides the option it refers to.

Parameters
Opointer to the option
Namethe string name for the option to handle during parsing

Literal options are used by some parsers to register special option values. This is how the PassNameParser registers pass names for opt.

Definition at line 408 of file CommandLine.cpp.

References GlobalParser, and Name.

Referenced by llvm::cl::parser< DataType >::addLiteralOption().

◆ apply() [1/2]

template<class Opt , class Mod >
void llvm::cl::apply ( Opt *  O,
const Mod M 
)

Definition at line 1321 of file CommandLine.h.

References llvm::cl::applicator< Mod >::opt().

◆ apply() [2/2]

template<class Opt , class Mod , class... Mods>
void llvm::cl::apply ( Opt *  O,
const Mod M,
const Mods &...  Ms 
)

◆ callback()

template<typename F >
cb< typename detail::callback_traits< F >::result_type, typename detail::callback_traits< F >::arg_type > llvm::cl::callback ( F  CB)

Definition at line 530 of file CommandLine.h.

◆ expandResponseFiles() [1/2]

bool llvm::cl::expandResponseFiles ( int  Argc,
const char *const Argv,
const char EnvVar,
SmallVectorImpl< const char * > &  NewArgv 
)

A convenience helper which concatenates the options specified by the environment variable EnvVar and command line options, then expands response files recursively.

Returns
true if all @files were expanded successfully or there were none.

Referenced by llvm::opt::OptTable::parseArgs().

◆ expandResponseFiles() [2/2]

bool llvm::cl::expandResponseFiles ( int  Argc,
const char *const Argv,
const char EnvVar,
StringSaver Saver,
SmallVectorImpl< const char * > &  NewArgv 
)

A convenience helper which concatenates the options specified by the environment variable EnvVar and command line options, then expands response files recursively.

The tokenizer is a predefined GNU or Windows one.

Returns
true if all @files were expanded successfully or there were none.

Definition at line 1338 of file CommandLine.cpp.

References llvm::SmallVectorImpl< T >::append(), llvm::errs(), llvm::cl::ExpansionContext::expandResponseFiles(), llvm::StringSaver::getAllocator(), llvm::sys::Process::GetEnv(), TokenizeGNUCommandLine(), TokenizeWindowsCommandLine(), and llvm::dwarf::toString().

◆ ExpandResponseFiles()

bool llvm::cl::ExpandResponseFiles ( StringSaver Saver,
TokenizerCallback  Tokenizer,
SmallVectorImpl< const char * > &  Argv 
)

A convenience helper which supports the typical use case of expansion function call.

Definition at line 1361 of file CommandLine.cpp.

References llvm::errs(), llvm::cl::ExpansionContext::expandResponseFiles(), llvm::StringSaver::getAllocator(), and llvm::dwarf::toString().

Referenced by llvm::libDriverMain().

◆ getGeneralCategory()

OptionCategory & llvm::cl::getGeneralCategory ( )

Definition at line 2679 of file CommandLine.cpp.

Referenced by llvm::cl::Option::addCategory(), and llvm::cl::Option::Option().

◆ getRegisteredOptions()

StringMap< Option * > & llvm::cl::getRegisteredOptions ( SubCommand Sub = SubCommand::getTopLevel())

Use this to get a StringMap to all registered named options (e.g.

-help).

Returns
A reference to the StringMap used by the cl APIs to parse options.

Access to unnamed arguments (i.e. positional) are not provided because it is expected that the client already has access to these.

Typical usage:

main(int argc,char* argv[]) {
assert(opts.count("help") == 1)
opts["help"]->setDescription("Show alphabetical help information")
// More code
llvm::cl::ParseCommandLineOptions(argc,argv);
//More code
}
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:128
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:277
StringMap< Option * > & getRegisteredOptions(SubCommand &Sub=SubCommand::getTopLevel())
Use this to get a StringMap to all registered named options (e.g.
bool ParseCommandLineOptions(int argc, const char *const *argv, StringRef Overview="", raw_ostream *Errs=nullptr, const char *EnvVar=nullptr, bool LongOptionsUseDoubleDash=false)
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18

This interface is useful for modifying options in libraries that are out of the control of the client. The options should be modified before calling llvm::cl::ParseCommandLineOptions().

Hopefully this API can be deprecated soon. Any situation where options need to be modified by tools or libraries should be handled by sane APIs rather than just handing around a global list.

Definition at line 2759 of file CommandLine.cpp.

References assert(), GlobalParser, initCommonOptions(), and llvm::cl::SubCommand::OptionsMap.

◆ getRegisteredSubcommands()

iterator_range< typename SmallPtrSet< SubCommand *, 4 >::iterator > llvm::cl::getRegisteredSubcommands ( )

Use this to get all registered SubCommands from the provided parser.

Returns
A range of all SubCommand pointers registered with the parser.

Typical usage:

main(int argc, char* argv[]) {
if (*S) {
std::cout << "Executing subcommand: " << S->getName() << std::endl;
// Execute some function based on the name...
}
}
}
iterator_range< typename SmallPtrSet< SubCommand *, 4 >::iterator > getRegisteredSubcommands()
Use this to get all registered SubCommands from the provided parser.

This interface is useful for defining subcommands in libraries and the dispatch from a single point (like in the main function).

Definition at line 2768 of file CommandLine.cpp.

References GlobalParser.

◆ HideUnrelatedOptions() [1/2]

void llvm::cl::HideUnrelatedOptions ( ArrayRef< const cl::OptionCategory * >  Categories,
SubCommand Sub = SubCommand::getTopLevel() 
)

Mark all options not part of the categories as cl::ReallyHidden.

Parameters
Categoriesthe categories of options to keep displaying.

Some tools (like clang-format) like to be able to hide all options that are not specific to the tool. This function allows a tool to specify a single option category to display in the -help output.

Definition at line 2785 of file CommandLine.cpp.

References CommonOptions, I, initCommonOptions(), llvm::is_contained(), llvm::cl::SubCommand::OptionsMap, and ReallyHidden.

◆ HideUnrelatedOptions() [2/2]

void llvm::cl::HideUnrelatedOptions ( cl::OptionCategory Category,
SubCommand Sub = SubCommand::getTopLevel() 
)

Mark all options not part of this category as cl::ReallyHidden.

Parameters
Categorythe category of options to keep displaying

Some tools (like clang-format) like to be able to hide all options that are not specific to the tool. This function allows a tool to specify a single option category to display in the -help output.

Definition at line 2772 of file CommandLine.cpp.

References CommonOptions, I, initCommonOptions(), llvm::cl::SubCommand::OptionsMap, and ReallyHidden.

◆ init()

template<class Ty >
initializer< Ty > llvm::cl::init ( const Ty &  Val)

◆ list_init()

template<class Ty >
list_initializer< Ty > llvm::cl::list_init ( ArrayRef< Ty >  Vals)

Definition at line 455 of file CommandLine.h.

◆ location()

template<class Ty >
LocationClass< Ty > llvm::cl::location ( Ty &  L)

Definition at line 470 of file CommandLine.h.

Referenced by llvm::initStatisticOptions().

◆ ParseCommandLineOptions()

bool llvm::cl::ParseCommandLineOptions ( int  argc,
const char *const argv,
StringRef  Overview = "",
raw_ostream Errs = nullptr,
const char EnvVar = nullptr,
bool  LongOptionsUseDoubleDash = false 
)

◆ PrintHelpMessage()

void llvm::cl::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 option had been given on the command line.

Parameters
Hiddenif true will print hidden options
Categorizedif true print options in categories

Definition at line 2735 of file CommandLine.cpp.

References CommonOptions, and Hidden.

◆ printOptionDiff() [1/2]

template<class ParserClass , class ValDT >
void llvm::cl::printOptionDiff ( const Option O,
const basic_parser< typename ParserClass::parser_data_type > &  P,
const ValDT &  V,
const OptionValue< ValDT > &  Default,
size_t  GlobalWidth 
)

Definition at line 1251 of file CommandLine.h.

References llvm::Default, P, and printer.

◆ printOptionDiff() [2/2]

template<class ParserClass , class DT >
void llvm::cl::printOptionDiff ( const Option O,
const generic_parser_base P,
const DT &  V,
const OptionValue< DT > &  Default,
size_t  GlobalWidth 
)

Definition at line 1224 of file CommandLine.h.

References llvm::Default, and P.

◆ PrintOptionValues()

void llvm::cl::PrintOptionValues ( )

Definition at line 2716 of file CommandLine.cpp.

References GlobalParser.

◆ PrintVersionMessage()

void llvm::cl::PrintVersionMessage ( )

Utility function for printing version number.

Definition at line 2747 of file CommandLine.cpp.

References CommonOptions.

◆ ProvidePositionalOption()

bool llvm::cl::ProvidePositionalOption ( Option Handler,
StringRef  Arg,
int  i 
)

Parses Arg into the option handler Handler.

Definition at line 692 of file CommandLine.cpp.

References llvm::cl::Option::ArgStr, and ProvideOption().

◆ ResetAllOptionOccurrences()

void llvm::cl::ResetAllOptionOccurrences ( )

Reset all command line options to a state that looks as if they have never appeared on the command line.

Reset all options at least once, so that we can parse different options.

This is useful for being able to parse a command line multiple times (especially useful for writing tests).

Definition at line 1457 of file CommandLine.cpp.

◆ ResetCommandLineParser()

void llvm::cl::ResetCommandLineParser ( )

Reset the command line parser back to its initial state.

This removes all options, categories, and subcommands and returns the parser to a state where no options are supported.

Definition at line 2800 of file CommandLine.cpp.

References GlobalParser.

◆ SetVersionPrinter()

void llvm::cl::SetVersionPrinter ( VersionPrinterTy  func)

===------------------------------------------------------------------—===// Override the default (LLVM specific) version printer used to print out the version when –version is given on the command line.

This allows other systems using the CommandLine utilities to print their own version string.

Definition at line 2751 of file CommandLine.cpp.

References CommonOptions.

◆ tokenizeConfigFile()

void llvm::cl::tokenizeConfigFile ( StringRef  Source,
StringSaver Saver,
SmallVectorImpl< const char * > &  NewArgv,
bool  MarkEOLs = false 
)

Tokenizes content of configuration file.

Parameters
[in]SourceThe string representing content of config file.
[in]SaverDelegates back to the caller for saving parsed strings.
[out]NewArgvAll parsed strings are appended to NewArgv.
[in]MarkEOLsAdded for compatibility with TokenizerCallback.

It works like TokenizeGNUCommandLine with ability to skip comment lines.

Definition at line 1058 of file CommandLine.cpp.

References End, isWhitespace(), and TokenizeGNUCommandLine().

◆ TokenizeGNUCommandLine()

void llvm::cl::TokenizeGNUCommandLine ( StringRef  Source,
StringSaver Saver,
SmallVectorImpl< const char * > &  NewArgv,
bool  MarkEOLs = false 
)

Tokenizes a command line that can contain escapes and quotes.

The quoting rules match those used by GCC and other tools that use libiberty's buildargv() or expandargv() utilities, and do not match bash. They differ from buildargv() on treatment of backslashes that do not escape a special character to make it possible to accept most Windows file paths.

Parameters
[in]SourceThe string to be split on whitespace with quotes.
[in]SaverDelegates back to the caller for saving parsed strings.
[in]MarkEOLstrue if tokenizing a response file and you want end of lines and end of the response file to be marked with a nullptr string.
[out]NewArgvAll parsed strings are appended to NewArgv.

Definition at line 806 of file CommandLine.cpp.

References llvm::CallingConv::C, llvm::SmallVectorImpl< T >::clear(), llvm::StringRef::data(), E, llvm::SmallVectorBase< Size_T >::empty(), I, isQuote(), isWhitespace(), llvm::SmallVectorTemplateBase< T, bool >::push_back(), llvm::StringSaver::save(), and llvm::SmallString< InternalLen >::str().

Referenced by expandResponseFiles(), ParseCommandLineOptions(), and tokenizeConfigFile().

◆ TokenizeWindowsCommandLine()

void llvm::cl::TokenizeWindowsCommandLine ( StringRef  Source,
StringSaver Saver,
SmallVectorImpl< const char * > &  NewArgv,
bool  MarkEOLs = false 
)

Tokenizes a string of Windows command line arguments, which may contain quotes and escaped quotes.

See MSDN docs for CommandLineToArgvW for information on the quoting rules. http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx

For handling a full Windows command line including the executable name at the start, see TokenizeWindowsCommandLineFull below.

Parameters
[in]SourceThe string to be split on whitespace with quotes.
[in]SaverDelegates back to the caller for saving parsed strings.
[in]MarkEOLstrue if tokenizing a response file and you want end of lines and end of the response file to be marked with a nullptr string.
[out]NewArgvAll parsed strings are appended to NewArgv.

Definition at line 1026 of file CommandLine.cpp.

References llvm::SmallVectorTemplateBase< T, bool >::push_back(), and tokenizeWindowsCommandLineImpl().

Referenced by expandResponseFiles(), and llvm::libDriverMain().

◆ TokenizeWindowsCommandLineFull()

void llvm::cl::TokenizeWindowsCommandLineFull ( StringRef  Source,
StringSaver Saver,
SmallVectorImpl< const char * > &  NewArgv,
bool  MarkEOLs = false 
)

Tokenizes a Windows full command line, including command name at the start.

This uses the same syntax rules as TokenizeWindowsCommandLine for all but the first token. But the first token is expected to be parsed as the executable file name in the way CreateProcess would do it, rather than the way the C library startup code would do it: CreateProcess does not consider that \ is ever an escape character (because " is not a valid filename char, hence there's never a need to escape it to be used literally).

Parameters are the same as for TokenizeWindowsCommandLine. In particular, if you set MarkEOLs = true, then the first word of every line will be parsed using the special rules for command names, making this function suitable for parsing a file full of commands to execute.

Definition at line 1046 of file CommandLine.cpp.

References llvm::SmallVectorTemplateBase< T, bool >::push_back(), and tokenizeWindowsCommandLineImpl().

◆ TokenizeWindowsCommandLineNoCopy()

void llvm::cl::TokenizeWindowsCommandLineNoCopy ( StringRef  Source,
StringSaver Saver,
SmallVectorImpl< StringRef > &  NewArgv 
)

Tokenizes a Windows command line while attempting to avoid copies.

If no quoting or escaping was used, this produces substrings of the original string. If a token requires unquoting, it will be allocated with the StringSaver.

Definition at line 1038 of file CommandLine.cpp.

References llvm::SmallVectorTemplateBase< T, bool >::push_back(), and tokenizeWindowsCommandLineImpl().

Referenced by llvm::jitlink::COFFDirectiveParser::parse().

◆ values()

template<typename... OptsTy>
ValuesClass llvm::cl::values ( OptsTy...  Options)

Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to the ValuesClass constructor.

Definition at line 718 of file CommandLine.h.

References Options.

Referenced by llvm::codegen::RegisterCodeGenFlags::RegisterCodeGenFlags(), and llvm::mc::RegisterMCTargetOptionsFlags::RegisterMCTargetOptionsFlags().

Variable Documentation

◆ AllSubCommands

ManagedStatic< SubCommand > llvm::cl::AllSubCommands
extern

Definition at line 462 of file CommandLine.cpp.

Referenced by llvm::cl::SubCommand::getAll().

◆ TopLevelSubCommand

LLVM_REQUIRE_CONSTANT_INITIALIZATION ManagedStatic< SubCommand > llvm::cl::TopLevelSubCommand
extern

Definition at line 459 of file CommandLine.cpp.

Referenced by llvm::cl::SubCommand::getTopLevel().