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