lib/Support/ConvertUTFWrapper.cpp

   1 //===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----===
   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/Support/ConvertUTF.h"
  11 #include "llvm/Support/SwapByteOrder.h"
  12 #include <string>
  13 #include <vector>
  14
  15 namespace llvm {
  16
  17 bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
  18                        char *&ResultPtr, const UTF8 *&ErrorPtr) {
  19   assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4);
  20   ConversionResult result = conversionOK;
  21   // Copy the character span over.
  22   if (WideCharWidth == 1) {
  23     const UTF8 *Pos = reinterpret_cast<const UTF8*>(Source.begin());
  24     if (!isLegalUTF8String(&Pos, reinterpret_cast<const UTF8*>(Source.end()))) {
  25       result = sourceIllegal;
  26       ErrorPtr = Pos;
  27     } else {
  28       memcpy(ResultPtr, Source.data(), Source.size());
  29       ResultPtr += Source.size();
  30     }
  31   } else if (WideCharWidth == 2) {
  32     const UTF8 *sourceStart = (const UTF8*)Source.data();
  33     // FIXME: Make the type of the result buffer correct instead of
  34     // using reinterpret_cast.
  35     UTF16 *targetStart = reinterpret_cast<UTF16*>(ResultPtr);
  36     ConversionFlags flags = strictConversion;
  37     result = ConvertUTF8toUTF16(
  38         &sourceStart, sourceStart + Source.size(),
  39         &targetStart, targetStart + 2*Source.size(), flags);
  40     if (result == conversionOK)
  41       ResultPtr = reinterpret_cast<char*>(targetStart);
  42     else
  43       ErrorPtr = sourceStart;
  44   } else if (WideCharWidth == 4) {
  45     const UTF8 *sourceStart = (const UTF8*)Source.data();
  46     // FIXME: Make the type of the result buffer correct instead of
  47     // using reinterpret_cast.
  48     UTF32 *targetStart = reinterpret_cast<UTF32*>(ResultPtr);
  49     ConversionFlags flags = strictConversion;
  50     result = ConvertUTF8toUTF32(
  51         &sourceStart, sourceStart + Source.size(),
  52         &targetStart, targetStart + 4*Source.size(), flags);
  53     if (result == conversionOK)
  54       ResultPtr = reinterpret_cast<char*>(targetStart);
  55     else
  56       ErrorPtr = sourceStart;
  57   }
  58   assert((result != targetExhausted)
  59          && "ConvertUTF8toUTFXX exhausted target buffer");
  60   return result == conversionOK;
  61 }
  62
  63 bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr) {
  64   const UTF32 *SourceStart = &Source;
  65   const UTF32 *SourceEnd = SourceStart + 1;
  66   UTF8 *TargetStart = reinterpret_cast<UTF8 *>(ResultPtr);
  67   UTF8 *TargetEnd = TargetStart + 4;
  68   ConversionResult CR = ConvertUTF32toUTF8(&SourceStart, SourceEnd,
  69                                            &TargetStart, TargetEnd,
  70                                            strictConversion);
  71   if (CR != conversionOK)
  72     return false;
  73
  74   ResultPtr = reinterpret_cast<char*>(TargetStart);
  75   return true;
  76 }
  77
  78 bool hasUTF16ByteOrderMark(ArrayRef<char> S) {
  79   return (S.size() >= 2 &&
  80           ((S[0] == '\xff' && S[1] == '\xfe') ||
  81            (S[0] == '\xfe' && S[1] == '\xff')));
  82 }
  83
  84 bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out) {
  85   assert(Out.empty());
  86
  87   // Error out on an uneven byte count.
  88   if (SrcBytes.size() % 2)
  89     return false;
  90
  91   // Avoid OOB by returning early on empty input.
  92   if (SrcBytes.empty())
  93     return true;
  94
  95   const UTF16 *Src = reinterpret_cast<const UTF16 *>(SrcBytes.begin());
  96   const UTF16 *SrcEnd = reinterpret_cast<const UTF16 *>(SrcBytes.end());
  97
  98   // Byteswap if necessary.
  99   std::vector<UTF16> ByteSwapped;
 100   if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) {
 101     ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd);
 102     for (unsigned I = 0, E = ByteSwapped.size(); I != E; ++I)
 103       ByteSwapped[I] = llvm::sys::SwapByteOrder_16(ByteSwapped[I]);
 104     Src = &ByteSwapped[0];
 105     SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
 106   }
 107
 108   // Skip the BOM for conversion.
 109   if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE)
 110     Src++;
 111
 112   // Just allocate enough space up front.  We'll shrink it later.  Allocate
 113   // enough that we can fit a null terminator without reallocating.
 114   Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1);
 115   UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]);
 116   UTF8 *DstEnd = Dst + Out.size();
 117
 118   ConversionResult CR =
 119       ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
 120   assert(CR != targetExhausted);
 121
 122   if (CR != conversionOK) {
 123     Out.clear();
 124     return false;
 125   }
 126
 127   Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]);
 128   Out.push_back(0);
 129   Out.pop_back();
 130   return true;
 131 }
 132
 133 bool convertUTF8ToUTF16String(StringRef SrcUTF8,
 134                               SmallVectorImpl<UTF16> &DstUTF16) {
 135   assert(DstUTF16.empty());
 136
 137   // Avoid OOB by returning early on empty input.
 138   if (SrcUTF8.empty()) {
 139     DstUTF16.push_back(0);
 140     DstUTF16.pop_back();
 141     return true;
 142   }
 143
 144   const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.begin());
 145   const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.end());
 146
 147   // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding
 148   // as UTF-16 should always require the same amount or less code units than the
 149   // UTF-8 encoding.  Allocate one extra byte for the null terminator though,
 150   // so that someone calling DstUTF16.data() gets a null terminated string.
 151   // We resize down later so we don't have to worry that this over allocates.
 152   DstUTF16.resize(SrcUTF8.size()+1);
 153   UTF16 *Dst = &DstUTF16[0];
 154   UTF16 *DstEnd = Dst + DstUTF16.size();
 155
 156   ConversionResult CR =
 157       ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
 158   assert(CR != targetExhausted);
 159
 160   if (CR != conversionOK) {
 161     DstUTF16.clear();
 162     return false;
 163   }
 164
 165   DstUTF16.resize(Dst - &DstUTF16[0]);
 166   DstUTF16.push_back(0);
 167   DstUTF16.pop_back();
 168   return true;
 169 }
 170
 171 } // end namespace llvm
 172