contrib/llvm/lib/Option/ArgList.cpp

   1 //===--- ArgList.cpp - Argument List Management ---------------------------===//
   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/ArgList.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/SmallString.h"
  13 #include "llvm/ADT/Twine.h"
  14 #include "llvm/Option/Arg.h"
  15 #include "llvm/Option/Option.h"
  16 #include "llvm/Support/Debug.h"
  17 #include "llvm/Support/raw_ostream.h"
  18
  19 using namespace llvm;
  20 using namespace llvm::opt;
  21
  22 void ArgList::append(Arg *A) {
  23   Args.push_back(A);
  24
  25   // Update ranges for the option and all of its groups.
  26   for (Option O = A->getOption().getUnaliasedOption(); O.isValid();
  27        O = O.getGroup()) {
  28     auto &R =
  29         OptRanges.insert(std::make_pair(O.getID(), emptyRange())).first->second;
  30     R.first = std::min<unsigned>(R.first, Args.size() - 1);
  31     R.second = Args.size();
  32   }
  33 }
  34
  35 void ArgList::eraseArg(OptSpecifier Id) {
  36   // Zero out the removed entries but keep them around so that we don't
  37   // need to invalidate OptRanges.
  38   for (Arg *const &A : filtered(Id)) {
  39     // Avoid the need for a non-const filtered iterator variant.
  40     Arg **ArgsBegin = Args.data();
  41     ArgsBegin[&A - ArgsBegin] = nullptr;
  42   }
  43   OptRanges.erase(Id.getID());
  44 }
  45
  46 ArgList::OptRange
  47 ArgList::getRange(std::initializer_list<OptSpecifier> Ids) const {
  48   OptRange R = emptyRange();
  49   for (auto Id : Ids) {
  50     auto I = OptRanges.find(Id.getID());
  51     if (I != OptRanges.end()) {
  52       R.first = std::min(R.first, I->second.first);
  53       R.second = std::max(R.second, I->second.second);
  54     }
  55   }
  56   // Map an empty {-1, 0} range to {0, 0} so it can be used to form iterators.
  57   if (R.first == -1u)
  58     R.first = 0;
  59   return R;
  60 }
  61
  62 bool ArgList::hasFlag(OptSpecifier Pos, OptSpecifier Neg, bool Default) const {
  63   if (Arg *A = getLastArg(Pos, Neg))
  64     return A->getOption().matches(Pos);
  65   return Default;
  66 }
  67
  68 bool ArgList::hasFlag(OptSpecifier Pos, OptSpecifier PosAlias, OptSpecifier Neg,
  69                       bool Default) const {
  70   if (Arg *A = getLastArg(Pos, PosAlias, Neg))
  71     return A->getOption().matches(Pos) || A->getOption().matches(PosAlias);
  72   return Default;
  73 }
  74
  75 StringRef ArgList::getLastArgValue(OptSpecifier Id, StringRef Default) const {
  76   if (Arg *A = getLastArg(Id))
  77     return A->getValue();
  78   return Default;
  79 }
  80
  81 std::vector<std::string> ArgList::getAllArgValues(OptSpecifier Id) const {
  82   SmallVector<const char *, 16> Values;
  83   AddAllArgValues(Values, Id);
  84   return std::vector<std::string>(Values.begin(), Values.end());
  85 }
  86
  87 void ArgList::AddLastArg(ArgStringList &Output, OptSpecifier Id) const {
  88   if (Arg *A = getLastArg(Id)) {
  89     A->claim();
  90     A->render(*this, Output);
  91   }
  92 }
  93
  94 void ArgList::AddLastArg(ArgStringList &Output, OptSpecifier Id0,
  95                          OptSpecifier Id1) const {
  96   if (Arg *A = getLastArg(Id0, Id1)) {
  97     A->claim();
  98     A->render(*this, Output);
  99   }
 100 }
 101
 102 void ArgList::AddAllArgsExcept(ArgStringList &Output,
 103                                ArrayRef<OptSpecifier> Ids,
 104                                ArrayRef<OptSpecifier> ExcludeIds) const {
 105   for (const Arg *Arg : *this) {
 106     bool Excluded = false;
 107     for (OptSpecifier Id : ExcludeIds) {
 108       if (Arg->getOption().matches(Id)) {
 109         Excluded = true;
 110         break;
 111       }
 112     }
 113     if (!Excluded) {
 114       for (OptSpecifier Id : Ids) {
 115         if (Arg->getOption().matches(Id)) {
 116           Arg->claim();
 117           Arg->render(*this, Output);
 118           break;
 119         }
 120       }
 121     }
 122   }
 123 }
 124
 125 /// This is a nicer interface when you don't have a list of Ids to exclude.
 126 void ArgList::AddAllArgs(ArgStringList &Output,
 127                          ArrayRef<OptSpecifier> Ids) const {
 128   ArrayRef<OptSpecifier> Exclude = None;
 129   AddAllArgsExcept(Output, Ids, Exclude);
 130 }
 131
 132 /// This 3-opt variant of AddAllArgs could be eliminated in favor of one
 133 /// that accepts a single specifier, given the above which accepts any number.
 134 void ArgList::AddAllArgs(ArgStringList &Output, OptSpecifier Id0,
 135                          OptSpecifier Id1, OptSpecifier Id2) const {
 136   for (auto Arg: filtered(Id0, Id1, Id2)) {
 137     Arg->claim();
 138     Arg->render(*this, Output);
 139   }
 140 }
 141
 142 void ArgList::AddAllArgValues(ArgStringList &Output, OptSpecifier Id0,
 143                               OptSpecifier Id1, OptSpecifier Id2) const {
 144   for (auto Arg : filtered(Id0, Id1, Id2)) {
 145     Arg->claim();
 146     const auto &Values = Arg->getValues();
 147     Output.append(Values.begin(), Values.end());
 148   }
 149 }
 150
 151 void ArgList::AddAllArgsTranslated(ArgStringList &Output, OptSpecifier Id0,
 152                                    const char *Translation,
 153                                    bool Joined) const {
 154   for (auto Arg: filtered(Id0)) {
 155     Arg->claim();
 156
 157     if (Joined) {
 158       Output.push_back(MakeArgString(StringRef(Translation) +
 159                                      Arg->getValue(0)));
 160     } else {
 161       Output.push_back(Translation);
 162       Output.push_back(Arg->getValue(0));
 163     }
 164   }
 165 }
 166
 167 void ArgList::ClaimAllArgs(OptSpecifier Id0) const {
 168   for (auto *Arg : filtered(Id0))
 169     Arg->claim();
 170 }
 171
 172 void ArgList::ClaimAllArgs() const {
 173   for (auto *Arg : *this)
 174     if (!Arg->isClaimed())
 175       Arg->claim();
 176 }
 177
 178 const char *ArgList::GetOrMakeJoinedArgString(unsigned Index,
 179                                               StringRef LHS,
 180                                               StringRef RHS) const {
 181   StringRef Cur = getArgString(Index);
 182   if (Cur.size() == LHS.size() + RHS.size() &&
 183       Cur.startswith(LHS) && Cur.endswith(RHS))
 184     return Cur.data();
 185
 186   return MakeArgString(LHS + RHS);
 187 }
 188
 189 void ArgList::print(raw_ostream &O) const {
 190   for (Arg *A : *this) {
 191     O << "* ";
 192     A->print(O);
 193   }
 194 }
 195
 196 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 197 LLVM_DUMP_METHOD void ArgList::dump() const { print(dbgs()); }
 198 #endif
 199
 200 //
 201
 202 void InputArgList::releaseMemory() {
 203   // An InputArgList always owns its arguments.
 204   for (Arg *A : *this)
 205     delete A;
 206 }
 207
 208 InputArgList::InputArgList(const char* const *ArgBegin,
 209                            const char* const *ArgEnd)
 210   : NumInputArgStrings(ArgEnd - ArgBegin) {
 211   ArgStrings.append(ArgBegin, ArgEnd);
 212 }
 213
 214 unsigned InputArgList::MakeIndex(StringRef String0) const {
 215   unsigned Index = ArgStrings.size();
 216
 217   // Tuck away so we have a reliable const char *.
 218   SynthesizedStrings.push_back(String0);
 219   ArgStrings.push_back(SynthesizedStrings.back().c_str());
 220
 221   return Index;
 222 }
 223
 224 unsigned InputArgList::MakeIndex(StringRef String0,
 225                                  StringRef String1) const {
 226   unsigned Index0 = MakeIndex(String0);
 227   unsigned Index1 = MakeIndex(String1);
 228   assert(Index0 + 1 == Index1 && "Unexpected non-consecutive indices!");
 229   (void) Index1;
 230   return Index0;
 231 }
 232
 233 const char *InputArgList::MakeArgStringRef(StringRef Str) const {
 234   return getArgString(MakeIndex(Str));
 235 }
 236
 237 //
 238
 239 DerivedArgList::DerivedArgList(const InputArgList &BaseArgs)
 240     : BaseArgs(BaseArgs) {}
 241
 242 const char *DerivedArgList::MakeArgStringRef(StringRef Str) const {
 243   return BaseArgs.MakeArgString(Str);
 244 }
 245
 246 void DerivedArgList::AddSynthesizedArg(Arg *A) {
 247   SynthesizedArgs.push_back(std::unique_ptr<Arg>(A));
 248 }
 249
 250 Arg *DerivedArgList::MakeFlagArg(const Arg *BaseArg, const Option Opt) const {
 251   SynthesizedArgs.push_back(
 252       make_unique<Arg>(Opt, MakeArgString(Opt.getPrefix() + Opt.getName()),
 253                        BaseArgs.MakeIndex(Opt.getName()), BaseArg));
 254   return SynthesizedArgs.back().get();
 255 }
 256
 257 Arg *DerivedArgList::MakePositionalArg(const Arg *BaseArg, const Option Opt,
 258                                        StringRef Value) const {
 259   unsigned Index = BaseArgs.MakeIndex(Value);
 260   SynthesizedArgs.push_back(
 261       make_unique<Arg>(Opt, MakeArgString(Opt.getPrefix() + Opt.getName()),
 262                        Index, BaseArgs.getArgString(Index), BaseArg));
 263   return SynthesizedArgs.back().get();
 264 }
 265
 266 Arg *DerivedArgList::MakeSeparateArg(const Arg *BaseArg, const Option Opt,
 267                                      StringRef Value) const {
 268   unsigned Index = BaseArgs.MakeIndex(Opt.getName(), Value);
 269   SynthesizedArgs.push_back(
 270       make_unique<Arg>(Opt, MakeArgString(Opt.getPrefix() + Opt.getName()),
 271                        Index, BaseArgs.getArgString(Index + 1), BaseArg));
 272   return SynthesizedArgs.back().get();
 273 }
 274
 275 Arg *DerivedArgList::MakeJoinedArg(const Arg *BaseArg, const Option Opt,
 276                                    StringRef Value) const {
 277   unsigned Index = BaseArgs.MakeIndex((Opt.getName() + Value).str());
 278   SynthesizedArgs.push_back(make_unique<Arg>(
 279       Opt, MakeArgString(Opt.getPrefix() + Opt.getName()), Index,
 280       BaseArgs.getArgString(Index) + Opt.getName().size(), BaseArg));
 281   return SynthesizedArgs.back().get();
 282 }