LLVM 17.0.0git
CommandLine.h
Go to the documentation of this file.
1//===- llvm/Support/CommandLine.h - Command line handler --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This class implements a command line argument processor that is useful when
10// creating a tool. It provides a simple, minimalistic interface that is easily
11// extensible and supports nonlocal (library) command line options.
12//
13// Note that rather than trying to figure out what this code does, you should
14// read the library documentation located in docs/CommandLine.html or looks at
15// the many example usages in tools/*/*.cpp
16//
17//===----------------------------------------------------------------------===//
18
19#ifndef LLVM_SUPPORT_COMMANDLINE_H
20#define LLVM_SUPPORT_COMMANDLINE_H
21
22#include "llvm/ADT/ArrayRef.h"
23#include "llvm/ADT/STLExtras.h"
26#include "llvm/ADT/StringMap.h"
27#include "llvm/ADT/StringRef.h"
28#include "llvm/ADT/Twine.h"
34#include <cassert>
35#include <climits>
36#include <cstddef>
37#include <functional>
38#include <initializer_list>
39#include <string>
40#include <type_traits>
41#include <vector>
42
43namespace llvm {
44
45namespace vfs {
46class FileSystem;
47}
48
49class StringSaver;
50
51/// This namespace contains all of the command line option processing machinery.
52/// It is intentionally a short name to make qualified usage concise.
53namespace cl {
54
55//===----------------------------------------------------------------------===//
56// Command line option processing entry point.
57//
58// Returns true on success. Otherwise, this will print the error message to
59// stderr and exit if \p Errs is not set (nullptr by default), or print the
60// error message to \p Errs and return false if \p Errs is provided.
61//
62// If EnvVar is not nullptr, command-line options are also parsed from the
63// environment variable named by EnvVar. Precedence is given to occurrences
64// from argv. This precedence is currently implemented by parsing argv after
65// the environment variable, so it is only implemented correctly for options
66// that give precedence to later occurrences. If your program supports options
67// that give precedence to earlier occurrences, you will need to extend this
68// function to support it correctly.
69bool ParseCommandLineOptions(int argc, const char *const *argv,
70 StringRef Overview = "",
71 raw_ostream *Errs = nullptr,
72 const char *EnvVar = nullptr,
73 bool LongOptionsUseDoubleDash = false);
74
75// Function pointer type for printing version information.
76using VersionPrinterTy = std::function<void(raw_ostream &)>;
77
78///===---------------------------------------------------------------------===//
79/// Override the default (LLVM specific) version printer used to print out the
80/// version when --version is given on the command line. This allows other
81/// systems using the CommandLine utilities to print their own version string.
83
84///===---------------------------------------------------------------------===//
85/// Add an extra printer to use in addition to the default one. This can be
86/// called multiple times, and each time it adds a new function to the list
87/// which will be called after the basic LLVM version printing is complete.
88/// Each can then add additional information specific to the tool.
90
91// Print option values.
92// With -print-options print the difference between option values and defaults.
93// With -print-all-options print all option values.
94// (Currently not perfect, but best-effort.)
96
97// Forward declaration - AddLiteralOption needs to be up here to make gcc happy.
98class Option;
99
100/// Adds a new option for parsing and provides the option it refers to.
101///
102/// \param O pointer to the option
103/// \param Name the string name for the option to handle during parsing
104///
105/// Literal options are used by some parsers to register special option values.
106/// This is how the PassNameParser registers pass names for opt.
108
109//===----------------------------------------------------------------------===//
110// Flags permitted to be passed to command line arguments
111//
112
113enum NumOccurrencesFlag { // Flags for the number of occurrences allowed
114 Optional = 0x00, // Zero or One occurrence
115 ZeroOrMore = 0x01, // Zero or more occurrences allowed
116 Required = 0x02, // One occurrence required
117 OneOrMore = 0x03, // One or more occurrences required
118
119 // Indicates that this option is fed anything that follows the last positional
120 // argument required by the application (it is an error if there are zero
121 // positional arguments, and a ConsumeAfter option is used).
122 // Thus, for example, all arguments to LLI are processed until a filename is
123 // found. Once a filename is found, all of the succeeding arguments are
124 // passed, unprocessed, to the ConsumeAfter option.
125 //
126 ConsumeAfter = 0x04
128
129enum ValueExpected { // Is a value required for the option?
130 // zero reserved for the unspecified value
131 ValueOptional = 0x01, // The value can appear... or not
132 ValueRequired = 0x02, // The value is required to appear!
133 ValueDisallowed = 0x03 // A value may not be specified (for flags)
135
136enum OptionHidden { // Control whether -help shows this option
137 NotHidden = 0x00, // Option included in -help & -help-hidden
138 Hidden = 0x01, // -help doesn't, but -help-hidden does
139 ReallyHidden = 0x02 // Neither -help nor -help-hidden show this arg
141
142// This controls special features that the option might have that cause it to be
143// parsed differently...
144//
145// Prefix - This option allows arguments that are otherwise unrecognized to be
146// matched by options that are a prefix of the actual value. This is useful for
147// cases like a linker, where options are typically of the form '-lfoo' or
148// '-L../../include' where -l or -L are the actual flags. When prefix is
149// enabled, and used, the value for the flag comes from the suffix of the
150// argument.
151//
152// AlwaysPrefix - Only allow the behavior enabled by the Prefix flag and reject
153// the Option=Value form.
154//
155
157 NormalFormatting = 0x00, // Nothing special
158 Positional = 0x01, // Is a positional argument, no '-' required
159 Prefix = 0x02, // Can this option directly prefix its value?
160 AlwaysPrefix = 0x03 // Can this option only directly prefix its value?
162
163enum MiscFlags { // Miscellaneous flags to adjust argument
164 CommaSeparated = 0x01, // Should this cl::list split between commas?
165 PositionalEatsArgs = 0x02, // Should this positional cl::list eat -args?
166 Sink = 0x04, // Should this cl::list eat all unknown options?
167
168 // Can this option group with other options?
169 // If this is enabled, multiple letter options are allowed to bunch together
170 // with only a single hyphen for the whole group. This allows emulation
171 // of the behavior that ls uses for example: ls -la === ls -l -a
172 Grouping = 0x08,
173
174 // Default option
175 DefaultOption = 0x10
177
178//===----------------------------------------------------------------------===//
179//
181private:
182 StringRef const Name;
183 StringRef const Description;
184
185 void registerCategory();
186
187public:
189 StringRef const Description = "")
190 : Name(Name), Description(Description) {
191 registerCategory();
192 }
193
194 StringRef getName() const { return Name; }
195 StringRef getDescription() const { return Description; }
196};
197
198// The general Option Category (used as default category).
199OptionCategory &getGeneralCategory();
200
201//===----------------------------------------------------------------------===//
202//
204private:
205 StringRef Name;
206 StringRef Description;
207
208protected:
209 void registerSubCommand();
211
212public:
213 SubCommand(StringRef Name, StringRef Description = "")
214 : Name(Name), Description(Description) {
216 }
217 SubCommand() = default;
218
219 // Get the special subcommand representing no subcommand.
220 static SubCommand &getTopLevel();
221
222 // Get the special subcommand that can be used to put an option into all
223 // subcomands.
224 static SubCommand &getAll();
225
226 void reset();
227
228 explicit operator bool() const;
229
230 StringRef getName() const { return Name; }
231 StringRef getDescription() const { return Description; }
232
236
237 Option *ConsumeAfterOpt = nullptr; // The ConsumeAfter option if it exists.
238};
239
240// A special subcommand representing no subcommand
242
243// A special subcommand that can be used to put an option into all subcommands.
245
246//===----------------------------------------------------------------------===//
247//
248class Option {
249 friend class alias;
250
251 // Overriden by subclasses to handle the value passed into an argument. Should
252 // return true if there was an error processing the argument and the program
253 // should exit.
254 //
255 virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
256 StringRef Arg) = 0;
257
258 virtual enum ValueExpected getValueExpectedFlagDefault() const {
259 return ValueOptional;
260 }
261
262 // Out of line virtual function to provide home for the class.
263 virtual void anchor();
264
265 uint16_t NumOccurrences; // The number of times specified
266 // Occurrences, HiddenFlag, and Formatting are all enum types but to avoid
267 // problems with signed enums in bitfields.
268 uint16_t Occurrences : 3; // enum NumOccurrencesFlag
269 // not using the enum type for 'Value' because zero is an implementation
270 // detail representing the non-value
271 uint16_t Value : 2;
272 uint16_t HiddenFlag : 2; // enum OptionHidden
273 uint16_t Formatting : 2; // enum FormattingFlags
274 uint16_t Misc : 5;
275 uint16_t FullyInitialized : 1; // Has addArgument been called?
276 uint16_t Position; // Position of last occurrence of the option
277 uint16_t AdditionalVals; // Greater than 0 for multi-valued option.
278
279public:
280 StringRef ArgStr; // The argument string itself (ex: "help", "o")
281 StringRef HelpStr; // The descriptive text message for -help
282 StringRef ValueStr; // String describing what the value of this option is
284 Categories; // The Categories this option belongs to
285 SmallPtrSet<SubCommand *, 1> Subs; // The subcommands this option belongs to.
286
288 return (enum NumOccurrencesFlag)Occurrences;
289 }
290
292 return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
293 }
294
295 inline enum OptionHidden getOptionHiddenFlag() const {
296 return (enum OptionHidden)HiddenFlag;
297 }
298
299 inline enum FormattingFlags getFormattingFlag() const {
300 return (enum FormattingFlags)Formatting;
301 }
302
303 inline unsigned getMiscFlags() const { return Misc; }
304 inline unsigned getPosition() const { return Position; }
305 inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
306
307 // Return true if the argstr != ""
308 bool hasArgStr() const { return !ArgStr.empty(); }
309 bool isPositional() const { return getFormattingFlag() == cl::Positional; }
310 bool isSink() const { return getMiscFlags() & cl::Sink; }
311 bool isDefaultOption() const { return getMiscFlags() & cl::DefaultOption; }
312
313 bool isConsumeAfter() const {
315 }
316
317 bool isInAllSubCommands() const {
319 }
320
321 //-------------------------------------------------------------------------===
322 // Accessor functions set by OptionModifiers
323 //
324 void setArgStr(StringRef S);
327 void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
328 void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
329 void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
330 void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }
331 void setMiscFlag(enum MiscFlags M) { Misc |= M; }
332 void setPosition(unsigned pos) { Position = pos; }
334 void addSubCommand(SubCommand &S) { Subs.insert(&S); }
335
336protected:
337 explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
338 enum OptionHidden Hidden)
339 : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
340 HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0),
341 FullyInitialized(false), Position(0), AdditionalVals(0) {
342 Categories.push_back(&getGeneralCategory());
343 }
344
345 inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
346
347public:
348 virtual ~Option() = default;
349
350 // Register this argument with the commandline system.
351 //
352 void addArgument();
353
354 /// Unregisters this option from the CommandLine system.
355 ///
356 /// This option must have been the last option registered.
357 /// For testing purposes only.
358 void removeArgument();
359
360 // Return the width of the option tag for printing...
361 virtual size_t getOptionWidth() const = 0;
362
363 // Print out information about this option. The to-be-maintained width is
364 // specified.
365 //
366 virtual void printOptionInfo(size_t GlobalWidth) const = 0;
367
368 virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
369
370 virtual void setDefault() = 0;
371
372 // Prints the help string for an option.
373 //
374 // This maintains the Indent for multi-line descriptions.
375 // FirstLineIndentedBy is the count of chars of the first line
376 // i.e. the one containing the --<option name>.
377 static void printHelpStr(StringRef HelpStr, size_t Indent,
378 size_t FirstLineIndentedBy);
379
380 // Prints the help string for an enum value.
381 //
382 // This maintains the Indent for multi-line descriptions.
383 // FirstLineIndentedBy is the count of chars of the first line
384 // i.e. the one containing the =<value>.
385 static void printEnumValHelpStr(StringRef HelpStr, size_t Indent,
386 size_t FirstLineIndentedBy);
387
389
390 // Wrapper around handleOccurrence that enforces Flags.
391 //
392 virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
393 bool MultiArg = false);
394
395 // Prints option name followed by message. Always returns true.
396 bool error(const Twine &Message, StringRef ArgName = StringRef(), raw_ostream &Errs = llvm::errs());
397 bool error(const Twine &Message, raw_ostream &Errs) {
398 return error(Message, StringRef(), Errs);
399 }
400
401 inline int getNumOccurrences() const { return NumOccurrences; }
402 void reset();
403};
404
405//===----------------------------------------------------------------------===//
406// Command line option modifiers that can be used to modify the behavior of
407// command line option parsers...
408//
409
410// Modifier to set the description shown in the -help output...
411struct desc {
413
414 desc(StringRef Str) : Desc(Str) {}
415
416 void apply(Option &O) const { O.setDescription(Desc); }
417};
418
419// Modifier to set the value description shown in the -help output...
422
423 value_desc(StringRef Str) : Desc(Str) {}
424
425 void apply(Option &O) const { O.setValueStr(Desc); }
426};
427
428// Specify a default (initial) value for the command line argument, if the
429// default constructor for the argument type does not give you what you want.
430// This is only valid on "opt" arguments, not on "list" arguments.
431template <class Ty> struct initializer {
432 const Ty &Init;
433 initializer(const Ty &Val) : Init(Val) {}
434
435 template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
436};
437
438template <class Ty> struct list_initializer {
441
442 template <class Opt> void apply(Opt &O) const { O.setInitialValues(Inits); }
443};
444
445template <class Ty> initializer<Ty> init(const Ty &Val) {
446 return initializer<Ty>(Val);
447}
448
449template <class Ty>
451 return list_initializer<Ty>(Vals);
452}
453
454// Allow the user to specify which external variable they want to store the
455// results of the command line argument processing into, if they don't want to
456// store it in the option itself.
457template <class Ty> struct LocationClass {
458 Ty &Loc;
459
460 LocationClass(Ty &L) : Loc(L) {}
461
462 template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
463};
464
465template <class Ty> LocationClass<Ty> location(Ty &L) {
466 return LocationClass<Ty>(L);
467}
468
469// Specify the Option category for the command line argument to belong to.
470struct cat {
472
474
475 template <class Opt> void apply(Opt &O) const { O.addCategory(Category); }
476};
477
478// Specify the subcommand that this option belongs to.
479struct sub {
481
482 sub(SubCommand &S) : Sub(S) {}
483
484 template <class Opt> void apply(Opt &O) const { O.addSubCommand(Sub); }
485};
486
487// Specify a callback function to be called when an option is seen.
488// Can be used to set other options automatically.
489template <typename R, typename Ty> struct cb {
490 std::function<R(Ty)> CB;
491
492 cb(std::function<R(Ty)> CB) : CB(CB) {}
493
494 template <typename Opt> void apply(Opt &O) const { O.setCallback(CB); }
495};
496
497namespace detail {
498template <typename F>
499struct callback_traits : public callback_traits<decltype(&F::operator())> {};
500
501template <typename R, typename C, typename... Args>
502struct callback_traits<R (C::*)(Args...) const> {
503 using result_type = R;
504 using arg_type = std::tuple_element_t<0, std::tuple<Args...>>;
505 static_assert(sizeof...(Args) == 1, "callback function must have one and only one parameter");
506 static_assert(std::is_same<result_type, void>::value,
507 "callback return type must be void");
508 static_assert(std::is_lvalue_reference<arg_type>::value &&
509 std::is_const<std::remove_reference_t<arg_type>>::value,
510 "callback arg_type must be a const lvalue reference");
511};
512} // namespace detail
513
514template <typename F>
518 using result_type = typename detail::callback_traits<F>::result_type;
519 using arg_type = typename detail::callback_traits<F>::arg_type;
520 return cb<result_type, arg_type>(CB);
521}
522
523//===----------------------------------------------------------------------===//
524
525// Support value comparison outside the template.
527 virtual bool compare(const GenericOptionValue &V) const = 0;
528
529protected:
534
535private:
536 virtual void anchor();
537};
538
539template <class DataType> struct OptionValue;
540
541// The default value safely does nothing. Option value printing is only
542// best-effort.
543template <class DataType, bool isClass>
545 // Temporary storage for argument passing.
547
548 bool hasValue() const { return false; }
549
550 const DataType &getValue() const { llvm_unreachable("no default value"); }
551
552 // Some options may take their value from a different data type.
553 template <class DT> void setValue(const DT & /*V*/) {}
554
555 bool compare(const DataType & /*V*/) const { return false; }
556
557 bool compare(const GenericOptionValue & /*V*/) const override {
558 return false;
559 }
560
561protected:
562 ~OptionValueBase() = default;
563};
564
565// Simple copy of the option value.
566template <class DataType> class OptionValueCopy : public GenericOptionValue {
567 DataType Value;
568 bool Valid = false;
569
570protected:
573 ~OptionValueCopy() = default;
574
575public:
576 OptionValueCopy() = default;
577
578 bool hasValue() const { return Valid; }
579
580 const DataType &getValue() const {
581 assert(Valid && "invalid option value");
582 return Value;
583 }
584
585 void setValue(const DataType &V) {
586 Valid = true;
587 Value = V;
588 }
589
590 bool compare(const DataType &V) const { return Valid && (Value != V); }
591
592 bool compare(const GenericOptionValue &V) const override {
593 const OptionValueCopy<DataType> &VC =
594 static_cast<const OptionValueCopy<DataType> &>(V);
595 if (!VC.hasValue())
596 return false;
597 return compare(VC.getValue());
598 }
599};
600
601// Non-class option values.
602template <class DataType>
603struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
604 using WrapperType = DataType;
605
606protected:
607 OptionValueBase() = default;
610 ~OptionValueBase() = default;
611};
612
613// Top-level option class.
614template <class DataType>
615struct OptionValue final
616 : OptionValueBase<DataType, std::is_class<DataType>::value> {
617 OptionValue() = default;
618
619 OptionValue(const DataType &V) { this->setValue(V); }
620
621 // Some options may take their value from a different data type.
622 template <class DT> OptionValue<DataType> &operator=(const DT &V) {
623 this->setValue(V);
624 return *this;
625 }
626};
627
628// Other safe-to-copy-by-value common option types.
630template <>
631struct OptionValue<cl::boolOrDefault> final
632 : OptionValueCopy<cl::boolOrDefault> {
634
635 OptionValue() = default;
636
637 OptionValue(const cl::boolOrDefault &V) { this->setValue(V); }
638
640 setValue(V);
641 return *this;
642 }
643
644private:
645 void anchor() override;
646};
647
648template <>
649struct OptionValue<std::string> final : OptionValueCopy<std::string> {
651
652 OptionValue() = default;
653
654 OptionValue(const std::string &V) { this->setValue(V); }
655
656 OptionValue<std::string> &operator=(const std::string &V) {
657 setValue(V);
658 return *this;
659 }
660
661private:
662 void anchor() override;
663};
664
665//===----------------------------------------------------------------------===//
666// Enum valued command line option
667//
668
669// This represents a single enum value, using "int" as the underlying type.
672 int Value;
674};
675
676#define clEnumVal(ENUMVAL, DESC) \
677 llvm::cl::OptionEnumValue { #ENUMVAL, int(ENUMVAL), DESC }
678#define clEnumValN(ENUMVAL, FLAGNAME, DESC) \
679 llvm::cl::OptionEnumValue { FLAGNAME, int(ENUMVAL), DESC }
680
681// For custom data types, allow specifying a group of values together as the
682// values that go into the mapping that the option handler uses.
683//
685 // Use a vector instead of a map, because the lists should be short,
686 // the overhead is less, and most importantly, it keeps them in the order
687 // inserted so we can print our option out nicely.
689
690public:
691 ValuesClass(std::initializer_list<OptionEnumValue> Options)
692 : Values(Options) {}
693
694 template <class Opt> void apply(Opt &O) const {
695 for (const auto &Value : Values)
696 O.getParser().addLiteralOption(Value.Name, Value.Value,
697 Value.Description);
698 }
699};
700
701/// Helper to build a ValuesClass by forwarding a variable number of arguments
702/// as an initializer list to the ValuesClass constructor.
703template <typename... OptsTy> ValuesClass values(OptsTy... Options) {
704 return ValuesClass({Options...});
705}
706
707//===----------------------------------------------------------------------===//
708// Parameterizable parser for different data types. By default, known data types
709// (string, int, bool) have specialized parsers, that do what you would expect.
710// The default parser, used for data types that are not built-in, uses a mapping
711// table to map specific options to values, which is used, among other things,
712// to handle enum types.
713
714//--------------------------------------------------
715// This class holds all the non-generic code that we do not need replicated for
716// every instance of the generic parser. This also allows us to put stuff into
717// CommandLine.cpp
718//
720protected:
722 public:
724 : Name(name), HelpStr(helpStr) {}
727 };
728
729public:
731
732 virtual ~generic_parser_base() = default;
733 // Base class should have virtual-destructor
734
735 // Virtual function implemented by generic subclass to indicate how many
736 // entries are in Values.
737 //
738 virtual unsigned getNumOptions() const = 0;
739
740 // Return option name N.
741 virtual StringRef getOption(unsigned N) const = 0;
742
743 // Return description N
744 virtual StringRef getDescription(unsigned N) const = 0;
745
746 // Return the width of the option tag for printing...
747 virtual size_t getOptionWidth(const Option &O) const;
748
749 virtual const GenericOptionValue &getOptionValue(unsigned N) const = 0;
750
751 // Print out information about this option. The to-be-maintained width is
752 // specified.
753 //
754 virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const;
755
756 void printGenericOptionDiff(const Option &O, const GenericOptionValue &V,
758 size_t GlobalWidth) const;
759
760 // Print the value of an option and it's default.
761 //
762 // Template definition ensures that the option and default have the same
763 // DataType (via the same AnyOptionValue).
764 template <class AnyOptionValue>
765 void printOptionDiff(const Option &O, const AnyOptionValue &V,
766 const AnyOptionValue &Default,
767 size_t GlobalWidth) const {
768 printGenericOptionDiff(O, V, Default, GlobalWidth);
769 }
770
771 void initialize() {}
772
774 // If there has been no argstr specified, that means that we need to add an
775 // argument for every possible option. This ensures that our options are
776 // vectored to us.
777 if (!Owner.hasArgStr())
778 for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
779 OptionNames.push_back(getOption(i));
780 }
781
783 // If there is an ArgStr specified, then we are of the form:
784 //
785 // -opt=O2 or -opt O2 or -optO2
786 //
787 // In which case, the value is required. Otherwise if an arg str has not
788 // been specified, we are of the form:
789 //
790 // -O2 or O2 or -la (where -l and -a are separate options)
791 //
792 // If this is the case, we cannot allow a value.
793 //
794 if (Owner.hasArgStr())
795 return ValueRequired;
796 else
797 return ValueDisallowed;
798 }
799
800 // Return the option number corresponding to the specified
801 // argument string. If the option is not found, getNumOptions() is returned.
802 //
803 unsigned findOption(StringRef Name);
804
805protected:
807};
808
809// Default parser implementation - This implementation depends on having a
810// mapping of recognized options to values of some sort. In addition to this,
811// each entry in the mapping also tracks a help message that is printed with the
812// command line option for -help. Because this is a simple mapping parser, the
813// data type can be any unsupported type.
814//
815template <class DataType> class parser : public generic_parser_base {
816protected:
818 public:
819 OptionInfo(StringRef name, DataType v, StringRef helpStr)
820 : GenericOptionInfo(name, helpStr), V(v) {}
821
823 };
825
826public:
828
829 using parser_data_type = DataType;
830
831 // Implement virtual functions needed by generic_parser_base
832 unsigned getNumOptions() const override { return unsigned(Values.size()); }
833 StringRef getOption(unsigned N) const override { return Values[N].Name; }
834 StringRef getDescription(unsigned N) const override {
835 return Values[N].HelpStr;
836 }
837
838 // Return the value of option name N.
839 const GenericOptionValue &getOptionValue(unsigned N) const override {
840 return Values[N].V;
841 }
842
843 // Return true on error.
844 bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
845 StringRef ArgVal;
846 if (Owner.hasArgStr())
847 ArgVal = Arg;
848 else
849 ArgVal = ArgName;
850
851 for (size_t i = 0, e = Values.size(); i != e; ++i)
852 if (Values[i].Name == ArgVal) {
853 V = Values[i].V.getValue();
854 return false;
855 }
856
857 return O.error("Cannot find option named '" + ArgVal + "'!");
858 }
859
860 /// Add an entry to the mapping table.
861 ///
862 template <class DT>
863 void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr) {
864 assert(findOption(Name) == Values.size() && "Option already exists!");
865 OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
866 Values.push_back(X);
868 }
869
870 /// Remove the specified option.
871 ///
873 unsigned N = findOption(Name);
874 assert(N != Values.size() && "Option not found!");
875 Values.erase(Values.begin() + N);
876 }
877};
878
879//--------------------------------------------------
880// Super class of parsers to provide boilerplate code
881//
882class basic_parser_impl { // non-template implementation of basic_parser<t>
883public:
885
886 virtual ~basic_parser_impl() = default;
887
889 return ValueRequired;
890 }
891
893
894 void initialize() {}
895
896 // Return the width of the option tag for printing...
897 size_t getOptionWidth(const Option &O) const;
898
899 // Print out information about this option. The to-be-maintained width is
900 // specified.
901 //
902 void printOptionInfo(const Option &O, size_t GlobalWidth) const;
903
904 // Print a placeholder for options that don't yet support printOptionDiff().
905 void printOptionNoValue(const Option &O, size_t GlobalWidth) const;
906
907 // Overload in subclass to provide a better default value.
908 virtual StringRef getValueName() const { return "value"; }
909
910 // An out-of-line virtual method to provide a 'home' for this class.
911 virtual void anchor();
912
913protected:
914 // A helper for basic_parser::printOptionDiff.
915 void printOptionName(const Option &O, size_t GlobalWidth) const;
916};
917
918// The real basic parser is just a template wrapper that provides a typedef for
919// the provided data type.
920//
921template <class DataType> class basic_parser : public basic_parser_impl {
922public:
923 using parser_data_type = DataType;
925
927};
928
929//--------------------------------------------------
930
931extern template class basic_parser<bool>;
932
933template <> class parser<bool> : public basic_parser<bool> {
934public:
936
937 // Return true on error.
938 bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
939
940 void initialize() {}
941
943 return ValueOptional;
944 }
945
946 // Do not print =<value> at all.
947 StringRef getValueName() const override { return StringRef(); }
948
949 void printOptionDiff(const Option &O, bool V, OptVal Default,
950 size_t GlobalWidth) const;
951
952 // An out-of-line virtual method to provide a 'home' for this class.
953 void anchor() override;
954};
955
956//--------------------------------------------------
957
958extern template class basic_parser<boolOrDefault>;
959
961public:
963
964 // Return true on error.
966
968 return ValueOptional;
969 }
970
971 // Do not print =<value> at all.
972 StringRef getValueName() const override { return StringRef(); }
973
975 size_t GlobalWidth) const;
976
977 // An out-of-line virtual method to provide a 'home' for this class.
978 void anchor() override;
979};
980
981//--------------------------------------------------
982
983extern template class basic_parser<int>;
984
985template <> class parser<int> : public basic_parser<int> {
986public:
988
989 // Return true on error.
990 bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
991
992 // Overload in subclass to provide a better default value.
993 StringRef getValueName() const override { return "int"; }
994
995 void printOptionDiff(const Option &O, int V, OptVal Default,
996 size_t GlobalWidth) const;
997
998 // An out-of-line virtual method to provide a 'home' for this class.
999 void anchor() override;
1000};
1001
1002//--------------------------------------------------
1003
1004extern template class basic_parser<long>;
1005
1006template <> class parser<long> final : public basic_parser<long> {
1007public:
1009
1010 // Return true on error.
1011 bool parse(Option &O, StringRef ArgName, StringRef Arg, long &Val);
1012
1013 // Overload in subclass to provide a better default value.
1014 StringRef getValueName() const override { return "long"; }
1015
1016 void printOptionDiff(const Option &O, long V, OptVal Default,
1017 size_t GlobalWidth) const;
1018
1019 // An out-of-line virtual method to provide a 'home' for this class.
1020 void anchor() override;
1021};
1022
1023//--------------------------------------------------
1024
1025extern template class basic_parser<long long>;
1026
1027template <> class parser<long long> : public basic_parser<long long> {
1028public:
1030
1031 // Return true on error.
1032 bool parse(Option &O, StringRef ArgName, StringRef Arg, long long &Val);
1033
1034 // Overload in subclass to provide a better default value.
1035 StringRef getValueName() const override { return "long"; }
1036
1037 void printOptionDiff(const Option &O, long long V, OptVal Default,
1038 size_t GlobalWidth) const;
1039
1040 // An out-of-line virtual method to provide a 'home' for this class.
1041 void anchor() override;
1042};
1043
1044//--------------------------------------------------
1045
1046extern template class basic_parser<unsigned>;
1047
1048template <> class parser<unsigned> : public basic_parser<unsigned> {
1049public:
1051
1052 // Return true on error.
1053 bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
1054
1055 // Overload in subclass to provide a better default value.
1056 StringRef getValueName() const override { return "uint"; }
1057
1058 void printOptionDiff(const Option &O, unsigned V, OptVal Default,
1059 size_t GlobalWidth) const;
1060
1061 // An out-of-line virtual method to provide a 'home' for this class.
1062 void anchor() override;
1063};
1064
1065//--------------------------------------------------
1066
1067extern template class basic_parser<unsigned long>;
1068
1069template <>
1071public:
1073
1074 // Return true on error.
1075 bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned long &Val);
1076
1077 // Overload in subclass to provide a better default value.
1078 StringRef getValueName() const override { return "ulong"; }
1079
1080 void printOptionDiff(const Option &O, unsigned long V, OptVal Default,
1081 size_t GlobalWidth) const;
1082
1083 // An out-of-line virtual method to provide a 'home' for this class.
1084 void anchor() override;
1085};
1086
1087//--------------------------------------------------
1088
1089extern template class basic_parser<unsigned long long>;
1090
1091template <>
1093public:
1095
1096 // Return true on error.
1098 unsigned long long &Val);
1099
1100 // Overload in subclass to provide a better default value.
1101 StringRef getValueName() const override { return "ulong"; }
1102
1103 void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
1104 size_t GlobalWidth) const;
1105
1106 // An out-of-line virtual method to provide a 'home' for this class.
1107 void anchor() override;
1108};
1109
1110//--------------------------------------------------
1111
1112extern template class basic_parser<double>;
1113
1114template <> class parser<double> : public basic_parser<double> {
1115public:
1117
1118 // Return true on error.
1119 bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
1120
1121 // Overload in subclass to provide a better default value.
1122 StringRef getValueName() const override { return "number"; }
1123
1124 void printOptionDiff(const Option &O, double V, OptVal Default,
1125 size_t GlobalWidth) const;
1126
1127 // An out-of-line virtual method to provide a 'home' for this class.
1128 void anchor() override;
1129};
1130
1131//--------------------------------------------------
1132
1133extern template class basic_parser<float>;
1134
1135template <> class parser<float> : public basic_parser<float> {
1136public:
1138
1139 // Return true on error.
1140 bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
1141
1142 // Overload in subclass to provide a better default value.
1143 StringRef getValueName() const override { return "number"; }
1144
1145 void printOptionDiff(const Option &O, float V, OptVal Default,
1146 size_t GlobalWidth) const;
1147
1148 // An out-of-line virtual method to provide a 'home' for this class.
1149 void anchor() override;
1150};
1151
1152//--------------------------------------------------
1153
1154extern template class basic_parser<std::string>;
1155
1157public:
1159
1160 // Return true on error.
1161 bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
1162 Value = Arg.str();
1163 return false;
1164 }
1165
1166 // Overload in subclass to provide a better default value.
1167 StringRef getValueName() const override { return "string"; }
1168
1170 size_t GlobalWidth) const;
1171
1172 // An out-of-line virtual method to provide a 'home' for this class.
1173 void anchor() override;
1174};
1175
1176//--------------------------------------------------
1177
1178extern template class basic_parser<char>;
1179
1180template <> class parser<char> : public basic_parser<char> {
1181public:
1183
1184 // Return true on error.
1186 Value = Arg[0];
1187 return false;
1188 }
1189
1190 // Overload in subclass to provide a better default value.
1191 StringRef getValueName() const override { return "char"; }
1192
1193 void printOptionDiff(const Option &O, char V, OptVal Default,
1194 size_t GlobalWidth) const;
1195
1196 // An out-of-line virtual method to provide a 'home' for this class.
1197 void anchor() override;
1198};
1199
1200//--------------------------------------------------
1201// This collection of wrappers is the intermediary between class opt and class
1202// parser to handle all the template nastiness.
1203
1204// This overloaded function is selected by the generic parser.
1205template <class ParserClass, class DT>
1206void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,
1207 const OptionValue<DT> &Default, size_t GlobalWidth) {
1208 OptionValue<DT> OV = V;
1209 P.printOptionDiff(O, OV, Default, GlobalWidth);
1210}
1211
1212// This is instantiated for basic parsers when the parsed value has a different
1213// type than the option value. e.g. HelpPrinter.
1214template <class ParserDT, class ValDT> struct OptionDiffPrinter {
1215 void print(const Option &O, const parser<ParserDT> &P, const ValDT & /*V*/,
1216 const OptionValue<ValDT> & /*Default*/, size_t GlobalWidth) {
1217 P.printOptionNoValue(O, GlobalWidth);
1218 }
1219};
1220
1221// This is instantiated for basic parsers when the parsed value has the same
1222// type as the option value.
1223template <class DT> struct OptionDiffPrinter<DT, DT> {
1224 void print(const Option &O, const parser<DT> &P, const DT &V,
1225 const OptionValue<DT> &Default, size_t GlobalWidth) {
1226 P.printOptionDiff(O, V, Default, GlobalWidth);
1227 }
1228};
1229
1230// This overloaded function is selected by the basic parser, which may parse a
1231// different type than the option type.
1232template <class ParserClass, class ValDT>
1234 const Option &O,
1236 const ValDT &V, const OptionValue<ValDT> &Default, size_t GlobalWidth) {
1237
1239 printer.print(O, static_cast<const ParserClass &>(P), V, Default,
1240 GlobalWidth);
1241}
1242
1243//===----------------------------------------------------------------------===//
1244// This class is used because we must use partial specialization to handle
1245// literal string arguments specially (const char* does not correctly respond to
1246// the apply method). Because the syntax to use this is a pain, we have the
1247// 'apply' method below to handle the nastiness...
1248//
1249template <class Mod> struct applicator {
1250 template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
1251};
1252
1253// Handle const char* as a special case...
1254template <unsigned n> struct applicator<char[n]> {
1255 template <class Opt> static void opt(StringRef Str, Opt &O) {
1256 O.setArgStr(Str);
1257 }
1258};
1259template <unsigned n> struct applicator<const char[n]> {
1260 template <class Opt> static void opt(StringRef Str, Opt &O) {
1261 O.setArgStr(Str);
1262 }
1263};
1264template <> struct applicator<StringRef > {
1265 template <class Opt> static void opt(StringRef Str, Opt &O) {
1266 O.setArgStr(Str);
1267 }
1268};
1269
1271 static void opt(NumOccurrencesFlag N, Option &O) {
1272 O.setNumOccurrencesFlag(N);
1273 }
1274};
1275
1276template <> struct applicator<ValueExpected> {
1277 static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
1278};
1279
1280template <> struct applicator<OptionHidden> {
1281 static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
1282};
1283
1285 static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
1286};
1287
1288template <> struct applicator<MiscFlags> {
1289 static void opt(MiscFlags MF, Option &O) {
1290 assert((MF != Grouping || O.ArgStr.size() == 1) &&
1291 "cl::Grouping can only apply to single character Options.");
1292 O.setMiscFlag(MF);
1293 }
1294};
1295
1296// Apply modifiers to an option in a type safe way.
1297template <class Opt, class Mod, class... Mods>
1298void apply(Opt *O, const Mod &M, const Mods &... Ms) {
1299 applicator<Mod>::opt(M, *O);
1300 apply(O, Ms...);
1301}
1302
1303template <class Opt, class Mod> void apply(Opt *O, const Mod &M) {
1304 applicator<Mod>::opt(M, *O);
1305}
1306
1307//===----------------------------------------------------------------------===//
1308// Default storage class definition: external storage. This implementation
1309// assumes the user will specify a variable to store the data into with the
1310// cl::location(x) modifier.
1311//
1312template <class DataType, bool ExternalStorage, bool isClass>
1314 DataType *Location = nullptr; // Where to store the object...
1315 OptionValue<DataType> Default;
1316
1317 void check_location() const {
1318 assert(Location && "cl::location(...) not specified for a command "
1319 "line option with external storage, "
1320 "or cl::init specified before cl::location()!!");
1321 }
1322
1323public:
1324 opt_storage() = default;
1325
1326 bool setLocation(Option &O, DataType &L) {
1327 if (Location)
1328 return O.error("cl::location(x) specified more than once!");
1329 Location = &L;
1330 Default = L;
1331 return false;
1332 }
1333
1334 template <class T> void setValue(const T &V, bool initial = false) {
1335 check_location();
1336 *Location = V;
1337 if (initial)
1338 Default = V;
1339 }
1340
1341 DataType &getValue() {
1342 check_location();
1343 return *Location;
1344 }
1345 const DataType &getValue() const {
1346 check_location();
1347 return *Location;
1348 }
1349
1350 operator DataType() const { return this->getValue(); }
1351
1352 const OptionValue<DataType> &getDefault() const { return Default; }
1353};
1354
1355// Define how to hold a class type object, such as a string. Since we can
1356// inherit from a class, we do so. This makes us exactly compatible with the
1357// object in all cases that it is used.
1358//
1359template <class DataType>
1360class opt_storage<DataType, false, true> : public DataType {
1361public:
1363
1364 template <class T> void setValue(const T &V, bool initial = false) {
1365 DataType::operator=(V);
1366 if (initial)
1367 Default = V;
1368 }
1369
1370 DataType &getValue() { return *this; }
1371 const DataType &getValue() const { return *this; }
1372
1373 const OptionValue<DataType> &getDefault() const { return Default; }
1374};
1375
1376// Define a partial specialization to handle things we cannot inherit from. In
1377// this case, we store an instance through containment, and overload operators
1378// to get at the value.
1379//
1380template <class DataType> class opt_storage<DataType, false, false> {
1381public:
1382 DataType Value;
1384
1385 // Make sure we initialize the value with the default constructor for the
1386 // type.
1387 opt_storage() : Value(DataType()), Default() {}
1388
1389 template <class T> void setValue(const T &V, bool initial = false) {
1390 Value = V;
1391 if (initial)
1392 Default = V;
1393 }
1394 DataType &getValue() { return Value; }
1395 DataType getValue() const { return Value; }
1396
1397 const OptionValue<DataType> &getDefault() const { return Default; }
1398
1399 operator DataType() const { return getValue(); }
1400
1401 // If the datatype is a pointer, support -> on it.
1402 DataType operator->() const { return Value; }
1403};
1404
1405//===----------------------------------------------------------------------===//
1406// A scalar command line option.
1407//
1408template <class DataType, bool ExternalStorage = false,
1409 class ParserClass = parser<DataType>>
1410class opt : public Option,
1411 public opt_storage<DataType, ExternalStorage,
1412 std::is_class<DataType>::value> {
1413 ParserClass Parser;
1414
1415 bool handleOccurrence(unsigned pos, StringRef ArgName,
1416 StringRef Arg) override {
1417 typename ParserClass::parser_data_type Val =
1418 typename ParserClass::parser_data_type();
1419 if (Parser.parse(*this, ArgName, Arg, Val))
1420 return true; // Parse error!
1421 this->setValue(Val);
1422 this->setPosition(pos);
1423 Callback(Val);
1424 return false;
1425 }
1426
1427 enum ValueExpected getValueExpectedFlagDefault() const override {
1428 return Parser.getValueExpectedFlagDefault();
1429 }
1430
1431 void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1432 return Parser.getExtraOptionNames(OptionNames);
1433 }
1434
1435 // Forward printing stuff to the parser...
1436 size_t getOptionWidth() const override {
1437 return Parser.getOptionWidth(*this);
1438 }
1439
1440 void printOptionInfo(size_t GlobalWidth) const override {
1441 Parser.printOptionInfo(*this, GlobalWidth);
1442 }
1443
1444 void printOptionValue(size_t GlobalWidth, bool Force) const override {
1445 if (Force || this->getDefault().compare(this->getValue())) {
1446 cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
1447 this->getDefault(), GlobalWidth);
1448 }
1449 }
1450
1451 template <class T,
1452 class = std::enable_if_t<std::is_assignable<T &, T>::value>>
1453 void setDefaultImpl() {
1454 const OptionValue<DataType> &V = this->getDefault();
1455 if (V.hasValue())
1456 this->setValue(V.getValue());
1457 else
1458 this->setValue(T());
1459 }
1460
1461 template <class T,
1462 class = std::enable_if_t<!std::is_assignable<T &, T>::value>>
1463 void setDefaultImpl(...) {}
1464
1465 void setDefault() override { setDefaultImpl<DataType>(); }
1466
1467 void done() {
1468 addArgument();
1469 Parser.initialize();
1470 }
1471
1472public:
1473 // Command line options should not be copyable
1474 opt(const opt &) = delete;
1475 opt &operator=(const opt &) = delete;
1476
1477 // setInitialValue - Used by the cl::init modifier...
1478 void setInitialValue(const DataType &V) { this->setValue(V, true); }
1479
1480 ParserClass &getParser() { return Parser; }
1481
1482 template <class T> DataType &operator=(const T &Val) {
1483 this->setValue(Val);
1484 Callback(Val);
1485 return this->getValue();
1486 }
1487
1488 template <class... Mods>
1489 explicit opt(const Mods &... Ms)
1490 : Option(llvm::cl::Optional, NotHidden), Parser(*this) {
1491 apply(this, Ms...);
1492 done();
1493 }
1494
1496 std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1497 Callback = CB;
1498 }
1499
1500 std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1501 [](const typename ParserClass::parser_data_type &) {};
1502};
1503
1504extern template class opt<unsigned>;
1505extern template class opt<int>;
1506extern template class opt<std::string>;
1507extern template class opt<char>;
1508extern template class opt<bool>;
1509
1510//===----------------------------------------------------------------------===//
1511// Default storage class definition: external storage. This implementation
1512// assumes the user will specify a variable to store the data into with the
1513// cl::location(x) modifier.
1514//
1515template <class DataType, class StorageClass> class list_storage {
1516 StorageClass *Location = nullptr; // Where to store the object...
1517 std::vector<OptionValue<DataType>> Default =
1518 std::vector<OptionValue<DataType>>();
1519 bool DefaultAssigned = false;
1520
1521public:
1522 list_storage() = default;
1523
1524 void clear() {}
1525
1527 if (Location)
1528 return O.error("cl::location(x) specified more than once!");
1529 Location = &L;
1530 return false;
1531 }
1532
1533 template <class T> void addValue(const T &V, bool initial = false) {
1534 assert(Location != nullptr &&
1535 "cl::location(...) not specified for a command "
1536 "line option with external storage!");
1537 Location->push_back(V);
1538 if (initial)
1539 Default.push_back(V);
1540 }
1541
1542 const std::vector<OptionValue<DataType>> &getDefault() const {
1543 return Default;
1544 }
1545
1546 void assignDefault() { DefaultAssigned = true; }
1547 void overwriteDefault() { DefaultAssigned = false; }
1548 bool isDefaultAssigned() { return DefaultAssigned; }
1549};
1550
1551// Define how to hold a class type object, such as a string.
1552// Originally this code inherited from std::vector. In transitioning to a new
1553// API for command line options we should change this. The new implementation
1554// of this list_storage specialization implements the minimum subset of the
1555// std::vector API required for all the current clients.
1556//
1557// FIXME: Reduce this API to a more narrow subset of std::vector
1558//
1559template <class DataType> class list_storage<DataType, bool> {
1560 std::vector<DataType> Storage;
1561 std::vector<OptionValue<DataType>> Default;
1562 bool DefaultAssigned = false;
1563
1564public:
1565 using iterator = typename std::vector<DataType>::iterator;
1566
1567 iterator begin() { return Storage.begin(); }
1568 iterator end() { return Storage.end(); }
1569
1570 using const_iterator = typename std::vector<DataType>::const_iterator;
1571
1572 const_iterator begin() const { return Storage.begin(); }
1573 const_iterator end() const { return Storage.end(); }
1574
1575 using size_type = typename std::vector<DataType>::size_type;
1576
1577 size_type size() const { return Storage.size(); }
1578
1579 bool empty() const { return Storage.empty(); }
1580
1581 void push_back(const DataType &value) { Storage.push_back(value); }
1582 void push_back(DataType &&value) { Storage.push_back(value); }
1583
1584 using reference = typename std::vector<DataType>::reference;
1585 using const_reference = typename std::vector<DataType>::const_reference;
1586
1587 reference operator[](size_type pos) { return Storage[pos]; }
1588 const_reference operator[](size_type pos) const { return Storage[pos]; }
1589
1590 void clear() {
1591 Storage.clear();
1592 }
1593
1594 iterator erase(const_iterator pos) { return Storage.erase(pos); }
1596 return Storage.erase(first, last);
1597 }
1598
1599 iterator erase(iterator pos) { return Storage.erase(pos); }
1601 return Storage.erase(first, last);
1602 }
1603
1604 iterator insert(const_iterator pos, const DataType &value) {
1605 return Storage.insert(pos, value);
1606 }
1608 return Storage.insert(pos, value);
1609 }
1610
1611 iterator insert(iterator pos, const DataType &value) {
1612 return Storage.insert(pos, value);
1613 }
1614 iterator insert(iterator pos, DataType &&value) {
1615 return Storage.insert(pos, value);
1616 }
1617
1618 reference front() { return Storage.front(); }
1619 const_reference front() const { return Storage.front(); }
1620
1621 operator std::vector<DataType> &() { return Storage; }
1622 operator ArrayRef<DataType>() const { return Storage; }
1623 std::vector<DataType> *operator&() { return &Storage; }
1624 const std::vector<DataType> *operator&() const { return &Storage; }
1625
1626 template <class T> void addValue(const T &V, bool initial = false) {
1627 Storage.push_back(V);
1628 if (initial)
1629 Default.push_back(OptionValue<DataType>(V));
1630 }
1631
1632 const std::vector<OptionValue<DataType>> &getDefault() const {
1633 return Default;
1634 }
1635
1636 void assignDefault() { DefaultAssigned = true; }
1637 void overwriteDefault() { DefaultAssigned = false; }
1638 bool isDefaultAssigned() { return DefaultAssigned; }
1639};
1640
1641//===----------------------------------------------------------------------===//
1642// A list of command line options.
1643//
1644template <class DataType, class StorageClass = bool,
1645 class ParserClass = parser<DataType>>
1646class list : public Option, public list_storage<DataType, StorageClass> {
1647 std::vector<unsigned> Positions;
1648 ParserClass Parser;
1649
1650 enum ValueExpected getValueExpectedFlagDefault() const override {
1651 return Parser.getValueExpectedFlagDefault();
1652 }
1653
1654 void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1655 return Parser.getExtraOptionNames(OptionNames);
1656 }
1657
1658 bool handleOccurrence(unsigned pos, StringRef ArgName,
1659 StringRef Arg) override {
1660 typename ParserClass::parser_data_type Val =
1661 typename ParserClass::parser_data_type();
1663 clear();
1665 }
1666 if (Parser.parse(*this, ArgName, Arg, Val))
1667 return true; // Parse Error!
1669 setPosition(pos);
1670 Positions.push_back(pos);
1671 Callback(Val);
1672 return false;
1673 }
1674
1675 // Forward printing stuff to the parser...
1676 size_t getOptionWidth() const override {
1677 return Parser.getOptionWidth(*this);
1678 }
1679
1680 void printOptionInfo(size_t GlobalWidth) const override {
1681 Parser.printOptionInfo(*this, GlobalWidth);
1682 }
1683
1684 // Unimplemented: list options don't currently store their default value.
1685 void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1686 }
1687
1688 void setDefault() override {
1689 Positions.clear();
1693 }
1694
1695 void done() {
1696 addArgument();
1697 Parser.initialize();
1698 }
1699
1700public:
1701 // Command line options should not be copyable
1702 list(const list &) = delete;
1703 list &operator=(const list &) = delete;
1704
1705 ParserClass &getParser() { return Parser; }
1706
1707 unsigned getPosition(unsigned optnum) const {
1708 assert(optnum < this->size() && "Invalid option index");
1709 return Positions[optnum];
1710 }
1711
1712 void clear() {
1713 Positions.clear();
1715 }
1716
1717 // setInitialValues - Used by the cl::list_init modifier...
1720 "Cannot have two default values");
1722 for (auto &Val : Vs)
1724 }
1725
1727
1728 template <class... Mods>
1729 explicit list(const Mods &... Ms)
1730 : Option(ZeroOrMore, NotHidden), Parser(*this) {
1731 apply(this, Ms...);
1732 done();
1733 }
1734
1736 std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1737 Callback = CB;
1738 }
1739
1740 std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1741 [](const typename ParserClass::parser_data_type &) {};
1742};
1743
1744// Modifier to set the number of additional values.
1747 explicit multi_val(unsigned N) : AdditionalVals(N) {}
1748
1749 template <typename D, typename S, typename P>
1750 void apply(list<D, S, P> &L) const {
1752 }
1753};
1754
1755//===----------------------------------------------------------------------===//
1756// Default storage class definition: external storage. This implementation
1757// assumes the user will specify a variable to store the data into with the
1758// cl::location(x) modifier.
1759//
1760template <class DataType, class StorageClass> class bits_storage {
1761 unsigned *Location = nullptr; // Where to store the bits...
1762
1763 template <class T> static unsigned Bit(const T &V) {
1764 unsigned BitPos = static_cast<unsigned>(V);
1765 assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1766 "enum exceeds width of bit vector!");
1767 return 1 << BitPos;
1768 }
1769
1770public:
1771 bits_storage() = default;
1772
1773 bool setLocation(Option &O, unsigned &L) {
1774 if (Location)
1775 return O.error("cl::location(x) specified more than once!");
1776 Location = &L;
1777 return false;
1778 }
1779
1780 template <class T> void addValue(const T &V) {
1781 assert(Location != nullptr &&
1782 "cl::location(...) not specified for a command "
1783 "line option with external storage!");
1784 *Location |= Bit(V);
1785 }
1786
1787 unsigned getBits() { return *Location; }
1788
1789 void clear() {
1790 if (Location)
1791 *Location = 0;
1792 }
1793
1794 template <class T> bool isSet(const T &V) {
1795 return (*Location & Bit(V)) != 0;
1796 }
1797};
1798
1799// Define how to hold bits. Since we can inherit from a class, we do so.
1800// This makes us exactly compatible with the bits in all cases that it is used.
1801//
1802template <class DataType> class bits_storage<DataType, bool> {
1803 unsigned Bits{0}; // Where to store the bits...
1804
1805 template <class T> static unsigned Bit(const T &V) {
1806 unsigned BitPos = static_cast<unsigned>(V);
1807 assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1808 "enum exceeds width of bit vector!");
1809 return 1 << BitPos;
1810 }
1811
1812public:
1813 template <class T> void addValue(const T &V) { Bits |= Bit(V); }
1814
1815 unsigned getBits() { return Bits; }
1816
1817 void clear() { Bits = 0; }
1818
1819 template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
1820};
1821
1822//===----------------------------------------------------------------------===//
1823// A bit vector of command options.
1824//
1825template <class DataType, class Storage = bool,
1826 class ParserClass = parser<DataType>>
1827class bits : public Option, public bits_storage<DataType, Storage> {
1828 std::vector<unsigned> Positions;
1829 ParserClass Parser;
1830
1831 enum ValueExpected getValueExpectedFlagDefault() const override {
1832 return Parser.getValueExpectedFlagDefault();
1833 }
1834
1835 void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1836 return Parser.getExtraOptionNames(OptionNames);
1837 }
1838
1839 bool handleOccurrence(unsigned pos, StringRef ArgName,
1840 StringRef Arg) override {
1841 typename ParserClass::parser_data_type Val =
1842 typename ParserClass::parser_data_type();
1843 if (Parser.parse(*this, ArgName, Arg, Val))
1844 return true; // Parse Error!
1845 this->addValue(Val);
1846 setPosition(pos);
1847 Positions.push_back(pos);
1848 Callback(Val);
1849 return false;
1850 }
1851
1852 // Forward printing stuff to the parser...
1853 size_t getOptionWidth() const override {
1854 return Parser.getOptionWidth(*this);
1855 }
1856
1857 void printOptionInfo(size_t GlobalWidth) const override {
1858 Parser.printOptionInfo(*this, GlobalWidth);
1859 }
1860
1861 // Unimplemented: bits options don't currently store their default values.
1862 void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1863 }
1864
1865 void setDefault() override { bits_storage<DataType, Storage>::clear(); }
1866
1867 void done() {
1868 addArgument();
1869 Parser.initialize();
1870 }
1871
1872public:
1873 // Command line options should not be copyable
1874 bits(const bits &) = delete;
1875 bits &operator=(const bits &) = delete;
1876
1877 ParserClass &getParser() { return Parser; }
1878
1879 unsigned getPosition(unsigned optnum) const {
1880 assert(optnum < this->size() && "Invalid option index");
1881 return Positions[optnum];
1882 }
1883
1884 template <class... Mods>
1885 explicit bits(const Mods &... Ms)
1886 : Option(ZeroOrMore, NotHidden), Parser(*this) {
1887 apply(this, Ms...);
1888 done();
1889 }
1890
1892 std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1893 Callback = CB;
1894 }
1895
1896 std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1897 [](const typename ParserClass::parser_data_type &) {};
1898};
1899
1900//===----------------------------------------------------------------------===//
1901// Aliased command line option (alias this name to a preexisting name)
1902//
1903
1904class alias : public Option {
1905 Option *AliasFor;
1906
1907 bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
1908 StringRef Arg) override {
1909 return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
1910 }
1911
1912 bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
1913 bool MultiArg = false) override {
1914 return AliasFor->addOccurrence(pos, AliasFor->ArgStr, Value, MultiArg);
1915 }
1916
1917 // Handle printing stuff...
1918 size_t getOptionWidth() const override;
1919 void printOptionInfo(size_t GlobalWidth) const override;
1920
1921 // Aliases do not need to print their values.
1922 void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1923 }
1924
1925 void setDefault() override { AliasFor->setDefault(); }
1926
1927 ValueExpected getValueExpectedFlagDefault() const override {
1928 return AliasFor->getValueExpectedFlag();
1929 }
1930
1931 void done() {
1932 if (!hasArgStr())
1933 error("cl::alias must have argument name specified!");
1934 if (!AliasFor)
1935 error("cl::alias must have an cl::aliasopt(option) specified!");
1936 if (!Subs.empty())
1937 error("cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!");
1938 Subs = AliasFor->Subs;
1939 Categories = AliasFor->Categories;
1940 addArgument();
1941 }
1942
1943public:
1944 // Command line options should not be copyable
1945 alias(const alias &) = delete;
1946 alias &operator=(const alias &) = delete;
1947
1949 if (AliasFor)
1950 error("cl::alias must only have one cl::aliasopt(...) specified!");
1951 AliasFor = &O;
1952 }
1953
1954 template <class... Mods>
1955 explicit alias(const Mods &... Ms)
1956 : Option(Optional, Hidden), AliasFor(nullptr) {
1957 apply(this, Ms...);
1958 done();
1959 }
1960};
1961
1962// Modifier to set the option an alias aliases.
1963struct aliasopt {
1965
1966 explicit aliasopt(Option &O) : Opt(O) {}
1967
1968 void apply(alias &A) const { A.setAliasFor(Opt); }
1969};
1970
1971// Provide additional help at the end of the normal help output. All occurrences
1972// of cl::extrahelp will be accumulated and printed to stderr at the end of the
1973// regular help, just before exit is called.
1976
1977 explicit extrahelp(StringRef help);
1978};
1979
1980void PrintVersionMessage();
1981
1982/// This function just prints the help message, exactly the same way as if the
1983/// -help or -help-hidden option had been given on the command line.
1984///
1985/// \param Hidden if true will print hidden options
1986/// \param Categorized if true print options in categories
1987void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
1988
1989//===----------------------------------------------------------------------===//
1990// Public interface for accessing registered options.
1991//
1992
1993/// Use this to get a StringMap to all registered named options
1994/// (e.g. -help).
1995///
1996/// \return A reference to the StringMap used by the cl APIs to parse options.
1997///
1998/// Access to unnamed arguments (i.e. positional) are not provided because
1999/// it is expected that the client already has access to these.
2000///
2001/// Typical usage:
2002/// \code
2003/// main(int argc,char* argv[]) {
2004/// StringMap<llvm::cl::Option*> &opts = llvm::cl::getRegisteredOptions();
2005/// assert(opts.count("help") == 1)
2006/// opts["help"]->setDescription("Show alphabetical help information")
2007/// // More code
2008/// llvm::cl::ParseCommandLineOptions(argc,argv);
2009/// //More code
2010/// }
2011/// \endcode
2012///
2013/// This interface is useful for modifying options in libraries that are out of
2014/// the control of the client. The options should be modified before calling
2015/// llvm::cl::ParseCommandLineOptions().
2016///
2017/// Hopefully this API can be deprecated soon. Any situation where options need
2018/// to be modified by tools or libraries should be handled by sane APIs rather
2019/// than just handing around a global list.
2022
2023/// Use this to get all registered SubCommands from the provided parser.
2024///
2025/// \return A range of all SubCommand pointers registered with the parser.
2026///
2027/// Typical usage:
2028/// \code
2029/// main(int argc, char* argv[]) {
2030/// llvm::cl::ParseCommandLineOptions(argc, argv);
2031/// for (auto* S : llvm::cl::getRegisteredSubcommands()) {
2032/// if (*S) {
2033/// std::cout << "Executing subcommand: " << S->getName() << std::endl;
2034/// // Execute some function based on the name...
2035/// }
2036/// }
2037/// }
2038/// \endcode
2039///
2040/// This interface is useful for defining subcommands in libraries and
2041/// the dispatch from a single point (like in the main function).
2044
2045//===----------------------------------------------------------------------===//
2046// Standalone command line processing utilities.
2047//
2048
2049/// Tokenizes a command line that can contain escapes and quotes.
2050//
2051/// The quoting rules match those used by GCC and other tools that use
2052/// libiberty's buildargv() or expandargv() utilities, and do not match bash.
2053/// They differ from buildargv() on treatment of backslashes that do not escape
2054/// a special character to make it possible to accept most Windows file paths.
2055///
2056/// \param [in] Source The string to be split on whitespace with quotes.
2057/// \param [in] Saver Delegates back to the caller for saving parsed strings.
2058/// \param [in] MarkEOLs true if tokenizing a response file and you want end of
2059/// lines and end of the response file to be marked with a nullptr string.
2060/// \param [out] NewArgv All parsed strings are appended to NewArgv.
2061void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
2063 bool MarkEOLs = false);
2064
2065/// Tokenizes a string of Windows command line arguments, which may contain
2066/// quotes and escaped quotes.
2067///
2068/// See MSDN docs for CommandLineToArgvW for information on the quoting rules.
2069/// http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx
2070///
2071/// For handling a full Windows command line including the executable name at
2072/// the start, see TokenizeWindowsCommandLineFull below.
2073///
2074/// \param [in] Source The string to be split on whitespace with quotes.
2075/// \param [in] Saver Delegates back to the caller for saving parsed strings.
2076/// \param [in] MarkEOLs true if tokenizing a response file and you want end of
2077/// lines and end of the response file to be marked with a nullptr string.
2078/// \param [out] NewArgv All parsed strings are appended to NewArgv.
2081 bool MarkEOLs = false);
2082
2083/// Tokenizes a Windows command line while attempting to avoid copies. If no
2084/// quoting or escaping was used, this produces substrings of the original
2085/// string. If a token requires unquoting, it will be allocated with the
2086/// StringSaver.
2089
2090/// Tokenizes a Windows full command line, including command name at the start.
2091///
2092/// This uses the same syntax rules as TokenizeWindowsCommandLine for all but
2093/// the first token. But the first token is expected to be parsed as the
2094/// executable file name in the way CreateProcess would do it, rather than the
2095/// way the C library startup code would do it: CreateProcess does not consider
2096/// that \ is ever an escape character (because " is not a valid filename char,
2097/// hence there's never a need to escape it to be used literally).
2098///
2099/// Parameters are the same as for TokenizeWindowsCommandLine. In particular,
2100/// if you set MarkEOLs = true, then the first word of every line will be
2101/// parsed using the special rules for command names, making this function
2102/// suitable for parsing a file full of commands to execute.
2105 bool MarkEOLs = false);
2106
2107/// String tokenization function type. Should be compatible with either
2108/// Windows or Unix command line tokenizers.
2109using TokenizerCallback = void (*)(StringRef Source, StringSaver &Saver,
2111 bool MarkEOLs);
2112
2113/// Tokenizes content of configuration file.
2114///
2115/// \param [in] Source The string representing content of config file.
2116/// \param [in] Saver Delegates back to the caller for saving parsed strings.
2117/// \param [out] NewArgv All parsed strings are appended to NewArgv.
2118/// \param [in] MarkEOLs Added for compatibility with TokenizerCallback.
2119///
2120/// It works like TokenizeGNUCommandLine with ability to skip comment lines.
2121///
2122void tokenizeConfigFile(StringRef Source, StringSaver &Saver,
2124 bool MarkEOLs = false);
2125
2126/// Contains options that control response file expansion.
2128 /// Provides persistent storage for parsed strings.
2129 StringSaver Saver;
2130
2131 /// Tokenization strategy. Typically Unix or Windows.
2132 TokenizerCallback Tokenizer;
2133
2134 /// File system used for all file access when running the expansion.
2135 vfs::FileSystem *FS;
2136
2137 /// Path used to resolve relative rsp files. If empty, the file system
2138 /// current directory is used instead.
2139 StringRef CurrentDir;
2140
2141 /// Directories used for search of config files.
2142 ArrayRef<StringRef> SearchDirs;
2143
2144 /// True if names of nested response files must be resolved relative to
2145 /// including file.
2146 bool RelativeNames = false;
2147
2148 /// If true, mark end of lines and the end of the response file with nullptrs
2149 /// in the Argv vector.
2150 bool MarkEOLs = false;
2151
2152 /// If true, body of config file is expanded.
2153 bool InConfigFile = false;
2154
2155 llvm::Error expandResponseFile(StringRef FName,
2157
2158public:
2160
2162 MarkEOLs = X;
2163 return *this;
2164 }
2165
2167 RelativeNames = X;
2168 return *this;
2169 }
2170
2172 CurrentDir = X;
2173 return *this;
2174 }
2175
2177 SearchDirs = X;
2178 return *this;
2179 }
2180
2182 FS = X;
2183 return *this;
2184 }
2185
2186 /// Looks for the specified configuration file.
2187 ///
2188 /// \param[in] FileName Name of the file to search for.
2189 /// \param[out] FilePath File absolute path, if it was found.
2190 /// \return True if file was found.
2191 ///
2192 /// If the specified file name contains a directory separator, it is searched
2193 /// for by its absolute path. Otherwise looks for file sequentially in
2194 /// directories specified by SearchDirs field.
2195 bool findConfigFile(StringRef FileName, SmallVectorImpl<char> &FilePath);
2196
2197 /// Reads command line options from the given configuration file.
2198 ///
2199 /// \param [in] CfgFile Path to configuration file.
2200 /// \param [out] Argv Array to which the read options are added.
2201 /// \return true if the file was successfully read.
2202 ///
2203 /// It reads content of the specified file, tokenizes it and expands "@file"
2204 /// commands resolving file names in them relative to the directory where
2205 /// CfgFilename resides. It also expands "<CFGDIR>" to the base path of the
2206 /// current config file.
2208
2209 /// Expands constructs "@file" in the provided array of arguments recursively.
2211};
2212
2213/// A convenience helper which concatenates the options specified by the
2214/// environment variable EnvVar and command line options, then expands
2215/// response files recursively.
2216/// \return true if all @files were expanded successfully or there were none.
2217bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
2219
2220/// A convenience helper which supports the typical use case of expansion
2221/// function call.
2224
2225/// A convenience helper which concatenates the options specified by the
2226/// environment variable EnvVar and command line options, then expands response
2227/// files recursively. The tokenizer is a predefined GNU or Windows one.
2228/// \return true if all @files were expanded successfully or there were none.
2229bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
2230 StringSaver &Saver,
2232
2233/// Mark all options not part of this category as cl::ReallyHidden.
2234///
2235/// \param Category the category of options to keep displaying
2236///
2237/// Some tools (like clang-format) like to be able to hide all options that are
2238/// not specific to the tool. This function allows a tool to specify a single
2239/// option category to display in the -help output.
2242
2243/// Mark all options not part of the categories as cl::ReallyHidden.
2244///
2245/// \param Categories the categories of options to keep displaying.
2246///
2247/// Some tools (like clang-format) like to be able to hide all options that are
2248/// not specific to the tool. This function allows a tool to specify a single
2249/// option category to display in the -help output.
2252
2253/// Reset all command line options to a state that looks as if they have
2254/// never appeared on the command line. This is useful for being able to parse
2255/// a command line multiple times (especially useful for writing tests).
2257
2258/// Reset the command line parser back to its initial state. This
2259/// removes
2260/// all options, categories, and subcommands and returns the parser to a state
2261/// where no options are supported.
2263
2264/// Parses `Arg` into the option handler `Handler`.
2265bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
2266
2267} // end namespace cl
2268
2269} // end namespace llvm
2270
2271#endif // LLVM_SUPPORT_COMMANDLINE_H
aarch64 promote const
This file defines the StringMap class.
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
basic Basic Alias true
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
dxil pretty printer
Given that RA is a live value
std::string Name
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static LVOptions Options
Definition: LVOptions.cpp:25
#define F(x, y, z)
Definition: MD5.cpp:55
#define T
return ToRemove size() > 0
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const char * name
Definition: SMEABIPass.cpp:49
This file contains some templates that are useful if you are working with the STL at all.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
#define error(X)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:83
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:111
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:21
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LLVM Value Representation.
Definition: Value.h:74
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:52
Contains options that control response file expansion.
Definition: CommandLine.h:2127
ExpansionContext & setCurrentDir(StringRef X)
Definition: CommandLine.h:2171
ExpansionContext & setVFS(vfs::FileSystem *X)
Definition: CommandLine.h:2181
ExpansionContext & setMarkEOLs(bool X)
Definition: CommandLine.h:2161
ExpansionContext & setSearchDirs(ArrayRef< StringRef > X)
Definition: CommandLine.h:2176
ExpansionContext & setRelativeNames(bool X)
Definition: CommandLine.h:2166
bool findConfigFile(StringRef FileName, SmallVectorImpl< char > &FilePath)
Looks for the specified configuration file.
Error expandResponseFiles(SmallVectorImpl< const char * > &Argv)
Expands constructs "@file" in the provided array of arguments recursively.
Error readConfigFile(StringRef CfgFile, SmallVectorImpl< const char * > &Argv)
Reads command line options from the given configuration file.
OptionCategory(StringRef const Name, StringRef const Description="")
Definition: CommandLine.h:188
StringRef getDescription() const
Definition: CommandLine.h:195
StringRef getName() const
Definition: CommandLine.h:194
OptionValueCopy & operator=(const OptionValueCopy &)=default
bool compare(const GenericOptionValue &V) const override
Definition: CommandLine.h:592
void setValue(const DataType &V)
Definition: CommandLine.h:585
const DataType & getValue() const
Definition: CommandLine.h:580
OptionValueCopy(const OptionValueCopy &)=default
bool compare(const DataType &V) const
Definition: CommandLine.h:590
bool isPositional() const
Definition: CommandLine.h:309
virtual void getExtraOptionNames(SmallVectorImpl< StringRef > &)
Definition: CommandLine.h:388
void setValueExpectedFlag(enum ValueExpected Val)
Definition: CommandLine.h:328
void setPosition(unsigned pos)
Definition: CommandLine.h:332
bool isConsumeAfter() const
Definition: CommandLine.h:313
StringRef ValueStr
Definition: CommandLine.h:282
SmallPtrSet< SubCommand *, 1 > Subs
Definition: CommandLine.h:285
StringRef ArgStr
Definition: CommandLine.h:280
int getNumOccurrences() const
Definition: CommandLine.h:401
enum ValueExpected getValueExpectedFlag() const
Definition: CommandLine.h:291
void addCategory(OptionCategory &C)
void setValueStr(StringRef S)
Definition: CommandLine.h:326
void setNumOccurrencesFlag(enum NumOccurrencesFlag Val)
Definition: CommandLine.h:327
void setNumAdditionalVals(unsigned n)
Definition: CommandLine.h:345
virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value, bool MultiArg=false)
void setDescription(StringRef S)
Definition: CommandLine.h:325
void setFormattingFlag(enum FormattingFlags V)
Definition: CommandLine.h:330
void setHiddenFlag(enum OptionHidden Val)
Definition: CommandLine.h:329
void setMiscFlag(enum MiscFlags M)
Definition: CommandLine.h:331
enum FormattingFlags getFormattingFlag() const
Definition: CommandLine.h:299
virtual void printOptionInfo(size_t GlobalWidth) const =0
enum NumOccurrencesFlag getNumOccurrencesFlag() const
Definition: CommandLine.h:287
SmallVector< OptionCategory *, 1 > Categories
Definition: CommandLine.h:284
bool isSink() const
Definition: CommandLine.h:310
void addSubCommand(SubCommand &S)
Definition: CommandLine.h:334
void setArgStr(StringRef S)
bool hasArgStr() const
Definition: CommandLine.h:308
bool isDefaultOption() const
Definition: CommandLine.h:311
unsigned getMiscFlags() const
Definition: CommandLine.h:303
virtual void setDefault()=0
virtual void printOptionValue(size_t GlobalWidth, bool Force) const =0
bool isInAllSubCommands() const
Definition: CommandLine.h:317
virtual ~Option()=default
static void printEnumValHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
unsigned getNumAdditionalVals() const
Definition: CommandLine.h:305
void removeArgument()
Unregisters this option from the CommandLine system.
Option(enum NumOccurrencesFlag OccurrencesFlag, enum OptionHidden Hidden)
Definition: CommandLine.h:337
enum OptionHidden getOptionHiddenFlag() const
Definition: CommandLine.h:295
bool error(const Twine &Message, raw_ostream &Errs)
Definition: CommandLine.h:397
static void printHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
virtual size_t getOptionWidth() const =0
StringRef HelpStr
Definition: CommandLine.h:281
unsigned getPosition() const
Definition: CommandLine.h:304
StringRef getName() const
Definition: CommandLine.h:230
SubCommand(StringRef Name, StringRef Description="")
Definition: CommandLine.h:213
SmallVector< Option *, 4 > SinkOpts
Definition: CommandLine.h:234
static SubCommand & getTopLevel()
static SubCommand & getAll()
Option * ConsumeAfterOpt
Definition: CommandLine.h:237
SmallVector< Option *, 4 > PositionalOpts
Definition: CommandLine.h:233
StringMap< Option * > OptionsMap
Definition: CommandLine.h:235
StringRef getDescription() const
Definition: CommandLine.h:231
void apply(Opt &O) const
Definition: CommandLine.h:694
ValuesClass(std::initializer_list< OptionEnumValue > Options)
Definition: CommandLine.h:691
alias(const alias &)=delete
void setAliasFor(Option &O)
Definition: CommandLine.h:1948
alias & operator=(const alias &)=delete
alias(const Mods &... Ms)
Definition: CommandLine.h:1955
void printOptionInfo(const Option &O, size_t GlobalWidth) const
enum ValueExpected getValueExpectedFlagDefault() const
Definition: CommandLine.h:888
void getExtraOptionNames(SmallVectorImpl< StringRef > &)
Definition: CommandLine.h:892
virtual StringRef getValueName() const
Definition: CommandLine.h:908
virtual ~basic_parser_impl()=default
void printOptionNoValue(const Option &O, size_t GlobalWidth) const
size_t getOptionWidth(const Option &O) const
void printOptionName(const Option &O, size_t GlobalWidth) const
OptionValue< DataType > OptVal
Definition: CommandLine.h:924
bool isSet(const T &V)
Definition: CommandLine.h:1794
void addValue(const T &V)
Definition: CommandLine.h:1780
bool setLocation(Option &O, unsigned &L)
Definition: CommandLine.h:1773
bits & operator=(const bits &)=delete
bits(const Mods &... Ms)
Definition: CommandLine.h:1885
ParserClass & getParser()
Definition: CommandLine.h:1877
unsigned getPosition(unsigned optnum) const
Definition: CommandLine.h:1879
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
Definition: CommandLine.h:1891
std::function< void(const typename ParserClass::parser_data_type &)> Callback
Definition: CommandLine.h:1896
bits(const bits &)=delete
GenericOptionInfo(StringRef name, StringRef helpStr)
Definition: CommandLine.h:723
virtual size_t getOptionWidth(const Option &O) const
virtual StringRef getDescription(unsigned N) const =0
virtual const GenericOptionValue & getOptionValue(unsigned N) const =0
virtual unsigned getNumOptions() const =0
virtual StringRef getOption(unsigned N) const =0
void printOptionDiff(const Option &O, const AnyOptionValue &V, const AnyOptionValue &Default, size_t GlobalWidth) const
Definition: CommandLine.h:765
void printGenericOptionDiff(const Option &O, const GenericOptionValue &V, const GenericOptionValue &Default, size_t GlobalWidth) const
virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const
unsigned findOption(StringRef Name)
virtual ~generic_parser_base()=default
void getExtraOptionNames(SmallVectorImpl< StringRef > &OptionNames)
Definition: CommandLine.h:773
enum ValueExpected getValueExpectedFlagDefault() const
Definition: CommandLine.h:782
typename std::vector< DataType >::const_iterator const_iterator
Definition: CommandLine.h:1570
typename std::vector< DataType >::const_reference const_reference
Definition: CommandLine.h:1585
iterator erase(const_iterator first, const_iterator last)
Definition: CommandLine.h:1595
iterator insert(const_iterator pos, const DataType &value)
Definition: CommandLine.h:1604
iterator erase(iterator first, iterator last)
Definition: CommandLine.h:1600
const_reference operator[](size_type pos) const
Definition: CommandLine.h:1588
void addValue(const T &V, bool initial=false)
Definition: CommandLine.h:1626
void push_back(const DataType &value)
Definition: CommandLine.h:1581
typename std::vector< DataType >::reference reference
Definition: CommandLine.h:1584
reference operator[](size_type pos)
Definition: CommandLine.h:1587
const std::vector< DataType > * operator&() const
Definition: CommandLine.h:1624
iterator insert(iterator pos, const DataType &value)
Definition: CommandLine.h:1611
typename std::vector< DataType >::size_type size_type
Definition: CommandLine.h:1575
iterator insert(const_iterator pos, DataType &&value)
Definition: CommandLine.h:1607
std::vector< DataType > * operator&()
Definition: CommandLine.h:1623
const std::vector< OptionValue< DataType > > & getDefault() const
Definition: CommandLine.h:1632
iterator erase(const_iterator pos)
Definition: CommandLine.h:1594
iterator insert(iterator pos, DataType &&value)
Definition: CommandLine.h:1614
typename std::vector< DataType >::iterator iterator
Definition: CommandLine.h:1565
const std::vector< OptionValue< DataType > > & getDefault() const
Definition: CommandLine.h:1542
void addValue(const T &V, bool initial=false)
Definition: CommandLine.h:1533
bool setLocation(Option &O, StorageClass &L)
Definition: CommandLine.h:1526
list(const Mods &... Ms)
Definition: CommandLine.h:1729
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
Definition: CommandLine.h:1735
list(const list &)=delete
void setInitialValues(ArrayRef< DataType > Vs)
Definition: CommandLine.h:1718
std::function< void(const typename ParserClass::parser_data_type &)> Callback
Definition: CommandLine.h:1740
list & operator=(const list &)=delete
ParserClass & getParser()
Definition: CommandLine.h:1705
unsigned getPosition(unsigned optnum) const
Definition: CommandLine.h:1707
void setNumAdditionalVals(unsigned n)
Definition: CommandLine.h:1726
const OptionValue< DataType > & getDefault() const
Definition: CommandLine.h:1397
void setValue(const T &V, bool initial=false)
Definition: CommandLine.h:1389
void setValue(const T &V, bool initial=false)
Definition: CommandLine.h:1364
const OptionValue< DataType > & getDefault() const
Definition: CommandLine.h:1373
const DataType & getValue() const
Definition: CommandLine.h:1345
bool setLocation(Option &O, DataType &L)
Definition: CommandLine.h:1326
void setValue(const T &V, bool initial=false)
Definition: CommandLine.h:1334
const OptionValue< DataType > & getDefault() const
Definition: CommandLine.h:1352
DataType & getValue()
Definition: CommandLine.h:1341
ParserClass & getParser()
Definition: CommandLine.h:1480
opt & operator=(const opt &)=delete
void setInitialValue(const DataType &V)
Definition: CommandLine.h:1478
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
Definition: CommandLine.h:1495
opt(const opt &)=delete
DataType & operator=(const T &Val)
Definition: CommandLine.h:1482
opt(const Mods &... Ms)
Definition: CommandLine.h:1489
std::function< void(const typename ParserClass::parser_data_type &)> Callback
Definition: CommandLine.h:1500
OptionInfo(StringRef name, DataType v, StringRef helpStr)
Definition: CommandLine.h:819
OptionValue< DataType > V
Definition: CommandLine.h:822
bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val)
void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
Definition: CommandLine.h:972
enum ValueExpected getValueExpectedFlagDefault() const
Definition: CommandLine.h:967
enum ValueExpected getValueExpectedFlagDefault() const
Definition: CommandLine.h:942
void printOptionDiff(const Option &O, bool V, OptVal Default, size_t GlobalWidth) const
bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val)
StringRef getValueName() const override
Definition: CommandLine.h:947
void anchor() override
bool parse(Option &, StringRef, StringRef Arg, char &Value)
Definition: CommandLine.h:1185
void printOptionDiff(const Option &O, char V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
Definition: CommandLine.h:1191
void anchor() override
void printOptionDiff(const Option &O, double V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
Definition: CommandLine.h:1122
bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val)
bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val)
void anchor() override
StringRef getValueName() const override
Definition: CommandLine.h:1143
void printOptionDiff(const Option &O, float V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
Definition: CommandLine.h:993
void printOptionDiff(const Option &O, int V, OptVal Default, size_t GlobalWidth) const
void anchor() override
bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val)
StringRef getValueName() const override
Definition: CommandLine.h:1014
bool parse(Option &O, StringRef ArgName, StringRef Arg, long &Val)
void printOptionDiff(const Option &O, long V, OptVal Default, size_t GlobalWidth) const
void anchor() override
bool parse(Option &O, StringRef ArgName, StringRef Arg, long long &Val)
StringRef getValueName() const override
Definition: CommandLine.h:1035
void printOptionDiff(const Option &O, long long V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
Definition: CommandLine.h:1167
void printOptionDiff(const Option &O, StringRef V, const OptVal &Default, size_t GlobalWidth) const
bool parse(Option &, StringRef, StringRef Arg, std::string &Value)
Definition: CommandLine.h:1161
bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val)
void printOptionDiff(const Option &O, unsigned V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
Definition: CommandLine.h:1056
StringRef getValueName() const override
Definition: CommandLine.h:1078
void printOptionDiff(const Option &O, unsigned long V, OptVal Default, size_t GlobalWidth) const
bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned long &Val)
StringRef getValueName() const override
Definition: CommandLine.h:1101
void printOptionDiff(const Option &O, unsigned long long V, OptVal Default, size_t GlobalWidth) const
bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned long long &Val)
DataType parser_data_type
Definition: CommandLine.h:829
SmallVector< OptionInfo, 8 > Values
Definition: CommandLine.h:824
parser(Option &O)
Definition: CommandLine.h:827
void removeLiteralOption(StringRef Name)
Remove the specified option.
Definition: CommandLine.h:872
StringRef getDescription(unsigned N) const override
Definition: CommandLine.h:834
void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr)
Add an entry to the mapping table.
Definition: CommandLine.h:863
const GenericOptionValue & getOptionValue(unsigned N) const override
Definition: CommandLine.h:839
StringRef getOption(unsigned N) const override
Definition: CommandLine.h:833
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V)
Definition: CommandLine.h:844
unsigned getNumOptions() const override
Definition: CommandLine.h:832
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
The virtual file system interface.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
StorageClass
Definition: XCOFF.h:169
std::function< void(raw_ostream &)> VersionPrinterTy
Definition: CommandLine.h:76
void(*)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs) TokenizerCallback
String tokenization function type.
Definition: CommandLine.h:2111
void PrintVersionMessage()
Utility function for printing version number.
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, SmallVectorImpl< const char * > &NewArgv)
A convenience helper which concatenates the options specified by the environment variable EnvVar and ...
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.
list_initializer< Ty > list_init(ArrayRef< Ty > Vals)
Definition: CommandLine.h:450
OptionCategory & getGeneralCategory()
NumOccurrencesFlag
Definition: CommandLine.h:113
@ ConsumeAfter
Definition: CommandLine.h:126
@ ValueOptional
Definition: CommandLine.h:131
@ ValueDisallowed
Definition: CommandLine.h:133
@ ValueRequired
Definition: CommandLine.h:132
void ResetAllOptionOccurrences()
Reset all command line options to a state that looks as if they have never appeared on the command li...
void SetVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// Override the default (LLV...
void tokenizeConfigFile(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes content of configuration file.
@ ReallyHidden
Definition: CommandLine.h:139
StringMap< Option * > & getRegisteredOptions(SubCommand &Sub=SubCommand::getTopLevel())
Use this to get a StringMap to all registered named options (e.g.
void ResetCommandLineParser()
Reset the command line parser back to its initial state.
bool ParseCommandLineOptions(int argc, const char *const *argv, StringRef Overview="", raw_ostream *Errs=nullptr, const char *EnvVar=nullptr, bool LongOptionsUseDoubleDash=false)
ManagedStatic< SubCommand > TopLevelSubCommand
void PrintOptionValues()
iterator_range< typename SmallPtrSet< SubCommand *, 4 >::iterator > getRegisteredSubcommands()
Use this to get all registered SubCommands from the provided parser.
void apply(Opt *O, const Mod &M, const Mods &... Ms)
Definition: CommandLine.h:1298
void AddLiteralOption(Option &O, StringRef Name)
Adds a new option for parsing and provides the option it refers to.
void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
Definition: CommandLine.h:1206
void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver, SmallVectorImpl< StringRef > &NewArgv)
Tokenizes a Windows command line while attempting to avoid copies.
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:703
bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i)
Parses Arg into the option handler Handler.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:445
@ CommaSeparated
Definition: CommandLine.h:164
@ DefaultOption
Definition: CommandLine.h:175
@ PositionalEatsArgs
Definition: CommandLine.h:165
ManagedStatic< SubCommand > AllSubCommands
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:465
cb< typename detail::callback_traits< F >::result_type, typename detail::callback_traits< F >::arg_type > callback(F CB)
Definition: CommandLine.h:517
void HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub=SubCommand::getTopLevel())
Mark all options not part of this category as cl::ReallyHidden.
void AddExtraVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// Add an extra printer to u...
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...
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.
@ NormalFormatting
Definition: CommandLine.h:157
@ AlwaysPrefix
Definition: CommandLine.h:160
void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes a command line that can contain escapes and quotes.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::optional< T > Optional
Definition: Optional.h:24
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ Mod
The access may modify the value stored in memory.
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1869
@ Default
The result values are uniform if and only if all operands are uniform.
Definition: BitVector.h:851
#define N
GenericOptionValue(const GenericOptionValue &)=default
GenericOptionValue & operator=(const GenericOptionValue &)=default
virtual bool compare(const GenericOptionValue &V) const =0
void apply(Opt &O) const
Definition: CommandLine.h:462
void print(const Option &O, const parser< DT > &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
Definition: CommandLine.h:1224
void print(const Option &O, const parser< ParserDT > &P, const ValDT &, const OptionValue< ValDT > &, size_t GlobalWidth)
Definition: CommandLine.h:1215
OptionValueBase & operator=(const OptionValueBase &)=default
OptionValueBase(const OptionValueBase &)=default
bool compare(const DataType &) const
Definition: CommandLine.h:555
const DataType & getValue() const
Definition: CommandLine.h:550
bool compare(const GenericOptionValue &) const override
Definition: CommandLine.h:557
OptionValue< DataType > WrapperType
Definition: CommandLine.h:546
void setValue(const DT &)
Definition: CommandLine.h:553
OptionValue< cl::boolOrDefault > & operator=(const cl::boolOrDefault &V)
Definition: CommandLine.h:639
OptionValue(const cl::boolOrDefault &V)
Definition: CommandLine.h:637
OptionValue< std::string > & operator=(const std::string &V)
Definition: CommandLine.h:656
OptionValue(const std::string &V)
Definition: CommandLine.h:654
OptionValue(const DataType &V)
Definition: CommandLine.h:619
OptionValue< DataType > & operator=(const DT &V)
Definition: CommandLine.h:622
void apply(alias &A) const
Definition: CommandLine.h:1968
aliasopt(Option &O)
Definition: CommandLine.h:1966
static void opt(FormattingFlags FF, Option &O)
Definition: CommandLine.h:1285
static void opt(MiscFlags MF, Option &O)
Definition: CommandLine.h:1289
static void opt(NumOccurrencesFlag N, Option &O)
Definition: CommandLine.h:1271
static void opt(OptionHidden OH, Option &O)
Definition: CommandLine.h:1281
static void opt(StringRef Str, Opt &O)
Definition: CommandLine.h:1265
static void opt(ValueExpected VE, Option &O)
Definition: CommandLine.h:1277
static void opt(StringRef Str, Opt &O)
Definition: CommandLine.h:1255
static void opt(StringRef Str, Opt &O)
Definition: CommandLine.h:1260
static void opt(const Mod &M, Opt &O)
Definition: CommandLine.h:1250
void apply(Opt &O) const
Definition: CommandLine.h:475
cat(OptionCategory &c)
Definition: CommandLine.h:473
OptionCategory & Category
Definition: CommandLine.h:471
void apply(Opt &O) const
Definition: CommandLine.h:494
cb(std::function< R(Ty)> CB)
Definition: CommandLine.h:492
std::function< R(Ty)> CB
Definition: CommandLine.h:490
desc(StringRef Str)
Definition: CommandLine.h:414
void apply(Option &O) const
Definition: CommandLine.h:416
StringRef Desc
Definition: CommandLine.h:412
std::tuple_element_t< 0, std::tuple< Args... > > arg_type
Definition: CommandLine.h:504
initializer(const Ty &Val)
Definition: CommandLine.h:433
void apply(Opt &O) const
Definition: CommandLine.h:435
list_initializer(ArrayRef< Ty > Vals)
Definition: CommandLine.h:440
void apply(Opt &O) const
Definition: CommandLine.h:442
multi_val(unsigned N)
Definition: CommandLine.h:1747
void apply(list< D, S, P > &L) const
Definition: CommandLine.h:1750
sub(SubCommand &S)
Definition: CommandLine.h:482
SubCommand & Sub
Definition: CommandLine.h:480
void apply(Opt &O) const
Definition: CommandLine.h:484
void apply(Option &O) const
Definition: CommandLine.h:425
value_desc(StringRef Str)
Definition: CommandLine.h:423