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