LLVM 20.0.0git
ConvertUTFWrapper.cpp
Go to the documentation of this file.
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"
14#include <string>
15#include <vector>
16
17namespace llvm {
18
19bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
20 char *&ResultPtr, const UTF8 *&ErrorPtr) {
21 assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4);
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);
39 result =
40 ConvertUTF8toUTF16(&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);
52 result =
53 ConvertUTF8toUTF32(&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
65bool 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;
71 &SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);
72 if (CR != conversionOK)
73 return false;
74
75 ResultPtr = reinterpret_cast<char *>(TargetStart);
76 return true;
77}
78
80 return (S.size() >= 2 && ((S[0] == '\xff' && S[1] == '\xfe') ||
81 (S[0] == '\xfe' && S[1] == '\xff')));
82}
83
84bool 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 assert((uintptr_t)Src % sizeof(UTF16) == 0);
99
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);
104 for (UTF16 &I : ByteSwapped)
105 I = llvm::byteswap<uint16_t>(I);
106 Src = &ByteSwapped[0];
107 SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
108 }
109
110 // Skip the BOM for conversion.
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
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
135bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out) {
137 llvm::ArrayRef<char>(reinterpret_cast<const char *>(Src.data()),
138 Src.size() * sizeof(UTF16)),
139 Out);
140}
141
142bool 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)
163 I = llvm::byteswap<uint32_t>(I);
164 Src = &ByteSwapped[0];
165 SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
166 }
167
168 // Skip the BOM for conversion.
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
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
193bool convertUTF32ToUTF8String(ArrayRef<UTF32> Src, std::string &Out) {
195 llvm::ArrayRef<char>(reinterpret_cast<const char *>(Src.data()),
196 Src.size() * sizeof(UTF32)),
197 Out);
198}
199
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
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
238static_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
242template <typename TResult>
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
259bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result) {
260 return ConvertUTF8toWideInternal(Source, Result);
261}
262
263bool 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
271bool 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) {
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,
295 Result.resize(reinterpret_cast<char *>(ResultPtr) - &Result[0]);
296 return true;
297 } else {
298 Result.clear();
299 return false;
300 }
301 } else {
303 "Control should never reach this point; see static_assert further up");
304 }
305}
306
307} // end namespace llvm
308
#define UNI_UTF32_BYTE_ORDER_MARK_SWAPPED
Definition: ConvertUTF.h:146
#define UNI_UTF32_BYTE_ORDER_MARK_NATIVE
Definition: ConvertUTF.h:145
#define UNI_MAX_UTF8_BYTES_PER_CODE_POINT
Definition: ConvertUTF.h:140
#define UNI_UTF16_BYTE_ORDER_MARK_NATIVE
Definition: ConvertUTF.h:142
#define UNI_UTF16_BYTE_ORDER_MARK_SWAPPED
Definition: ConvertUTF.h:143
bool End
Definition: ELF_riscv.cpp:480
#define I(x, y, z)
Definition: MD5.cpp:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator end() const
Definition: ArrayRef.h:154
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
iterator begin() const
Definition: ArrayRef.h:153
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void resize(size_type N)
Definition: SmallVector.h:651
void push_back(const T &Elt)
Definition: SmallVector.h:426
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
iterator begin() const
Definition: StringRef.h:111
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
iterator end() const
Definition: StringRef.h:113
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
unsigned short UTF16
Definition: ConvertUTF.h:129
ConversionResult ConvertUTF8toUTF32(const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF32 **targetStart, UTF32 *targetEnd, ConversionFlags flags)
Convert a partial UTF8 sequence to UTF32.
Definition: ConvertUTF.cpp:736
bool hasUTF16ByteOrderMark(ArrayRef< char > SrcBytes)
Returns true if a blob of text starts with a UTF-16 big or little endian byte order mark.
ConversionFlags
Definition: ConvertUTF.h:155
@ strictConversion
Definition: ConvertUTF.h:156
ConversionResult
Definition: ConvertUTF.h:148
@ targetExhausted
Definition: ConvertUTF.h:151
@ conversionOK
Definition: ConvertUTF.h:149
@ sourceIllegal
Definition: ConvertUTF.h:152
bool convertWideToUTF8(const std::wstring &Source, std::string &Result)
Converts a std::wstring to a UTF-8 encoded std::string.
bool convertUTF16ToUTF8String(ArrayRef< char > SrcBytes, std::string &Out)
Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
static bool ConvertUTF8toWideInternal(llvm::StringRef Source, TResult &Result)
ConversionResult ConvertUTF16toUTF8(const UTF16 **sourceStart, const UTF16 *sourceEnd, UTF8 **targetStart, UTF8 *targetEnd, ConversionFlags flags)
Definition: ConvertUTF.cpp:263
bool convertUTF32ToUTF8String(ArrayRef< char > SrcBytes, std::string &Out)
Converts a stream of raw bytes assumed to be UTF32 into a UTF8 std::string.
bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source, char *&ResultPtr, const UTF8 *&ErrorPtr)
Convert an UTF8 StringRef to UTF8, UTF16, or UTF32 depending on WideCharWidth.
ConversionResult ConvertUTF32toUTF8(const UTF32 **sourceStart, const UTF32 *sourceEnd, UTF8 **targetStart, UTF8 *targetEnd, ConversionFlags flags)
Definition: ConvertUTF.cpp:333
Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd)
Definition: ConvertUTF.cpp:555
bool convertUTF8ToUTF16String(StringRef SrcUTF8, SmallVectorImpl< UTF16 > &DstUTF16)
Converts a UTF-8 string into a UTF-16 string with native endianness.
bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr)
Convert an Unicode code point to UTF8 sequence.
unsigned char UTF8
Definition: ConvertUTF.h:130
ConversionResult ConvertUTF8toUTF16(const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF16 **targetStart, UTF16 *targetEnd, ConversionFlags flags)
Definition: ConvertUTF.cpp:567
unsigned int UTF32
Definition: ConvertUTF.h:128