LLVM 22.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.
69LLVM_ABI bool 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 //
127};
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)
134};
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
140};
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?
161};
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
176};
177
178//===----------------------------------------------------------------------===//
179//
181private:
182 StringRef const Name;
183 StringRef const Description;
184
185 LLVM_ABI 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).
199LLVM_ABI OptionCategory &getGeneralCategory();
200
201//===----------------------------------------------------------------------===//
202//
204private:
205 StringRef Name;
206 StringRef Description;
207
208protected:
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.
221
222 // Get the special subcommand that can be used to put an option into all
223 // subcommands.
224 LLVM_ABI static SubCommand &getAll();
225
226 LLVM_ABI void reset();
227
228 LLVM_ABI 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
242
243public:
244 SubCommandGroup(std::initializer_list<SubCommand *> IL) : Subs(IL) {}
245
246 ArrayRef<SubCommand *> getSubCommands() const { return Subs; }
247};
248
249//===----------------------------------------------------------------------===//
250//
252 friend class alias;
253
254 // Overriden by subclasses to handle the value passed into an argument. Should
255 // return true if there was an error processing the argument and the program
256 // should exit.
257 //
258 virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
259 StringRef Arg) = 0;
260
261 virtual enum ValueExpected getValueExpectedFlagDefault() const {
262 return ValueOptional;
263 }
264
265 // Out of line virtual function to provide home for the class.
266 virtual void anchor();
267
268 uint16_t NumOccurrences; // The number of times specified
269 // Occurrences, HiddenFlag, and Formatting are all enum types but to avoid
270 // problems with signed enums in bitfields.
271 uint16_t Occurrences : 3; // enum NumOccurrencesFlag
272 // not using the enum type for 'Value' because zero is an implementation
273 // detail representing the non-value
274 uint16_t Value : 2;
275 uint16_t HiddenFlag : 2; // enum OptionHidden
276 uint16_t Formatting : 2; // enum FormattingFlags
277 uint16_t Misc : 5;
278 uint16_t FullyInitialized : 1; // Has addArgument been called?
279 uint16_t Position; // Position of last occurrence of the option
280 uint16_t AdditionalVals; // Greater than 0 for multi-valued option.
281
282public:
283 StringRef ArgStr; // The argument string itself (ex: "help", "o")
284 StringRef HelpStr; // The descriptive text message for -help
285 StringRef ValueStr; // String describing what the value of this option is
287 Categories; // The Categories this option belongs to
288 SmallPtrSet<SubCommand *, 1> Subs; // The subcommands this option belongs to.
289
291 return (enum NumOccurrencesFlag)Occurrences;
292 }
293
295 return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
296 }
297
298 inline enum OptionHidden getOptionHiddenFlag() const {
299 return (enum OptionHidden)HiddenFlag;
300 }
301
302 inline enum FormattingFlags getFormattingFlag() const {
303 return (enum FormattingFlags)Formatting;
304 }
305
306 inline unsigned getMiscFlags() const { return Misc; }
307 inline unsigned getPosition() const { return Position; }
308 inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
309
310 // Return true if the argstr != ""
311 bool hasArgStr() const { return !ArgStr.empty(); }
312 bool isPositional() const { return getFormattingFlag() == cl::Positional; }
313 bool isSink() const { return getMiscFlags() & cl::Sink; }
314 bool isDefaultOption() const { return getMiscFlags() & cl::DefaultOption; }
315
316 bool isConsumeAfter() const {
318 }
319
320 //-------------------------------------------------------------------------===
321 // Accessor functions set by OptionModifiers
322 //
323 void setArgStr(StringRef S);
326 void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
327 void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
328 void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
329 void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }
330 void setMiscFlag(enum MiscFlags M) { Misc |= M; }
331 void setPosition(unsigned pos) { Position = pos; }
332 void addCategory(OptionCategory &C);
333 void addSubCommand(SubCommand &S) { Subs.insert(&S); }
334
335protected:
336 explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
337 enum OptionHidden Hidden)
338 : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
339 HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0),
340 FullyInitialized(false), Position(0), AdditionalVals(0) {
341 Categories.push_back(&getGeneralCategory());
342 }
343
344 inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
345
346public:
347 virtual ~Option() = default;
348
349 // Register this argument with the commandline system.
350 //
351 void addArgument();
352
353 /// Unregisters this option from the CommandLine system.
354 ///
355 /// This option must have been the last option registered.
356 /// For testing purposes only.
357 void removeArgument();
358
359 // Return the width of the option tag for printing...
360 virtual size_t getOptionWidth() const = 0;
361
362 // Print out information about this option. The to-be-maintained width is
363 // specified.
364 //
365 virtual void printOptionInfo(size_t GlobalWidth) const = 0;
366
367 virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
368
369 virtual void setDefault() = 0;
370
371 // Prints the help string for an option.
372 //
373 // This maintains the Indent for multi-line descriptions.
374 // FirstLineIndentedBy is the count of chars of the first line
375 // i.e. the one containing the --<option name>.
376 static void printHelpStr(StringRef HelpStr, size_t Indent,
377 size_t FirstLineIndentedBy);
378
379 // Prints the help string for an enum value.
380 //
381 // This maintains the Indent for multi-line descriptions.
382 // FirstLineIndentedBy is the count of chars of the first line
383 // i.e. the one containing the =<value>.
384 static void printEnumValHelpStr(StringRef HelpStr, size_t Indent,
385 size_t FirstLineIndentedBy);
386
388
389 // Wrapper around handleOccurrence that enforces Flags.
390 //
391 virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
392 bool MultiArg = false);
393
394 // Prints option name followed by message. Always returns true.
395 bool error(const Twine &Message, StringRef ArgName = StringRef(), raw_ostream &Errs = llvm::errs());
396 bool error(const Twine &Message, raw_ostream &Errs) {
397 return error(Message, StringRef(), Errs);
398 }
399
400 inline int getNumOccurrences() const { return NumOccurrences; }
401 void reset();
402};
403
404//===----------------------------------------------------------------------===//
405// Command line option modifiers that can be used to modify the behavior of
406// command line option parsers...
407//
408
409// Modifier to set the description shown in the -help output...
410struct desc {
412
413 desc(StringRef Str) : Desc(Str) {}
414
415 void apply(Option &O) const { O.setDescription(Desc); }
416};
417
418// Modifier to set the value description shown in the -help output...
421
422 value_desc(StringRef Str) : Desc(Str) {}
423
424 void apply(Option &O) const { O.setValueStr(Desc); }
425};
426
427// Specify a default (initial) value for the command line argument, if the
428// default constructor for the argument type does not give you what you want.
429// This is only valid on "opt" arguments, not on "list" arguments.
430template <class Ty> struct initializer {
431 const Ty &Init;
432 initializer(const Ty &Val) : Init(Val) {}
433
434 template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
435};
436
437template <class Ty> struct list_initializer {
440
441 template <class Opt> void apply(Opt &O) const { O.setInitialValues(Inits); }
442};
443
444template <class Ty> initializer<Ty> init(const Ty &Val) {
445 return initializer<Ty>(Val);
446}
447
448template <class Ty>
452
453// Allow the user to specify which external variable they want to store the
454// results of the command line argument processing into, if they don't want to
455// store it in the option itself.
456template <class Ty> struct LocationClass {
457 Ty &Loc;
458
459 LocationClass(Ty &L) : Loc(L) {}
460
461 template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
462};
463
464template <class Ty> LocationClass<Ty> location(Ty &L) {
465 return LocationClass<Ty>(L);
466}
467
468// Specify the Option category for the command line argument to belong to.
469struct cat {
471
473
474 template <class Opt> void apply(Opt &O) const { O.addCategory(Category); }
475};
476
477// Specify the subcommand that this option belongs to.
478struct sub {
479 SubCommand *Sub = nullptr;
481
482 sub(SubCommand &S) : Sub(&S) {}
484
485 template <class Opt> void apply(Opt &O) const {
486 if (Sub)
487 O.addSubCommand(*Sub);
488 else if (Group)
489 for (SubCommand *SC : Group->getSubCommands())
490 O.addSubCommand(*SC);
491 }
492};
493
494// Specify a callback function to be called when an option is seen.
495// Can be used to set other options automatically.
496template <typename R, typename Ty> struct cb {
497 std::function<R(Ty)> CB;
498
499 cb(std::function<R(Ty)> CB) : CB(CB) {}
500
501 template <typename Opt> void apply(Opt &O) const { O.setCallback(CB); }
502};
503
504namespace detail {
505template <typename F>
506struct callback_traits : public callback_traits<decltype(&F::operator())> {};
507
508template <typename R, typename C, typename... Args>
509struct callback_traits<R (C::*)(Args...) const> {
510 using result_type = R;
511 using arg_type = std::tuple_element_t<0, std::tuple<Args...>>;
512 static_assert(sizeof...(Args) == 1, "callback function must have one and only one parameter");
513 static_assert(std::is_same_v<result_type, void>,
514 "callback return type must be void");
515 static_assert(std::is_lvalue_reference_v<arg_type> &&
516 std::is_const_v<std::remove_reference_t<arg_type>>,
517 "callback arg_type must be a const lvalue reference");
518};
519} // namespace detail
520
521template <typename F>
525 using result_type = typename detail::callback_traits<F>::result_type;
526 using arg_type = typename detail::callback_traits<F>::arg_type;
527 return cb<result_type, arg_type>(CB);
528}
529
530//===----------------------------------------------------------------------===//
531
532// Support value comparison outside the template.
534 virtual bool compare(const GenericOptionValue &V) const = 0;
535
536protected:
541
542private:
543 virtual void anchor();
544};
545
546template <class DataType> struct OptionValue;
547
548// The default value safely does nothing. Option value printing is only
549// best-effort.
550template <class DataType, bool isClass>
552 // Temporary storage for argument passing.
554
555 bool hasValue() const { return false; }
556
557 const DataType &getValue() const { llvm_unreachable("no default value"); }
558
559 // Some options may take their value from a different data type.
560 template <class DT> void setValue(const DT & /*V*/) {}
561
562 // Returns whether this instance matches the argument.
563 bool compare(const DataType & /*V*/) const { return false; }
564
565 bool compare(const GenericOptionValue & /*V*/) const override {
566 return false;
567 }
568
569protected:
570 ~OptionValueBase() = default;
571};
572
573// Simple copy of the option value.
574template <class DataType> class OptionValueCopy : public GenericOptionValue {
575 DataType Value;
576 bool Valid = false;
577
578protected:
581 ~OptionValueCopy() = default;
582
583public:
584 OptionValueCopy() = default;
585
586 bool hasValue() const { return Valid; }
587
588 const DataType &getValue() const {
589 assert(Valid && "invalid option value");
590 return Value;
591 }
592
593 void setValue(const DataType &V) {
594 Valid = true;
595 Value = V;
596 }
597
598 // Returns whether this instance matches V.
599 bool compare(const DataType &V) const { return Valid && (Value == V); }
600
601 bool compare(const GenericOptionValue &V) const override {
602 const OptionValueCopy<DataType> &VC =
603 static_cast<const OptionValueCopy<DataType> &>(V);
604 if (!VC.hasValue())
605 return false;
606 return compare(VC.getValue());
607 }
608};
609
610// Non-class option values.
611template <class DataType>
612struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
613 using WrapperType = DataType;
614
615protected:
616 OptionValueBase() = default;
619 ~OptionValueBase() = default;
620};
621
622// Top-level option class.
623template <class DataType>
624struct OptionValue final
625 : OptionValueBase<DataType, std::is_class_v<DataType>> {
626 OptionValue() = default;
627
628 OptionValue(const DataType &V) { this->setValue(V); }
629
630 // Some options may take their value from a different data type.
631 template <class DT> OptionValue<DataType> &operator=(const DT &V) {
632 this->setValue(V);
633 return *this;
634 }
635};
636
637// Other safe-to-copy-by-value common option types.
639template <>
641 : OptionValueCopy<cl::boolOrDefault> {
643
644 OptionValue() = default;
645
646 OptionValue(const cl::boolOrDefault &V) { this->setValue(V); }
647
649 setValue(V);
650 return *this;
651 }
652
653private:
654 void anchor() override;
655};
656
657template <>
658struct LLVM_ABI OptionValue<std::string> final : OptionValueCopy<std::string> {
660
661 OptionValue() = default;
662
663 OptionValue(const std::string &V) { this->setValue(V); }
664
665 OptionValue<std::string> &operator=(const std::string &V) {
666 setValue(V);
667 return *this;
668 }
669
670private:
671 void anchor() override;
672};
673
674//===----------------------------------------------------------------------===//
675// Enum valued command line option
676//
677
678// This represents a single enum value, using "int" as the underlying type.
684
685#define clEnumVal(ENUMVAL, DESC) \
686 llvm::cl::OptionEnumValue { #ENUMVAL, int(ENUMVAL), DESC }
687#define clEnumValN(ENUMVAL, FLAGNAME, DESC) \
688 llvm::cl::OptionEnumValue { FLAGNAME, int(ENUMVAL), DESC }
689
690// For custom data types, allow specifying a group of values together as the
691// values that go into the mapping that the option handler uses.
692//
694 // Use a vector instead of a map, because the lists should be short,
695 // the overhead is less, and most importantly, it keeps them in the order
696 // inserted so we can print our option out nicely.
698
699public:
700 ValuesClass(std::initializer_list<OptionEnumValue> Options)
701 : Values(Options) {}
702
703 template <class Opt> void apply(Opt &O) const {
704 for (const auto &Value : Values)
705 O.getParser().addLiteralOption(Value.Name, Value.Value,
706 Value.Description);
707 }
708};
709
710/// Helper to build a ValuesClass by forwarding a variable number of arguments
711/// as an initializer list to the ValuesClass constructor.
712template <typename... OptsTy> ValuesClass values(OptsTy... Options) {
713 return ValuesClass({Options...});
714}
715
716//===----------------------------------------------------------------------===//
717// Parameterizable parser for different data types. By default, known data types
718// (string, int, bool) have specialized parsers, that do what you would expect.
719// The default parser, used for data types that are not built-in, uses a mapping
720// table to map specific options to values, which is used, among other things,
721// to handle enum types.
722
723//--------------------------------------------------
724// This class holds all the non-generic code that we do not need replicated for
725// every instance of the generic parser. This also allows us to put stuff into
726// CommandLine.cpp
727//
729protected:
737
738public:
740
741 virtual ~generic_parser_base() = default;
742 // Base class should have virtual-destructor
743
744 // Virtual function implemented by generic subclass to indicate how many
745 // entries are in Values.
746 //
747 virtual unsigned getNumOptions() const = 0;
748
749 // Return option name N.
750 virtual StringRef getOption(unsigned N) const = 0;
751
752 // Return description N
753 virtual StringRef getDescription(unsigned N) const = 0;
754
755 // Return the width of the option tag for printing...
756 virtual size_t getOptionWidth(const Option &O) const;
757
758 virtual const GenericOptionValue &getOptionValue(unsigned N) const = 0;
759
760 // Print out information about this option. The to-be-maintained width is
761 // specified.
762 //
763 virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const;
764
765 void printGenericOptionDiff(const Option &O, const GenericOptionValue &V,
767 size_t GlobalWidth) const;
768
769 // Print the value of an option and it's default.
770 //
771 // Template definition ensures that the option and default have the same
772 // DataType (via the same AnyOptionValue).
773 template <class AnyOptionValue>
774 void printOptionDiff(const Option &O, const AnyOptionValue &V,
775 const AnyOptionValue &Default,
776 size_t GlobalWidth) const {
777 printGenericOptionDiff(O, V, Default, GlobalWidth);
778 }
779
780 void initialize() {}
781
783 // If there has been no argstr specified, that means that we need to add an
784 // argument for every possible option. This ensures that our options are
785 // vectored to us.
786 if (!Owner.hasArgStr())
787 for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
788 OptionNames.push_back(getOption(i));
789 }
790
792 // If there is an ArgStr specified, then we are of the form:
793 //
794 // -opt=O2 or -opt O2 or -optO2
795 //
796 // In which case, the value is required. Otherwise if an arg str has not
797 // been specified, we are of the form:
798 //
799 // -O2 or O2 or -la (where -l and -a are separate options)
800 //
801 // If this is the case, we cannot allow a value.
802 //
803 if (Owner.hasArgStr())
804 return ValueRequired;
805 else
806 return ValueDisallowed;
807 }
808
809 // Return the option number corresponding to the specified
810 // argument string. If the option is not found, getNumOptions() is returned.
811 //
812 unsigned findOption(StringRef Name);
813
814protected:
816};
817
818// Default parser implementation - This implementation depends on having a
819// mapping of recognized options to values of some sort. In addition to this,
820// each entry in the mapping also tracks a help message that is printed with the
821// command line option for -help. Because this is a simple mapping parser, the
822// data type can be any unsupported type.
823//
824template <class DataType> class parser : public generic_parser_base {
825protected:
827 public:
828 OptionInfo(StringRef name, DataType v, StringRef helpStr)
829 : GenericOptionInfo(name, helpStr), V(v) {}
830
832 };
834
835public:
837
838 using parser_data_type = DataType;
839
840 // Implement virtual functions needed by generic_parser_base
841 unsigned getNumOptions() const override { return unsigned(Values.size()); }
842 StringRef getOption(unsigned N) const override { return Values[N].Name; }
843 StringRef getDescription(unsigned N) const override {
844 return Values[N].HelpStr;
845 }
846
847 // Return the value of option name N.
848 const GenericOptionValue &getOptionValue(unsigned N) const override {
849 return Values[N].V;
850 }
851
852 // Return true on error.
853 bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
854 StringRef ArgVal;
855 if (Owner.hasArgStr())
856 ArgVal = Arg;
857 else
858 ArgVal = ArgName;
859
860 for (size_t i = 0, e = Values.size(); i != e; ++i)
861 if (Values[i].Name == ArgVal) {
862 V = Values[i].V.getValue();
863 return false;
864 }
865
866 return O.error("Cannot find option named '" + ArgVal + "'!");
867 }
868
869 /// Add an entry to the mapping table.
870 ///
871 template <class DT>
872 void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr) {
873#ifndef NDEBUG
874 if (findOption(Name) != Values.size())
875 report_fatal_error("Option '" + Name + "' already exists!");
876#endif
877 OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
878 Values.push_back(X);
879 AddLiteralOption(Owner, Name);
880 }
881
882 /// Remove the specified option.
883 ///
885 unsigned N = findOption(Name);
886 assert(N != Values.size() && "Option not found!");
887 Values.erase(Values.begin() + N);
888 }
889};
890
891//--------------------------------------------------
892// Super class of parsers to provide boilerplate code
893//
895 basic_parser_impl { // non-template implementation of basic_parser<t>
896public:
898
899 virtual ~basic_parser_impl() = default;
900
904
906
907 void initialize() {}
908
909 // Return the width of the option tag for printing...
910 size_t getOptionWidth(const Option &O) const;
911
912 // Print out information about this option. The to-be-maintained width is
913 // specified.
914 //
915 void printOptionInfo(const Option &O, size_t GlobalWidth) const;
916
917 // Print a placeholder for options that don't yet support printOptionDiff().
918 void printOptionNoValue(const Option &O, size_t GlobalWidth) const;
919
920 // Overload in subclass to provide a better default value.
921 virtual StringRef getValueName() const { return "value"; }
922
923 // An out-of-line virtual method to provide a 'home' for this class.
924 virtual void anchor();
925
926protected:
927 // A helper for basic_parser::printOptionDiff.
928 void printOptionName(const Option &O, size_t GlobalWidth) const;
929};
930
931// The real basic parser is just a template wrapper that provides a typedef for
932// the provided data type.
933//
934template <class DataType> class basic_parser : public basic_parser_impl {
935public:
936 using parser_data_type = DataType;
938
940};
941
942//--------------------------------------------------
943
944extern template class LLVM_TEMPLATE_ABI basic_parser<bool>;
945
946template <> class LLVM_ABI parser<bool> : public basic_parser<bool> {
947public:
949
950 // Return true on error.
951 bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
952
953 void initialize() {}
954
958
959 // Do not print =<value> at all.
960 StringRef getValueName() const override { return StringRef(); }
961
962 void printOptionDiff(const Option &O, bool V, OptVal Default,
963 size_t GlobalWidth) const;
964
965 // An out-of-line virtual method to provide a 'home' for this class.
966 void anchor() override;
967};
968
969//--------------------------------------------------
970
972
973template <>
975public:
977
978 // Return true on error.
979 bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
980
984
985 // Do not print =<value> at all.
986 StringRef getValueName() const override { return StringRef(); }
987
989 size_t GlobalWidth) const;
990
991 // An out-of-line virtual method to provide a 'home' for this class.
992 void anchor() override;
993};
994
995//--------------------------------------------------
996
997extern template class LLVM_TEMPLATE_ABI basic_parser<int>;
998
999template <> class LLVM_ABI parser<int> : public basic_parser<int> {
1000public:
1002
1003 // Return true on error.
1004 bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
1005
1006 // Overload in subclass to provide a better default value.
1007 StringRef getValueName() const override { return "int"; }
1008
1009 void printOptionDiff(const Option &O, int V, OptVal Default,
1010 size_t GlobalWidth) const;
1011
1012 // An out-of-line virtual method to provide a 'home' for this class.
1013 void anchor() override;
1014};
1015
1016//--------------------------------------------------
1017
1018extern template class LLVM_TEMPLATE_ABI basic_parser<long>;
1019
1020template <> class LLVM_ABI parser<long> final : public basic_parser<long> {
1021public:
1023
1024 // Return true on error.
1025 bool parse(Option &O, StringRef ArgName, StringRef Arg, long &Val);
1026
1027 // Overload in subclass to provide a better default value.
1028 StringRef getValueName() const override { return "long"; }
1029
1030 void printOptionDiff(const Option &O, long V, OptVal Default,
1031 size_t GlobalWidth) const;
1032
1033 // An out-of-line virtual method to provide a 'home' for this class.
1034 void anchor() override;
1035};
1036
1037//--------------------------------------------------
1038
1039extern template class LLVM_TEMPLATE_ABI basic_parser<long long>;
1040
1042public:
1044
1045 // Return true on error.
1046 bool parse(Option &O, StringRef ArgName, StringRef Arg, long long &Val);
1047
1048 // Overload in subclass to provide a better default value.
1049 StringRef getValueName() const override { return "long"; }
1050
1051 void printOptionDiff(const Option &O, long long V, OptVal Default,
1052 size_t GlobalWidth) const;
1053
1054 // An out-of-line virtual method to provide a 'home' for this class.
1055 void anchor() override;
1056};
1057
1058//--------------------------------------------------
1059
1060extern template class LLVM_TEMPLATE_ABI basic_parser<unsigned>;
1061
1063public:
1065
1066 // Return true on error.
1067 bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
1068
1069 // Overload in subclass to provide a better default value.
1070 StringRef getValueName() const override { return "uint"; }
1071
1072 void printOptionDiff(const Option &O, unsigned V, OptVal Default,
1073 size_t GlobalWidth) const;
1074
1075 // An out-of-line virtual method to provide a 'home' for this class.
1076 void anchor() override;
1077};
1078
1079//--------------------------------------------------
1080
1082
1083template <>
1086public:
1088
1089 // Return true on error.
1090 bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned long &Val);
1091
1092 // Overload in subclass to provide a better default value.
1093 StringRef getValueName() const override { return "ulong"; }
1094
1095 void printOptionDiff(const Option &O, unsigned long V, OptVal Default,
1096 size_t GlobalWidth) const;
1097
1098 // An out-of-line virtual method to provide a 'home' for this class.
1099 void anchor() override;
1100};
1101
1102//--------------------------------------------------
1103
1105
1106template <>
1109public:
1111
1112 // Return true on error.
1113 bool parse(Option &O, StringRef ArgName, StringRef Arg,
1114 unsigned long long &Val);
1115
1116 // Overload in subclass to provide a better default value.
1117 StringRef getValueName() const override { return "ulong"; }
1118
1119 void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
1120 size_t GlobalWidth) const;
1121
1122 // An out-of-line virtual method to provide a 'home' for this class.
1123 void anchor() override;
1124};
1125
1126//--------------------------------------------------
1127
1128extern template class LLVM_TEMPLATE_ABI basic_parser<double>;
1129
1131public:
1133
1134 // Return true on error.
1135 bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
1136
1137 // Overload in subclass to provide a better default value.
1138 StringRef getValueName() const override { return "number"; }
1139
1140 void printOptionDiff(const Option &O, double V, OptVal Default,
1141 size_t GlobalWidth) const;
1142
1143 // An out-of-line virtual method to provide a 'home' for this class.
1144 void anchor() override;
1145};
1146
1147//--------------------------------------------------
1148
1149extern template class LLVM_TEMPLATE_ABI basic_parser<float>;
1150
1151template <> class LLVM_ABI parser<float> : public basic_parser<float> {
1152public:
1154
1155 // Return true on error.
1156 bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
1157
1158 // Overload in subclass to provide a better default value.
1159 StringRef getValueName() const override { return "number"; }
1160
1161 void printOptionDiff(const Option &O, float V, OptVal Default,
1162 size_t GlobalWidth) const;
1163
1164 // An out-of-line virtual method to provide a 'home' for this class.
1165 void anchor() override;
1166};
1167
1168//--------------------------------------------------
1169
1170extern template class LLVM_TEMPLATE_ABI basic_parser<std::string>;
1171
1172template <>
1174public:
1176
1177 // Return true on error.
1178 bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
1179 Value = Arg.str();
1180 return false;
1181 }
1182
1183 // Overload in subclass to provide a better default value.
1184 StringRef getValueName() const override { return "string"; }
1185
1187 size_t GlobalWidth) const;
1188
1189 // An out-of-line virtual method to provide a 'home' for this class.
1190 void anchor() override;
1191};
1192
1193//--------------------------------------------------
1194
1195extern template class LLVM_TEMPLATE_ABI basic_parser<char>;
1196
1197template <> class LLVM_ABI parser<char> : public basic_parser<char> {
1198public:
1200
1201 // Return true on error.
1202 bool parse(Option &, StringRef, StringRef Arg, char &Value) {
1203 Value = Arg[0];
1204 return false;
1205 }
1206
1207 // Overload in subclass to provide a better default value.
1208 StringRef getValueName() const override { return "char"; }
1209
1210 void printOptionDiff(const Option &O, char V, OptVal Default,
1211 size_t GlobalWidth) const;
1212
1213 // An out-of-line virtual method to provide a 'home' for this class.
1214 void anchor() override;
1215};
1216
1217//--------------------------------------------------
1218// This collection of wrappers is the intermediary between class opt and class
1219// parser to handle all the template nastiness.
1220
1221// This overloaded function is selected by the generic parser.
1222template <class ParserClass, class DT>
1223void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,
1224 const OptionValue<DT> &Default, size_t GlobalWidth) {
1225 OptionValue<DT> OV = V;
1226 P.printOptionDiff(O, OV, Default, GlobalWidth);
1227}
1228
1229// This is instantiated for basic parsers when the parsed value has a different
1230// type than the option value. e.g. HelpPrinter.
1231template <class ParserDT, class ValDT> struct OptionDiffPrinter {
1232 void print(const Option &O, const parser<ParserDT> &P, const ValDT & /*V*/,
1233 const OptionValue<ValDT> & /*Default*/, size_t GlobalWidth) {
1234 P.printOptionNoValue(O, GlobalWidth);
1235 }
1236};
1237
1238// This is instantiated for basic parsers when the parsed value has the same
1239// type as the option value.
1240template <class DT> struct OptionDiffPrinter<DT, DT> {
1241 void print(const Option &O, const parser<DT> &P, const DT &V,
1242 const OptionValue<DT> &Default, size_t GlobalWidth) {
1243 P.printOptionDiff(O, V, Default, GlobalWidth);
1244 }
1245};
1246
1247// This overloaded function is selected by the basic parser, which may parse a
1248// different type than the option type.
1249template <class ParserClass, class ValDT>
1251 const Option &O,
1253 const ValDT &V, const OptionValue<ValDT> &Default, size_t GlobalWidth) {
1254
1256 printer.print(O, static_cast<const ParserClass &>(P), V, Default,
1257 GlobalWidth);
1258}
1259
1260//===----------------------------------------------------------------------===//
1261// This class is used because we must use partial specialization to handle
1262// literal string arguments specially (const char* does not correctly respond to
1263// the apply method). Because the syntax to use this is a pain, we have the
1264// 'apply' method below to handle the nastiness...
1265//
1266template <class Mod> struct applicator {
1267 template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
1268};
1269
1270// Handle const char* as a special case...
1271template <unsigned n> struct applicator<char[n]> {
1272 template <class Opt> static void opt(StringRef Str, Opt &O) {
1273 O.setArgStr(Str);
1274 }
1275};
1276template <unsigned n> struct applicator<const char[n]> {
1277 template <class Opt> static void opt(StringRef Str, Opt &O) {
1278 O.setArgStr(Str);
1279 }
1280};
1281template <> struct applicator<StringRef > {
1282 template <class Opt> static void opt(StringRef Str, Opt &O) {
1283 O.setArgStr(Str);
1284 }
1285};
1286
1288 static void opt(NumOccurrencesFlag N, Option &O) {
1289 O.setNumOccurrencesFlag(N);
1290 }
1291};
1292
1293template <> struct applicator<ValueExpected> {
1294 static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
1295};
1296
1297template <> struct applicator<OptionHidden> {
1298 static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
1299};
1300
1302 static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
1303};
1304
1305template <> struct applicator<MiscFlags> {
1306 static void opt(MiscFlags MF, Option &O) {
1307 assert((MF != Grouping || O.ArgStr.size() == 1) &&
1308 "cl::Grouping can only apply to single character Options.");
1309 O.setMiscFlag(MF);
1310 }
1311};
1312
1313// Apply modifiers to an option in a type safe way.
1314template <class Opt, class Mod, class... Mods>
1315void apply(Opt *O, const Mod &M, const Mods &... Ms) {
1316 applicator<Mod>::opt(M, *O);
1317 apply(O, Ms...);
1318}
1319
1320template <class Opt, class Mod> void apply(Opt *O, const Mod &M) {
1321 applicator<Mod>::opt(M, *O);
1322}
1323
1324//===----------------------------------------------------------------------===//
1325// Default storage class definition: external storage. This implementation
1326// assumes the user will specify a variable to store the data into with the
1327// cl::location(x) modifier.
1328//
1329template <class DataType, bool ExternalStorage, bool isClass>
1331 DataType *Location = nullptr; // Where to store the object...
1332 OptionValue<DataType> Default;
1333
1334 void check_location() const {
1335 assert(Location && "cl::location(...) not specified for a command "
1336 "line option with external storage, "
1337 "or cl::init specified before cl::location()!!");
1338 }
1339
1340public:
1341 opt_storage() = default;
1342
1343 bool setLocation(Option &O, DataType &L) {
1344 if (Location)
1345 return O.error("cl::location(x) specified more than once!");
1346 Location = &L;
1347 Default = L;
1348 return false;
1349 }
1350
1351 template <class T> void setValue(const T &V, bool initial = false) {
1352 check_location();
1353 *Location = V;
1354 if (initial)
1355 Default = V;
1356 }
1357
1358 DataType &getValue() {
1359 check_location();
1360 return *Location;
1361 }
1362 const DataType &getValue() const {
1363 check_location();
1364 return *Location;
1365 }
1366
1367 operator DataType() const { return this->getValue(); }
1368
1369 const OptionValue<DataType> &getDefault() const { return Default; }
1370};
1371
1372// Define how to hold a class type object, such as a string. Since we can
1373// inherit from a class, we do so. This makes us exactly compatible with the
1374// object in all cases that it is used.
1375//
1376template <class DataType>
1377class opt_storage<DataType, false, true> : public DataType {
1378public:
1380
1381 template <class T> void setValue(const T &V, bool initial = false) {
1382 DataType::operator=(V);
1383 if (initial)
1384 Default = V;
1385 }
1386
1387 DataType &getValue() { return *this; }
1388 const DataType &getValue() const { return *this; }
1389
1390 const OptionValue<DataType> &getDefault() const { return Default; }
1391};
1392
1393// Define a partial specialization to handle things we cannot inherit from. In
1394// this case, we store an instance through containment, and overload operators
1395// to get at the value.
1396//
1397template <class DataType> class opt_storage<DataType, false, false> {
1398public:
1399 DataType Value;
1401
1402 // Make sure we initialize the value with the default constructor for the
1403 // type.
1404 opt_storage() : Value(DataType()), Default() {}
1405
1406 template <class T> void setValue(const T &V, bool initial = false) {
1407 Value = V;
1408 if (initial)
1409 Default = V;
1410 }
1411 DataType &getValue() { return Value; }
1412 DataType getValue() const { return Value; }
1413
1414 const OptionValue<DataType> &getDefault() const { return Default; }
1415
1416 operator DataType() const { return getValue(); }
1417
1418 // If the datatype is a pointer, support -> on it.
1419 DataType operator->() const { return Value; }
1420};
1421
1422//===----------------------------------------------------------------------===//
1423// A scalar command line option.
1424//
1425template <class DataType, bool ExternalStorage = false,
1426 class ParserClass = parser<DataType>>
1427class opt
1428 : public Option,
1429 public opt_storage<DataType, ExternalStorage, std::is_class_v<DataType>> {
1430 ParserClass Parser;
1431
1432 bool handleOccurrence(unsigned pos, StringRef ArgName,
1433 StringRef Arg) override {
1434 typename ParserClass::parser_data_type Val =
1435 typename ParserClass::parser_data_type();
1436 if (Parser.parse(*this, ArgName, Arg, Val))
1437 return true; // Parse error!
1438 this->setValue(Val);
1439 this->setPosition(pos);
1440 Callback(Val);
1441 return false;
1442 }
1443
1444 enum ValueExpected getValueExpectedFlagDefault() const override {
1445 return Parser.getValueExpectedFlagDefault();
1446 }
1447
1448 void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1449 return Parser.getExtraOptionNames(OptionNames);
1450 }
1451
1452 // Forward printing stuff to the parser...
1453 size_t getOptionWidth() const override {
1454 return Parser.getOptionWidth(*this);
1455 }
1456
1457 void printOptionInfo(size_t GlobalWidth) const override {
1458 Parser.printOptionInfo(*this, GlobalWidth);
1459 }
1460
1461 void printOptionValue(size_t GlobalWidth, bool Force) const override {
1462 if (Force || !this->getDefault().compare(this->getValue())) {
1463 cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
1464 this->getDefault(), GlobalWidth);
1465 }
1466 }
1467
1468 void setDefault() override {
1469 if constexpr (std::is_assignable_v<DataType &, DataType>) {
1470 const OptionValue<DataType> &V = this->getDefault();
1471 if (V.hasValue())
1472 this->setValue(V.getValue());
1473 else
1474 this->setValue(DataType());
1475 }
1476 }
1477
1478 void done() {
1479 addArgument();
1480 Parser.initialize();
1481 }
1482
1483public:
1484 // Command line options should not be copyable
1485 opt(const opt &) = delete;
1486 opt &operator=(const opt &) = delete;
1487
1488 // setInitialValue - Used by the cl::init modifier...
1489 void setInitialValue(const DataType &V) { this->setValue(V, true); }
1490
1491 ParserClass &getParser() { return Parser; }
1492
1493 template <class T> DataType &operator=(const T &Val) {
1494 this->setValue(Val);
1495 Callback(Val);
1496 return this->getValue();
1497 }
1498
1499 template <class T> DataType &operator=(T &&Val) {
1500 this->getValue() = std::forward<T>(Val);
1501 Callback(this->getValue());
1502 return this->getValue();
1503 }
1504
1505 template <class... Mods>
1506 explicit opt(const Mods &... Ms)
1507 : Option(llvm::cl::Optional, NotHidden), Parser(*this) {
1508 apply(this, Ms...);
1509 done();
1510 }
1511
1513 std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1514 Callback = CB;
1515 }
1516
1517 std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1518 [](const typename ParserClass::parser_data_type &) {};
1519};
1520
1521#if !(defined(LLVM_ENABLE_LLVM_EXPORT_ANNOTATIONS) && defined(_MSC_VER))
1522// Only instantiate opt<std::string> when not building a Windows DLL. When
1523// exporting opt<std::string>, MSVC implicitly exports symbols for
1524// std::basic_string through transitive inheritance via std::string. These
1525// symbols may appear in clients, leading to duplicate symbol conflicts.
1526extern template class LLVM_TEMPLATE_ABI opt<std::string>;
1527#endif
1528
1529extern template class LLVM_TEMPLATE_ABI opt<unsigned>;
1530extern template class LLVM_TEMPLATE_ABI opt<int>;
1531extern template class LLVM_TEMPLATE_ABI opt<char>;
1532extern template class LLVM_TEMPLATE_ABI opt<bool>;
1533
1534//===----------------------------------------------------------------------===//
1535// Default storage class definition: external storage. This implementation
1536// assumes the user will specify a variable to store the data into with the
1537// cl::location(x) modifier.
1538//
1539template <class DataType, class StorageClass> class list_storage {
1540 StorageClass *Location = nullptr; // Where to store the object...
1541 std::vector<OptionValue<DataType>> Default =
1542 std::vector<OptionValue<DataType>>();
1543 bool DefaultAssigned = false;
1544
1545public:
1546 list_storage() = default;
1547
1548 void clear() {}
1549
1551 if (Location)
1552 return O.error("cl::location(x) specified more than once!");
1553 Location = &L;
1554 return false;
1555 }
1556
1557 template <class T> void addValue(const T &V, bool initial = false) {
1558 assert(Location != nullptr &&
1559 "cl::location(...) not specified for a command "
1560 "line option with external storage!");
1561 Location->push_back(V);
1562 if (initial)
1563 Default.push_back(V);
1564 }
1565
1566 const std::vector<OptionValue<DataType>> &getDefault() const {
1567 return Default;
1568 }
1569
1570 void assignDefault() { DefaultAssigned = true; }
1571 void overwriteDefault() { DefaultAssigned = false; }
1572 bool isDefaultAssigned() { return DefaultAssigned; }
1573};
1574
1575// Define how to hold a class type object, such as a string.
1576// Originally this code inherited from std::vector. In transitioning to a new
1577// API for command line options we should change this. The new implementation
1578// of this list_storage specialization implements the minimum subset of the
1579// std::vector API required for all the current clients.
1580//
1581// FIXME: Reduce this API to a more narrow subset of std::vector
1582//
1583template <class DataType> class list_storage<DataType, bool> {
1584 std::vector<DataType> Storage;
1585 std::vector<OptionValue<DataType>> Default;
1586 bool DefaultAssigned = false;
1587
1588public:
1589 using iterator = typename std::vector<DataType>::iterator;
1590
1591 iterator begin() { return Storage.begin(); }
1592 iterator end() { return Storage.end(); }
1593
1594 using const_iterator = typename std::vector<DataType>::const_iterator;
1595
1596 const_iterator begin() const { return Storage.begin(); }
1597 const_iterator end() const { return Storage.end(); }
1598
1599 using size_type = typename std::vector<DataType>::size_type;
1600
1601 size_type size() const { return Storage.size(); }
1602
1603 bool empty() const { return Storage.empty(); }
1604
1605 void push_back(const DataType &value) { Storage.push_back(value); }
1606 void push_back(DataType &&value) { Storage.push_back(value); }
1607
1608 using reference = typename std::vector<DataType>::reference;
1609 using const_reference = typename std::vector<DataType>::const_reference;
1610
1611 reference operator[](size_type pos) { return Storage[pos]; }
1612 const_reference operator[](size_type pos) const { return Storage[pos]; }
1613
1614 void clear() {
1615 Storage.clear();
1616 }
1617
1618 iterator erase(const_iterator pos) { return Storage.erase(pos); }
1620 return Storage.erase(first, last);
1621 }
1622
1623 iterator erase(iterator pos) { return Storage.erase(pos); }
1625 return Storage.erase(first, last);
1626 }
1627
1628 iterator insert(const_iterator pos, const DataType &value) {
1629 return Storage.insert(pos, value);
1630 }
1631 iterator insert(const_iterator pos, DataType &&value) {
1632 return Storage.insert(pos, value);
1633 }
1634
1635 iterator insert(iterator pos, const DataType &value) {
1636 return Storage.insert(pos, value);
1637 }
1638 iterator insert(iterator pos, DataType &&value) {
1639 return Storage.insert(pos, value);
1640 }
1641
1642 reference front() { return Storage.front(); }
1643 const_reference front() const { return Storage.front(); }
1644
1645 operator std::vector<DataType> &() { return Storage; }
1646 operator ArrayRef<DataType>() const { return Storage; }
1647 std::vector<DataType> *operator&() { return &Storage; }
1648 const std::vector<DataType> *operator&() const { return &Storage; }
1649
1650 template <class T> void addValue(const T &V, bool initial = false) {
1651 Storage.push_back(V);
1652 if (initial)
1653 Default.push_back(OptionValue<DataType>(V));
1654 }
1655
1656 const std::vector<OptionValue<DataType>> &getDefault() const {
1657 return Default;
1658 }
1659
1660 void assignDefault() { DefaultAssigned = true; }
1661 void overwriteDefault() { DefaultAssigned = false; }
1662 bool isDefaultAssigned() { return DefaultAssigned; }
1663};
1664
1665//===----------------------------------------------------------------------===//
1666// A list of command line options.
1667//
1668template <class DataType, class StorageClass = bool,
1669 class ParserClass = parser<DataType>>
1670class list : public Option, public list_storage<DataType, StorageClass> {
1671 std::vector<unsigned> Positions;
1672 ParserClass Parser;
1673
1674 enum ValueExpected getValueExpectedFlagDefault() const override {
1675 return Parser.getValueExpectedFlagDefault();
1676 }
1677
1678 void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1679 return Parser.getExtraOptionNames(OptionNames);
1680 }
1681
1682 bool handleOccurrence(unsigned pos, StringRef ArgName,
1683 StringRef Arg) override {
1684 typename ParserClass::parser_data_type Val =
1685 typename ParserClass::parser_data_type();
1687 clear();
1689 }
1690 if (Parser.parse(*this, ArgName, Arg, Val))
1691 return true; // Parse Error!
1693 setPosition(pos);
1694 Positions.push_back(pos);
1695 Callback(Val);
1696 return false;
1697 }
1698
1699 // Forward printing stuff to the parser...
1700 size_t getOptionWidth() const override {
1701 return Parser.getOptionWidth(*this);
1702 }
1703
1704 void printOptionInfo(size_t GlobalWidth) const override {
1705 Parser.printOptionInfo(*this, GlobalWidth);
1706 }
1707
1708 // Unimplemented: list options don't currently store their default value.
1709 void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1710 }
1711
1712 void setDefault() override {
1713 Positions.clear();
1717 }
1718
1719 void done() {
1720 addArgument();
1721 Parser.initialize();
1722 }
1723
1724public:
1725 // Command line options should not be copyable
1726 list(const list &) = delete;
1727 list &operator=(const list &) = delete;
1728
1729 ParserClass &getParser() { return Parser; }
1730
1731 unsigned getPosition(unsigned optnum) const {
1732 assert(optnum < this->size() && "Invalid option index");
1733 return Positions[optnum];
1734 }
1735
1736 void clear() {
1737 Positions.clear();
1739 }
1740
1741 // setInitialValues - Used by the cl::list_init modifier...
1749
1751
1752 template <class... Mods>
1753 explicit list(const Mods &... Ms)
1754 : Option(ZeroOrMore, NotHidden), Parser(*this) {
1755 apply(this, Ms...);
1756 done();
1757 }
1758
1760 std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1761 Callback = CB;
1762 }
1763
1764 std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1765 [](const typename ParserClass::parser_data_type &) {};
1766};
1767
1768// Modifier to set the number of additional values.
1771 explicit multi_val(unsigned N) : AdditionalVals(N) {}
1772
1773 template <typename D, typename S, typename P>
1774 void apply(list<D, S, P> &L) const {
1775 L.setNumAdditionalVals(AdditionalVals);
1776 }
1777};
1778
1779//===----------------------------------------------------------------------===//
1780// Default storage class definition: external storage. This implementation
1781// assumes the user will specify a variable to store the data into with the
1782// cl::location(x) modifier.
1783//
1784template <class DataType, class StorageClass> class bits_storage {
1785 unsigned *Location = nullptr; // Where to store the bits...
1786
1787 template <class T> static unsigned Bit(const T &V) {
1788 unsigned BitPos = static_cast<unsigned>(V);
1789 assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1790 "enum exceeds width of bit vector!");
1791 return 1 << BitPos;
1792 }
1793
1794public:
1795 bits_storage() = default;
1796
1797 bool setLocation(Option &O, unsigned &L) {
1798 if (Location)
1799 return O.error("cl::location(x) specified more than once!");
1800 Location = &L;
1801 return false;
1802 }
1803
1804 template <class T> void addValue(const T &V) {
1805 assert(Location != nullptr &&
1806 "cl::location(...) not specified for a command "
1807 "line option with external storage!");
1808 *Location |= Bit(V);
1809 }
1810
1811 unsigned getBits() { return *Location; }
1812
1813 void clear() {
1814 if (Location)
1815 *Location = 0;
1816 }
1817
1818 template <class T> bool isSet(const T &V) {
1819 return (*Location & Bit(V)) != 0;
1820 }
1821};
1822
1823// Define how to hold bits. Since we can inherit from a class, we do so.
1824// This makes us exactly compatible with the bits in all cases that it is used.
1825//
1826template <class DataType> class bits_storage<DataType, bool> {
1827 unsigned Bits{0}; // Where to store the bits...
1828
1829 template <class T> static unsigned Bit(const T &V) {
1830 unsigned BitPos = static_cast<unsigned>(V);
1831 assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1832 "enum exceeds width of bit vector!");
1833 return 1 << BitPos;
1834 }
1835
1836public:
1837 template <class T> void addValue(const T &V) { Bits |= Bit(V); }
1838
1839 unsigned getBits() { return Bits; }
1840
1841 void clear() { Bits = 0; }
1842
1843 template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
1844};
1845
1846//===----------------------------------------------------------------------===//
1847// A bit vector of command options.
1848//
1849template <class DataType, class Storage = bool,
1850 class ParserClass = parser<DataType>>
1851class bits : public Option, public bits_storage<DataType, Storage> {
1852 std::vector<unsigned> Positions;
1853 ParserClass Parser;
1854
1855 enum ValueExpected getValueExpectedFlagDefault() const override {
1856 return Parser.getValueExpectedFlagDefault();
1857 }
1858
1859 void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1860 return Parser.getExtraOptionNames(OptionNames);
1861 }
1862
1863 bool handleOccurrence(unsigned pos, StringRef ArgName,
1864 StringRef Arg) override {
1865 typename ParserClass::parser_data_type Val =
1866 typename ParserClass::parser_data_type();
1867 if (Parser.parse(*this, ArgName, Arg, Val))
1868 return true; // Parse Error!
1869 this->addValue(Val);
1870 setPosition(pos);
1871 Positions.push_back(pos);
1872 Callback(Val);
1873 return false;
1874 }
1875
1876 // Forward printing stuff to the parser...
1877 size_t getOptionWidth() const override {
1878 return Parser.getOptionWidth(*this);
1879 }
1880
1881 void printOptionInfo(size_t GlobalWidth) const override {
1882 Parser.printOptionInfo(*this, GlobalWidth);
1883 }
1884
1885 // Unimplemented: bits options don't currently store their default values.
1886 void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1887 }
1888
1890
1891 void done() {
1892 addArgument();
1893 Parser.initialize();
1894 }
1895
1896public:
1897 // Command line options should not be copyable
1898 bits(const bits &) = delete;
1899 bits &operator=(const bits &) = delete;
1900
1901 ParserClass &getParser() { return Parser; }
1902
1903 unsigned getPosition(unsigned optnum) const {
1904 assert(optnum < this->size() && "Invalid option index");
1905 return Positions[optnum];
1906 }
1907
1908 template <class... Mods>
1909 explicit bits(const Mods &... Ms)
1910 : Option(ZeroOrMore, NotHidden), Parser(*this) {
1911 apply(this, Ms...);
1912 done();
1913 }
1914
1916 std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1917 Callback = CB;
1918 }
1919
1920 std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1921 [](const typename ParserClass::parser_data_type &) {};
1922};
1923
1924//===----------------------------------------------------------------------===//
1925// Aliased command line option (alias this name to a preexisting name)
1926//
1927
1928class LLVM_ABI alias : public Option {
1929 Option *AliasFor;
1930
1931 bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
1932 StringRef Arg) override {
1933 return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
1934 }
1935
1936 bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
1937 bool MultiArg = false) override {
1938 return AliasFor->addOccurrence(pos, AliasFor->ArgStr, Value, MultiArg);
1939 }
1940
1941 // Handle printing stuff...
1942 size_t getOptionWidth() const override;
1943 void printOptionInfo(size_t GlobalWidth) const override;
1944
1945 // Aliases do not need to print their values.
1946 void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1947 }
1948
1949 void setDefault() override { AliasFor->setDefault(); }
1950
1951 ValueExpected getValueExpectedFlagDefault() const override {
1952 return AliasFor->getValueExpectedFlag();
1953 }
1954
1955 void done() {
1956 if (!hasArgStr())
1957 error("cl::alias must have argument name specified!");
1958 if (!AliasFor)
1959 error("cl::alias must have an cl::aliasopt(option) specified!");
1960 if (!Subs.empty())
1961 error("cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!");
1962 Subs = AliasFor->Subs;
1963 Categories = AliasFor->Categories;
1964 addArgument();
1965 }
1966
1967public:
1968 // Command line options should not be copyable
1969 alias(const alias &) = delete;
1970 alias &operator=(const alias &) = delete;
1971
1973 if (AliasFor)
1974 error("cl::alias must only have one cl::aliasopt(...) specified!");
1975 AliasFor = &O;
1976 }
1977
1978 template <class... Mods>
1979 explicit alias(const Mods &... Ms)
1980 : Option(Optional, Hidden), AliasFor(nullptr) {
1981 apply(this, Ms...);
1982 done();
1983 }
1984};
1985
1986// Modifier to set the option an alias aliases.
1987struct aliasopt {
1989
1990 explicit aliasopt(Option &O) : Opt(O) {}
1991
1992 void apply(alias &A) const { A.setAliasFor(Opt); }
1993};
1994
1995// Provide additional help at the end of the normal help output. All occurrences
1996// of cl::extrahelp will be accumulated and printed to stderr at the end of the
1997// regular help, just before exit is called.
2000
2001 LLVM_ABI explicit extrahelp(StringRef help);
2002};
2003
2005
2006/// This function just prints the help message, exactly the same way as if the
2007/// -help or -help-hidden option had been given on the command line.
2008///
2009/// \param Hidden if true will print hidden options
2010/// \param Categorized if true print options in categories
2011LLVM_ABI void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
2012
2013/// An array of optional enabled settings in the LLVM build configuration,
2014/// which may be of interest to compiler developers. For example, includes
2015/// "+assertions" if assertions are enabled. Used by printBuildConfig.
2017
2018/// Prints the compiler build configuration.
2019/// Designed for compiler developers, not compiler end-users.
2020/// Intended to be used in --version output when enabled.
2022
2023//===----------------------------------------------------------------------===//
2024// Public interface for accessing registered options.
2025//
2026
2027/// Use this to get a StringMap to all registered named options
2028/// (e.g. -help).
2029///
2030/// \return A reference to the StringMap used by the cl APIs to parse options.
2031///
2032/// Access to unnamed arguments (i.e. positional) are not provided because
2033/// it is expected that the client already has access to these.
2034///
2035/// Typical usage:
2036/// \code
2037/// main(int argc,char* argv[]) {
2038/// StringMap<llvm::cl::Option*> &opts = llvm::cl::getRegisteredOptions();
2039/// assert(opts.count("help") == 1)
2040/// opts["help"]->setDescription("Show alphabetical help information")
2041/// // More code
2042/// llvm::cl::ParseCommandLineOptions(argc,argv);
2043/// //More code
2044/// }
2045/// \endcode
2046///
2047/// This interface is useful for modifying options in libraries that are out of
2048/// the control of the client. The options should be modified before calling
2049/// llvm::cl::ParseCommandLineOptions().
2050///
2051/// Hopefully this API can be deprecated soon. Any situation where options need
2052/// to be modified by tools or libraries should be handled by sane APIs rather
2053/// than just handing around a global list.
2056
2057/// Use this to get all registered SubCommands from the provided parser.
2058///
2059/// \return A range of all SubCommand pointers registered with the parser.
2060///
2061/// Typical usage:
2062/// \code
2063/// main(int argc, char* argv[]) {
2064/// llvm::cl::ParseCommandLineOptions(argc, argv);
2065/// for (auto* S : llvm::cl::getRegisteredSubcommands()) {
2066/// if (*S) {
2067/// std::cout << "Executing subcommand: " << S->getName() << std::endl;
2068/// // Execute some function based on the name...
2069/// }
2070/// }
2071/// }
2072/// \endcode
2073///
2074/// This interface is useful for defining subcommands in libraries and
2075/// the dispatch from a single point (like in the main function).
2078
2079//===----------------------------------------------------------------------===//
2080// Standalone command line processing utilities.
2081//
2082
2083/// Tokenizes a command line that can contain escapes and quotes.
2084//
2085/// The quoting rules match those used by GCC and other tools that use
2086/// libiberty's buildargv() or expandargv() utilities, and do not match bash.
2087/// They differ from buildargv() on treatment of backslashes that do not escape
2088/// a special character to make it possible to accept most Windows file paths.
2089///
2090/// \param [in] Source The string to be split on whitespace with quotes.
2091/// \param [in] Saver Delegates back to the caller for saving parsed strings.
2092/// \param [in] MarkEOLs true if tokenizing a response file and you want end of
2093/// lines and end of the response file to be marked with a nullptr string.
2094/// \param [out] NewArgv All parsed strings are appended to NewArgv.
2097 bool MarkEOLs = false);
2098
2099/// Tokenizes a string of Windows command line arguments, which may contain
2100/// quotes and escaped quotes.
2101///
2102/// See MSDN docs for CommandLineToArgvW for information on the quoting rules.
2103/// http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx
2104///
2105/// For handling a full Windows command line including the executable name at
2106/// the start, see TokenizeWindowsCommandLineFull below.
2107///
2108/// \param [in] Source The string to be split on whitespace with quotes.
2109/// \param [in] Saver Delegates back to the caller for saving parsed strings.
2110/// \param [in] MarkEOLs true if tokenizing a response file and you want end of
2111/// lines and end of the response file to be marked with a nullptr string.
2112/// \param [out] NewArgv All parsed strings are appended to NewArgv.
2115 bool MarkEOLs = false);
2116
2117/// Tokenizes a Windows command line while attempting to avoid copies. If no
2118/// quoting or escaping was used, this produces substrings of the original
2119/// string. If a token requires unquoting, it will be allocated with the
2120/// StringSaver.
2121LLVM_ABI void
2124
2125/// Tokenizes a Windows full command line, including command name at the start.
2126///
2127/// This uses the same syntax rules as TokenizeWindowsCommandLine for all but
2128/// the first token. But the first token is expected to be parsed as the
2129/// executable file name in the way CreateProcess would do it, rather than the
2130/// way the C library startup code would do it: CreateProcess does not consider
2131/// that \ is ever an escape character (because " is not a valid filename char,
2132/// hence there's never a need to escape it to be used literally).
2133///
2134/// Parameters are the same as for TokenizeWindowsCommandLine. In particular,
2135/// if you set MarkEOLs = true, then the first word of every line will be
2136/// parsed using the special rules for command names, making this function
2137/// suitable for parsing a file full of commands to execute.
2138LLVM_ABI void
2141 bool MarkEOLs = false);
2142
2143/// String tokenization function type. Should be compatible with either
2144/// Windows or Unix command line tokenizers.
2145using TokenizerCallback = void (*)(StringRef Source, StringSaver &Saver,
2147 bool MarkEOLs);
2148
2149/// Tokenizes content of configuration file.
2150///
2151/// \param [in] Source The string representing content of config file.
2152/// \param [in] Saver Delegates back to the caller for saving parsed strings.
2153/// \param [out] NewArgv All parsed strings are appended to NewArgv.
2154/// \param [in] MarkEOLs Added for compatibility with TokenizerCallback.
2155///
2156/// It works like TokenizeGNUCommandLine with ability to skip comment lines.
2157///
2160 bool MarkEOLs = false);
2161
2162/// Contains options that control response file expansion.
2164 /// Provides persistent storage for parsed strings.
2165 StringSaver Saver;
2166
2167 /// Tokenization strategy. Typically Unix or Windows.
2168 TokenizerCallback Tokenizer;
2169
2170 /// File system used for all file access when running the expansion.
2171 vfs::FileSystem *FS;
2172
2173 /// Path used to resolve relative rsp files. If empty, the file system
2174 /// current directory is used instead.
2175 StringRef CurrentDir;
2176
2177 /// Directories used for search of config files.
2178 ArrayRef<StringRef> SearchDirs;
2179
2180 /// True if names of nested response files must be resolved relative to
2181 /// including file.
2182 bool RelativeNames = false;
2183
2184 /// If true, mark end of lines and the end of the response file with nullptrs
2185 /// in the Argv vector.
2186 bool MarkEOLs = false;
2187
2188 /// If true, body of config file is expanded.
2189 bool InConfigFile = false;
2190
2191 llvm::Error expandResponseFile(StringRef FName,
2193
2194public:
2196
2198 MarkEOLs = X;
2199 return *this;
2200 }
2201
2203 RelativeNames = X;
2204 return *this;
2205 }
2206
2208 CurrentDir = X;
2209 return *this;
2210 }
2211
2213 SearchDirs = X;
2214 return *this;
2215 }
2216
2218 FS = X;
2219 return *this;
2220 }
2221
2222 /// Looks for the specified configuration file.
2223 ///
2224 /// \param[in] FileName Name of the file to search for.
2225 /// \param[out] FilePath File absolute path, if it was found.
2226 /// \return True if file was found.
2227 ///
2228 /// If the specified file name contains a directory separator, it is searched
2229 /// for by its absolute path. Otherwise looks for file sequentially in
2230 /// directories specified by SearchDirs field.
2231 LLVM_ABI bool findConfigFile(StringRef FileName,
2232 SmallVectorImpl<char> &FilePath);
2233
2234 /// Reads command line options from the given configuration file.
2235 ///
2236 /// \param [in] CfgFile Path to configuration file.
2237 /// \param [out] Argv Array to which the read options are added.
2238 /// \return true if the file was successfully read.
2239 ///
2240 /// It reads content of the specified file, tokenizes it and expands "@file"
2241 /// commands resolving file names in them relative to the directory where
2242 /// CfgFilename resides. It also expands "<CFGDIR>" to the base path of the
2243 /// current config file.
2246
2247 /// Expands constructs "@file" in the provided array of arguments recursively.
2249};
2250
2251/// A convenience helper which concatenates the options specified by the
2252/// environment variable EnvVar and command line options, then expands
2253/// response files recursively.
2254/// \return true if all @files were expanded successfully or there were none.
2255LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv,
2256 const char *EnvVar,
2258
2259/// A convenience helper which supports the typical use case of expansion
2260/// function call.
2262 TokenizerCallback Tokenizer,
2264
2265/// A convenience helper which concatenates the options specified by the
2266/// environment variable EnvVar and command line options, then expands response
2267/// files recursively. The tokenizer is a predefined GNU or Windows one.
2268/// \return true if all @files were expanded successfully or there were none.
2269LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv,
2270 const char *EnvVar, StringSaver &Saver,
2272
2273/// Mark all options not part of this category as cl::ReallyHidden.
2274///
2275/// \param Category the category of options to keep displaying
2276///
2277/// Some tools (like clang-format) like to be able to hide all options that are
2278/// not specific to the tool. This function allows a tool to specify a single
2279/// option category to display in the -help output.
2282
2283/// Mark all options not part of the categories as cl::ReallyHidden.
2284///
2285/// \param Categories the categories of options to keep displaying.
2286///
2287/// Some tools (like clang-format) like to be able to hide all options that are
2288/// not specific to the tool. This function allows a tool to specify a single
2289/// option category to display in the -help output.
2290LLVM_ABI void
2293
2294/// Reset all command line options to a state that looks as if they have
2295/// never appeared on the command line. This is useful for being able to parse
2296/// a command line multiple times (especially useful for writing tests).
2298
2299/// Reset the command line parser back to its initial state. This
2300/// removes
2301/// all options, categories, and subcommands and returns the parser to a state
2302/// where no options are supported.
2304
2305/// Parses `Arg` into the option handler `Handler`.
2306LLVM_ABI bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
2307
2308} // end namespace cl
2309
2310} // end namespace llvm
2311
2312#endif // LLVM_SUPPORT_COMMANDLINE_H
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
aarch64 promote const
This file defines the StringMap class.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_ABI
Definition Compiler.h:213
#define LLVM_TEMPLATE_ABI
Definition Compiler.h:214
dxil pretty printer
global merge func
static LVOptions Options
Definition LVOptions.cpp:25
#define F(x, y, z)
Definition MD5.cpp:55
#define G(x, y, z)
Definition MD5.cpp:56
#define T
#define P(N)
static const char * name
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)
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:41
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition StringMap.h:133
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
std::string str() const
str - Get the contents as an std::string.
Definition StringRef.h:233
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition StringSaver.h:22
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
LLVM Value Representation.
Definition Value.h:75
LLVM_ABI Value(Type *Ty, unsigned scid)
Definition Value.cpp:53
ExpansionContext & setCurrentDir(StringRef X)
ExpansionContext & setVFS(vfs::FileSystem *X)
ExpansionContext & setMarkEOLs(bool X)
ExpansionContext & setSearchDirs(ArrayRef< StringRef > X)
ExpansionContext & setRelativeNames(bool X)
LLVM_ABI bool findConfigFile(StringRef FileName, SmallVectorImpl< char > &FilePath)
Looks for the specified configuration file.
LLVM_ABI ExpansionContext(BumpPtrAllocator &A, TokenizerCallback T)
LLVM_ABI Error expandResponseFiles(SmallVectorImpl< const char * > &Argv)
Expands constructs "@file" in the provided array of arguments recursively.
LLVM_ABI Error readConfigFile(StringRef CfgFile, SmallVectorImpl< const char * > &Argv)
Reads command line options from the given configuration file.
OptionCategory(StringRef const Name, StringRef const Description="")
StringRef getDescription() const
StringRef getName() const
OptionValueCopy & operator=(const OptionValueCopy &)=default
bool compare(const GenericOptionValue &V) const override
void setValue(const DataType &V)
const DataType & getValue() const
OptionValueCopy(const OptionValueCopy &)=default
bool compare(const DataType &V) const
bool isPositional() const
virtual void getExtraOptionNames(SmallVectorImpl< StringRef > &)
void setValueExpectedFlag(enum ValueExpected Val)
void setPosition(unsigned pos)
bool isConsumeAfter() const
StringRef ValueStr
SmallPtrSet< SubCommand *, 1 > Subs
int getNumOccurrences() const
friend class alias
enum ValueExpected getValueExpectedFlag() const
void setValueStr(StringRef S)
void setNumOccurrencesFlag(enum NumOccurrencesFlag Val)
void setNumAdditionalVals(unsigned n)
void setDescription(StringRef S)
void setFormattingFlag(enum FormattingFlags V)
void setHiddenFlag(enum OptionHidden Val)
void setMiscFlag(enum MiscFlags M)
enum FormattingFlags getFormattingFlag() const
virtual void printOptionInfo(size_t GlobalWidth) const =0
enum NumOccurrencesFlag getNumOccurrencesFlag() const
SmallVector< OptionCategory *, 1 > Categories
bool isSink() const
void addSubCommand(SubCommand &S)
bool hasArgStr() const
bool isDefaultOption() const
unsigned getMiscFlags() const
virtual void setDefault()=0
virtual void printOptionValue(size_t GlobalWidth, bool Force) const =0
virtual ~Option()=default
static void printEnumValHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
unsigned getNumAdditionalVals() const
void removeArgument()
Unregisters this option from the CommandLine system.
Option(enum NumOccurrencesFlag OccurrencesFlag, enum OptionHidden Hidden)
enum OptionHidden getOptionHiddenFlag() const
bool error(const Twine &Message, raw_ostream &Errs)
static void printHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
virtual size_t getOptionWidth() const =0
StringRef HelpStr
unsigned getPosition() const
SubCommandGroup(std::initializer_list< SubCommand * > IL)
ArrayRef< SubCommand * > getSubCommands() const
StringRef getName() const
SubCommand(StringRef Name, StringRef Description="")
SmallVector< Option *, 4 > SinkOpts
static LLVM_ABI SubCommand & getTopLevel()
LLVM_ABI void unregisterSubCommand()
static LLVM_ABI SubCommand & getAll()
LLVM_ABI void reset()
LLVM_ABI void registerSubCommand()
SmallVector< Option *, 4 > PositionalOpts
StringMap< Option * > OptionsMap
StringRef getDescription() const
void apply(Opt &O) const
ValuesClass(std::initializer_list< OptionEnumValue > Options)
alias(const alias &)=delete
void setAliasFor(Option &O)
alias & operator=(const alias &)=delete
alias(const Mods &... Ms)
enum ValueExpected getValueExpectedFlagDefault() const
void getExtraOptionNames(SmallVectorImpl< StringRef > &)
virtual StringRef getValueName() const
virtual ~basic_parser_impl()=default
OptionValue< DataType > OptVal
bool isSet(const T &V)
void addValue(const T &V)
bool setLocation(Option &O, unsigned &L)
bits & operator=(const bits &)=delete
bits(const Mods &... Ms)
ParserClass & getParser()
unsigned getPosition(unsigned optnum) const
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
std::function< void(const typename ParserClass::parser_data_type &)> Callback
bits(const bits &)=delete
GenericOptionInfo(StringRef name, StringRef helpStr)
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
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)
enum ValueExpected getValueExpectedFlagDefault() const
typename std::vector< DataType >::const_iterator const_iterator
typename std::vector< DataType >::const_reference const_reference
iterator erase(const_iterator first, const_iterator last)
iterator insert(const_iterator pos, const DataType &value)
iterator erase(iterator first, iterator last)
const_reference operator[](size_type pos) const
void addValue(const T &V, bool initial=false)
void push_back(const DataType &value)
typename std::vector< DataType >::reference reference
const std::vector< DataType > * operator&() const
iterator insert(iterator pos, const DataType &value)
typename std::vector< DataType >::size_type size_type
iterator insert(const_iterator pos, DataType &&value)
std::vector< DataType > * operator&()
const std::vector< OptionValue< DataType > > & getDefault() const
iterator erase(const_iterator pos)
iterator insert(iterator pos, DataType &&value)
typename std::vector< DataType >::iterator iterator
const std::vector< OptionValue< DataType > > & getDefault() const
void addValue(const T &V, bool initial=false)
bool setLocation(Option &O, StorageClass &L)
list(const Mods &... Ms)
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
list(const list &)=delete
void setInitialValues(ArrayRef< DataType > Vs)
std::function< void(const typename ParserClass::parser_data_type &)> Callback
list & operator=(const list &)=delete
ParserClass & getParser()
unsigned getPosition(unsigned optnum) const
void setNumAdditionalVals(unsigned n)
const OptionValue< DataType > & getDefault() const
void setValue(const T &V, bool initial=false)
void setValue(const T &V, bool initial=false)
const OptionValue< DataType > & getDefault() const
const DataType & getValue() const
bool setLocation(Option &O, DataType &L)
void setValue(const T &V, bool initial=false)
const OptionValue< DataType > & getDefault() const
ParserClass & getParser()
opt & operator=(const opt &)=delete
void setInitialValue(const DataType &V)
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
opt(const opt &)=delete
DataType & operator=(const T &Val)
opt(const Mods &... Ms)
DataType & operator=(T &&Val)
std::function< void(const typename ParserClass::parser_data_type &)> Callback
OptionInfo(StringRef name, DataType v, StringRef helpStr)
OptionValue< DataType > V
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
enum ValueExpected getValueExpectedFlagDefault() const
enum ValueExpected getValueExpectedFlagDefault() const
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
void anchor() override
bool parse(Option &, StringRef, StringRef Arg, char &Value)
void printOptionDiff(const Option &O, char V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
void anchor() override
void printOptionDiff(const Option &O, double V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
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
void printOptionDiff(const Option &O, float V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
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
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
void printOptionDiff(const Option &O, long long V, OptVal Default, size_t GlobalWidth) const
StringRef getValueName() const override
void printOptionDiff(const Option &O, StringRef V, const OptVal &Default, size_t GlobalWidth) const
bool parse(Option &, StringRef, StringRef Arg, std::string &Value)
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
StringRef getValueName() const override
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
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
SmallVector< OptionInfo, 8 > Values
parser(Option &O)
void removeLiteralOption(StringRef Name)
Remove the specified option.
StringRef getDescription(unsigned N) const override
void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr)
Add an entry to the mapping table.
const GenericOptionValue & getOptionValue(unsigned N) const override
StringRef getOption(unsigned N) const override
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V)
unsigned getNumOptions() const override
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:53
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
This namespace contains all of the command line option processing machinery.
Definition CommandLine.h:53
LLVM_ABI void PrintVersionMessage()
Utility function for printing version number.
LLVM_ABI bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &Argv)
A convenience helper which supports the typical use case of expansion function call.
LLVM_ABI 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)
LLVM_ABI OptionCategory & getGeneralCategory()
@ ValueDisallowed
LLVM_ABI void ResetAllOptionOccurrences()
Reset all command line options to a state that looks as if they have never appeared on the command li...
LLVM_ABI void SetVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// Override the default (LLV...
LLVM_ABI void tokenizeConfigFile(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes content of configuration file.
LLVM_ABI StringMap< Option * > & getRegisteredOptions(SubCommand &Sub=SubCommand::getTopLevel())
Use this to get a StringMap to all registered named options (e.g.
LLVM_ABI void ResetCommandLineParser()
Reset the command line parser back to its initial state.
LLVM_ABI bool ParseCommandLineOptions(int argc, const char *const *argv, StringRef Overview="", raw_ostream *Errs=nullptr, const char *EnvVar=nullptr, bool LongOptionsUseDoubleDash=false)
LLVM_ABI void PrintOptionValues()
LLVM_ABI 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)
LLVM_ABI 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)
LLVM_ABI 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 ...
template class LLVM_TEMPLATE_ABI basic_parser< bool >
LLVM_ABI void printBuildConfig(raw_ostream &OS)
Prints the compiler build configuration.
void(*)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs) TokenizerCallback
String tokenization function type.
LLVM_ABI bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i)
Parses Arg into the option handler Handler.
LLVM_ABI 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 ...
initializer< Ty > init(const Ty &Val)
std::function< void(raw_ostream &)> VersionPrinterTy
Definition CommandLine.h:76
@ PositionalEatsArgs
LLVM_ABI ArrayRef< StringRef > getCompilerBuildConfig()
An array of optional enabled settings in the LLVM build configuration, which may be of interest to co...
LocationClass< Ty > location(Ty &L)
cb< typename detail::callback_traits< F >::result_type, typename detail::callback_traits< F >::arg_type > callback(F CB)
LLVM_ABI void HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub=SubCommand::getTopLevel())
Mark all options not part of this category as cl::ReallyHidden.
LLVM_ABI void AddExtraVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// Add an extra printer to u...
LLVM_ABI 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...
LLVM_ABI 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
LLVM_ABI 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.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition STLExtras.h:1685
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:167
BumpPtrAllocatorImpl BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition Allocator.h:383
LLVM_ABI 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.
Definition ModRef.h:34
@ Sub
Subtraction of integers.
ArrayRef(const T &OneElt) -> ArrayRef< T >
@ Default
The result values are uniform if and only if all operands are uniform.
Definition Uniformity.h:20
Implement std::hash so that hash_code can be used in STL containers.
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
void print(const Option &O, const parser< DT > &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
void print(const Option &O, const parser< ParserDT > &P, const ValDT &, const OptionValue< ValDT > &, size_t GlobalWidth)
OptionValueBase & operator=(const OptionValueBase &)=default
OptionValueBase(const OptionValueBase &)=default
bool compare(const DataType &) const
const DataType & getValue() const
bool compare(const GenericOptionValue &) const override
OptionValue< DataType > WrapperType
void setValue(const DT &)
OptionValue< cl::boolOrDefault > & operator=(const cl::boolOrDefault &V)
OptionValue(const cl::boolOrDefault &V)
OptionValue< std::string > & operator=(const std::string &V)
OptionValue(const std::string &V)
OptionValue(const DataType &V)
OptionValue< DataType > & operator=(const DT &V)
void apply(alias &A) const
static void opt(FormattingFlags FF, Option &O)
static void opt(MiscFlags MF, Option &O)
static void opt(NumOccurrencesFlag N, Option &O)
static void opt(OptionHidden OH, Option &O)
static void opt(StringRef Str, Opt &O)
static void opt(ValueExpected VE, Option &O)
static void opt(StringRef Str, Opt &O)
static void opt(StringRef Str, Opt &O)
static void opt(const Mod &M, Opt &O)
void apply(Opt &O) const
cat(OptionCategory &c)
OptionCategory & Category
void apply(Opt &O) const
cb(std::function< R(Ty)> CB)
std::function< R(Ty)> CB
desc(StringRef Str)
void apply(Option &O) const
StringRef Desc
std::tuple_element_t< 0, std::tuple< Args... > > arg_type
LLVM_ABI extrahelp(StringRef help)
initializer(const Ty &Val)
void apply(Opt &O) const
list_initializer(ArrayRef< Ty > Vals)
void apply(Opt &O) const
multi_val(unsigned N)
void apply(list< D, S, P > &L) const
sub(SubCommand &S)
SubCommand * Sub
sub(SubCommandGroup &G)
void apply(Opt &O) const
SubCommandGroup * Group
void apply(Option &O) const
value_desc(StringRef Str)