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