lib/Driver/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 "clang/Driver/ArgList.h"
  11 #include "clang/Driver/Arg.h"
  12 #include "clang/Driver/Option.h"
  13
  14 using namespace clang::driver;
  15
  16 ArgList::ArgList(arglist_type &_Args) : Args(_Args) {
  17 }
  18
  19 ArgList::~ArgList() {
  20 }
  21
  22 void ArgList::append(Arg *A) {
  23   Args.push_back(A);
  24 }
  25
  26 Arg *ArgList::getLastArg(options::ID Id, bool Claim) const {
  27   // FIXME: Make search efficient?
  28   for (const_reverse_iterator it = rbegin(), ie = rend(); it != ie; ++it) {
  29     if ((*it)->getOption().matches(Id)) {
  30       if (Claim) (*it)->claim();
  31       return *it;
  32     }
  33   }
  34
  35   return 0;
  36 }
  37
  38 Arg *ArgList::getLastArg(options::ID Id0, options::ID Id1, bool Claim) const {
  39   Arg *Res, *A0 = getLastArg(Id0, false), *A1 = getLastArg(Id1, false);
  40
  41   if (A0 && A1)
  42     Res = A0->getIndex() > A1->getIndex() ? A0 : A1;
  43   else
  44     Res = A0 ? A0 : A1;
  45
  46   if (Claim && Res)
  47     Res->claim();
  48
  49   return Res;
  50 }
  51
  52 Arg *ArgList::getLastArg(options::ID Id0, options::ID Id1, options::ID Id2,
  53                          bool Claim) const {
  54   Arg *Res = 0;
  55   Arg *A0 = getLastArg(Id0, false);
  56   Arg *A1 = getLastArg(Id1, false);
  57   Arg *A2 = getLastArg(Id2, false);
  58
  59   int A0Idx = A0 ? A0->getIndex() : -1;
  60   int A1Idx = A1 ? A1->getIndex() : -1;
  61   int A2Idx = A2 ? A2->getIndex() : -1;
  62
  63   if (A0Idx > A1Idx) {
  64     if (A0Idx > A2Idx)
  65       Res = A0;
  66     else if (A2Idx != -1)
  67       Res = A2;
  68   } else {
  69     if (A1Idx > A2Idx)
  70       Res = A1;
  71     else if (A2Idx != -1)
  72       Res = A2;
  73   }
  74
  75   if (Claim && Res)
  76     Res->claim();
  77
  78   return Res;
  79 }
  80
  81 bool ArgList::hasFlag(options::ID Pos, options::ID Neg, bool Default) const {
  82   if (Arg *A = getLastArg(Pos, Neg))
  83     return A->getOption().matches(Pos);
  84   return Default;
  85 }
  86
  87 void ArgList::AddLastArg(ArgStringList &Output, options::ID Id) const {
  88   if (Arg *A = getLastArg(Id)) {
  89     A->claim();
  90     A->render(*this, Output);
  91   }
  92 }
  93
  94 void ArgList::AddAllArgs(ArgStringList &Output, options::ID Id0) const {
  95   // FIXME: Make fast.
  96   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
  97     const Arg *A = *it;
  98     if (A->getOption().matches(Id0)) {
  99       A->claim();
 100       A->render(*this, Output);
 101     }
 102   }
 103 }
 104
 105 void ArgList::AddAllArgs(ArgStringList &Output, options::ID Id0,
 106                          options::ID Id1) const {
 107   // FIXME: Make fast.
 108   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
 109     const Arg *A = *it;
 110     if (A->getOption().matches(Id0) || A->getOption().matches(Id1)) {
 111       A->claim();
 112       A->render(*this, Output);
 113     }
 114   }
 115 }
 116
 117 void ArgList::AddAllArgs(ArgStringList &Output, options::ID Id0,
 118                          options::ID Id1, options::ID Id2) const {
 119   // FIXME: Make fast.
 120   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
 121     const Arg *A = *it;
 122     if (A->getOption().matches(Id0) || A->getOption().matches(Id1) ||
 123         A->getOption().matches(Id2)) {
 124       A->claim();
 125       A->render(*this, Output);
 126     }
 127   }
 128 }
 129
 130 void ArgList::AddAllArgValues(ArgStringList &Output, options::ID Id0) const {
 131   // FIXME: Make fast.
 132   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
 133     const Arg *A = *it;
 134     if (A->getOption().matches(Id0)) {
 135       A->claim();
 136       for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
 137         Output.push_back(A->getValue(*this, i));
 138     }
 139   }
 140 }
 141
 142 void ArgList::AddAllArgValues(ArgStringList &Output, options::ID Id0,
 143                               options::ID Id1) const {
 144   // FIXME: Make fast.
 145   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
 146     const Arg *A = *it;
 147     if (A->getOption().matches(Id0) || A->getOption().matches(Id1)) {
 148       A->claim();
 149       for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
 150         Output.push_back(A->getValue(*this, i));
 151     }
 152   }
 153 }
 154
 155 void ArgList::AddAllArgsTranslated(ArgStringList &Output, options::ID Id0,
 156                                    const char *Translation,
 157                                    bool Joined) const {
 158   // FIXME: Make fast.
 159   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
 160     const Arg *A = *it;
 161     if (A->getOption().matches(Id0)) {
 162       A->claim();
 163
 164       if (Joined) {
 165         std::string Value = Translation;
 166         Value += A->getValue(*this, 0);
 167         Output.push_back(MakeArgString(Value.c_str()));
 168       } else {
 169         Output.push_back(Translation);
 170         Output.push_back(A->getValue(*this, 0));
 171       }
 172     }
 173   }
 174 }
 175
 176 void ArgList::ClaimAllArgs(options::ID Id0) const {
 177   // FIXME: Make fast.
 178   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
 179     const Arg *A = *it;
 180     if (A->getOption().matches(Id0))
 181       A->claim();
 182   }
 183 }
 184
 185 //
 186
 187 InputArgList::InputArgList(const char **ArgBegin, const char **ArgEnd)
 188   : ArgList(ActualArgs), NumInputArgStrings(ArgEnd - ArgBegin)
 189 {
 190   ArgStrings.append(ArgBegin, ArgEnd);
 191 }
 192
 193 InputArgList::~InputArgList() {
 194   // An InputArgList always owns its arguments.
 195   for (iterator it = begin(), ie = end(); it != ie; ++it)
 196     delete *it;
 197 }
 198
 199 unsigned InputArgList::MakeIndex(const char *String0) const {
 200   unsigned Index = ArgStrings.size();
 201
 202   // Tuck away so we have a reliable const char *.
 203   SynthesizedStrings.push_back(String0);
 204   ArgStrings.push_back(SynthesizedStrings.back().c_str());
 205
 206   return Index;
 207 }
 208
 209 unsigned InputArgList::MakeIndex(const char *String0,
 210                                  const char *String1) const {
 211   unsigned Index0 = MakeIndex(String0);
 212   unsigned Index1 = MakeIndex(String1);
 213   assert(Index0 + 1 == Index1 && "Unexpected non-consecutive indices!");
 214   (void) Index1;
 215   return Index0;
 216 }
 217
 218 const char *InputArgList::MakeArgString(const char *Str) const {
 219   return getArgString(MakeIndex(Str));
 220 }
 221
 222 //
 223
 224 DerivedArgList::DerivedArgList(InputArgList &_BaseArgs, bool _OnlyProxy)
 225   : ArgList(_OnlyProxy ? _BaseArgs.getArgs() : ActualArgs),
 226     BaseArgs(_BaseArgs), OnlyProxy(_OnlyProxy)
 227 {
 228 }
 229
 230 DerivedArgList::~DerivedArgList() {
 231   // We only own the arguments we explicitly synthesized.
 232   for (iterator it = SynthesizedArgs.begin(), ie = SynthesizedArgs.end();
 233        it != ie; ++it)
 234     delete *it;
 235 }
 236
 237 const char *DerivedArgList::MakeArgString(const char *Str) const {
 238   return BaseArgs.MakeArgString(Str);
 239 }
 240
 241 Arg *DerivedArgList::MakeFlagArg(const Arg *BaseArg, const Option *Opt) const {
 242   return new FlagArg(Opt, BaseArgs.MakeIndex(Opt->getName()), BaseArg);
 243 }
 244
 245 Arg *DerivedArgList::MakePositionalArg(const Arg *BaseArg, const Option *Opt,
 246                                        const char *Value) const {
 247   return new PositionalArg(Opt, BaseArgs.MakeIndex(Value), BaseArg);
 248 }
 249
 250 Arg *DerivedArgList::MakeSeparateArg(const Arg *BaseArg, const Option *Opt,
 251                                      const char *Value) const {
 252   return new SeparateArg(Opt, BaseArgs.MakeIndex(Opt->getName(), Value), 1,
 253                          BaseArg);
 254 }
 255
 256 Arg *DerivedArgList::MakeJoinedArg(const Arg *BaseArg, const Option *Opt,
 257                                    const char *Value) const {
 258   std::string Joined(Opt->getName());
 259   Joined += Value;
 260   return new JoinedArg(Opt, BaseArgs.MakeIndex(Joined.c_str()), BaseArg);
 261 }