1 //===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----=== 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/ArrayRef.h" 10 #include "llvm/ADT/StringRef.h" 11 #include "llvm/Support/ConvertUTF.h" 12 #include "llvm/Support/ErrorHandling.h" 13 #include "llvm/Support/SwapByteOrder.h" 14 #include <string> 15 #include <vector> 16 17 namespace llvm { 18 19 bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source, 20 char *&ResultPtr, const UTF8 *&ErrorPtr) { 21 assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4); 22 ConversionResult result = conversionOK; 23 // Copy the character span over. 24 if (WideCharWidth == 1) { 25 const UTF8 *Pos = reinterpret_cast<const UTF8*>(Source.begin()); 26 if (!isLegalUTF8String(&Pos, reinterpret_cast<const UTF8*>(Source.end()))) { 27 result = sourceIllegal; 28 ErrorPtr = Pos; 29 } else { 30 memcpy(ResultPtr, Source.data(), Source.size()); 31 ResultPtr += Source.size(); 32 } 33 } else if (WideCharWidth == 2) { 34 const UTF8 *sourceStart = (const UTF8*)Source.data(); 35 // FIXME: Make the type of the result buffer correct instead of 36 // using reinterpret_cast. 37 UTF16 *targetStart = reinterpret_cast<UTF16*>(ResultPtr); 38 ConversionFlags flags = strictConversion; 39 result = ConvertUTF8toUTF16( 40 &sourceStart, sourceStart + Source.size(), 41 &targetStart, targetStart + Source.size(), flags); 42 if (result == conversionOK) 43 ResultPtr = reinterpret_cast<char*>(targetStart); 44 else 45 ErrorPtr = sourceStart; 46 } else if (WideCharWidth == 4) { 47 const UTF8 *sourceStart = (const UTF8*)Source.data(); 48 // FIXME: Make the type of the result buffer correct instead of 49 // using reinterpret_cast. 50 UTF32 *targetStart = reinterpret_cast<UTF32*>(ResultPtr); 51 ConversionFlags flags = strictConversion; 52 result = ConvertUTF8toUTF32( 53 &sourceStart, sourceStart + Source.size(), 54 &targetStart, targetStart + Source.size(), flags); 55 if (result == conversionOK) 56 ResultPtr = reinterpret_cast<char*>(targetStart); 57 else 58 ErrorPtr = sourceStart; 59 } 60 assert((result != targetExhausted) 61 && "ConvertUTF8toUTFXX exhausted target buffer"); 62 return result == conversionOK; 63 } 64 65 bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr) { 66 const UTF32 *SourceStart = &Source; 67 const UTF32 *SourceEnd = SourceStart + 1; 68 UTF8 *TargetStart = reinterpret_cast<UTF8 *>(ResultPtr); 69 UTF8 *TargetEnd = TargetStart + 4; 70 ConversionResult CR = ConvertUTF32toUTF8(&SourceStart, SourceEnd, 71 &TargetStart, TargetEnd, 72 strictConversion); 73 if (CR != conversionOK) 74 return false; 75 76 ResultPtr = reinterpret_cast<char*>(TargetStart); 77 return true; 78 } 79 80 bool hasUTF16ByteOrderMark(ArrayRef<char> S) { 81 return (S.size() >= 2 && 82 ((S[0] == '\xff' && S[1] == '\xfe') || 83 (S[0] == '\xfe' && S[1] == '\xff'))); 84 } 85 86 bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out) { 87 assert(Out.empty()); 88 89 // Error out on an uneven byte count. 90 if (SrcBytes.size() % 2) 91 return false; 92 93 // Avoid OOB by returning early on empty input. 94 if (SrcBytes.empty()) 95 return true; 96 97 const UTF16 *Src = reinterpret_cast<const UTF16 *>(SrcBytes.begin()); 98 const UTF16 *SrcEnd = reinterpret_cast<const UTF16 *>(SrcBytes.end()); 99 100 assert((uintptr_t)Src % sizeof(UTF16) == 0); 101 102 // Byteswap if necessary. 103 std::vector<UTF16> ByteSwapped; 104 if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) { 105 ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd); 106 for (UTF16 &I : ByteSwapped) 107 I = llvm::ByteSwap_16(I); 108 Src = &ByteSwapped[0]; 109 SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1; 110 } 111 112 // Skip the BOM for conversion. 113 if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE) 114 Src++; 115 116 // Just allocate enough space up front. We'll shrink it later. Allocate 117 // enough that we can fit a null terminator without reallocating. 118 Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1); 119 UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]); 120 UTF8 *DstEnd = Dst + Out.size(); 121 122 ConversionResult CR = 123 ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion); 124 assert(CR != targetExhausted); 125 126 if (CR != conversionOK) { 127 Out.clear(); 128 return false; 129 } 130 131 Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]); 132 Out.push_back(0); 133 Out.pop_back(); 134 return true; 135 } 136 137 bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out) 138 { 139 return convertUTF16ToUTF8String( 140 llvm::ArrayRef<char>(reinterpret_cast<const char *>(Src.data()), 141 Src.size() * sizeof(UTF16)), Out); 142 } 143 144 bool convertUTF8ToUTF16String(StringRef SrcUTF8, 145 SmallVectorImpl<UTF16> &DstUTF16) { 146 assert(DstUTF16.empty()); 147 148 // Avoid OOB by returning early on empty input. 149 if (SrcUTF8.empty()) { 150 DstUTF16.push_back(0); 151 DstUTF16.pop_back(); 152 return true; 153 } 154 155 const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.begin()); 156 const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.end()); 157 158 // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding 159 // as UTF-16 should always require the same amount or less code units than the 160 // UTF-8 encoding. Allocate one extra byte for the null terminator though, 161 // so that someone calling DstUTF16.data() gets a null terminated string. 162 // We resize down later so we don't have to worry that this over allocates. 163 DstUTF16.resize(SrcUTF8.size()+1); 164 UTF16 *Dst = &DstUTF16[0]; 165 UTF16 *DstEnd = Dst + DstUTF16.size(); 166 167 ConversionResult CR = 168 ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion); 169 assert(CR != targetExhausted); 170 171 if (CR != conversionOK) { 172 DstUTF16.clear(); 173 return false; 174 } 175 176 DstUTF16.resize(Dst - &DstUTF16[0]); 177 DstUTF16.push_back(0); 178 DstUTF16.pop_back(); 179 return true; 180 } 181 182 static_assert(sizeof(wchar_t) == 1 || sizeof(wchar_t) == 2 || 183 sizeof(wchar_t) == 4, 184 "Expected wchar_t to be 1, 2, or 4 bytes"); 185 186 template <typename TResult> 187 static inline bool ConvertUTF8toWideInternal(llvm::StringRef Source, 188 TResult &Result) { 189 // Even in the case of UTF-16, the number of bytes in a UTF-8 string is 190 // at least as large as the number of elements in the resulting wide 191 // string, because surrogate pairs take at least 4 bytes in UTF-8. 192 Result.resize(Source.size() + 1); 193 char *ResultPtr = reinterpret_cast<char *>(&Result[0]); 194 const UTF8 *ErrorPtr; 195 if (!ConvertUTF8toWide(sizeof(wchar_t), Source, ResultPtr, ErrorPtr)) { 196 Result.clear(); 197 return false; 198 } 199 Result.resize(reinterpret_cast<wchar_t *>(ResultPtr) - &Result[0]); 200 return true; 201 } 202 203 bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result) { 204 return ConvertUTF8toWideInternal(Source, Result); 205 } 206 207 bool ConvertUTF8toWide(const char *Source, std::wstring &Result) { 208 if (!Source) { 209 Result.clear(); 210 return true; 211 } 212 return ConvertUTF8toWide(llvm::StringRef(Source), Result); 213 } 214 215 bool convertWideToUTF8(const std::wstring &Source, std::string &Result) { 216 if (sizeof(wchar_t) == 1) { 217 const UTF8 *Start = reinterpret_cast<const UTF8 *>(Source.data()); 218 const UTF8 *End = 219 reinterpret_cast<const UTF8 *>(Source.data() + Source.size()); 220 if (!isLegalUTF8String(&Start, End)) 221 return false; 222 Result.resize(Source.size()); 223 memcpy(&Result[0], Source.data(), Source.size()); 224 return true; 225 } else if (sizeof(wchar_t) == 2) { 226 return convertUTF16ToUTF8String( 227 llvm::ArrayRef<UTF16>(reinterpret_cast<const UTF16 *>(Source.data()), 228 Source.size()), 229 Result); 230 } else if (sizeof(wchar_t) == 4) { 231 const UTF32 *Start = reinterpret_cast<const UTF32 *>(Source.data()); 232 const UTF32 *End = 233 reinterpret_cast<const UTF32 *>(Source.data() + Source.size()); 234 Result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT * Source.size()); 235 UTF8 *ResultPtr = reinterpret_cast<UTF8 *>(&Result[0]); 236 UTF8 *ResultEnd = reinterpret_cast<UTF8 *>(&Result[0] + Result.size()); 237 if (ConvertUTF32toUTF8(&Start, End, &ResultPtr, ResultEnd, 238 strictConversion) == conversionOK) { 239 Result.resize(reinterpret_cast<char *>(ResultPtr) - &Result[0]); 240 return true; 241 } else { 242 Result.clear(); 243 return false; 244 } 245 } else { 246 llvm_unreachable( 247 "Control should never reach this point; see static_assert further up"); 248 } 249 } 250 251 } // end namespace llvm 252 253