1249259Sdim//===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----=== 2249259Sdim// 3249259Sdim// The LLVM Compiler Infrastructure 4249259Sdim// 5249259Sdim// This file is distributed under the University of Illinois Open Source 6249259Sdim// License. See LICENSE.TXT for details. 7249259Sdim// 8249259Sdim//===----------------------------------------------------------------------===// 9249259Sdim 10249259Sdim#include "llvm/Support/ConvertUTF.h" 11261991Sdim#include "llvm/Support/SwapByteOrder.h" 12261991Sdim#include <string> 13261991Sdim#include <vector> 14249259Sdim 15249259Sdimnamespace llvm { 16249259Sdim 17249259Sdimbool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source, 18249259Sdim char *&ResultPtr, const UTF8 *&ErrorPtr) { 19249259Sdim assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4); 20249259Sdim ConversionResult result = conversionOK; 21249259Sdim // Copy the character span over. 22249259Sdim if (WideCharWidth == 1) { 23249259Sdim const UTF8 *Pos = reinterpret_cast<const UTF8*>(Source.begin()); 24249259Sdim if (!isLegalUTF8String(&Pos, reinterpret_cast<const UTF8*>(Source.end()))) { 25249259Sdim result = sourceIllegal; 26249259Sdim ErrorPtr = Pos; 27249259Sdim } else { 28249259Sdim memcpy(ResultPtr, Source.data(), Source.size()); 29249259Sdim ResultPtr += Source.size(); 30249259Sdim } 31249259Sdim } else if (WideCharWidth == 2) { 32249259Sdim const UTF8 *sourceStart = (const UTF8*)Source.data(); 33249259Sdim // FIXME: Make the type of the result buffer correct instead of 34249259Sdim // using reinterpret_cast. 35249259Sdim UTF16 *targetStart = reinterpret_cast<UTF16*>(ResultPtr); 36249259Sdim ConversionFlags flags = strictConversion; 37249259Sdim result = ConvertUTF8toUTF16( 38249259Sdim &sourceStart, sourceStart + Source.size(), 39249259Sdim &targetStart, targetStart + 2*Source.size(), flags); 40249259Sdim if (result == conversionOK) 41249259Sdim ResultPtr = reinterpret_cast<char*>(targetStart); 42249259Sdim else 43249259Sdim ErrorPtr = sourceStart; 44249259Sdim } else if (WideCharWidth == 4) { 45249259Sdim const UTF8 *sourceStart = (const UTF8*)Source.data(); 46249259Sdim // FIXME: Make the type of the result buffer correct instead of 47249259Sdim // using reinterpret_cast. 48249259Sdim UTF32 *targetStart = reinterpret_cast<UTF32*>(ResultPtr); 49249259Sdim ConversionFlags flags = strictConversion; 50249259Sdim result = ConvertUTF8toUTF32( 51249259Sdim &sourceStart, sourceStart + Source.size(), 52249259Sdim &targetStart, targetStart + 4*Source.size(), flags); 53249259Sdim if (result == conversionOK) 54249259Sdim ResultPtr = reinterpret_cast<char*>(targetStart); 55249259Sdim else 56249259Sdim ErrorPtr = sourceStart; 57249259Sdim } 58249259Sdim assert((result != targetExhausted) 59249259Sdim && "ConvertUTF8toUTFXX exhausted target buffer"); 60249259Sdim return result == conversionOK; 61249259Sdim} 62249259Sdim 63249259Sdimbool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr) { 64249259Sdim const UTF32 *SourceStart = &Source; 65249259Sdim const UTF32 *SourceEnd = SourceStart + 1; 66249259Sdim UTF8 *TargetStart = reinterpret_cast<UTF8 *>(ResultPtr); 67249259Sdim UTF8 *TargetEnd = TargetStart + 4; 68249259Sdim ConversionResult CR = ConvertUTF32toUTF8(&SourceStart, SourceEnd, 69249259Sdim &TargetStart, TargetEnd, 70249259Sdim strictConversion); 71249259Sdim if (CR != conversionOK) 72249259Sdim return false; 73249259Sdim 74249259Sdim ResultPtr = reinterpret_cast<char*>(TargetStart); 75249259Sdim return true; 76249259Sdim} 77249259Sdim 78261991Sdimbool hasUTF16ByteOrderMark(ArrayRef<char> S) { 79261991Sdim return (S.size() >= 2 && 80261991Sdim ((S[0] == '\xff' && S[1] == '\xfe') || 81261991Sdim (S[0] == '\xfe' && S[1] == '\xff'))); 82261991Sdim} 83261991Sdim 84261991Sdimbool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out) { 85261991Sdim assert(Out.empty()); 86261991Sdim 87261991Sdim // Error out on an uneven byte count. 88261991Sdim if (SrcBytes.size() % 2) 89261991Sdim return false; 90261991Sdim 91261991Sdim // Avoid OOB by returning early on empty input. 92261991Sdim if (SrcBytes.empty()) 93261991Sdim return true; 94261991Sdim 95261991Sdim const UTF16 *Src = reinterpret_cast<const UTF16 *>(SrcBytes.begin()); 96261991Sdim const UTF16 *SrcEnd = reinterpret_cast<const UTF16 *>(SrcBytes.end()); 97261991Sdim 98261991Sdim // Byteswap if necessary. 99261991Sdim std::vector<UTF16> ByteSwapped; 100261991Sdim if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) { 101261991Sdim ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd); 102261991Sdim for (unsigned I = 0, E = ByteSwapped.size(); I != E; ++I) 103261991Sdim ByteSwapped[I] = llvm::sys::SwapByteOrder_16(ByteSwapped[I]); 104261991Sdim Src = &ByteSwapped[0]; 105261991Sdim SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1; 106261991Sdim } 107261991Sdim 108261991Sdim // Skip the BOM for conversion. 109261991Sdim if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE) 110261991Sdim Src++; 111261991Sdim 112288943Sdim // Just allocate enough space up front. We'll shrink it later. Allocate 113288943Sdim // enough that we can fit a null terminator without reallocating. 114288943Sdim Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1); 115261991Sdim UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]); 116261991Sdim UTF8 *DstEnd = Dst + Out.size(); 117261991Sdim 118261991Sdim ConversionResult CR = 119261991Sdim ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion); 120261991Sdim assert(CR != targetExhausted); 121261991Sdim 122261991Sdim if (CR != conversionOK) { 123261991Sdim Out.clear(); 124261991Sdim return false; 125261991Sdim } 126261991Sdim 127261991Sdim Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]); 128288943Sdim Out.push_back(0); 129288943Sdim Out.pop_back(); 130261991Sdim return true; 131261991Sdim} 132261991Sdim 133288943Sdimbool convertUTF8ToUTF16String(StringRef SrcUTF8, 134288943Sdim SmallVectorImpl<UTF16> &DstUTF16) { 135288943Sdim assert(DstUTF16.empty()); 136288943Sdim 137288943Sdim // Avoid OOB by returning early on empty input. 138288943Sdim if (SrcUTF8.empty()) { 139288943Sdim DstUTF16.push_back(0); 140288943Sdim DstUTF16.pop_back(); 141288943Sdim return true; 142288943Sdim } 143288943Sdim 144288943Sdim const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.begin()); 145288943Sdim const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.end()); 146288943Sdim 147288943Sdim // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding 148288943Sdim // as UTF-16 should always require the same amount or less code units than the 149288943Sdim // UTF-8 encoding. Allocate one extra byte for the null terminator though, 150288943Sdim // so that someone calling DstUTF16.data() gets a null terminated string. 151288943Sdim // We resize down later so we don't have to worry that this over allocates. 152288943Sdim DstUTF16.resize(SrcUTF8.size()+1); 153288943Sdim UTF16 *Dst = &DstUTF16[0]; 154288943Sdim UTF16 *DstEnd = Dst + DstUTF16.size(); 155288943Sdim 156288943Sdim ConversionResult CR = 157288943Sdim ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion); 158288943Sdim assert(CR != targetExhausted); 159288943Sdim 160288943Sdim if (CR != conversionOK) { 161288943Sdim DstUTF16.clear(); 162288943Sdim return false; 163288943Sdim } 164288943Sdim 165288943Sdim DstUTF16.resize(Dst - &DstUTF16[0]); 166288943Sdim DstUTF16.push_back(0); 167288943Sdim DstUTF16.pop_back(); 168288943Sdim return true; 169288943Sdim} 170288943Sdim 171249259Sdim} // end namespace llvm 172249259Sdim 173