xref: /freebsd/contrib/llvm-project/llvm/lib/Support/ConvertUTFWrapper.cpp (revision 7ef62cebc2f965b0f640263e179276928885e33d) 
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 =
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);
51     ConversionFlags flags = strictConversion;
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 
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(
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 
79 bool hasUTF16ByteOrderMark(ArrayRef<char> S) {
80   return (S.size() >= 2 && ((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   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_16(I);
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 
135 bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out) {
136   return convertUTF16ToUTF8String(
137       llvm::ArrayRef<char>(reinterpret_cast<const char *>(Src.data()),
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)
163       I = llvm::ByteSwap_32(I);
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);
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 
309