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"
11263509Sdim#include "llvm/Support/SwapByteOrder.h"
12263509Sdim#include <string>
13263509Sdim#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
78263509Sdimbool hasUTF16ByteOrderMark(ArrayRef<char> S) {
79263509Sdim  return (S.size() >= 2 &&
80263509Sdim          ((S[0] == '\xff' && S[1] == '\xfe') ||
81263509Sdim           (S[0] == '\xfe' && S[1] == '\xff')));
82263509Sdim}
83263509Sdim
84263509Sdimbool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out) {
85263509Sdim  assert(Out.empty());
86263509Sdim
87263509Sdim  // Error out on an uneven byte count.
88263509Sdim  if (SrcBytes.size() % 2)
89263509Sdim    return false;
90263509Sdim
91263509Sdim  // Avoid OOB by returning early on empty input.
92263509Sdim  if (SrcBytes.empty())
93263509Sdim    return true;
94263509Sdim
95263509Sdim  const UTF16 *Src = reinterpret_cast<const UTF16 *>(SrcBytes.begin());
96263509Sdim  const UTF16 *SrcEnd = reinterpret_cast<const UTF16 *>(SrcBytes.end());
97263509Sdim
98263509Sdim  // Byteswap if necessary.
99263509Sdim  std::vector<UTF16> ByteSwapped;
100263509Sdim  if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) {
101263509Sdim    ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd);
102263509Sdim    for (unsigned I = 0, E = ByteSwapped.size(); I != E; ++I)
103263509Sdim      ByteSwapped[I] = llvm::sys::SwapByteOrder_16(ByteSwapped[I]);
104263509Sdim    Src = &ByteSwapped[0];
105263509Sdim    SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
106263509Sdim  }
107263509Sdim
108263509Sdim  // Skip the BOM for conversion.
109263509Sdim  if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE)
110263509Sdim    Src++;
111263509Sdim
112263509Sdim  // Just allocate enough space up front.  We'll shrink it later.
113263509Sdim  Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT);
114263509Sdim  UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]);
115263509Sdim  UTF8 *DstEnd = Dst + Out.size();
116263509Sdim
117263509Sdim  ConversionResult CR =
118263509Sdim      ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
119263509Sdim  assert(CR != targetExhausted);
120263509Sdim
121263509Sdim  if (CR != conversionOK) {
122263509Sdim    Out.clear();
123263509Sdim    return false;
124263509Sdim  }
125263509Sdim
126263509Sdim  Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]);
127263509Sdim  return true;
128263509Sdim}
129263509Sdim
130249259Sdim} // end namespace llvm
131249259Sdim
132