lib/Support/Twine.cpp

   1 //===-- Twine.cpp - Fast Temporary String Concatenation -------------------===//
   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/Twine.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/Support/Debug.h"
  13 #include "llvm/Support/raw_ostream.h"
  14 using namespace llvm;
  15
  16 std::string Twine::str() const {
  17   // If we're storing only a std::string, just return it.
  18   if (LHSKind == StdStringKind && RHSKind == EmptyKind)
  19     return *LHS.stdString;
  20
  21   // Otherwise, flatten and copy the contents first.
  22   SmallString<256> Vec;
  23   return toStringRef(Vec).str();
  24 }
  25
  26 void Twine::toVector(SmallVectorImpl<char> &Out) const {
  27   raw_svector_ostream OS(Out);
  28   print(OS);
  29 }
  30
  31 StringRef Twine::toStringRef(SmallVectorImpl<char> &Out) const {
  32   if (isSingleStringRef())
  33     return getSingleStringRef();
  34   toVector(Out);
  35   return StringRef(Out.data(), Out.size());
  36 }
  37
  38 StringRef Twine::toNullTerminatedStringRef(SmallVectorImpl<char> &Out) const {
  39   if (isUnary()) {
  40     switch (getLHSKind()) {
  41     case CStringKind:
  42       // Already null terminated, yay!
  43       return StringRef(LHS.cString);
  44     case StdStringKind: {
  45       const std::string *str = LHS.stdString;
  46       return StringRef(str->c_str(), str->size());
  47     }
  48     default:
  49       break;
  50     }
  51   }
  52   toVector(Out);
  53   Out.push_back(0);
  54   Out.pop_back();
  55   return StringRef(Out.data(), Out.size());
  56 }
  57
  58 void Twine::printOneChild(raw_ostream &OS, Child Ptr,
  59                           NodeKind Kind) const {
  60   switch (Kind) {
  61   case Twine::NullKind: break;
  62   case Twine::EmptyKind: break;
  63   case Twine::TwineKind:
  64     Ptr.twine->print(OS);
  65     break;
  66   case Twine::CStringKind:
  67     OS << Ptr.cString;
  68     break;
  69   case Twine::StdStringKind:
  70     OS << *Ptr.stdString;
  71     break;
  72   case Twine::StringRefKind:
  73     OS << *Ptr.stringRef;
  74     break;
  75   case Twine::CharKind:
  76     OS << Ptr.character;
  77     break;
  78   case Twine::DecUIKind:
  79     OS << Ptr.decUI;
  80     break;
  81   case Twine::DecIKind:
  82     OS << Ptr.decI;
  83     break;
  84   case Twine::DecULKind:
  85     OS << *Ptr.decUL;
  86     break;
  87   case Twine::DecLKind:
  88     OS << *Ptr.decL;
  89     break;
  90   case Twine::DecULLKind:
  91     OS << *Ptr.decULL;
  92     break;
  93   case Twine::DecLLKind:
  94     OS << *Ptr.decLL;
  95     break;
  96   case Twine::UHexKind:
  97     OS.write_hex(*Ptr.uHex);
  98     break;
  99   }
 100 }
 101
 102 void Twine::printOneChildRepr(raw_ostream &OS, Child Ptr,
 103                               NodeKind Kind) const {
 104   switch (Kind) {
 105   case Twine::NullKind:
 106     OS << "null"; break;
 107   case Twine::EmptyKind:
 108     OS << "empty"; break;
 109   case Twine::TwineKind:
 110     OS << "rope:";
 111     Ptr.twine->printRepr(OS);
 112     break;
 113   case Twine::CStringKind:
 114     OS << "cstring:\""
 115        << Ptr.cString << "\"";
 116     break;
 117   case Twine::StdStringKind:
 118     OS << "std::string:\""
 119        << Ptr.stdString << "\"";
 120     break;
 121   case Twine::StringRefKind:
 122     OS << "stringref:\""
 123        << Ptr.stringRef << "\"";
 124     break;
 125   case Twine::CharKind:
 126     OS << "char:\"" << Ptr.character << "\"";
 127     break;
 128   case Twine::DecUIKind:
 129     OS << "decUI:\"" << Ptr.decUI << "\"";
 130     break;
 131   case Twine::DecIKind:
 132     OS << "decI:\"" << Ptr.decI << "\"";
 133     break;
 134   case Twine::DecULKind:
 135     OS << "decUL:\"" << *Ptr.decUL << "\"";
 136     break;
 137   case Twine::DecLKind:
 138     OS << "decL:\"" << *Ptr.decL << "\"";
 139     break;
 140   case Twine::DecULLKind:
 141     OS << "decULL:\"" << *Ptr.decULL << "\"";
 142     break;
 143   case Twine::DecLLKind:
 144     OS << "decLL:\"" << *Ptr.decLL << "\"";
 145     break;
 146   case Twine::UHexKind:
 147     OS << "uhex:\"" << Ptr.uHex << "\"";
 148     break;
 149   }
 150 }
 151
 152 void Twine::print(raw_ostream &OS) const {
 153   printOneChild(OS, LHS, getLHSKind());
 154   printOneChild(OS, RHS, getRHSKind());
 155 }
 156
 157 void Twine::printRepr(raw_ostream &OS) const {
 158   OS << "(Twine ";
 159   printOneChildRepr(OS, LHS, getLHSKind());
 160   OS << " ";
 161   printOneChildRepr(OS, RHS, getRHSKind());
 162   OS << ")";
 163 }
 164
 165 void Twine::dump() const {
 166   print(llvm::dbgs());
 167 }
 168
 169 void Twine::dumpRepr() const {
 170   printRepr(llvm::dbgs());
 171 }