1//===- llvm/Support/CommandLine.h - Command line handler --------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This class implements a command line argument processor that is useful when
11// creating a tool.  It provides a simple, minimalistic interface that is easily
12// extensible and supports nonlocal (library) command line options.
13//
14// Note that rather than trying to figure out what this code does, you should
15// read the library documentation located in docs/CommandLine.html or looks at
16// the many example usages in tools/*/*.cpp
17//
18//===----------------------------------------------------------------------===//
19
20#ifndef LLVM_SUPPORT_COMMANDLINE_H
21#define LLVM_SUPPORT_COMMANDLINE_H
22
23#include "llvm/ADT/ArrayRef.h"
24#include "llvm/ADT/SmallVector.h"
25#include "llvm/ADT/StringMap.h"
26#include "llvm/ADT/Twine.h"
27#include "llvm/Support/Compiler.h"
28#include <cassert>
29#include <climits>
30#include <cstdarg>
31#include <utility>
32#include <vector>
33
34namespace llvm {
35
36/// cl Namespace - This namespace contains all of the command line option
37/// processing machinery.  It is intentionally a short name to make qualified
38/// usage concise.
39namespace cl {
40
41//===----------------------------------------------------------------------===//
42// ParseCommandLineOptions - Command line option processing entry point.
43//
44void ParseCommandLineOptions(int argc, const char *const *argv,
45                             const char *Overview = nullptr);
46
47//===----------------------------------------------------------------------===//
48// ParseEnvironmentOptions - Environment variable option processing alternate
49//                           entry point.
50//
51void ParseEnvironmentOptions(const char *progName, const char *envvar,
52                             const char *Overview = nullptr);
53
54///===---------------------------------------------------------------------===//
55/// SetVersionPrinter - Override the default (LLVM specific) version printer
56///                     used to print out the version when --version is given
57///                     on the command line. This allows other systems using the
58///                     CommandLine utilities to print their own version string.
59void SetVersionPrinter(void (*func)());
60
61///===---------------------------------------------------------------------===//
62/// AddExtraVersionPrinter - Add an extra printer to use in addition to the
63///                          default one. This can be called multiple times,
64///                          and each time it adds a new function to the list
65///                          which will be called after the basic LLVM version
66///                          printing is complete. Each can then add additional
67///                          information specific to the tool.
68void AddExtraVersionPrinter(void (*func)());
69
70// PrintOptionValues - Print option values.
71// With -print-options print the difference between option values and defaults.
72// With -print-all-options print all option values.
73// (Currently not perfect, but best-effort.)
74void PrintOptionValues();
75
76// Forward declaration - AddLiteralOption needs to be up here to make gcc happy.
77class Option;
78
79/// \brief Adds a new option for parsing and provides the option it refers to.
80///
81/// \param O pointer to the option
82/// \param Name the string name for the option to handle during parsing
83///
84/// Literal options are used by some parsers to register special option values.
85/// This is how the PassNameParser registers pass names for opt.
86void AddLiteralOption(Option &O, const char *Name);
87
88//===----------------------------------------------------------------------===//
89// Flags permitted to be passed to command line arguments
90//
91
92enum NumOccurrencesFlag { // Flags for the number of occurrences allowed
93  Optional = 0x00,        // Zero or One occurrence
94  ZeroOrMore = 0x01,      // Zero or more occurrences allowed
95  Required = 0x02,        // One occurrence required
96  OneOrMore = 0x03,       // One or more occurrences required
97
98  // ConsumeAfter - Indicates that this option is fed anything that follows the
99  // last positional argument required by the application (it is an error if
100  // there are zero positional arguments, and a ConsumeAfter option is used).
101  // Thus, for example, all arguments to LLI are processed until a filename is
102  // found.  Once a filename is found, all of the succeeding arguments are
103  // passed, unprocessed, to the ConsumeAfter option.
104  //
105  ConsumeAfter = 0x04
106};
107
108enum ValueExpected { // Is a value required for the option?
109  // zero reserved for the unspecified value
110  ValueOptional = 0x01,  // The value can appear... or not
111  ValueRequired = 0x02,  // The value is required to appear!
112  ValueDisallowed = 0x03 // A value may not be specified (for flags)
113};
114
115enum OptionHidden {   // Control whether -help shows this option
116  NotHidden = 0x00,   // Option included in -help & -help-hidden
117  Hidden = 0x01,      // -help doesn't, but -help-hidden does
118  ReallyHidden = 0x02 // Neither -help nor -help-hidden show this arg
119};
120
121// Formatting flags - This controls special features that the option might have
122// that cause it to be parsed differently...
123//
124// Prefix - This option allows arguments that are otherwise unrecognized to be
125// matched by options that are a prefix of the actual value.  This is useful for
126// cases like a linker, where options are typically of the form '-lfoo' or
127// '-L../../include' where -l or -L are the actual flags.  When prefix is
128// enabled, and used, the value for the flag comes from the suffix of the
129// argument.
130//
131// Grouping - With this option enabled, multiple letter options are allowed to
132// bunch together with only a single hyphen for the whole group.  This allows
133// emulation of the behavior that ls uses for example: ls -la === ls -l -a
134//
135
136enum FormattingFlags {
137  NormalFormatting = 0x00, // Nothing special
138  Positional = 0x01,       // Is a positional argument, no '-' required
139  Prefix = 0x02,           // Can this option directly prefix its value?
140  Grouping = 0x03          // Can this option group with other options?
141};
142
143enum MiscFlags {             // Miscellaneous flags to adjust argument
144  CommaSeparated = 0x01,     // Should this cl::list split between commas?
145  PositionalEatsArgs = 0x02, // Should this positional cl::list eat -args?
146  Sink = 0x04                // Should this cl::list eat all unknown options?
147};
148
149//===----------------------------------------------------------------------===//
150// Option Category class
151//
152class OptionCategory {
153private:
154  const char *const Name;
155  const char *const Description;
156  void registerCategory();
157
158public:
159  OptionCategory(const char *const Name,
160                 const char *const Description = nullptr)
161      : Name(Name), Description(Description) {
162    registerCategory();
163  }
164  const char *getName() const { return Name; }
165  const char *getDescription() const { return Description; }
166};
167
168// The general Option Category (used as default category).
169extern OptionCategory GeneralCategory;
170
171//===----------------------------------------------------------------------===//
172// Option Base class
173//
174class alias;
175class Option {
176  friend class alias;
177
178  // handleOccurrences - Overriden by subclasses to handle the value passed into
179  // an argument.  Should return true if there was an error processing the
180  // argument and the program should exit.
181  //
182  virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
183                                StringRef Arg) = 0;
184
185  virtual enum ValueExpected getValueExpectedFlagDefault() const {
186    return ValueOptional;
187  }
188
189  // Out of line virtual function to provide home for the class.
190  virtual void anchor();
191
192  int NumOccurrences; // The number of times specified
193  // Occurrences, HiddenFlag, and Formatting are all enum types but to avoid
194  // problems with signed enums in bitfields.
195  unsigned Occurrences : 3; // enum NumOccurrencesFlag
196  // not using the enum type for 'Value' because zero is an implementation
197  // detail representing the non-value
198  unsigned Value : 2;
199  unsigned HiddenFlag : 2; // enum OptionHidden
200  unsigned Formatting : 2; // enum FormattingFlags
201  unsigned Misc : 3;
202  unsigned Position;       // Position of last occurrence of the option
203  unsigned AdditionalVals; // Greater than 0 for multi-valued option.
204
205public:
206  const char *ArgStr;   // The argument string itself (ex: "help", "o")
207  const char *HelpStr;  // The descriptive text message for -help
208  const char *ValueStr; // String describing what the value of this option is
209  OptionCategory *Category; // The Category this option belongs to
210  bool FullyInitialized;    // Has addArguemnt been called?
211
212  inline enum NumOccurrencesFlag getNumOccurrencesFlag() const {
213    return (enum NumOccurrencesFlag)Occurrences;
214  }
215  inline enum ValueExpected getValueExpectedFlag() const {
216    return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
217  }
218  inline enum OptionHidden getOptionHiddenFlag() const {
219    return (enum OptionHidden)HiddenFlag;
220  }
221  inline enum FormattingFlags getFormattingFlag() const {
222    return (enum FormattingFlags)Formatting;
223  }
224  inline unsigned getMiscFlags() const { return Misc; }
225  inline unsigned getPosition() const { return Position; }
226  inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
227
228  // hasArgStr - Return true if the argstr != ""
229  bool hasArgStr() const { return ArgStr[0] != 0; }
230
231  //-------------------------------------------------------------------------===
232  // Accessor functions set by OptionModifiers
233  //
234  void setArgStr(const char *S);
235  void setDescription(const char *S) { HelpStr = S; }
236  void setValueStr(const char *S) { ValueStr = S; }
237  void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
238  void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
239  void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
240  void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }
241  void setMiscFlag(enum MiscFlags M) { Misc |= M; }
242  void setPosition(unsigned pos) { Position = pos; }
243  void setCategory(OptionCategory &C) { Category = &C; }
244
245protected:
246  explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
247                  enum OptionHidden Hidden)
248      : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
249        HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0), Position(0),
250        AdditionalVals(0), ArgStr(""), HelpStr(""), ValueStr(""),
251        Category(&GeneralCategory), FullyInitialized(false) {}
252
253  inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
254
255public:
256  // addArgument - Register this argument with the commandline system.
257  //
258  void addArgument();
259
260  /// Unregisters this option from the CommandLine system.
261  ///
262  /// This option must have been the last option registered.
263  /// For testing purposes only.
264  void removeArgument();
265
266  // Return the width of the option tag for printing...
267  virtual size_t getOptionWidth() const = 0;
268
269  // printOptionInfo - Print out information about this option.  The
270  // to-be-maintained width is specified.
271  //
272  virtual void printOptionInfo(size_t GlobalWidth) const = 0;
273
274  virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
275
276  virtual void getExtraOptionNames(SmallVectorImpl<const char *> &) {}
277
278  // addOccurrence - Wrapper around handleOccurrence that enforces Flags.
279  //
280  virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
281                             bool MultiArg = false);
282
283  // Prints option name followed by message.  Always returns true.
284  bool error(const Twine &Message, StringRef ArgName = StringRef());
285
286public:
287  inline int getNumOccurrences() const { return NumOccurrences; }
288  virtual ~Option() {}
289};
290
291//===----------------------------------------------------------------------===//
292// Command line option modifiers that can be used to modify the behavior of
293// command line option parsers...
294//
295
296// desc - Modifier to set the description shown in the -help output...
297struct desc {
298  const char *Desc;
299  desc(const char *Str) : Desc(Str) {}
300  void apply(Option &O) const { O.setDescription(Desc); }
301};
302
303// value_desc - Modifier to set the value description shown in the -help
304// output...
305struct value_desc {
306  const char *Desc;
307  value_desc(const char *Str) : Desc(Str) {}
308  void apply(Option &O) const { O.setValueStr(Desc); }
309};
310
311// init - Specify a default (initial) value for the command line argument, if
312// the default constructor for the argument type does not give you what you
313// want.  This is only valid on "opt" arguments, not on "list" arguments.
314//
315template <class Ty> struct initializer {
316  const Ty &Init;
317  initializer(const Ty &Val) : Init(Val) {}
318
319  template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
320};
321
322template <class Ty> initializer<Ty> init(const Ty &Val) {
323  return initializer<Ty>(Val);
324}
325
326// location - Allow the user to specify which external variable they want to
327// store the results of the command line argument processing into, if they don't
328// want to store it in the option itself.
329//
330template <class Ty> struct LocationClass {
331  Ty &Loc;
332  LocationClass(Ty &L) : Loc(L) {}
333
334  template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
335};
336
337template <class Ty> LocationClass<Ty> location(Ty &L) {
338  return LocationClass<Ty>(L);
339}
340
341// cat - Specifiy the Option category for the command line argument to belong
342// to.
343struct cat {
344  OptionCategory &Category;
345  cat(OptionCategory &c) : Category(c) {}
346
347  template <class Opt> void apply(Opt &O) const { O.setCategory(Category); }
348};
349
350//===----------------------------------------------------------------------===//
351// OptionValue class
352
353// Support value comparison outside the template.
354struct GenericOptionValue {
355  virtual bool compare(const GenericOptionValue &V) const = 0;
356
357protected:
358  ~GenericOptionValue() = default;
359  GenericOptionValue() = default;
360  GenericOptionValue(const GenericOptionValue&) = default;
361  GenericOptionValue &operator=(const GenericOptionValue &) = default;
362
363private:
364  virtual void anchor();
365};
366
367template <class DataType> struct OptionValue;
368
369// The default value safely does nothing. Option value printing is only
370// best-effort.
371template <class DataType, bool isClass>
372struct OptionValueBase : public GenericOptionValue {
373  // Temporary storage for argument passing.
374  typedef OptionValue<DataType> WrapperType;
375
376  bool hasValue() const { return false; }
377
378  const DataType &getValue() const { llvm_unreachable("no default value"); }
379
380  // Some options may take their value from a different data type.
381  template <class DT> void setValue(const DT & /*V*/) {}
382
383  bool compare(const DataType & /*V*/) const { return false; }
384
385  bool compare(const GenericOptionValue & /*V*/) const override {
386    return false;
387  }
388
389protected:
390  ~OptionValueBase() = default;
391};
392
393// Simple copy of the option value.
394template <class DataType> class OptionValueCopy : public GenericOptionValue {
395  DataType Value;
396  bool Valid;
397
398protected:
399  ~OptionValueCopy() = default;
400  OptionValueCopy(const OptionValueCopy&) = default;
401  OptionValueCopy &operator=(const OptionValueCopy&) = default;
402
403public:
404  OptionValueCopy() : Valid(false) {}
405
406  bool hasValue() const { return Valid; }
407
408  const DataType &getValue() const {
409    assert(Valid && "invalid option value");
410    return Value;
411  }
412
413  void setValue(const DataType &V) {
414    Valid = true;
415    Value = V;
416  }
417
418  bool compare(const DataType &V) const { return Valid && (Value != V); }
419
420  bool compare(const GenericOptionValue &V) const override {
421    const OptionValueCopy<DataType> &VC =
422        static_cast<const OptionValueCopy<DataType> &>(V);
423    if (!VC.hasValue())
424      return false;
425    return compare(VC.getValue());
426  }
427};
428
429// Non-class option values.
430template <class DataType>
431struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
432  typedef DataType WrapperType;
433
434protected:
435  ~OptionValueBase() = default;
436  OptionValueBase() = default;
437  OptionValueBase(const OptionValueBase&) = default;
438  OptionValueBase &operator=(const OptionValueBase&) = default;
439};
440
441// Top-level option class.
442template <class DataType>
443struct OptionValue final
444    : OptionValueBase<DataType, std::is_class<DataType>::value> {
445  OptionValue() = default;
446
447  OptionValue(const DataType &V) { this->setValue(V); }
448  // Some options may take their value from a different data type.
449  template <class DT> OptionValue<DataType> &operator=(const DT &V) {
450    this->setValue(V);
451    return *this;
452  }
453};
454
455// Other safe-to-copy-by-value common option types.
456enum boolOrDefault { BOU_UNSET, BOU_TRUE, BOU_FALSE };
457template <>
458struct OptionValue<cl::boolOrDefault> final
459    : OptionValueCopy<cl::boolOrDefault> {
460  typedef cl::boolOrDefault WrapperType;
461
462  OptionValue() {}
463
464  OptionValue(const cl::boolOrDefault &V) { this->setValue(V); }
465  OptionValue<cl::boolOrDefault> &operator=(const cl::boolOrDefault &V) {
466    setValue(V);
467    return *this;
468  }
469
470private:
471  void anchor() override;
472};
473
474template <>
475struct OptionValue<std::string> final : OptionValueCopy<std::string> {
476  typedef StringRef WrapperType;
477
478  OptionValue() {}
479
480  OptionValue(const std::string &V) { this->setValue(V); }
481  OptionValue<std::string> &operator=(const std::string &V) {
482    setValue(V);
483    return *this;
484  }
485
486private:
487  void anchor() override;
488};
489
490//===----------------------------------------------------------------------===//
491// Enum valued command line option
492//
493#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, int(ENUMVAL), DESC
494#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, int(ENUMVAL), DESC
495#define clEnumValEnd (reinterpret_cast<void *>(0))
496
497// values - For custom data types, allow specifying a group of values together
498// as the values that go into the mapping that the option handler uses.  Note
499// that the values list must always have a 0 at the end of the list to indicate
500// that the list has ended.
501//
502template <class DataType> class ValuesClass {
503  // Use a vector instead of a map, because the lists should be short,
504  // the overhead is less, and most importantly, it keeps them in the order
505  // inserted so we can print our option out nicely.
506  SmallVector<std::pair<const char *, std::pair<int, const char *>>, 4> Values;
507  void processValues(va_list Vals);
508
509public:
510  ValuesClass(const char *EnumName, DataType Val, const char *Desc,
511              va_list ValueArgs) {
512    // Insert the first value, which is required.
513    Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
514
515    // Process the varargs portion of the values...
516    while (const char *enumName = va_arg(ValueArgs, const char *)) {
517      DataType EnumVal = static_cast<DataType>(va_arg(ValueArgs, int));
518      const char *EnumDesc = va_arg(ValueArgs, const char *);
519      Values.push_back(std::make_pair(enumName, // Add value to value map
520                                      std::make_pair(EnumVal, EnumDesc)));
521    }
522  }
523
524  template <class Opt> void apply(Opt &O) const {
525    for (size_t i = 0, e = Values.size(); i != e; ++i)
526      O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
527                                     Values[i].second.second);
528  }
529};
530
531template <class DataType>
532ValuesClass<DataType> LLVM_END_WITH_NULL
533values(const char *Arg, DataType Val, const char *Desc, ...) {
534  va_list ValueArgs;
535  va_start(ValueArgs, Desc);
536  ValuesClass<DataType> Vals(Arg, Val, Desc, ValueArgs);
537  va_end(ValueArgs);
538  return Vals;
539}
540
541//===----------------------------------------------------------------------===//
542// parser class - Parameterizable parser for different data types.  By default,
543// known data types (string, int, bool) have specialized parsers, that do what
544// you would expect.  The default parser, used for data types that are not
545// built-in, uses a mapping table to map specific options to values, which is
546// used, among other things, to handle enum types.
547
548//--------------------------------------------------
549// generic_parser_base - This class holds all the non-generic code that we do
550// not need replicated for every instance of the generic parser.  This also
551// allows us to put stuff into CommandLine.cpp
552//
553class generic_parser_base {
554protected:
555  class GenericOptionInfo {
556  public:
557    GenericOptionInfo(const char *name, const char *helpStr)
558        : Name(name), HelpStr(helpStr) {}
559    const char *Name;
560    const char *HelpStr;
561  };
562
563public:
564  generic_parser_base(Option &O) : Owner(O) {}
565
566  virtual ~generic_parser_base() {} // Base class should have virtual-dtor
567
568  // getNumOptions - Virtual function implemented by generic subclass to
569  // indicate how many entries are in Values.
570  //
571  virtual unsigned getNumOptions() const = 0;
572
573  // getOption - Return option name N.
574  virtual const char *getOption(unsigned N) const = 0;
575
576  // getDescription - Return description N
577  virtual const char *getDescription(unsigned N) const = 0;
578
579  // Return the width of the option tag for printing...
580  virtual size_t getOptionWidth(const Option &O) const;
581
582  virtual const GenericOptionValue &getOptionValue(unsigned N) const = 0;
583
584  // printOptionInfo - Print out information about this option.  The
585  // to-be-maintained width is specified.
586  //
587  virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const;
588
589  void printGenericOptionDiff(const Option &O, const GenericOptionValue &V,
590                              const GenericOptionValue &Default,
591                              size_t GlobalWidth) const;
592
593  // printOptionDiff - print the value of an option and it's default.
594  //
595  // Template definition ensures that the option and default have the same
596  // DataType (via the same AnyOptionValue).
597  template <class AnyOptionValue>
598  void printOptionDiff(const Option &O, const AnyOptionValue &V,
599                       const AnyOptionValue &Default,
600                       size_t GlobalWidth) const {
601    printGenericOptionDiff(O, V, Default, GlobalWidth);
602  }
603
604  void initialize() {}
605
606  void getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) {
607    // If there has been no argstr specified, that means that we need to add an
608    // argument for every possible option.  This ensures that our options are
609    // vectored to us.
610    if (!Owner.hasArgStr())
611      for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
612        OptionNames.push_back(getOption(i));
613  }
614
615  enum ValueExpected getValueExpectedFlagDefault() const {
616    // If there is an ArgStr specified, then we are of the form:
617    //
618    //    -opt=O2   or   -opt O2  or  -optO2
619    //
620    // In which case, the value is required.  Otherwise if an arg str has not
621    // been specified, we are of the form:
622    //
623    //    -O2 or O2 or -la (where -l and -a are separate options)
624    //
625    // If this is the case, we cannot allow a value.
626    //
627    if (Owner.hasArgStr())
628      return ValueRequired;
629    else
630      return ValueDisallowed;
631  }
632
633  // findOption - Return the option number corresponding to the specified
634  // argument string.  If the option is not found, getNumOptions() is returned.
635  //
636  unsigned findOption(const char *Name);
637
638protected:
639  Option &Owner;
640};
641
642// Default parser implementation - This implementation depends on having a
643// mapping of recognized options to values of some sort.  In addition to this,
644// each entry in the mapping also tracks a help message that is printed with the
645// command line option for -help.  Because this is a simple mapping parser, the
646// data type can be any unsupported type.
647//
648template <class DataType> class parser : public generic_parser_base {
649protected:
650  class OptionInfo : public GenericOptionInfo {
651  public:
652    OptionInfo(const char *name, DataType v, const char *helpStr)
653        : GenericOptionInfo(name, helpStr), V(v) {}
654    OptionValue<DataType> V;
655  };
656  SmallVector<OptionInfo, 8> Values;
657
658public:
659  parser(Option &O) : generic_parser_base(O) {}
660  typedef DataType parser_data_type;
661
662  // Implement virtual functions needed by generic_parser_base
663  unsigned getNumOptions() const override { return unsigned(Values.size()); }
664  const char *getOption(unsigned N) const override { return Values[N].Name; }
665  const char *getDescription(unsigned N) const override {
666    return Values[N].HelpStr;
667  }
668
669  // getOptionValue - Return the value of option name N.
670  const GenericOptionValue &getOptionValue(unsigned N) const override {
671    return Values[N].V;
672  }
673
674  // parse - Return true on error.
675  bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
676    StringRef ArgVal;
677    if (Owner.hasArgStr())
678      ArgVal = Arg;
679    else
680      ArgVal = ArgName;
681
682    for (size_t i = 0, e = Values.size(); i != e; ++i)
683      if (Values[i].Name == ArgVal) {
684        V = Values[i].V.getValue();
685        return false;
686      }
687
688    return O.error("Cannot find option named '" + ArgVal + "'!");
689  }
690
691  /// addLiteralOption - Add an entry to the mapping table.
692  ///
693  template <class DT>
694  void addLiteralOption(const char *Name, const DT &V, const char *HelpStr) {
695    assert(findOption(Name) == Values.size() && "Option already exists!");
696    OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
697    Values.push_back(X);
698    AddLiteralOption(Owner, Name);
699  }
700
701  /// removeLiteralOption - Remove the specified option.
702  ///
703  void removeLiteralOption(const char *Name) {
704    unsigned N = findOption(Name);
705    assert(N != Values.size() && "Option not found!");
706    Values.erase(Values.begin() + N);
707  }
708};
709
710//--------------------------------------------------
711// basic_parser - Super class of parsers to provide boilerplate code
712//
713class basic_parser_impl { // non-template implementation of basic_parser<t>
714public:
715  basic_parser_impl(Option &O) {}
716
717
718  enum ValueExpected getValueExpectedFlagDefault() const {
719    return ValueRequired;
720  }
721
722  void getExtraOptionNames(SmallVectorImpl<const char *> &) {}
723
724  void initialize() {}
725
726  // Return the width of the option tag for printing...
727  size_t getOptionWidth(const Option &O) const;
728
729  // printOptionInfo - Print out information about this option.  The
730  // to-be-maintained width is specified.
731  //
732  void printOptionInfo(const Option &O, size_t GlobalWidth) const;
733
734  // printOptionNoValue - Print a placeholder for options that don't yet support
735  // printOptionDiff().
736  void printOptionNoValue(const Option &O, size_t GlobalWidth) const;
737
738  // getValueName - Overload in subclass to provide a better default value.
739  virtual const char *getValueName() const { return "value"; }
740
741  // An out-of-line virtual method to provide a 'home' for this class.
742  virtual void anchor();
743
744protected:
745  ~basic_parser_impl() = default;
746  // A helper for basic_parser::printOptionDiff.
747  void printOptionName(const Option &O, size_t GlobalWidth) const;
748};
749
750// basic_parser - The real basic parser is just a template wrapper that provides
751// a typedef for the provided data type.
752//
753template <class DataType> class basic_parser : public basic_parser_impl {
754public:
755  basic_parser(Option &O) : basic_parser_impl(O) {}
756  typedef DataType parser_data_type;
757  typedef OptionValue<DataType> OptVal;
758
759protected:
760  // Workaround Clang PR22793
761  ~basic_parser() {}
762};
763
764//--------------------------------------------------
765// parser<bool>
766//
767template <> class parser<bool> final : public basic_parser<bool> {
768public:
769  parser(Option &O) : basic_parser(O) {}
770
771  // parse - Return true on error.
772  bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
773
774  void initialize() {}
775
776  enum ValueExpected getValueExpectedFlagDefault() const {
777    return ValueOptional;
778  }
779
780  // getValueName - Do not print =<value> at all.
781  const char *getValueName() const override { return nullptr; }
782
783  void printOptionDiff(const Option &O, bool V, OptVal Default,
784                       size_t GlobalWidth) const;
785
786  // An out-of-line virtual method to provide a 'home' for this class.
787  void anchor() override;
788};
789
790EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<bool>);
791
792//--------------------------------------------------
793// parser<boolOrDefault>
794template <>
795class parser<boolOrDefault> final : public basic_parser<boolOrDefault> {
796public:
797  parser(Option &O) : basic_parser(O) {}
798
799  // parse - Return true on error.
800  bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
801
802  enum ValueExpected getValueExpectedFlagDefault() const {
803    return ValueOptional;
804  }
805
806  // getValueName - Do not print =<value> at all.
807  const char *getValueName() const override { return nullptr; }
808
809  void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default,
810                       size_t GlobalWidth) const;
811
812  // An out-of-line virtual method to provide a 'home' for this class.
813  void anchor() override;
814};
815
816EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>);
817
818//--------------------------------------------------
819// parser<int>
820//
821template <> class parser<int> final : public basic_parser<int> {
822public:
823  parser(Option &O) : basic_parser(O) {}
824
825  // parse - Return true on error.
826  bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
827
828  // getValueName - Overload in subclass to provide a better default value.
829  const char *getValueName() const override { return "int"; }
830
831  void printOptionDiff(const Option &O, int V, OptVal Default,
832                       size_t GlobalWidth) const;
833
834  // An out-of-line virtual method to provide a 'home' for this class.
835  void anchor() override;
836};
837
838EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<int>);
839
840//--------------------------------------------------
841// parser<unsigned>
842//
843template <> class parser<unsigned> final : public basic_parser<unsigned> {
844public:
845  parser(Option &O) : basic_parser(O) {}
846
847  // parse - Return true on error.
848  bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
849
850  // getValueName - Overload in subclass to provide a better default value.
851  const char *getValueName() const override { return "uint"; }
852
853  void printOptionDiff(const Option &O, unsigned V, OptVal Default,
854                       size_t GlobalWidth) const;
855
856  // An out-of-line virtual method to provide a 'home' for this class.
857  void anchor() override;
858};
859
860EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned>);
861
862//--------------------------------------------------
863// parser<unsigned long long>
864//
865template <>
866class parser<unsigned long long> final
867    : public basic_parser<unsigned long long> {
868public:
869  parser(Option &O) : basic_parser(O) {}
870
871  // parse - Return true on error.
872  bool parse(Option &O, StringRef ArgName, StringRef Arg,
873             unsigned long long &Val);
874
875  // getValueName - Overload in subclass to provide a better default value.
876  const char *getValueName() const override { return "uint"; }
877
878  void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
879                       size_t GlobalWidth) const;
880
881  // An out-of-line virtual method to provide a 'home' for this class.
882  void anchor() override;
883};
884
885EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>);
886
887//--------------------------------------------------
888// parser<double>
889//
890template <> class parser<double> final : public basic_parser<double> {
891public:
892  parser(Option &O) : basic_parser(O) {}
893
894  // parse - Return true on error.
895  bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
896
897  // getValueName - Overload in subclass to provide a better default value.
898  const char *getValueName() const override { return "number"; }
899
900  void printOptionDiff(const Option &O, double V, OptVal Default,
901                       size_t GlobalWidth) const;
902
903  // An out-of-line virtual method to provide a 'home' for this class.
904  void anchor() override;
905};
906
907EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<double>);
908
909//--------------------------------------------------
910// parser<float>
911//
912template <> class parser<float> final : public basic_parser<float> {
913public:
914  parser(Option &O) : basic_parser(O) {}
915
916  // parse - Return true on error.
917  bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
918
919  // getValueName - Overload in subclass to provide a better default value.
920  const char *getValueName() const override { return "number"; }
921
922  void printOptionDiff(const Option &O, float V, OptVal Default,
923                       size_t GlobalWidth) const;
924
925  // An out-of-line virtual method to provide a 'home' for this class.
926  void anchor() override;
927};
928
929EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<float>);
930
931//--------------------------------------------------
932// parser<std::string>
933//
934template <> class parser<std::string> final : public basic_parser<std::string> {
935public:
936  parser(Option &O) : basic_parser(O) {}
937
938  // parse - Return true on error.
939  bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
940    Value = Arg.str();
941    return false;
942  }
943
944  // getValueName - Overload in subclass to provide a better default value.
945  const char *getValueName() const override { return "string"; }
946
947  void printOptionDiff(const Option &O, StringRef V, OptVal Default,
948                       size_t GlobalWidth) const;
949
950  // An out-of-line virtual method to provide a 'home' for this class.
951  void anchor() override;
952};
953
954EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<std::string>);
955
956//--------------------------------------------------
957// parser<char>
958//
959template <> class parser<char> final : public basic_parser<char> {
960public:
961  parser(Option &O) : basic_parser(O) {}
962
963  // parse - Return true on error.
964  bool parse(Option &, StringRef, StringRef Arg, char &Value) {
965    Value = Arg[0];
966    return false;
967  }
968
969  // getValueName - Overload in subclass to provide a better default value.
970  const char *getValueName() const override { return "char"; }
971
972  void printOptionDiff(const Option &O, char V, OptVal Default,
973                       size_t GlobalWidth) const;
974
975  // An out-of-line virtual method to provide a 'home' for this class.
976  void anchor() override;
977};
978
979EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<char>);
980
981//--------------------------------------------------
982// PrintOptionDiff
983//
984// This collection of wrappers is the intermediary between class opt and class
985// parser to handle all the template nastiness.
986
987// This overloaded function is selected by the generic parser.
988template <class ParserClass, class DT>
989void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,
990                     const OptionValue<DT> &Default, size_t GlobalWidth) {
991  OptionValue<DT> OV = V;
992  P.printOptionDiff(O, OV, Default, GlobalWidth);
993}
994
995// This is instantiated for basic parsers when the parsed value has a different
996// type than the option value. e.g. HelpPrinter.
997template <class ParserDT, class ValDT> struct OptionDiffPrinter {
998  void print(const Option &O, const parser<ParserDT> &P, const ValDT & /*V*/,
999             const OptionValue<ValDT> & /*Default*/, size_t GlobalWidth) {
1000    P.printOptionNoValue(O, GlobalWidth);
1001  }
1002};
1003
1004// This is instantiated for basic parsers when the parsed value has the same
1005// type as the option value.
1006template <class DT> struct OptionDiffPrinter<DT, DT> {
1007  void print(const Option &O, const parser<DT> &P, const DT &V,
1008             const OptionValue<DT> &Default, size_t GlobalWidth) {
1009    P.printOptionDiff(O, V, Default, GlobalWidth);
1010  }
1011};
1012
1013// This overloaded function is selected by the basic parser, which may parse a
1014// different type than the option type.
1015template <class ParserClass, class ValDT>
1016void printOptionDiff(
1017    const Option &O,
1018    const basic_parser<typename ParserClass::parser_data_type> &P,
1019    const ValDT &V, const OptionValue<ValDT> &Default, size_t GlobalWidth) {
1020
1021  OptionDiffPrinter<typename ParserClass::parser_data_type, ValDT> printer;
1022  printer.print(O, static_cast<const ParserClass &>(P), V, Default,
1023                GlobalWidth);
1024}
1025
1026//===----------------------------------------------------------------------===//
1027// applicator class - This class is used because we must use partial
1028// specialization to handle literal string arguments specially (const char* does
1029// not correctly respond to the apply method).  Because the syntax to use this
1030// is a pain, we have the 'apply' method below to handle the nastiness...
1031//
1032template <class Mod> struct applicator {
1033  template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
1034};
1035
1036// Handle const char* as a special case...
1037template <unsigned n> struct applicator<char[n]> {
1038  template <class Opt> static void opt(const char *Str, Opt &O) {
1039    O.setArgStr(Str);
1040  }
1041};
1042template <unsigned n> struct applicator<const char[n]> {
1043  template <class Opt> static void opt(const char *Str, Opt &O) {
1044    O.setArgStr(Str);
1045  }
1046};
1047template <> struct applicator<const char *> {
1048  template <class Opt> static void opt(const char *Str, Opt &O) {
1049    O.setArgStr(Str);
1050  }
1051};
1052
1053template <> struct applicator<NumOccurrencesFlag> {
1054  static void opt(NumOccurrencesFlag N, Option &O) {
1055    O.setNumOccurrencesFlag(N);
1056  }
1057};
1058template <> struct applicator<ValueExpected> {
1059  static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
1060};
1061template <> struct applicator<OptionHidden> {
1062  static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
1063};
1064template <> struct applicator<FormattingFlags> {
1065  static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
1066};
1067template <> struct applicator<MiscFlags> {
1068  static void opt(MiscFlags MF, Option &O) { O.setMiscFlag(MF); }
1069};
1070
1071// apply method - Apply modifiers to an option in a type safe way.
1072template <class Opt, class Mod, class... Mods>
1073void apply(Opt *O, const Mod &M, const Mods &... Ms) {
1074  applicator<Mod>::opt(M, *O);
1075  apply(O, Ms...);
1076}
1077
1078template <class Opt, class Mod> void apply(Opt *O, const Mod &M) {
1079  applicator<Mod>::opt(M, *O);
1080}
1081
1082//===----------------------------------------------------------------------===//
1083// opt_storage class
1084
1085// Default storage class definition: external storage.  This implementation
1086// assumes the user will specify a variable to store the data into with the
1087// cl::location(x) modifier.
1088//
1089template <class DataType, bool ExternalStorage, bool isClass>
1090class opt_storage {
1091  DataType *Location; // Where to store the object...
1092  OptionValue<DataType> Default;
1093
1094  void check_location() const {
1095    assert(Location && "cl::location(...) not specified for a command "
1096                       "line option with external storage, "
1097                       "or cl::init specified before cl::location()!!");
1098  }
1099
1100public:
1101  opt_storage() : Location(nullptr) {}
1102
1103  bool setLocation(Option &O, DataType &L) {
1104    if (Location)
1105      return O.error("cl::location(x) specified more than once!");
1106    Location = &L;
1107    Default = L;
1108    return false;
1109  }
1110
1111  template <class T> void setValue(const T &V, bool initial = false) {
1112    check_location();
1113    *Location = V;
1114    if (initial)
1115      Default = V;
1116  }
1117
1118  DataType &getValue() {
1119    check_location();
1120    return *Location;
1121  }
1122  const DataType &getValue() const {
1123    check_location();
1124    return *Location;
1125  }
1126
1127  operator DataType() const { return this->getValue(); }
1128
1129  const OptionValue<DataType> &getDefault() const { return Default; }
1130};
1131
1132// Define how to hold a class type object, such as a string.  Since we can
1133// inherit from a class, we do so.  This makes us exactly compatible with the
1134// object in all cases that it is used.
1135//
1136template <class DataType>
1137class opt_storage<DataType, false, true> : public DataType {
1138public:
1139  OptionValue<DataType> Default;
1140
1141  template <class T> void setValue(const T &V, bool initial = false) {
1142    DataType::operator=(V);
1143    if (initial)
1144      Default = V;
1145  }
1146
1147  DataType &getValue() { return *this; }
1148  const DataType &getValue() const { return *this; }
1149
1150  const OptionValue<DataType> &getDefault() const { return Default; }
1151};
1152
1153// Define a partial specialization to handle things we cannot inherit from.  In
1154// this case, we store an instance through containment, and overload operators
1155// to get at the value.
1156//
1157template <class DataType> class opt_storage<DataType, false, false> {
1158public:
1159  DataType Value;
1160  OptionValue<DataType> Default;
1161
1162  // Make sure we initialize the value with the default constructor for the
1163  // type.
1164  opt_storage() : Value(DataType()), Default(DataType()) {}
1165
1166  template <class T> void setValue(const T &V, bool initial = false) {
1167    Value = V;
1168    if (initial)
1169      Default = V;
1170  }
1171  DataType &getValue() { return Value; }
1172  DataType getValue() const { return Value; }
1173
1174  const OptionValue<DataType> &getDefault() const { return Default; }
1175
1176  operator DataType() const { return getValue(); }
1177
1178  // If the datatype is a pointer, support -> on it.
1179  DataType operator->() const { return Value; }
1180};
1181
1182//===----------------------------------------------------------------------===//
1183// opt - A scalar command line option.
1184//
1185template <class DataType, bool ExternalStorage = false,
1186          class ParserClass = parser<DataType>>
1187class opt : public Option,
1188            public opt_storage<DataType, ExternalStorage,
1189                               std::is_class<DataType>::value> {
1190  ParserClass Parser;
1191
1192  bool handleOccurrence(unsigned pos, StringRef ArgName,
1193                        StringRef Arg) override {
1194    typename ParserClass::parser_data_type Val =
1195        typename ParserClass::parser_data_type();
1196    if (Parser.parse(*this, ArgName, Arg, Val))
1197      return true; // Parse error!
1198    this->setValue(Val);
1199    this->setPosition(pos);
1200    return false;
1201  }
1202
1203  enum ValueExpected getValueExpectedFlagDefault() const override {
1204    return Parser.getValueExpectedFlagDefault();
1205  }
1206  void
1207  getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
1208    return Parser.getExtraOptionNames(OptionNames);
1209  }
1210
1211  // Forward printing stuff to the parser...
1212  size_t getOptionWidth() const override {
1213    return Parser.getOptionWidth(*this);
1214  }
1215  void printOptionInfo(size_t GlobalWidth) const override {
1216    Parser.printOptionInfo(*this, GlobalWidth);
1217  }
1218
1219  void printOptionValue(size_t GlobalWidth, bool Force) const override {
1220    if (Force || this->getDefault().compare(this->getValue())) {
1221      cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
1222                                       this->getDefault(), GlobalWidth);
1223    }
1224  }
1225
1226  void done() {
1227    addArgument();
1228    Parser.initialize();
1229  }
1230
1231  // Command line options should not be copyable
1232  opt(const opt &) = delete;
1233  opt &operator=(const opt &) = delete;
1234
1235public:
1236  // setInitialValue - Used by the cl::init modifier...
1237  void setInitialValue(const DataType &V) { this->setValue(V, true); }
1238
1239  ParserClass &getParser() { return Parser; }
1240
1241  template <class T> DataType &operator=(const T &Val) {
1242    this->setValue(Val);
1243    return this->getValue();
1244  }
1245
1246  template <class... Mods>
1247  explicit opt(const Mods &... Ms)
1248      : Option(Optional, NotHidden), Parser(*this) {
1249    apply(this, Ms...);
1250    done();
1251  }
1252};
1253
1254EXTERN_TEMPLATE_INSTANTIATION(class opt<unsigned>);
1255EXTERN_TEMPLATE_INSTANTIATION(class opt<int>);
1256EXTERN_TEMPLATE_INSTANTIATION(class opt<std::string>);
1257EXTERN_TEMPLATE_INSTANTIATION(class opt<char>);
1258EXTERN_TEMPLATE_INSTANTIATION(class opt<bool>);
1259
1260//===----------------------------------------------------------------------===//
1261// list_storage class
1262
1263// Default storage class definition: external storage.  This implementation
1264// assumes the user will specify a variable to store the data into with the
1265// cl::location(x) modifier.
1266//
1267template <class DataType, class StorageClass> class list_storage {
1268  StorageClass *Location; // Where to store the object...
1269
1270public:
1271  list_storage() : Location(0) {}
1272
1273  bool setLocation(Option &O, StorageClass &L) {
1274    if (Location)
1275      return O.error("cl::location(x) specified more than once!");
1276    Location = &L;
1277    return false;
1278  }
1279
1280  template <class T> void addValue(const T &V) {
1281    assert(Location != 0 && "cl::location(...) not specified for a command "
1282                            "line option with external storage!");
1283    Location->push_back(V);
1284  }
1285};
1286
1287// Define how to hold a class type object, such as a string.  Since we can
1288// inherit from a class, we do so.  This makes us exactly compatible with the
1289// object in all cases that it is used.
1290//
1291template <class DataType>
1292class list_storage<DataType, bool> : public std::vector<DataType> {
1293public:
1294  template <class T> void addValue(const T &V) {
1295    std::vector<DataType>::push_back(V);
1296  }
1297};
1298
1299//===----------------------------------------------------------------------===//
1300// list - A list of command line options.
1301//
1302template <class DataType, class Storage = bool,
1303          class ParserClass = parser<DataType>>
1304class list : public Option, public list_storage<DataType, Storage> {
1305  std::vector<unsigned> Positions;
1306  ParserClass Parser;
1307
1308  enum ValueExpected getValueExpectedFlagDefault() const override {
1309    return Parser.getValueExpectedFlagDefault();
1310  }
1311  void
1312  getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
1313    return Parser.getExtraOptionNames(OptionNames);
1314  }
1315
1316  bool handleOccurrence(unsigned pos, StringRef ArgName,
1317                        StringRef Arg) override {
1318    typename ParserClass::parser_data_type Val =
1319        typename ParserClass::parser_data_type();
1320    if (Parser.parse(*this, ArgName, Arg, Val))
1321      return true; // Parse Error!
1322    list_storage<DataType, Storage>::addValue(Val);
1323    setPosition(pos);
1324    Positions.push_back(pos);
1325    return false;
1326  }
1327
1328  // Forward printing stuff to the parser...
1329  size_t getOptionWidth() const override {
1330    return Parser.getOptionWidth(*this);
1331  }
1332  void printOptionInfo(size_t GlobalWidth) const override {
1333    Parser.printOptionInfo(*this, GlobalWidth);
1334  }
1335
1336  // Unimplemented: list options don't currently store their default value.
1337  void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1338  }
1339
1340  void done() {
1341    addArgument();
1342    Parser.initialize();
1343  }
1344
1345  // Command line options should not be copyable
1346  list(const list &) = delete;
1347  list &operator=(const list &) = delete;
1348
1349public:
1350  ParserClass &getParser() { return Parser; }
1351
1352  unsigned getPosition(unsigned optnum) const {
1353    assert(optnum < this->size() && "Invalid option index");
1354    return Positions[optnum];
1355  }
1356
1357  void setNumAdditionalVals(unsigned n) { Option::setNumAdditionalVals(n); }
1358
1359  template <class... Mods>
1360  explicit list(const Mods &... Ms)
1361      : Option(ZeroOrMore, NotHidden), Parser(*this) {
1362    apply(this, Ms...);
1363    done();
1364  }
1365};
1366
1367// multi_val - Modifier to set the number of additional values.
1368struct multi_val {
1369  unsigned AdditionalVals;
1370  explicit multi_val(unsigned N) : AdditionalVals(N) {}
1371
1372  template <typename D, typename S, typename P>
1373  void apply(list<D, S, P> &L) const {
1374    L.setNumAdditionalVals(AdditionalVals);
1375  }
1376};
1377
1378//===----------------------------------------------------------------------===//
1379// bits_storage class
1380
1381// Default storage class definition: external storage.  This implementation
1382// assumes the user will specify a variable to store the data into with the
1383// cl::location(x) modifier.
1384//
1385template <class DataType, class StorageClass> class bits_storage {
1386  unsigned *Location; // Where to store the bits...
1387
1388  template <class T> static unsigned Bit(const T &V) {
1389    unsigned BitPos = reinterpret_cast<unsigned>(V);
1390    assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1391           "enum exceeds width of bit vector!");
1392    return 1 << BitPos;
1393  }
1394
1395public:
1396  bits_storage() : Location(nullptr) {}
1397
1398  bool setLocation(Option &O, unsigned &L) {
1399    if (Location)
1400      return O.error("cl::location(x) specified more than once!");
1401    Location = &L;
1402    return false;
1403  }
1404
1405  template <class T> void addValue(const T &V) {
1406    assert(Location != 0 && "cl::location(...) not specified for a command "
1407                            "line option with external storage!");
1408    *Location |= Bit(V);
1409  }
1410
1411  unsigned getBits() { return *Location; }
1412
1413  template <class T> bool isSet(const T &V) {
1414    return (*Location & Bit(V)) != 0;
1415  }
1416};
1417
1418// Define how to hold bits.  Since we can inherit from a class, we do so.
1419// This makes us exactly compatible with the bits in all cases that it is used.
1420//
1421template <class DataType> class bits_storage<DataType, bool> {
1422  unsigned Bits; // Where to store the bits...
1423
1424  template <class T> static unsigned Bit(const T &V) {
1425    unsigned BitPos = (unsigned)V;
1426    assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1427           "enum exceeds width of bit vector!");
1428    return 1 << BitPos;
1429  }
1430
1431public:
1432  template <class T> void addValue(const T &V) { Bits |= Bit(V); }
1433
1434  unsigned getBits() { return Bits; }
1435
1436  template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
1437};
1438
1439//===----------------------------------------------------------------------===//
1440// bits - A bit vector of command options.
1441//
1442template <class DataType, class Storage = bool,
1443          class ParserClass = parser<DataType>>
1444class bits : public Option, public bits_storage<DataType, Storage> {
1445  std::vector<unsigned> Positions;
1446  ParserClass Parser;
1447
1448  enum ValueExpected getValueExpectedFlagDefault() const override {
1449    return Parser.getValueExpectedFlagDefault();
1450  }
1451  void
1452  getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
1453    return Parser.getExtraOptionNames(OptionNames);
1454  }
1455
1456  bool handleOccurrence(unsigned pos, StringRef ArgName,
1457                        StringRef Arg) override {
1458    typename ParserClass::parser_data_type Val =
1459        typename ParserClass::parser_data_type();
1460    if (Parser.parse(*this, ArgName, Arg, Val))
1461      return true; // Parse Error!
1462    this->addValue(Val);
1463    setPosition(pos);
1464    Positions.push_back(pos);
1465    return false;
1466  }
1467
1468  // Forward printing stuff to the parser...
1469  size_t getOptionWidth() const override {
1470    return Parser.getOptionWidth(*this);
1471  }
1472  void printOptionInfo(size_t GlobalWidth) const override {
1473    Parser.printOptionInfo(*this, GlobalWidth);
1474  }
1475
1476  // Unimplemented: bits options don't currently store their default values.
1477  void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1478  }
1479
1480  void done() {
1481    addArgument();
1482    Parser.initialize();
1483  }
1484
1485  // Command line options should not be copyable
1486  bits(const bits &) = delete;
1487  bits &operator=(const bits &) = delete;
1488
1489public:
1490  ParserClass &getParser() { return Parser; }
1491
1492  unsigned getPosition(unsigned optnum) const {
1493    assert(optnum < this->size() && "Invalid option index");
1494    return Positions[optnum];
1495  }
1496
1497  template <class... Mods>
1498  explicit bits(const Mods &... Ms)
1499      : Option(ZeroOrMore, NotHidden), Parser(*this) {
1500    apply(this, Ms...);
1501    done();
1502  }
1503};
1504
1505//===----------------------------------------------------------------------===//
1506// Aliased command line option (alias this name to a preexisting name)
1507//
1508
1509class alias : public Option {
1510  Option *AliasFor;
1511  bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
1512                        StringRef Arg) override {
1513    return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
1514  }
1515  bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
1516                     bool MultiArg = false) override {
1517    return AliasFor->addOccurrence(pos, AliasFor->ArgStr, Value, MultiArg);
1518  }
1519  // Handle printing stuff...
1520  size_t getOptionWidth() const override;
1521  void printOptionInfo(size_t GlobalWidth) const override;
1522
1523  // Aliases do not need to print their values.
1524  void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1525  }
1526
1527  ValueExpected getValueExpectedFlagDefault() const override {
1528    return AliasFor->getValueExpectedFlag();
1529  }
1530
1531  void done() {
1532    if (!hasArgStr())
1533      error("cl::alias must have argument name specified!");
1534    if (!AliasFor)
1535      error("cl::alias must have an cl::aliasopt(option) specified!");
1536    addArgument();
1537  }
1538
1539  // Command line options should not be copyable
1540  alias(const alias &) = delete;
1541  alias &operator=(const alias &) = delete;
1542
1543public:
1544  void setAliasFor(Option &O) {
1545    if (AliasFor)
1546      error("cl::alias must only have one cl::aliasopt(...) specified!");
1547    AliasFor = &O;
1548  }
1549
1550  template <class... Mods>
1551  explicit alias(const Mods &... Ms)
1552      : Option(Optional, Hidden), AliasFor(nullptr) {
1553    apply(this, Ms...);
1554    done();
1555  }
1556};
1557
1558// aliasfor - Modifier to set the option an alias aliases.
1559struct aliasopt {
1560  Option &Opt;
1561  explicit aliasopt(Option &O) : Opt(O) {}
1562  void apply(alias &A) const { A.setAliasFor(Opt); }
1563};
1564
1565// extrahelp - provide additional help at the end of the normal help
1566// output. All occurrences of cl::extrahelp will be accumulated and
1567// printed to stderr at the end of the regular help, just before
1568// exit is called.
1569struct extrahelp {
1570  const char *morehelp;
1571  explicit extrahelp(const char *help);
1572};
1573
1574void PrintVersionMessage();
1575
1576/// This function just prints the help message, exactly the same way as if the
1577/// -help or -help-hidden option had been given on the command line.
1578///
1579/// NOTE: THIS FUNCTION TERMINATES THE PROGRAM!
1580///
1581/// \param Hidden if true will print hidden options
1582/// \param Categorized if true print options in categories
1583void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
1584
1585//===----------------------------------------------------------------------===//
1586// Public interface for accessing registered options.
1587//
1588
1589/// \brief Use this to get a StringMap to all registered named options
1590/// (e.g. -help). Note \p Map Should be an empty StringMap.
1591///
1592/// \return A reference to the StringMap used by the cl APIs to parse options.
1593///
1594/// Access to unnamed arguments (i.e. positional) are not provided because
1595/// it is expected that the client already has access to these.
1596///
1597/// Typical usage:
1598/// \code
1599/// main(int argc,char* argv[]) {
1600/// StringMap<llvm::cl::Option*> &opts = llvm::cl::getRegisteredOptions();
1601/// assert(opts.count("help") == 1)
1602/// opts["help"]->setDescription("Show alphabetical help information")
1603/// // More code
1604/// llvm::cl::ParseCommandLineOptions(argc,argv);
1605/// //More code
1606/// }
1607/// \endcode
1608///
1609/// This interface is useful for modifying options in libraries that are out of
1610/// the control of the client. The options should be modified before calling
1611/// llvm::cl::ParseCommandLineOptions().
1612///
1613/// Hopefully this API can be depricated soon. Any situation where options need
1614/// to be modified by tools or libraries should be handled by sane APIs rather
1615/// than just handing around a global list.
1616StringMap<Option *> &getRegisteredOptions();
1617
1618//===----------------------------------------------------------------------===//
1619// Standalone command line processing utilities.
1620//
1621
1622/// \brief Saves strings in the inheritor's stable storage and returns a stable
1623/// raw character pointer.
1624class StringSaver {
1625  virtual void anchor();
1626
1627public:
1628  virtual const char *SaveString(const char *Str) = 0;
1629  virtual ~StringSaver(){}; // Pacify -Wnon-virtual-dtor.
1630};
1631
1632/// \brief Tokenizes a command line that can contain escapes and quotes.
1633//
1634/// The quoting rules match those used by GCC and other tools that use
1635/// libiberty's buildargv() or expandargv() utilities, and do not match bash.
1636/// They differ from buildargv() on treatment of backslashes that do not escape
1637/// a special character to make it possible to accept most Windows file paths.
1638///
1639/// \param [in] Source The string to be split on whitespace with quotes.
1640/// \param [in] Saver Delegates back to the caller for saving parsed strings.
1641/// \param [in] MarkEOLs true if tokenizing a response file and you want end of
1642/// lines and end of the response file to be marked with a nullptr string.
1643/// \param [out] NewArgv All parsed strings are appended to NewArgv.
1644void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
1645                            SmallVectorImpl<const char *> &NewArgv,
1646                            bool MarkEOLs = false);
1647
1648/// \brief Tokenizes a Windows command line which may contain quotes and escaped
1649/// quotes.
1650///
1651/// See MSDN docs for CommandLineToArgvW for information on the quoting rules.
1652/// http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx
1653///
1654/// \param [in] Source The string to be split on whitespace with quotes.
1655/// \param [in] Saver Delegates back to the caller for saving parsed strings.
1656/// \param [in] MarkEOLs true if tokenizing a response file and you want end of
1657/// lines and end of the response file to be marked with a nullptr string.
1658/// \param [out] NewArgv All parsed strings are appended to NewArgv.
1659void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
1660                                SmallVectorImpl<const char *> &NewArgv,
1661                                bool MarkEOLs = false);
1662
1663/// \brief String tokenization function type.  Should be compatible with either
1664/// Windows or Unix command line tokenizers.
1665typedef void (*TokenizerCallback)(StringRef Source, StringSaver &Saver,
1666                                  SmallVectorImpl<const char *> &NewArgv,
1667                                  bool MarkEOLs);
1668
1669/// \brief Expand response files on a command line recursively using the given
1670/// StringSaver and tokenization strategy.  Argv should contain the command line
1671/// before expansion and will be modified in place. If requested, Argv will
1672/// also be populated with nullptrs indicating where each response file line
1673/// ends, which is useful for the "/link" argument that needs to consume all
1674/// remaining arguments only until the next end of line, when in a response
1675/// file.
1676///
1677/// \param [in] Saver Delegates back to the caller for saving parsed strings.
1678/// \param [in] Tokenizer Tokenization strategy. Typically Unix or Windows.
1679/// \param [in,out] Argv Command line into which to expand response files.
1680/// \param [in] MarkEOLs Mark end of lines and the end of the response file
1681/// with nullptrs in the Argv vector.
1682/// \return true if all @files were expanded successfully or there were none.
1683bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
1684                         SmallVectorImpl<const char *> &Argv,
1685                         bool MarkEOLs = false);
1686
1687/// \brief Mark all options not part of this category as cl::ReallyHidden.
1688///
1689/// \param Category the category of options to keep displaying
1690///
1691/// Some tools (like clang-format) like to be able to hide all options that are
1692/// not specific to the tool. This function allows a tool to specify a single
1693/// option category to display in the -help output.
1694void HideUnrelatedOptions(cl::OptionCategory &Category);
1695
1696/// \brief Mark all options not part of the categories as cl::ReallyHidden.
1697///
1698/// \param Categories the categories of options to keep displaying.
1699///
1700/// Some tools (like clang-format) like to be able to hide all options that are
1701/// not specific to the tool. This function allows a tool to specify a single
1702/// option category to display in the -help output.
1703void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories);
1704
1705} // End namespace cl
1706
1707} // End namespace llvm
1708
1709#endif
1710