llvm/lib/Support/Twine.cpp

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