| //===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----=== |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/Support/ConvertUTF.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/SwapByteOrder.h" |
| #include <string> |
| #include <vector> |
| |
| namespace llvm { |
| |
| bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source, |
| char *&ResultPtr, const UTF8 *&ErrorPtr) { |
| assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4); |
| ConversionResult result = conversionOK; |
| // Copy the character span over. |
| if (WideCharWidth == 1) { |
| const UTF8 *Pos = reinterpret_cast<const UTF8*>(Source.begin()); |
| if (!isLegalUTF8String(&Pos, reinterpret_cast<const UTF8*>(Source.end()))) { |
| result = sourceIllegal; |
| ErrorPtr = Pos; |
| } else { |
| memcpy(ResultPtr, Source.data(), Source.size()); |
| ResultPtr += Source.size(); |
| } |
| } else if (WideCharWidth == 2) { |
| const UTF8 *sourceStart = (const UTF8*)Source.data(); |
| // FIXME: Make the type of the result buffer correct instead of |
| // using reinterpret_cast. |
| UTF16 *targetStart = reinterpret_cast<UTF16*>(ResultPtr); |
| ConversionFlags flags = strictConversion; |
| result = ConvertUTF8toUTF16( |
| &sourceStart, sourceStart + Source.size(), |
| &targetStart, targetStart + Source.size(), flags); |
| if (result == conversionOK) |
| ResultPtr = reinterpret_cast<char*>(targetStart); |
| else |
| ErrorPtr = sourceStart; |
| } else if (WideCharWidth == 4) { |
| const UTF8 *sourceStart = (const UTF8*)Source.data(); |
| // FIXME: Make the type of the result buffer correct instead of |
| // using reinterpret_cast. |
| UTF32 *targetStart = reinterpret_cast<UTF32*>(ResultPtr); |
| ConversionFlags flags = strictConversion; |
| result = ConvertUTF8toUTF32( |
| &sourceStart, sourceStart + Source.size(), |
| &targetStart, targetStart + Source.size(), flags); |
| if (result == conversionOK) |
| ResultPtr = reinterpret_cast<char*>(targetStart); |
| else |
| ErrorPtr = sourceStart; |
| } |
| assert((result != targetExhausted) |
| && "ConvertUTF8toUTFXX exhausted target buffer"); |
| return result == conversionOK; |
| } |
| |
| bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr) { |
| const UTF32 *SourceStart = &Source; |
| const UTF32 *SourceEnd = SourceStart + 1; |
| UTF8 *TargetStart = reinterpret_cast<UTF8 *>(ResultPtr); |
| UTF8 *TargetEnd = TargetStart + 4; |
| ConversionResult CR = ConvertUTF32toUTF8(&SourceStart, SourceEnd, |
| &TargetStart, TargetEnd, |
| strictConversion); |
| if (CR != conversionOK) |
| return false; |
| |
| ResultPtr = reinterpret_cast<char*>(TargetStart); |
| return true; |
| } |
| |
| bool hasUTF16ByteOrderMark(ArrayRef<char> S) { |
| return (S.size() >= 2 && |
| ((S[0] == '\xff' && S[1] == '\xfe') || |
| (S[0] == '\xfe' && S[1] == '\xff'))); |
| } |
| |
| bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out) { |
| assert(Out.empty()); |
| |
| // Error out on an uneven byte count. |
| if (SrcBytes.size() % 2) |
| return false; |
| |
| // Avoid OOB by returning early on empty input. |
| if (SrcBytes.empty()) |
| return true; |
| |
| const UTF16 *Src = reinterpret_cast<const UTF16 *>(SrcBytes.begin()); |
| const UTF16 *SrcEnd = reinterpret_cast<const UTF16 *>(SrcBytes.end()); |
| |
| assert((uintptr_t)Src % sizeof(UTF16) == 0); |
| |
| // Byteswap if necessary. |
| std::vector<UTF16> ByteSwapped; |
| if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) { |
| ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd); |
| for (unsigned I = 0, E = ByteSwapped.size(); I != E; ++I) |
| ByteSwapped[I] = llvm::ByteSwap_16(ByteSwapped[I]); |
| Src = &ByteSwapped[0]; |
| SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1; |
| } |
| |
| // Skip the BOM for conversion. |
| if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE) |
| Src++; |
| |
| // Just allocate enough space up front. We'll shrink it later. Allocate |
| // enough that we can fit a null terminator without reallocating. |
| Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1); |
| UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]); |
| UTF8 *DstEnd = Dst + Out.size(); |
| |
| ConversionResult CR = |
| ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion); |
| assert(CR != targetExhausted); |
| |
| if (CR != conversionOK) { |
| Out.clear(); |
| return false; |
| } |
| |
| Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]); |
| Out.push_back(0); |
| Out.pop_back(); |
| return true; |
| } |
| |
| bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out) |
| { |
| return convertUTF16ToUTF8String( |
| llvm::ArrayRef<char>(reinterpret_cast<const char *>(Src.data()), |
| Src.size() * sizeof(UTF16)), Out); |
| } |
| |
| bool convertUTF8ToUTF16String(StringRef SrcUTF8, |
| SmallVectorImpl<UTF16> &DstUTF16) { |
| assert(DstUTF16.empty()); |
| |
| // Avoid OOB by returning early on empty input. |
| if (SrcUTF8.empty()) { |
| DstUTF16.push_back(0); |
| DstUTF16.pop_back(); |
| return true; |
| } |
| |
| const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.begin()); |
| const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.end()); |
| |
| // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding |
| // as UTF-16 should always require the same amount or less code units than the |
| // UTF-8 encoding. Allocate one extra byte for the null terminator though, |
| // so that someone calling DstUTF16.data() gets a null terminated string. |
| // We resize down later so we don't have to worry that this over allocates. |
| DstUTF16.resize(SrcUTF8.size()+1); |
| UTF16 *Dst = &DstUTF16[0]; |
| UTF16 *DstEnd = Dst + DstUTF16.size(); |
| |
| ConversionResult CR = |
| ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion); |
| assert(CR != targetExhausted); |
| |
| if (CR != conversionOK) { |
| DstUTF16.clear(); |
| return false; |
| } |
| |
| DstUTF16.resize(Dst - &DstUTF16[0]); |
| DstUTF16.push_back(0); |
| DstUTF16.pop_back(); |
| return true; |
| } |
| |
| static_assert(sizeof(wchar_t) == 1 || sizeof(wchar_t) == 2 || |
| sizeof(wchar_t) == 4, |
| "Expected wchar_t to be 1, 2, or 4 bytes"); |
| |
| template <typename TResult> |
| static inline bool ConvertUTF8toWideInternal(llvm::StringRef Source, |
| TResult &Result) { |
| // Even in the case of UTF-16, the number of bytes in a UTF-8 string is |
| // at least as large as the number of elements in the resulting wide |
| // string, because surrogate pairs take at least 4 bytes in UTF-8. |
| Result.resize(Source.size() + 1); |
| char *ResultPtr = reinterpret_cast<char *>(&Result[0]); |
| const UTF8 *ErrorPtr; |
| if (!ConvertUTF8toWide(sizeof(wchar_t), Source, ResultPtr, ErrorPtr)) { |
| Result.clear(); |
| return false; |
| } |
| Result.resize(reinterpret_cast<wchar_t *>(ResultPtr) - &Result[0]); |
| return true; |
| } |
| |
| bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result) { |
| return ConvertUTF8toWideInternal(Source, Result); |
| } |
| |
| bool ConvertUTF8toWide(const char *Source, std::wstring &Result) { |
| if (!Source) { |
| Result.clear(); |
| return true; |
| } |
| return ConvertUTF8toWide(llvm::StringRef(Source), Result); |
| } |
| |
| bool convertWideToUTF8(const std::wstring &Source, std::string &Result) { |
| if (sizeof(wchar_t) == 1) { |
| const UTF8 *Start = reinterpret_cast<const UTF8 *>(Source.data()); |
| const UTF8 *End = |
| reinterpret_cast<const UTF8 *>(Source.data() + Source.size()); |
| if (!isLegalUTF8String(&Start, End)) |
| return false; |
| Result.resize(Source.size()); |
| memcpy(&Result[0], Source.data(), Source.size()); |
| return true; |
| } else if (sizeof(wchar_t) == 2) { |
| return convertUTF16ToUTF8String( |
| llvm::ArrayRef<UTF16>(reinterpret_cast<const UTF16 *>(Source.data()), |
| Source.size()), |
| Result); |
| } else if (sizeof(wchar_t) == 4) { |
| const UTF32 *Start = reinterpret_cast<const UTF32 *>(Source.data()); |
| const UTF32 *End = |
| reinterpret_cast<const UTF32 *>(Source.data() + Source.size()); |
| Result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT * Source.size()); |
| UTF8 *ResultPtr = reinterpret_cast<UTF8 *>(&Result[0]); |
| UTF8 *ResultEnd = reinterpret_cast<UTF8 *>(&Result[0] + Result.size()); |
| if (ConvertUTF32toUTF8(&Start, End, &ResultPtr, ResultEnd, |
| strictConversion) == conversionOK) { |
| Result.resize(reinterpret_cast<char *>(ResultPtr) - &Result[0]); |
| return true; |
| } else { |
| Result.clear(); |
| return false; |
| } |
| } else { |
| llvm_unreachable( |
| "Control should never reach this point; see static_assert further up"); |
| } |
| } |
| |
| } // end namespace llvm |
| |