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