|
150
|
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.
|
|
236
|
37 UTF16 *targetStart = reinterpret_cast<UTF16 *>(ResultPtr);
|
|
150
|
38 ConversionFlags flags = strictConversion;
|
|
236
|
39 result =
|
|
|
40 ConvertUTF8toUTF16(&sourceStart, sourceStart + Source.size(),
|
|
|
41 &targetStart, targetStart + Source.size(), flags);
|
|
150
|
42 if (result == conversionOK)
|
|
236
|
43 ResultPtr = reinterpret_cast<char *>(targetStart);
|
|
150
|
44 else
|
|
|
45 ErrorPtr = sourceStart;
|
|
|
46 } else if (WideCharWidth == 4) {
|
|
236
|
47 const UTF8 *sourceStart = (const UTF8 *)Source.data();
|
|
150
|
48 // FIXME: Make the type of the result buffer correct instead of
|
|
|
49 // using reinterpret_cast.
|
|
236
|
50 UTF32 *targetStart = reinterpret_cast<UTF32 *>(ResultPtr);
|
|
150
|
51 ConversionFlags flags = strictConversion;
|
|
236
|
52 result =
|
|
|
53 ConvertUTF8toUTF32(&sourceStart, sourceStart + Source.size(),
|
|
|
54 &targetStart, targetStart + Source.size(), flags);
|
|
150
|
55 if (result == conversionOK)
|
|
236
|
56 ResultPtr = reinterpret_cast<char *>(targetStart);
|
|
150
|
57 else
|
|
|
58 ErrorPtr = sourceStart;
|
|
|
59 }
|
|
236
|
60 assert((result != targetExhausted) &&
|
|
|
61 "ConvertUTF8toUTFXX exhausted target buffer");
|
|
150
|
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;
|
|
236
|
70 ConversionResult CR = ConvertUTF32toUTF8(
|
|
|
71 &SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);
|
|
150
|
72 if (CR != conversionOK)
|
|
|
73 return false;
|
|
|
74
|
|
236
|
75 ResultPtr = reinterpret_cast<char *>(TargetStart);
|
|
150
|
76 return true;
|
|
|
77 }
|
|
|
78
|
|
|
79 bool hasUTF16ByteOrderMark(ArrayRef<char> S) {
|
|
236
|
80 return (S.size() >= 2 && ((S[0] == '\xff' && S[1] == '\xfe') ||
|
|
|
81 (S[0] == '\xfe' && S[1] == '\xff')));
|
|
150
|
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
|
|
221
|
98 assert((uintptr_t)Src % sizeof(UTF16) == 0);
|
|
|
99
|
|
150
|
100 // Byteswap if necessary.
|
|
|
101 std::vector<UTF16> ByteSwapped;
|
|
|
102 if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) {
|
|
|
103 ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd);
|
|
236
|
104 for (UTF16 &I : ByteSwapped)
|
|
252
|
105 I = llvm::byteswap<uint16_t>(I);
|
|
150
|
106 Src = &ByteSwapped[0];
|
|
|
107 SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
|
|
|
108 }
|
|
|
109
|
|
|
110 // Skip the BOM for conversion.
|
|
|
111 if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE)
|
|
|
112 Src++;
|
|
|
113
|
|
|
114 // Just allocate enough space up front. We'll shrink it later. Allocate
|
|
|
115 // enough that we can fit a null terminator without reallocating.
|
|
|
116 Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1);
|
|
|
117 UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]);
|
|
|
118 UTF8 *DstEnd = Dst + Out.size();
|
|
|
119
|
|
|
120 ConversionResult CR =
|
|
|
121 ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
|
|
|
122 assert(CR != targetExhausted);
|
|
|
123
|
|
|
124 if (CR != conversionOK) {
|
|
|
125 Out.clear();
|
|
|
126 return false;
|
|
|
127 }
|
|
|
128
|
|
|
129 Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]);
|
|
|
130 Out.push_back(0);
|
|
|
131 Out.pop_back();
|
|
|
132 return true;
|
|
|
133 }
|
|
|
134
|
|
236
|
135 bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out) {
|
|
150
|
136 return convertUTF16ToUTF8String(
|
|
|
137 llvm::ArrayRef<char>(reinterpret_cast<const char *>(Src.data()),
|
|
236
|
138 Src.size() * sizeof(UTF16)),
|
|
|
139 Out);
|
|
|
140 }
|
|
|
141
|
|
|
142 bool convertUTF32ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out) {
|
|
|
143 assert(Out.empty());
|
|
|
144
|
|
|
145 // Error out on an uneven byte count.
|
|
|
146 if (SrcBytes.size() % 4)
|
|
|
147 return false;
|
|
|
148
|
|
|
149 // Avoid OOB by returning early on empty input.
|
|
|
150 if (SrcBytes.empty())
|
|
|
151 return true;
|
|
|
152
|
|
|
153 const UTF32 *Src = reinterpret_cast<const UTF32 *>(SrcBytes.begin());
|
|
|
154 const UTF32 *SrcEnd = reinterpret_cast<const UTF32 *>(SrcBytes.end());
|
|
|
155
|
|
|
156 assert((uintptr_t)Src % sizeof(UTF32) == 0);
|
|
|
157
|
|
|
158 // Byteswap if necessary.
|
|
|
159 std::vector<UTF32> ByteSwapped;
|
|
|
160 if (Src[0] == UNI_UTF32_BYTE_ORDER_MARK_SWAPPED) {
|
|
|
161 ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd);
|
|
|
162 for (UTF32 &I : ByteSwapped)
|
|
252
|
163 I = llvm::byteswap<uint32_t>(I);
|
|
236
|
164 Src = &ByteSwapped[0];
|
|
|
165 SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
|
|
|
166 }
|
|
|
167
|
|
|
168 // Skip the BOM for conversion.
|
|
|
169 if (Src[0] == UNI_UTF32_BYTE_ORDER_MARK_NATIVE)
|
|
|
170 Src++;
|
|
|
171
|
|
|
172 // Just allocate enough space up front. We'll shrink it later. Allocate
|
|
|
173 // enough that we can fit a null terminator without reallocating.
|
|
|
174 Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1);
|
|
|
175 UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]);
|
|
|
176 UTF8 *DstEnd = Dst + Out.size();
|
|
|
177
|
|
|
178 ConversionResult CR =
|
|
|
179 ConvertUTF32toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
|
|
|
180 assert(CR != targetExhausted);
|
|
|
181
|
|
|
182 if (CR != conversionOK) {
|
|
|
183 Out.clear();
|
|
|
184 return false;
|
|
|
185 }
|
|
|
186
|
|
|
187 Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]);
|
|
|
188 Out.push_back(0);
|
|
|
189 Out.pop_back();
|
|
|
190 return true;
|
|
|
191 }
|
|
|
192
|
|
|
193 bool convertUTF32ToUTF8String(ArrayRef<UTF32> Src, std::string &Out) {
|
|
|
194 return convertUTF32ToUTF8String(
|
|
|
195 llvm::ArrayRef<char>(reinterpret_cast<const char *>(Src.data()),
|
|
|
196 Src.size() * sizeof(UTF32)),
|
|
|
197 Out);
|
|
150
|
198 }
|
|
|
199
|
|
|
200 bool convertUTF8ToUTF16String(StringRef SrcUTF8,
|
|
|
201 SmallVectorImpl<UTF16> &DstUTF16) {
|
|
|
202 assert(DstUTF16.empty());
|
|
|
203
|
|
|
204 // Avoid OOB by returning early on empty input.
|
|
|
205 if (SrcUTF8.empty()) {
|
|
|
206 DstUTF16.push_back(0);
|
|
|
207 DstUTF16.pop_back();
|
|
|
208 return true;
|
|
|
209 }
|
|
|
210
|
|
|
211 const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.begin());
|
|
|
212 const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.end());
|
|
|
213
|
|
|
214 // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding
|
|
|
215 // as UTF-16 should always require the same amount or less code units than the
|
|
|
216 // UTF-8 encoding. Allocate one extra byte for the null terminator though,
|
|
|
217 // so that someone calling DstUTF16.data() gets a null terminated string.
|
|
|
218 // We resize down later so we don't have to worry that this over allocates.
|
|
|
219 DstUTF16.resize(SrcUTF8.size()+1);
|
|
|
220 UTF16 *Dst = &DstUTF16[0];
|
|
|
221 UTF16 *DstEnd = Dst + DstUTF16.size();
|
|
|
222
|
|
|
223 ConversionResult CR =
|
|
|
224 ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
|
|
|
225 assert(CR != targetExhausted);
|
|
|
226
|
|
|
227 if (CR != conversionOK) {
|
|
|
228 DstUTF16.clear();
|
|
|
229 return false;
|
|
|
230 }
|
|
|
231
|
|
|
232 DstUTF16.resize(Dst - &DstUTF16[0]);
|
|
|
233 DstUTF16.push_back(0);
|
|
|
234 DstUTF16.pop_back();
|
|
|
235 return true;
|
|
|
236 }
|
|
|
237
|
|
|
238 static_assert(sizeof(wchar_t) == 1 || sizeof(wchar_t) == 2 ||
|
|
|
239 sizeof(wchar_t) == 4,
|
|
|
240 "Expected wchar_t to be 1, 2, or 4 bytes");
|
|
|
241
|
|
|
242 template <typename TResult>
|
|
|
243 static inline bool ConvertUTF8toWideInternal(llvm::StringRef Source,
|
|
|
244 TResult &Result) {
|
|
|
245 // Even in the case of UTF-16, the number of bytes in a UTF-8 string is
|
|
|
246 // at least as large as the number of elements in the resulting wide
|
|
|
247 // string, because surrogate pairs take at least 4 bytes in UTF-8.
|
|
|
248 Result.resize(Source.size() + 1);
|
|
|
249 char *ResultPtr = reinterpret_cast<char *>(&Result[0]);
|
|
|
250 const UTF8 *ErrorPtr;
|
|
|
251 if (!ConvertUTF8toWide(sizeof(wchar_t), Source, ResultPtr, ErrorPtr)) {
|
|
|
252 Result.clear();
|
|
|
253 return false;
|
|
|
254 }
|
|
|
255 Result.resize(reinterpret_cast<wchar_t *>(ResultPtr) - &Result[0]);
|
|
|
256 return true;
|
|
|
257 }
|
|
|
258
|
|
|
259 bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result) {
|
|
|
260 return ConvertUTF8toWideInternal(Source, Result);
|
|
|
261 }
|
|
|
262
|
|
|
263 bool ConvertUTF8toWide(const char *Source, std::wstring &Result) {
|
|
|
264 if (!Source) {
|
|
|
265 Result.clear();
|
|
|
266 return true;
|
|
|
267 }
|
|
|
268 return ConvertUTF8toWide(llvm::StringRef(Source), Result);
|
|
|
269 }
|
|
|
270
|
|
|
271 bool convertWideToUTF8(const std::wstring &Source, std::string &Result) {
|
|
|
272 if (sizeof(wchar_t) == 1) {
|
|
|
273 const UTF8 *Start = reinterpret_cast<const UTF8 *>(Source.data());
|
|
|
274 const UTF8 *End =
|
|
|
275 reinterpret_cast<const UTF8 *>(Source.data() + Source.size());
|
|
|
276 if (!isLegalUTF8String(&Start, End))
|
|
|
277 return false;
|
|
|
278 Result.resize(Source.size());
|
|
|
279 memcpy(&Result[0], Source.data(), Source.size());
|
|
|
280 return true;
|
|
|
281 } else if (sizeof(wchar_t) == 2) {
|
|
|
282 return convertUTF16ToUTF8String(
|
|
|
283 llvm::ArrayRef<UTF16>(reinterpret_cast<const UTF16 *>(Source.data()),
|
|
|
284 Source.size()),
|
|
|
285 Result);
|
|
|
286 } else if (sizeof(wchar_t) == 4) {
|
|
|
287 const UTF32 *Start = reinterpret_cast<const UTF32 *>(Source.data());
|
|
|
288 const UTF32 *End =
|
|
|
289 reinterpret_cast<const UTF32 *>(Source.data() + Source.size());
|
|
|
290 Result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT * Source.size());
|
|
|
291 UTF8 *ResultPtr = reinterpret_cast<UTF8 *>(&Result[0]);
|
|
|
292 UTF8 *ResultEnd = reinterpret_cast<UTF8 *>(&Result[0] + Result.size());
|
|
|
293 if (ConvertUTF32toUTF8(&Start, End, &ResultPtr, ResultEnd,
|
|
|
294 strictConversion) == conversionOK) {
|
|
|
295 Result.resize(reinterpret_cast<char *>(ResultPtr) - &Result[0]);
|
|
|
296 return true;
|
|
|
297 } else {
|
|
|
298 Result.clear();
|
|
|
299 return false;
|
|
|
300 }
|
|
|
301 } else {
|
|
|
302 llvm_unreachable(
|
|
|
303 "Control should never reach this point; see static_assert further up");
|
|
|
304 }
|
|
|
305 }
|
|
|
306
|
|
|
307 } // end namespace llvm
|
|
|
308
|
