include/llvm/Option/Option.h

   1 //===--- Option.h - Abstract Driver Options ---------------------*- 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 #ifndef LLVM_OPTION_OPTION_H
  11 #define LLVM_OPTION_OPTION_H
  12
  13 #include "llvm/ADT/SmallVector.h"
  14 #include "llvm/ADT/StringRef.h"
  15 #include "llvm/Option/OptTable.h"
  16 #include "llvm/Support/ErrorHandling.h"
  17
  18 namespace llvm {
  19 namespace opt {
  20 class Arg;
  21 class ArgList;
  22 /// ArgStringList - Type used for constructing argv lists for subprocesses.
  23 typedef SmallVector<const char*, 16> ArgStringList;
  24
  25 /// Base flags for all options. Custom flags may be added after.
  26 enum DriverFlag {
  27   HelpHidden       = (1 << 0),
  28   RenderAsInput    = (1 << 1),
  29   RenderJoined     = (1 << 2),
  30   RenderSeparate   = (1 << 3)
  31 };
  32
  33 /// Option - Abstract representation for a single form of driver
  34 /// argument.
  35 ///
  36 /// An Option class represents a form of option that the driver
  37 /// takes, for example how many arguments the option has and how
  38 /// they can be provided. Individual option instances store
  39 /// additional information about what group the option is a member
  40 /// of (if any), if the option is an alias, and a number of
  41 /// flags. At runtime the driver parses the command line into
  42 /// concrete Arg instances, each of which corresponds to a
  43 /// particular Option instance.
  44 class Option {
  45 public:
  46   enum OptionClass {
  47     GroupClass = 0,
  48     InputClass,
  49     UnknownClass,
  50     FlagClass,
  51     JoinedClass,
  52     SeparateClass,
  53     RemainingArgsClass,
  54     CommaJoinedClass,
  55     MultiArgClass,
  56     JoinedOrSeparateClass,
  57     JoinedAndSeparateClass
  58   };
  59
  60   enum RenderStyleKind {
  61     RenderCommaJoinedStyle,
  62     RenderJoinedStyle,
  63     RenderSeparateStyle,
  64     RenderValuesStyle
  65   };
  66
  67 protected:
  68   const OptTable::Info *Info;
  69   const OptTable *Owner;
  70
  71 public:
  72   Option(const OptTable::Info *Info, const OptTable *Owner);
  73   ~Option();
  74
  75   bool isValid() const {
  76     return Info != nullptr;
  77   }
  78
  79   unsigned getID() const {
  80     assert(Info && "Must have a valid info!");
  81     return Info->ID;
  82   }
  83
  84   OptionClass getKind() const {
  85     assert(Info && "Must have a valid info!");
  86     return OptionClass(Info->Kind);
  87   }
  88
  89   /// \brief Get the name of this option without any prefix.
  90   StringRef getName() const {
  91     assert(Info && "Must have a valid info!");
  92     return Info->Name;
  93   }
  94
  95   const Option getGroup() const {
  96     assert(Info && "Must have a valid info!");
  97     assert(Owner && "Must have a valid owner!");
  98     return Owner->getOption(Info->GroupID);
  99   }
 100
 101   const Option getAlias() const {
 102     assert(Info && "Must have a valid info!");
 103     assert(Owner && "Must have a valid owner!");
 104     return Owner->getOption(Info->AliasID);
 105   }
 106
 107   /// \brief Get the alias arguments as a \0 separated list.
 108   /// E.g. ["foo", "bar"] would be returned as "foo\0bar\0".
 109   const char *getAliasArgs() const {
 110     assert(Info && "Must have a valid info!");
 111     assert((!Info->AliasArgs || Info->AliasArgs[0] != 0) &&
 112            "AliasArgs should be either 0 or non-empty.");
 113
 114     return Info->AliasArgs;
 115   }
 116
 117   /// \brief Get the default prefix for this option.
 118   StringRef getPrefix() const {
 119     const char *Prefix = *Info->Prefixes;
 120     return Prefix ? Prefix : StringRef();
 121   }
 122
 123   /// \brief Get the name of this option with the default prefix.
 124   std::string getPrefixedName() const {
 125     std::string Ret = getPrefix();
 126     Ret += getName();
 127     return Ret;
 128   }
 129
 130   unsigned getNumArgs() const { return Info->Param; }
 131
 132   bool hasNoOptAsInput() const { return Info->Flags & RenderAsInput;}
 133
 134   RenderStyleKind getRenderStyle() const {
 135     if (Info->Flags & RenderJoined)
 136       return RenderJoinedStyle;
 137     if (Info->Flags & RenderSeparate)
 138       return RenderSeparateStyle;
 139     switch (getKind()) {
 140     case GroupClass:
 141     case InputClass:
 142     case UnknownClass:
 143       return RenderValuesStyle;
 144     case JoinedClass:
 145     case JoinedAndSeparateClass:
 146       return RenderJoinedStyle;
 147     case CommaJoinedClass:
 148       return RenderCommaJoinedStyle;
 149     case FlagClass:
 150     case SeparateClass:
 151     case MultiArgClass:
 152     case JoinedOrSeparateClass:
 153     case RemainingArgsClass:
 154       return RenderSeparateStyle;
 155     }
 156     llvm_unreachable("Unexpected kind!");
 157   }
 158
 159   /// Test if this option has the flag \a Val.
 160   bool hasFlag(unsigned Val) const {
 161     return Info->Flags & Val;
 162   }
 163
 164   /// getUnaliasedOption - Return the final option this option
 165   /// aliases (itself, if the option has no alias).
 166   const Option getUnaliasedOption() const {
 167     const Option Alias = getAlias();
 168     if (Alias.isValid()) return Alias.getUnaliasedOption();
 169     return *this;
 170   }
 171
 172   /// getRenderName - Return the name to use when rendering this
 173   /// option.
 174   StringRef getRenderName() const {
 175     return getUnaliasedOption().getName();
 176   }
 177
 178   /// matches - Predicate for whether this option is part of the
 179   /// given option (which may be a group).
 180   ///
 181   /// Note that matches against options which are an alias should never be
 182   /// done -- aliases do not participate in matching and so such a query will
 183   /// always be false.
 184   bool matches(OptSpecifier ID) const;
 185
 186   /// accept - Potentially accept the current argument, returning a
 187   /// new Arg instance, or 0 if the option does not accept this
 188   /// argument (or the argument is missing values).
 189   ///
 190   /// If the option accepts the current argument, accept() sets
 191   /// Index to the position where argument parsing should resume
 192   /// (even if the argument is missing values).
 193   ///
 194   /// \param ArgSize The number of bytes taken up by the matched Option prefix
 195   ///                and name. This is used to determine where joined values
 196   ///                start.
 197   Arg *accept(const ArgList &Args, unsigned &Index, unsigned ArgSize) const;
 198
 199   void dump() const;
 200 };
 201
 202 } // end namespace opt
 203 } // end namespace llvm
 204
 205 #endif