Remove Unicode handling from Subzero
This functionality isn't used by SwiftShader. The source files are
licensed under a custom license which may complicate their use in
downstream projects. Note that upstream LLVM has a different license
for these source files already.
Bug: b/179832693
Change-Id: I55142ff07e7c5c2c84c051a5818731b854b17155
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/68728
Tested-by: Nicolas Capens <nicolascapens@google.com>
Reviewed-by: Alexis Hétu <sugoi@google.com>
Kokoro-Result: kokoro <noreply+kokoro@google.com>
diff --git a/src/Reactor/BUILD.gn b/src/Reactor/BUILD.gn
index 45a2acf..67dfeb0 100644
--- a/src/Reactor/BUILD.gn
+++ b/src/Reactor/BUILD.gn
@@ -222,8 +222,6 @@
"$subzero_llvm_dir/lib/Support/APInt.cpp",
"$subzero_llvm_dir/lib/Support/Atomic.cpp",
"$subzero_llvm_dir/lib/Support/CommandLine.cpp",
- "$subzero_llvm_dir/lib/Support/ConvertUTF.cpp",
- "$subzero_llvm_dir/lib/Support/ConvertUTFWrapper.cpp",
"$subzero_llvm_dir/lib/Support/Debug.cpp",
"$subzero_llvm_dir/lib/Support/Errno.cpp",
"$subzero_llvm_dir/lib/Support/ErrorHandling.cpp",
diff --git a/third_party/llvm-subzero/Android.bp b/third_party/llvm-subzero/Android.bp
index f5e1c3a..1ef38d4 100644
--- a/third_party/llvm-subzero/Android.bp
+++ b/third_party/llvm-subzero/Android.bp
@@ -77,8 +77,6 @@
"lib/Support/Atomic.cpp",
"lib/Support/circular_raw_ostream.cpp",
"lib/Support/CommandLine.cpp",
- "lib/Support/ConvertUTF.cpp",
- "lib/Support/ConvertUTFWrapper.cpp",
"lib/Support/Debug.cpp",
"lib/Support/Errno.cpp",
"lib/Support/ErrorHandling.cpp",
diff --git a/third_party/llvm-subzero/CMakeLists.txt b/third_party/llvm-subzero/CMakeLists.txt
index c636842..15dc6c1 100644
--- a/third_party/llvm-subzero/CMakeLists.txt
+++ b/third_party/llvm-subzero/CMakeLists.txt
@@ -104,7 +104,6 @@
"include/llvm/Support/COFF.h"
"include/llvm/Support/CommandLine.h"
"include/llvm/Support/Compiler.h"
- "include/llvm/Support/ConvertUTF.h"
"include/llvm/Support/DataStream.h"
"include/llvm/Support/Debug.h"
"include/llvm/Support/ELF.h"
@@ -160,8 +159,6 @@
"lib/Support/Atomic.cpp"
"lib/Support/circular_raw_ostream.cpp"
"lib/Support/CommandLine.cpp"
- "lib/Support/ConvertUTF.cpp"
- "lib/Support/ConvertUTFWrapper.cpp"
"lib/Support/Debug.cpp"
"lib/Support/Errno.cpp"
"lib/Support/ErrorHandling.cpp"
diff --git a/third_party/llvm-subzero/include/llvm/Support/ConvertUTF.h b/third_party/llvm-subzero/include/llvm/Support/ConvertUTF.h
deleted file mode 100644
index f714c0e..0000000
--- a/third_party/llvm-subzero/include/llvm/Support/ConvertUTF.h
+++ /dev/null
@@ -1,291 +0,0 @@
-/*===--- ConvertUTF.h - Universal Character Names conversions ---------------===
- *
- * The LLVM Compiler Infrastructure
- *
- * This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- *
- *==------------------------------------------------------------------------==*/
-/*
- * Copyright 2001-2004 Unicode, Inc.
- *
- * Disclaimer
- *
- * This source code is provided as is by Unicode, Inc. No claims are
- * made as to fitness for any particular purpose. No warranties of any
- * kind are expressed or implied. The recipient agrees to determine
- * applicability of information provided. If this file has been
- * purchased on magnetic or optical media from Unicode, Inc., the
- * sole remedy for any claim will be exchange of defective media
- * within 90 days of receipt.
- *
- * Limitations on Rights to Redistribute This Code
- *
- * Unicode, Inc. hereby grants the right to freely use the information
- * supplied in this file in the creation of products supporting the
- * Unicode Standard, and to make copies of this file in any form
- * for internal or external distribution as long as this notice
- * remains attached.
- */
-
-/* ---------------------------------------------------------------------
-
- Conversions between UTF32, UTF-16, and UTF-8. Header file.
-
- Several funtions are included here, forming a complete set of
- conversions between the three formats. UTF-7 is not included
- here, but is handled in a separate source file.
-
- Each of these routines takes pointers to input buffers and output
- buffers. The input buffers are const.
-
- Each routine converts the text between *sourceStart and sourceEnd,
- putting the result into the buffer between *targetStart and
- targetEnd. Note: the end pointers are *after* the last item: e.g.
- *(sourceEnd - 1) is the last item.
-
- The return result indicates whether the conversion was successful,
- and if not, whether the problem was in the source or target buffers.
- (Only the first encountered problem is indicated.)
-
- After the conversion, *sourceStart and *targetStart are both
- updated to point to the end of last text successfully converted in
- the respective buffers.
-
- Input parameters:
- sourceStart - pointer to a pointer to the source buffer.
- The contents of this are modified on return so that
- it points at the next thing to be converted.
- targetStart - similarly, pointer to pointer to the target buffer.
- sourceEnd, targetEnd - respectively pointers to the ends of the
- two buffers, for overflow checking only.
-
- These conversion functions take a ConversionFlags argument. When this
- flag is set to strict, both irregular sequences and isolated surrogates
- will cause an error. When the flag is set to lenient, both irregular
- sequences and isolated surrogates are converted.
-
- Whether the flag is strict or lenient, all illegal sequences will cause
- an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
- or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
- must check for illegal sequences.
-
- When the flag is set to lenient, characters over 0x10FFFF are converted
- to the replacement character; otherwise (when the flag is set to strict)
- they constitute an error.
-
- Output parameters:
- The value "sourceIllegal" is returned from some routines if the input
- sequence is malformed. When "sourceIllegal" is returned, the source
- value will point to the illegal value that caused the problem. E.g.,
- in UTF-8 when a sequence is malformed, it points to the start of the
- malformed sequence.
-
- Author: Mark E. Davis, 1994.
- Rev History: Rick McGowan, fixes & updates May 2001.
- Fixes & updates, Sept 2001.
-
------------------------------------------------------------------------- */
-
-#ifndef LLVM_SUPPORT_CONVERTUTF_H
-#define LLVM_SUPPORT_CONVERTUTF_H
-
-#include <string>
-#include <cstddef>
-
-// Wrap everything in namespace llvm so that programs can link with llvm and
-// their own version of the unicode libraries.
-
-namespace llvm {
-
-/* ---------------------------------------------------------------------
- The following 4 definitions are compiler-specific.
- The C standard does not guarantee that wchar_t has at least
- 16 bits, so wchar_t is no less portable than unsigned short!
- All should be unsigned values to avoid sign extension during
- bit mask & shift operations.
------------------------------------------------------------------------- */
-
-typedef unsigned int UTF32; /* at least 32 bits */
-typedef unsigned short UTF16; /* at least 16 bits */
-typedef unsigned char UTF8; /* typically 8 bits */
-typedef unsigned char Boolean; /* 0 or 1 */
-
-/* Some fundamental constants */
-#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
-#define UNI_MAX_BMP (UTF32)0x0000FFFF
-#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
-#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
-#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
-
-#define UNI_MAX_UTF8_BYTES_PER_CODE_POINT 4
-
-#define UNI_UTF16_BYTE_ORDER_MARK_NATIVE 0xFEFF
-#define UNI_UTF16_BYTE_ORDER_MARK_SWAPPED 0xFFFE
-
-typedef enum {
- conversionOK, /* conversion successful */
- sourceExhausted, /* partial character in source, but hit end */
- targetExhausted, /* insuff. room in target for conversion */
- sourceIllegal /* source sequence is illegal/malformed */
-} ConversionResult;
-
-typedef enum {
- strictConversion = 0,
- lenientConversion
-} ConversionFlags;
-
-ConversionResult ConvertUTF8toUTF16 (
- const UTF8** sourceStart, const UTF8* sourceEnd,
- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
-
-/**
- * Convert a partial UTF8 sequence to UTF32. If the sequence ends in an
- * incomplete code unit sequence, returns \c sourceExhausted.
- */
-ConversionResult ConvertUTF8toUTF32Partial(
- const UTF8** sourceStart, const UTF8* sourceEnd,
- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-/**
- * Convert a partial UTF8 sequence to UTF32. If the sequence ends in an
- * incomplete code unit sequence, returns \c sourceIllegal.
- */
-ConversionResult ConvertUTF8toUTF32(
- const UTF8** sourceStart, const UTF8* sourceEnd,
- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF16toUTF8 (
- const UTF16** sourceStart, const UTF16* sourceEnd,
- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF32toUTF8 (
- const UTF32** sourceStart, const UTF32* sourceEnd,
- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF16toUTF32 (
- const UTF16** sourceStart, const UTF16* sourceEnd,
- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF32toUTF16 (
- const UTF32** sourceStart, const UTF32* sourceEnd,
- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
-
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
-
-Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd);
-
-unsigned getNumBytesForUTF8(UTF8 firstByte);
-
-/*************************************************************************/
-/* Below are LLVM-specific wrappers of the functions above. */
-
-template <typename T> class ArrayRef;
-template <typename T> class SmallVectorImpl;
-class StringRef;
-
-/**
- * Convert an UTF8 StringRef to UTF8, UTF16, or UTF32 depending on
- * WideCharWidth. The converted data is written to ResultPtr, which needs to
- * point to at least WideCharWidth * (Source.Size() + 1) bytes. On success,
- * ResultPtr will point one after the end of the copied string. On failure,
- * ResultPtr will not be changed, and ErrorPtr will be set to the location of
- * the first character which could not be converted.
- * \return true on success.
- */
-bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
- char *&ResultPtr, const UTF8 *&ErrorPtr);
-
-/**
-* Converts a UTF-8 StringRef to a std::wstring.
-* \return true on success.
-*/
-bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result);
-
-/**
-* Converts a UTF-8 C-string to a std::wstring.
-* \return true on success.
-*/
-bool ConvertUTF8toWide(const char *Source, std::wstring &Result);
-
-/**
-* Converts a std::wstring to a UTF-8 encoded std::string.
-* \return true on success.
-*/
-bool convertWideToUTF8(const std::wstring &Source, std::string &Result);
-
-
-/**
- * Convert an Unicode code point to UTF8 sequence.
- *
- * \param Source a Unicode code point.
- * \param [in,out] ResultPtr pointer to the output buffer, needs to be at least
- * \c UNI_MAX_UTF8_BYTES_PER_CODE_POINT bytes. On success \c ResultPtr is
- * updated one past end of the converted sequence.
- *
- * \returns true on success.
- */
-bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr);
-
-/**
- * Convert the first UTF8 sequence in the given source buffer to a UTF32
- * code point.
- *
- * \param [in,out] source A pointer to the source buffer. If the conversion
- * succeeds, this pointer will be updated to point to the byte just past the
- * end of the converted sequence.
- * \param sourceEnd A pointer just past the end of the source buffer.
- * \param [out] target The converted code
- * \param flags Whether the conversion is strict or lenient.
- *
- * \returns conversionOK on success
- *
- * \sa ConvertUTF8toUTF32
- */
-static inline ConversionResult convertUTF8Sequence(const UTF8 **source,
- const UTF8 *sourceEnd,
- UTF32 *target,
- ConversionFlags flags) {
- if (*source == sourceEnd)
- return sourceExhausted;
- unsigned size = getNumBytesForUTF8(**source);
- if ((ptrdiff_t)size > sourceEnd - *source)
- return sourceExhausted;
- return ConvertUTF8toUTF32(source, *source + size, &target, target + 1, flags);
-}
-
-/**
- * Returns true if a blob of text starts with a UTF-16 big or little endian byte
- * order mark.
- */
-bool hasUTF16ByteOrderMark(ArrayRef<char> SrcBytes);
-
-/**
- * Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
- *
- * \param [in] SrcBytes A buffer of what is assumed to be UTF-16 encoded text.
- * \param [out] Out Converted UTF-8 is stored here on success.
- * \returns true on success
- */
-bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
-
-/**
-* Converts a UTF16 string into a UTF8 std::string.
-*
-* \param [in] Src A buffer of UTF-16 encoded text.
-* \param [out] Out Converted UTF-8 is stored here on success.
-* \returns true on success
-*/
-bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out);
-
-/**
- * Converts a UTF-8 string into a UTF-16 string with native endianness.
- *
- * \returns true on success
- */
-bool convertUTF8ToUTF16String(StringRef SrcUTF8,
- SmallVectorImpl<UTF16> &DstUTF16);
-
-} /* end namespace llvm */
-
-#endif
diff --git a/third_party/llvm-subzero/include/llvm/Support/Program.h b/third_party/llvm-subzero/include/llvm/Support/Program.h
index 055f016..422f8c2 100644
--- a/third_party/llvm-subzero/include/llvm/Support/Program.h
+++ b/third_party/llvm-subzero/include/llvm/Support/Program.h
@@ -134,40 +134,6 @@
/// argument length limits.
bool commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<const char*> Args);
- /// File encoding options when writing contents that a non-UTF8 tool will
- /// read (on Windows systems). For UNIX, we always use UTF-8.
- enum WindowsEncodingMethod {
- /// UTF-8 is the LLVM native encoding, being the same as "do not perform
- /// encoding conversion".
- WEM_UTF8,
- WEM_CurrentCodePage,
- WEM_UTF16
- };
-
- /// Saves the UTF8-encoded \p contents string into the file \p FileName
- /// using a specific encoding.
- ///
- /// This write file function adds the possibility to choose which encoding
- /// to use when writing a text file. On Windows, this is important when
- /// writing files with internationalization support with an encoding that is
- /// different from the one used in LLVM (UTF-8). We use this when writing
- /// response files, since GCC tools on MinGW only understand legacy code
- /// pages, and VisualStudio tools only understand UTF-16.
- /// For UNIX, using different encodings is silently ignored, since all tools
- /// work well with UTF-8.
- /// This function assumes that you only use UTF-8 *text* data and will convert
- /// it to your desired encoding before writing to the file.
- ///
- /// FIXME: We use EM_CurrentCodePage to write response files for GNU tools in
- /// a MinGW/MinGW-w64 environment, which has serious flaws but currently is
- /// our best shot to make gcc/ld understand international characters. This
- /// should be changed as soon as binutils fix this to support UTF16 on mingw.
- ///
- /// \returns non-zero error_code if failed
- std::error_code
- writeFileWithEncoding(StringRef FileName, StringRef Contents,
- WindowsEncodingMethod Encoding = WEM_UTF8);
-
/// This function waits for the process specified by \p PI to finish.
/// \returns A \see ProcessInfo struct with Pid set to:
/// \li The process id of the child process if the child process has changed
diff --git a/third_party/llvm-subzero/lib/Support/CommandLine.cpp b/third_party/llvm-subzero/lib/Support/CommandLine.cpp
index 3605c0f..c1aa072 100644
--- a/third_party/llvm-subzero/lib/Support/CommandLine.cpp
+++ b/third_party/llvm-subzero/lib/Support/CommandLine.cpp
@@ -27,7 +27,6 @@
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Config/config.h"
-#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileSystem.h"
@@ -899,20 +898,6 @@
MemoryBuffer &MemBuf = *MemBufOrErr.get();
StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize());
- // If we have a UTF-16 byte order mark, convert to UTF-8 for parsing.
- ArrayRef<char> BufRef(MemBuf.getBufferStart(), MemBuf.getBufferEnd());
- std::string UTF8Buf;
- if (hasUTF16ByteOrderMark(BufRef)) {
- if (!convertUTF16ToUTF8String(BufRef, UTF8Buf))
- return false;
- Str = StringRef(UTF8Buf);
- }
- // If we see UTF-8 BOM sequence at the beginning of a file, we shall remove
- // these bytes before parsing.
- // Reference: http://en.wikipedia.org/wiki/UTF-8#Byte_order_mark
- else if (hasUTF8ByteOrderMark(BufRef))
- Str = StringRef(BufRef.data() + 3, BufRef.size() - 3);
-
// Tokenize the contents into NewArgv.
Tokenizer(Str, Saver, NewArgv, MarkEOLs);
diff --git a/third_party/llvm-subzero/lib/Support/ConvertUTF.cpp b/third_party/llvm-subzero/lib/Support/ConvertUTF.cpp
deleted file mode 100644
index 39fd218..0000000
--- a/third_party/llvm-subzero/lib/Support/ConvertUTF.cpp
+++ /dev/null
@@ -1,710 +0,0 @@
-/*===--- ConvertUTF.c - Universal Character Names conversions ---------------===
- *
- * The LLVM Compiler Infrastructure
- *
- * This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- *
- *===------------------------------------------------------------------------=*/
-/*
- * Copyright 2001-2004 Unicode, Inc.
- *
- * Disclaimer
- *
- * This source code is provided as is by Unicode, Inc. No claims are
- * made as to fitness for any particular purpose. No warranties of any
- * kind are expressed or implied. The recipient agrees to determine
- * applicability of information provided. If this file has been
- * purchased on magnetic or optical media from Unicode, Inc., the
- * sole remedy for any claim will be exchange of defective media
- * within 90 days of receipt.
- *
- * Limitations on Rights to Redistribute This Code
- *
- * Unicode, Inc. hereby grants the right to freely use the information
- * supplied in this file in the creation of products supporting the
- * Unicode Standard, and to make copies of this file in any form
- * for internal or external distribution as long as this notice
- * remains attached.
- */
-
-/* ---------------------------------------------------------------------
-
- Conversions between UTF32, UTF-16, and UTF-8. Source code file.
- Author: Mark E. Davis, 1994.
- Rev History: Rick McGowan, fixes & updates May 2001.
- Sept 2001: fixed const & error conditions per
- mods suggested by S. Parent & A. Lillich.
- June 2002: Tim Dodd added detection and handling of incomplete
- source sequences, enhanced error detection, added casts
- to eliminate compiler warnings.
- July 2003: slight mods to back out aggressive FFFE detection.
- Jan 2004: updated switches in from-UTF8 conversions.
- Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
-
- See the header file "ConvertUTF.h" for complete documentation.
-
------------------------------------------------------------------------- */
-
-
-#include "llvm/Support/ConvertUTF.h"
-#ifdef CVTUTF_DEBUG
-#include <stdio.h>
-#endif
-#include <assert.h>
-
-namespace llvm {
-
-static const int halfShift = 10; /* used for shifting by 10 bits */
-
-static const UTF32 halfBase = 0x0010000UL;
-static const UTF32 halfMask = 0x3FFUL;
-
-#define UNI_SUR_HIGH_START (UTF32)0xD800
-#define UNI_SUR_HIGH_END (UTF32)0xDBFF
-#define UNI_SUR_LOW_START (UTF32)0xDC00
-#define UNI_SUR_LOW_END (UTF32)0xDFFF
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Index into the table below with the first byte of a UTF-8 sequence to
- * get the number of trailing bytes that are supposed to follow it.
- * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
- * left as-is for anyone who may want to do such conversion, which was
- * allowed in earlier algorithms.
- */
-static const char trailingBytesForUTF8[256] = {
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
- 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
-};
-
-/*
- * Magic values subtracted from a buffer value during UTF8 conversion.
- * This table contains as many values as there might be trailing bytes
- * in a UTF-8 sequence.
- */
-static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
- 0x03C82080UL, 0xFA082080UL, 0x82082080UL };
-
-/*
- * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
- * into the first byte, depending on how many bytes follow. There are
- * as many entries in this table as there are UTF-8 sequence types.
- * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
- * for *legal* UTF-8 will be 4 or fewer bytes total.
- */
-static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-/* --------------------------------------------------------------------- */
-
-/* The interface converts a whole buffer to avoid function-call overhead.
- * Constants have been gathered. Loops & conditionals have been removed as
- * much as possible for efficiency, in favor of drop-through switches.
- * (See "Note A" at the bottom of the file for equivalent code.)
- * If your compiler supports it, the "isLegalUTF8" call can be turned
- * into an inline function.
- */
-
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF32toUTF16 (
- const UTF32** sourceStart, const UTF32* sourceEnd,
- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
- ConversionResult result = conversionOK;
- const UTF32* source = *sourceStart;
- UTF16* target = *targetStart;
- while (source < sourceEnd) {
- UTF32 ch;
- if (target >= targetEnd) {
- result = targetExhausted; break;
- }
- ch = *source++;
- if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
- /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
- if (flags == strictConversion) {
- --source; /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- } else {
- *target++ = UNI_REPLACEMENT_CHAR;
- }
- } else {
- *target++ = (UTF16)ch; /* normal case */
- }
- } else if (ch > UNI_MAX_LEGAL_UTF32) {
- if (flags == strictConversion) {
- result = sourceIllegal;
- } else {
- *target++ = UNI_REPLACEMENT_CHAR;
- }
- } else {
- /* target is a character in range 0xFFFF - 0x10FFFF. */
- if (target + 1 >= targetEnd) {
- --source; /* Back up source pointer! */
- result = targetExhausted; break;
- }
- ch -= halfBase;
- *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
- *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
- }
- }
- *sourceStart = source;
- *targetStart = target;
- return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF16toUTF32 (
- const UTF16** sourceStart, const UTF16* sourceEnd,
- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
- ConversionResult result = conversionOK;
- const UTF16* source = *sourceStart;
- UTF32* target = *targetStart;
- UTF32 ch, ch2;
- while (source < sourceEnd) {
- const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
- ch = *source++;
- /* If we have a surrogate pair, convert to UTF32 first. */
- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
- /* If the 16 bits following the high surrogate are in the source buffer... */
- if (source < sourceEnd) {
- ch2 = *source;
- /* If it's a low surrogate, convert to UTF32. */
- if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
- ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
- + (ch2 - UNI_SUR_LOW_START) + halfBase;
- ++source;
- } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
- --source; /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- }
- } else { /* We don't have the 16 bits following the high surrogate. */
- --source; /* return to the high surrogate */
- result = sourceExhausted;
- break;
- }
- } else if (flags == strictConversion) {
- /* UTF-16 surrogate values are illegal in UTF-32 */
- if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
- --source; /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- }
- }
- if (target >= targetEnd) {
- source = oldSource; /* Back up source pointer! */
- result = targetExhausted; break;
- }
- *target++ = ch;
- }
- *sourceStart = source;
- *targetStart = target;
-#ifdef CVTUTF_DEBUG
-if (result == sourceIllegal) {
- fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
- fflush(stderr);
-}
-#endif
- return result;
-}
-ConversionResult ConvertUTF16toUTF8 (
- const UTF16** sourceStart, const UTF16* sourceEnd,
- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
- ConversionResult result = conversionOK;
- const UTF16* source = *sourceStart;
- UTF8* target = *targetStart;
- while (source < sourceEnd) {
- UTF32 ch;
- unsigned short bytesToWrite = 0;
- const UTF32 byteMask = 0xBF;
- const UTF32 byteMark = 0x80;
- const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
- ch = *source++;
- /* If we have a surrogate pair, convert to UTF32 first. */
- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
- /* If the 16 bits following the high surrogate are in the source buffer... */
- if (source < sourceEnd) {
- UTF32 ch2 = *source;
- /* If it's a low surrogate, convert to UTF32. */
- if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
- ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
- + (ch2 - UNI_SUR_LOW_START) + halfBase;
- ++source;
- } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
- --source; /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- }
- } else { /* We don't have the 16 bits following the high surrogate. */
- --source; /* return to the high surrogate */
- result = sourceExhausted;
- break;
- }
- } else if (flags == strictConversion) {
- /* UTF-16 surrogate values are illegal in UTF-32 */
- if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
- --source; /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- }
- }
- /* Figure out how many bytes the result will require */
- if (ch < (UTF32)0x80) { bytesToWrite = 1;
- } else if (ch < (UTF32)0x800) { bytesToWrite = 2;
- } else if (ch < (UTF32)0x10000) { bytesToWrite = 3;
- } else if (ch < (UTF32)0x110000) { bytesToWrite = 4;
- } else { bytesToWrite = 3;
- ch = UNI_REPLACEMENT_CHAR;
- }
-
- target += bytesToWrite;
- if (target > targetEnd) {
- source = oldSource; /* Back up source pointer! */
- target -= bytesToWrite; result = targetExhausted; break;
- }
- switch (bytesToWrite) { /* note: everything falls through. */
- case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
- case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
- case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
- case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]);
- }
- target += bytesToWrite;
- }
- *sourceStart = source;
- *targetStart = target;
- return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF32toUTF8 (
- const UTF32** sourceStart, const UTF32* sourceEnd,
- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
- ConversionResult result = conversionOK;
- const UTF32* source = *sourceStart;
- UTF8* target = *targetStart;
- while (source < sourceEnd) {
- UTF32 ch;
- unsigned short bytesToWrite = 0;
- const UTF32 byteMask = 0xBF;
- const UTF32 byteMark = 0x80;
- ch = *source++;
- if (flags == strictConversion ) {
- /* UTF-16 surrogate values are illegal in UTF-32 */
- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
- --source; /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- }
- }
- /*
- * Figure out how many bytes the result will require. Turn any
- * illegally large UTF32 things (> Plane 17) into replacement chars.
- */
- if (ch < (UTF32)0x80) { bytesToWrite = 1;
- } else if (ch < (UTF32)0x800) { bytesToWrite = 2;
- } else if (ch < (UTF32)0x10000) { bytesToWrite = 3;
- } else if (ch <= UNI_MAX_LEGAL_UTF32) { bytesToWrite = 4;
- } else { bytesToWrite = 3;
- ch = UNI_REPLACEMENT_CHAR;
- result = sourceIllegal;
- }
-
- target += bytesToWrite;
- if (target > targetEnd) {
- --source; /* Back up source pointer! */
- target -= bytesToWrite; result = targetExhausted; break;
- }
- switch (bytesToWrite) { /* note: everything falls through. */
- case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
- case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
- case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
- case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
- }
- target += bytesToWrite;
- }
- *sourceStart = source;
- *targetStart = target;
- return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Utility routine to tell whether a sequence of bytes is legal UTF-8.
- * This must be called with the length pre-determined by the first byte.
- * If not calling this from ConvertUTF8to*, then the length can be set by:
- * length = trailingBytesForUTF8[*source]+1;
- * and the sequence is illegal right away if there aren't that many bytes
- * available.
- * If presented with a length > 4, this returns false. The Unicode
- * definition of UTF-8 goes up to 4-byte sequences.
- */
-
-static Boolean isLegalUTF8(const UTF8 *source, int length) {
- UTF8 a;
- const UTF8 *srcptr = source+length;
- switch (length) {
- default: return false;
- /* Everything else falls through when "true"... */
- case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
- case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
- case 2: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
-
- switch (*source) {
- /* no fall-through in this inner switch */
- case 0xE0: if (a < 0xA0) return false; break;
- case 0xED: if (a > 0x9F) return false; break;
- case 0xF0: if (a < 0x90) return false; break;
- case 0xF4: if (a > 0x8F) return false; break;
- default: if (a < 0x80) return false;
- }
-
- case 1: if (*source >= 0x80 && *source < 0xC2) return false;
- }
- if (*source > 0xF4) return false;
- return true;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Exported function to return whether a UTF-8 sequence is legal or not.
- * This is not used here; it's just exported.
- */
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
- int length = trailingBytesForUTF8[*source]+1;
- if (length > sourceEnd - source) {
- return false;
- }
- return isLegalUTF8(source, length);
-}
-
-/* --------------------------------------------------------------------- */
-
-static unsigned
-findMaximalSubpartOfIllFormedUTF8Sequence(const UTF8 *source,
- const UTF8 *sourceEnd) {
- UTF8 b1, b2, b3;
-
- assert(!isLegalUTF8Sequence(source, sourceEnd));
-
- /*
- * Unicode 6.3.0, D93b:
- *
- * Maximal subpart of an ill-formed subsequence: The longest code unit
- * subsequence starting at an unconvertible offset that is either:
- * a. the initial subsequence of a well-formed code unit sequence, or
- * b. a subsequence of length one.
- */
-
- if (source == sourceEnd)
- return 0;
-
- /*
- * Perform case analysis. See Unicode 6.3.0, Table 3-7. Well-Formed UTF-8
- * Byte Sequences.
- */
-
- b1 = *source;
- ++source;
- if (b1 >= 0xC2 && b1 <= 0xDF) {
- /*
- * First byte is valid, but we know that this code unit sequence is
- * invalid, so the maximal subpart has to end after the first byte.
- */
- return 1;
- }
-
- if (source == sourceEnd)
- return 1;
-
- b2 = *source;
- ++source;
-
- if (b1 == 0xE0) {
- return (b2 >= 0xA0 && b2 <= 0xBF) ? 2 : 1;
- }
- if (b1 >= 0xE1 && b1 <= 0xEC) {
- return (b2 >= 0x80 && b2 <= 0xBF) ? 2 : 1;
- }
- if (b1 == 0xED) {
- return (b2 >= 0x80 && b2 <= 0x9F) ? 2 : 1;
- }
- if (b1 >= 0xEE && b1 <= 0xEF) {
- return (b2 >= 0x80 && b2 <= 0xBF) ? 2 : 1;
- }
- if (b1 == 0xF0) {
- if (b2 >= 0x90 && b2 <= 0xBF) {
- if (source == sourceEnd)
- return 2;
-
- b3 = *source;
- return (b3 >= 0x80 && b3 <= 0xBF) ? 3 : 2;
- }
- return 1;
- }
- if (b1 >= 0xF1 && b1 <= 0xF3) {
- if (b2 >= 0x80 && b2 <= 0xBF) {
- if (source == sourceEnd)
- return 2;
-
- b3 = *source;
- return (b3 >= 0x80 && b3 <= 0xBF) ? 3 : 2;
- }
- return 1;
- }
- if (b1 == 0xF4) {
- if (b2 >= 0x80 && b2 <= 0x8F) {
- if (source == sourceEnd)
- return 2;
-
- b3 = *source;
- return (b3 >= 0x80 && b3 <= 0xBF) ? 3 : 2;
- }
- return 1;
- }
-
- assert((b1 >= 0x80 && b1 <= 0xC1) || b1 >= 0xF5);
- /*
- * There are no valid sequences that start with these bytes. Maximal subpart
- * is defined to have length 1 in these cases.
- */
- return 1;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Exported function to return the total number of bytes in a codepoint
- * represented in UTF-8, given the value of the first byte.
- */
-unsigned getNumBytesForUTF8(UTF8 first) {
- return trailingBytesForUTF8[first] + 1;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Exported function to return whether a UTF-8 string is legal or not.
- * This is not used here; it's just exported.
- */
-Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd) {
- while (*source != sourceEnd) {
- int length = trailingBytesForUTF8[**source] + 1;
- if (length > sourceEnd - *source || !isLegalUTF8(*source, length))
- return false;
- *source += length;
- }
- return true;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF8toUTF16 (
- const UTF8** sourceStart, const UTF8* sourceEnd,
- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
- ConversionResult result = conversionOK;
- const UTF8* source = *sourceStart;
- UTF16* target = *targetStart;
- while (source < sourceEnd) {
- UTF32 ch = 0;
- unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
- if (extraBytesToRead >= sourceEnd - source) {
- result = sourceExhausted; break;
- }
- /* Do this check whether lenient or strict */
- if (!isLegalUTF8(source, extraBytesToRead+1)) {
- result = sourceIllegal;
- break;
- }
- /*
- * The cases all fall through. See "Note A" below.
- */
- switch (extraBytesToRead) {
- case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
- case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
- case 3: ch += *source++; ch <<= 6;
- case 2: ch += *source++; ch <<= 6;
- case 1: ch += *source++; ch <<= 6;
- case 0: ch += *source++;
- }
- ch -= offsetsFromUTF8[extraBytesToRead];
-
- if (target >= targetEnd) {
- source -= (extraBytesToRead+1); /* Back up source pointer! */
- result = targetExhausted; break;
- }
- if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
- /* UTF-16 surrogate values are illegal in UTF-32 */
- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
- if (flags == strictConversion) {
- source -= (extraBytesToRead+1); /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- } else {
- *target++ = UNI_REPLACEMENT_CHAR;
- }
- } else {
- *target++ = (UTF16)ch; /* normal case */
- }
- } else if (ch > UNI_MAX_UTF16) {
- if (flags == strictConversion) {
- result = sourceIllegal;
- source -= (extraBytesToRead+1); /* return to the start */
- break; /* Bail out; shouldn't continue */
- } else {
- *target++ = UNI_REPLACEMENT_CHAR;
- }
- } else {
- /* target is a character in range 0xFFFF - 0x10FFFF. */
- if (target + 1 >= targetEnd) {
- source -= (extraBytesToRead+1); /* Back up source pointer! */
- result = targetExhausted; break;
- }
- ch -= halfBase;
- *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
- *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
- }
- }
- *sourceStart = source;
- *targetStart = target;
- return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-static ConversionResult ConvertUTF8toUTF32Impl(
- const UTF8** sourceStart, const UTF8* sourceEnd,
- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags,
- Boolean InputIsPartial) {
- ConversionResult result = conversionOK;
- const UTF8* source = *sourceStart;
- UTF32* target = *targetStart;
- while (source < sourceEnd) {
- UTF32 ch = 0;
- unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
- if (extraBytesToRead >= sourceEnd - source) {
- if (flags == strictConversion || InputIsPartial) {
- result = sourceExhausted;
- break;
- } else {
- result = sourceIllegal;
-
- /*
- * Replace the maximal subpart of ill-formed sequence with
- * replacement character.
- */
- source += findMaximalSubpartOfIllFormedUTF8Sequence(source,
- sourceEnd);
- *target++ = UNI_REPLACEMENT_CHAR;
- continue;
- }
- }
- if (target >= targetEnd) {
- result = targetExhausted; break;
- }
-
- /* Do this check whether lenient or strict */
- if (!isLegalUTF8(source, extraBytesToRead+1)) {
- result = sourceIllegal;
- if (flags == strictConversion) {
- /* Abort conversion. */
- break;
- } else {
- /*
- * Replace the maximal subpart of ill-formed sequence with
- * replacement character.
- */
- source += findMaximalSubpartOfIllFormedUTF8Sequence(source,
- sourceEnd);
- *target++ = UNI_REPLACEMENT_CHAR;
- continue;
- }
- }
- /*
- * The cases all fall through. See "Note A" below.
- */
- switch (extraBytesToRead) {
- case 5: ch += *source++; ch <<= 6;
- case 4: ch += *source++; ch <<= 6;
- case 3: ch += *source++; ch <<= 6;
- case 2: ch += *source++; ch <<= 6;
- case 1: ch += *source++; ch <<= 6;
- case 0: ch += *source++;
- }
- ch -= offsetsFromUTF8[extraBytesToRead];
-
- if (ch <= UNI_MAX_LEGAL_UTF32) {
- /*
- * UTF-16 surrogate values are illegal in UTF-32, and anything
- * over Plane 17 (> 0x10FFFF) is illegal.
- */
- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
- if (flags == strictConversion) {
- source -= (extraBytesToRead+1); /* return to the illegal value itself */
- result = sourceIllegal;
- break;
- } else {
- *target++ = UNI_REPLACEMENT_CHAR;
- }
- } else {
- *target++ = ch;
- }
- } else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
- result = sourceIllegal;
- *target++ = UNI_REPLACEMENT_CHAR;
- }
- }
- *sourceStart = source;
- *targetStart = target;
- return result;
-}
-
-ConversionResult ConvertUTF8toUTF32Partial(const UTF8 **sourceStart,
- const UTF8 *sourceEnd,
- UTF32 **targetStart,
- UTF32 *targetEnd,
- ConversionFlags flags) {
- return ConvertUTF8toUTF32Impl(sourceStart, sourceEnd, targetStart, targetEnd,
- flags, /*InputIsPartial=*/true);
-}
-
-ConversionResult ConvertUTF8toUTF32(const UTF8 **sourceStart,
- const UTF8 *sourceEnd, UTF32 **targetStart,
- UTF32 *targetEnd, ConversionFlags flags) {
- return ConvertUTF8toUTF32Impl(sourceStart, sourceEnd, targetStart, targetEnd,
- flags, /*InputIsPartial=*/false);
-}
-
-/* ---------------------------------------------------------------------
-
- Note A.
- The fall-through switches in UTF-8 reading code save a
- temp variable, some decrements & conditionals. The switches
- are equivalent to the following loop:
- {
- int tmpBytesToRead = extraBytesToRead+1;
- do {
- ch += *source++;
- --tmpBytesToRead;
- if (tmpBytesToRead) ch <<= 6;
- } while (tmpBytesToRead > 0);
- }
- In UTF-8 writing code, the switches on "bytesToWrite" are
- similarly unrolled loops.
-
- --------------------------------------------------------------------- */
-
-} // namespace llvm
diff --git a/third_party/llvm-subzero/lib/Support/ConvertUTFWrapper.cpp b/third_party/llvm-subzero/lib/Support/ConvertUTFWrapper.cpp
deleted file mode 100644
index 217cedb..0000000
--- a/third_party/llvm-subzero/lib/Support/ConvertUTFWrapper.cpp
+++ /dev/null
@@ -1,251 +0,0 @@
-//===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----===
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Support/ConvertUTF.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.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());
-
- // 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::sys::SwapByteOrder_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
-
diff --git a/third_party/llvm-subzero/lib/Support/Unix/Program.inc b/third_party/llvm-subzero/lib/Support/Unix/Program.inc
index 7d3537e..44e2d7c 100644
--- a/third_party/llvm-subzero/lib/Support/Unix/Program.inc
+++ b/third_party/llvm-subzero/lib/Support/Unix/Program.inc
@@ -429,23 +429,6 @@
return std::error_code();
}
-std::error_code
-llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
- WindowsEncodingMethod Encoding /*unused*/) {
- std::error_code EC;
- llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OpenFlags::F_Text);
-
- if (EC)
- return EC;
-
- OS << Contents;
-
- if (OS.has_error())
- return make_error_code(errc::io_error);
-
- return EC;
-}
-
bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<const char*> Args) {
static long ArgMax = sysconf(_SC_ARG_MAX);
diff --git a/third_party/llvm-subzero/lib/Support/Windows/Program.inc b/third_party/llvm-subzero/lib/Support/Windows/Program.inc
index 78fc538..17eeb80 100644
--- a/third_party/llvm-subzero/lib/Support/Windows/Program.inc
+++ b/third_party/llvm-subzero/lib/Support/Windows/Program.inc
@@ -13,7 +13,6 @@
#include "WindowsSupport.h"
#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/WindowsError.h"
@@ -491,50 +490,6 @@
return std::error_code();
}
-std::error_code
-llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
- WindowsEncodingMethod Encoding) {
- std::error_code EC;
- llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OpenFlags::F_Text);
- if (EC)
- return EC;
-
- if (Encoding == WEM_UTF8) {
- OS << Contents;
- } else if (Encoding == WEM_CurrentCodePage) {
- SmallVector<wchar_t, 1> ArgsUTF16;
- SmallVector<char, 1> ArgsCurCP;
-
- if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
- return EC;
-
- if ((EC = windows::UTF16ToCurCP(
- ArgsUTF16.data(), ArgsUTF16.size(), ArgsCurCP)))
- return EC;
-
- OS.write(ArgsCurCP.data(), ArgsCurCP.size());
- } else if (Encoding == WEM_UTF16) {
- SmallVector<wchar_t, 1> ArgsUTF16;
-
- if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
- return EC;
-
- // Endianness guessing
- char BOM[2];
- uint16_t src = UNI_UTF16_BYTE_ORDER_MARK_NATIVE;
- memcpy(BOM, &src, 2);
- OS.write(BOM, 2);
- OS.write((char *)ArgsUTF16.data(), ArgsUTF16.size() << 1);
- } else {
- llvm_unreachable("Unknown encoding");
- }
-
- if (OS.has_error())
- return make_error_code(errc::io_error);
-
- return EC;
-}
-
bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<const char*> Args) {
// The documented max length of the command line passed to CreateProcess.
static const size_t MaxCommandStringLength = 32768;
