lib/Option/Option.cpp

   1 //===- Option.cpp - Abstract Driver Options -------------------------------===//
   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 #include "llvm/ADT/StringRef.h"
  11 #include "llvm/ADT/Twine.h"
  12 #include "llvm/Config/llvm-config.h"
  13 #include "llvm/Option/Arg.h"
  14 #include "llvm/Option/ArgList.h"
  15 #include "llvm/Option/Option.h"
  16 #include "llvm/Option/OptTable.h"
  17 #include "llvm/Support/Compiler.h"
  18 #include "llvm/Support/Debug.h"
  19 #include "llvm/Support/ErrorHandling.h"
  20 #include "llvm/Support/raw_ostream.h"
  21 #include <cassert>
  22 #include <cstring>
  23
  24 using namespace llvm;
  25 using namespace llvm::opt;
  26
  27 Option::Option(const OptTable::Info *info, const OptTable *owner)
  28   : Info(info), Owner(owner) {
  29   // Multi-level aliases are not supported. This just simplifies option
  30   // tracking, it is not an inherent limitation.
  31   assert((!Info || !getAlias().isValid() || !getAlias().getAlias().isValid()) &&
  32          "Multi-level aliases are not supported.");
  33
  34   if (Info && getAliasArgs()) {
  35     assert(getAlias().isValid() && "Only alias options can have alias args.");
  36     assert(getKind() == FlagClass && "Only Flag aliases can have alias args.");
  37     assert(getAlias().getKind() != FlagClass &&
  38            "Cannot provide alias args to a flag option.");
  39   }
  40 }
  41
  42 void Option::print(raw_ostream &O) const {
  43   O << "<";
  44   switch (getKind()) {
  45 #define P(N) case N: O << #N; break
  46     P(GroupClass);
  47     P(InputClass);
  48     P(UnknownClass);
  49     P(FlagClass);
  50     P(JoinedClass);
  51     P(ValuesClass);
  52     P(SeparateClass);
  53     P(CommaJoinedClass);
  54     P(MultiArgClass);
  55     P(JoinedOrSeparateClass);
  56     P(JoinedAndSeparateClass);
  57     P(RemainingArgsClass);
  58     P(RemainingArgsJoinedClass);
  59 #undef P
  60   }
  61
  62   if (Info->Prefixes) {
  63     O << " Prefixes:[";
  64     for (const char *const *Pre = Info->Prefixes; *Pre != nullptr; ++Pre) {
  65       O << '"' << *Pre << (*(Pre + 1) == nullptr ? "\"" : "\", ");
  66     }
  67     O << ']';
  68   }
  69
  70   O << " Name:\"" << getName() << '"';
  71
  72   const Option Group = getGroup();
  73   if (Group.isValid()) {
  74     O << " Group:";
  75     Group.print(O);
  76   }
  77
  78   const Option Alias = getAlias();
  79   if (Alias.isValid()) {
  80     O << " Alias:";
  81     Alias.print(O);
  82   }
  83
  84   if (getKind() == MultiArgClass)
  85     O << " NumArgs:" << getNumArgs();
  86
  87   O << ">\n";
  88 }
  89
  90 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
  91 LLVM_DUMP_METHOD void Option::dump() const { print(dbgs()); }
  92 #endif
  93
  94 bool Option::matches(OptSpecifier Opt) const {
  95   // Aliases are never considered in matching, look through them.
  96   const Option Alias = getAlias();
  97   if (Alias.isValid())
  98     return Alias.matches(Opt);
  99
 100   // Check exact match.
 101   if (getID() == Opt.getID())
 102     return true;
 103
 104   const Option Group = getGroup();
 105   if (Group.isValid())
 106     return Group.matches(Opt);
 107   return false;
 108 }
 109
 110 Arg *Option::accept(const ArgList &Args,
 111                     unsigned &Index,
 112                     unsigned ArgSize) const {
 113   const Option &UnaliasedOption = getUnaliasedOption();
 114   StringRef Spelling;
 115   // If the option was an alias, get the spelling from the unaliased one.
 116   if (getID() == UnaliasedOption.getID()) {
 117     Spelling = StringRef(Args.getArgString(Index), ArgSize);
 118   } else {
 119     Spelling = Args.MakeArgString(Twine(UnaliasedOption.getPrefix()) +
 120                                   Twine(UnaliasedOption.getName()));
 121   }
 122
 123   switch (getKind()) {
 124   case FlagClass: {
 125     if (ArgSize != strlen(Args.getArgString(Index)))
 126       return nullptr;
 127
 128     Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
 129     if (getAliasArgs()) {
 130       const char *Val = getAliasArgs();
 131       while (*Val != '\0') {
 132         A->getValues().push_back(Val);
 133
 134         // Move past the '\0' to the next argument.
 135         Val += strlen(Val) + 1;
 136       }
 137     }
 138
 139     if (UnaliasedOption.getKind() == JoinedClass && !getAliasArgs())
 140       // A Flag alias for a Joined option must provide an argument.
 141       A->getValues().push_back("");
 142
 143     return A;
 144   }
 145   case JoinedClass: {
 146     const char *Value = Args.getArgString(Index) + ArgSize;
 147     return new Arg(UnaliasedOption, Spelling, Index++, Value);
 148   }
 149   case CommaJoinedClass: {
 150     // Always matches.
 151     const char *Str = Args.getArgString(Index) + ArgSize;
 152     Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
 153
 154     // Parse out the comma separated values.
 155     const char *Prev = Str;
 156     for (;; ++Str) {
 157       char c = *Str;
 158
 159       if (!c || c == ',') {
 160         if (Prev != Str) {
 161           char *Value = new char[Str - Prev + 1];
 162           memcpy(Value, Prev, Str - Prev);
 163           Value[Str - Prev] = '\0';
 164           A->getValues().push_back(Value);
 165         }
 166
 167         if (!c)
 168           break;
 169
 170         Prev = Str + 1;
 171       }
 172     }
 173     A->setOwnsValues(true);
 174
 175     return A;
 176   }
 177   case SeparateClass:
 178     // Matches iff this is an exact match.
 179     // FIXME: Avoid strlen.
 180     if (ArgSize != strlen(Args.getArgString(Index)))
 181       return nullptr;
 182
 183     Index += 2;
 184     if (Index > Args.getNumInputArgStrings() ||
 185         Args.getArgString(Index - 1) == nullptr)
 186       return nullptr;
 187
 188     return new Arg(UnaliasedOption, Spelling,
 189                    Index - 2, Args.getArgString(Index - 1));
 190   case MultiArgClass: {
 191     // Matches iff this is an exact match.
 192     // FIXME: Avoid strlen.
 193     if (ArgSize != strlen(Args.getArgString(Index)))
 194       return nullptr;
 195
 196     Index += 1 + getNumArgs();
 197     if (Index > Args.getNumInputArgStrings())
 198       return nullptr;
 199
 200     Arg *A = new Arg(UnaliasedOption, Spelling, Index - 1 - getNumArgs(),
 201                       Args.getArgString(Index - getNumArgs()));
 202     for (unsigned i = 1; i != getNumArgs(); ++i)
 203       A->getValues().push_back(Args.getArgString(Index - getNumArgs() + i));
 204     return A;
 205   }
 206   case JoinedOrSeparateClass: {
 207     // If this is not an exact match, it is a joined arg.
 208     // FIXME: Avoid strlen.
 209     if (ArgSize != strlen(Args.getArgString(Index))) {
 210       const char *Value = Args.getArgString(Index) + ArgSize;
 211       return new Arg(*this, Spelling, Index++, Value);
 212     }
 213
 214     // Otherwise it must be separate.
 215     Index += 2;
 216     if (Index > Args.getNumInputArgStrings() ||
 217         Args.getArgString(Index - 1) == nullptr)
 218       return nullptr;
 219
 220     return new Arg(UnaliasedOption, Spelling,
 221                    Index - 2, Args.getArgString(Index - 1));
 222   }
 223   case JoinedAndSeparateClass:
 224     // Always matches.
 225     Index += 2;
 226     if (Index > Args.getNumInputArgStrings() ||
 227         Args.getArgString(Index - 1) == nullptr)
 228       return nullptr;
 229
 230     return new Arg(UnaliasedOption, Spelling, Index - 2,
 231                    Args.getArgString(Index - 2) + ArgSize,
 232                    Args.getArgString(Index - 1));
 233   case RemainingArgsClass: {
 234     // Matches iff this is an exact match.
 235     // FIXME: Avoid strlen.
 236     if (ArgSize != strlen(Args.getArgString(Index)))
 237       return nullptr;
 238     Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
 239     while (Index < Args.getNumInputArgStrings() &&
 240            Args.getArgString(Index) != nullptr)
 241       A->getValues().push_back(Args.getArgString(Index++));
 242     return A;
 243   }
 244   case RemainingArgsJoinedClass: {
 245     Arg *A = new Arg(UnaliasedOption, Spelling, Index);
 246     if (ArgSize != strlen(Args.getArgString(Index))) {
 247       // An inexact match means there is a joined arg.
 248       A->getValues().push_back(Args.getArgString(Index) + ArgSize);
 249     }
 250     Index++;
 251     while (Index < Args.getNumInputArgStrings() &&
 252            Args.getArgString(Index) != nullptr)
 253       A->getValues().push_back(Args.getArgString(Index++));
 254     return A;
 255   }
 256
 257   default:
 258     llvm_unreachable("Invalid option kind!");
 259   }
 260 }