diff options
Diffstat (limited to 'intl/uconv/ucvlatin/nsUTF16ToUnicode.cpp')
| -rw-r--r-- | intl/uconv/ucvlatin/nsUTF16ToUnicode.cpp | 361 |
1 files changed, 361 insertions, 0 deletions
diff --git a/intl/uconv/ucvlatin/nsUTF16ToUnicode.cpp b/intl/uconv/ucvlatin/nsUTF16ToUnicode.cpp new file mode 100644 index 000000000..56c88ff3e --- /dev/null +++ b/intl/uconv/ucvlatin/nsUTF16ToUnicode.cpp @@ -0,0 +1,361 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsUTF16ToUnicode.h" +#include "nsCharTraits.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/EndianUtils.h" + +enum { + STATE_NORMAL = 0, + STATE_HALF_CODE_POINT = 1, + STATE_FIRST_CALL = 2, + STATE_SECOND_BYTE = STATE_FIRST_CALL | STATE_HALF_CODE_POINT, + STATE_ODD_SURROGATE_PAIR = 4 +}; + +nsresult +nsUTF16ToUnicodeBase::UTF16ConvertToUnicode(const char * aSrc, + int32_t * aSrcLength, + char16_t * aDest, + int32_t * aDestLength, + bool aSwapBytes) +{ + const char* src = aSrc; + const char* srcEnd = aSrc + *aSrcLength; + char16_t* dest = aDest; + char16_t* destEnd = aDest + *aDestLength; + char16_t oddHighSurrogate; + + switch(mState) { + case STATE_FIRST_CALL: + NS_ASSERTION(*aSrcLength > 1, "buffer too short"); + src+=2; + mState = STATE_NORMAL; + break; + + case STATE_SECOND_BYTE: + NS_ASSERTION(*aSrcLength > 0, "buffer too short"); + src++; + mState = STATE_NORMAL; + break; + + case STATE_ODD_SURROGATE_PAIR: + if (*aDestLength < 2) + goto error; + else { + *dest++ = mOddHighSurrogate; + *dest++ = mOddLowSurrogate; + mOddHighSurrogate = mOddLowSurrogate = 0; + mState = STATE_NORMAL; + } + break; + + case STATE_NORMAL: + case STATE_HALF_CODE_POINT: + default: + break; + } + + oddHighSurrogate = mOddHighSurrogate; + + if (src == srcEnd) { + *aDestLength = dest - aDest; + return (mState != STATE_NORMAL || oddHighSurrogate) ? + NS_OK_UDEC_MOREINPUT : NS_OK; + } + + const char* srcEvenEnd; + + char16_t u; + if (mState == STATE_HALF_CODE_POINT) { + if (dest == destEnd) + goto error; + + // the 1st byte of a 16-bit code unit was stored in |mOddByte| in the + // previous run while the 2nd byte has to come from |*src|. + mState = STATE_NORMAL; +#if MOZ_BIG_ENDIAN + u = (mOddByte << 8) | uint8_t(*src++); // safe, we know we have at least one byte. +#else + u = (*src++ << 8) | mOddByte; // safe, we know we have at least one byte. +#endif + srcEvenEnd = src + ((srcEnd - src) & ~1); // handle even number of bytes in main loop + goto have_codepoint; + } else { + srcEvenEnd = src + ((srcEnd - src) & ~1); // handle even number of bytes in main loop + } + + while (src != srcEvenEnd) { + if (dest == destEnd) + goto error; + +#if !defined(__sparc__) && !defined(__arm__) + u = *(const char16_t*)src; +#else + memcpy(&u, src, 2); +#endif + src += 2; + +have_codepoint: + if (aSwapBytes) + u = u << 8 | u >> 8; + + if (!IS_SURROGATE(u)) { + if (oddHighSurrogate) { + if (mErrBehavior == kOnError_Signal) { + goto error2; + } + *dest++ = UCS2_REPLACEMENT_CHAR; + if (dest == destEnd) + goto error; + oddHighSurrogate = 0; + } + *dest++ = u; + } else if (NS_IS_HIGH_SURROGATE(u)) { + if (oddHighSurrogate) { + if (mErrBehavior == kOnError_Signal) { + goto error2; + } + *dest++ = UCS2_REPLACEMENT_CHAR; + if (dest == destEnd) + goto error; + } + oddHighSurrogate = u; + } + else /* if (NS_IS_LOW_SURROGATE(u)) */ { + if (oddHighSurrogate && *aDestLength > 1) { + if (dest + 1 >= destEnd) { + mOddLowSurrogate = u; + mOddHighSurrogate = oddHighSurrogate; + mState = STATE_ODD_SURROGATE_PAIR; + goto error; + } + *dest++ = oddHighSurrogate; + *dest++ = u; + } else { + if (mErrBehavior == kOnError_Signal) { + goto error2; + } + *dest++ = UCS2_REPLACEMENT_CHAR; + } + oddHighSurrogate = 0; + } + } + if (src != srcEnd) { + // store the lead byte of a 16-bit unit for the next run. + mOddByte = *src++; + mState = STATE_HALF_CODE_POINT; + } + + mOddHighSurrogate = oddHighSurrogate; + + *aDestLength = dest - aDest; + *aSrcLength = src - aSrc; + return (mState != STATE_NORMAL || oddHighSurrogate) ? + NS_OK_UDEC_MOREINPUT : NS_OK; + +error: + *aDestLength = dest - aDest; + *aSrcLength = src - aSrc; + return NS_OK_UDEC_MOREOUTPUT; + +error2: + *aDestLength = dest - aDest; + *aSrcLength = --src - aSrc; + return NS_ERROR_ILLEGAL_INPUT; +} + +NS_IMETHODIMP +nsUTF16ToUnicodeBase::Reset() +{ + mState = STATE_FIRST_CALL; + mOddByte = 0; + mOddHighSurrogate = 0; + mOddLowSurrogate = 0; + return NS_OK; +} + +NS_IMETHODIMP +nsUTF16ToUnicodeBase::GetMaxLength(const char * aSrc, int32_t aSrcLength, + int32_t * aDestLength) +{ + mozilla::CheckedInt32 length = aSrcLength; + + if (STATE_HALF_CODE_POINT & mState) { + length += 1; + } + + if (!length.isValid()) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // the left-over data of the previous run have to be taken into account. + *aDestLength = length.value() / 2; + if (mOddHighSurrogate) + (*aDestLength)++; + if (mOddLowSurrogate) + (*aDestLength)++; + return NS_OK; +} + + +NS_IMETHODIMP +nsUTF16BEToUnicode::Convert(const char * aSrc, int32_t * aSrcLength, + char16_t * aDest, int32_t * aDestLength) +{ + switch (mState) { + case STATE_FIRST_CALL: + if (*aSrcLength < 2) { + if (*aSrcLength < 1) { + *aDestLength = 0; + return NS_OK; + } + if (uint8_t(*aSrc) != 0xFE) { + mState = STATE_NORMAL; + break; + } + *aDestLength = 0; + mState = STATE_SECOND_BYTE; + return NS_OK_UDEC_MOREINPUT; + } +#if MOZ_LITTLE_ENDIAN + // on LE machines, BE BOM is 0xFFFE + if (0xFFFE != *((char16_t*)aSrc)) { + mState = STATE_NORMAL; + } +#else + if (0xFEFF != *((char16_t*)aSrc)) { + mState = STATE_NORMAL; + } +#endif + break; + + case STATE_SECOND_BYTE: + if (*aSrcLength < 1) { + *aDestLength = 0; + return NS_OK_UDEC_MOREINPUT; + } + if (uint8_t(*aSrc) != 0xFF) { + mOddByte = 0xFE; + mState = STATE_HALF_CODE_POINT; + } + break; + } + + return UTF16ConvertToUnicode(aSrc, aSrcLength, aDest, aDestLength, + bool(MOZ_LITTLE_ENDIAN)); +} + +NS_IMETHODIMP +nsUTF16LEToUnicode::Convert(const char * aSrc, int32_t * aSrcLength, + char16_t * aDest, int32_t * aDestLength) +{ + switch (mState) { + case STATE_FIRST_CALL: + if (*aSrcLength < 2) { + if (*aSrcLength < 1) { + *aDestLength = 0; + return NS_OK; + } + if (uint8_t(*aSrc) != 0xFF) { + mState = STATE_NORMAL; + break; + } + *aDestLength = 0; + mState = STATE_SECOND_BYTE; + return NS_OK_UDEC_MOREINPUT; + } +#if MOZ_BIG_ENDIAN + // on BE machines, LE BOM is 0xFFFE + if (0xFFFE != *((char16_t*)aSrc)) { + mState = STATE_NORMAL; + } +#else + if (0xFEFF != *((char16_t*)aSrc)) { + mState = STATE_NORMAL; + } +#endif + break; + + case STATE_SECOND_BYTE: + if (*aSrcLength < 1) { + *aDestLength = 0; + return NS_OK_UDEC_MOREINPUT; + } + if (uint8_t(*aSrc) != 0xFE) { + mOddByte = 0xFF; + mState = STATE_HALF_CODE_POINT; + } + break; + } + + return UTF16ConvertToUnicode(aSrc, aSrcLength, aDest, aDestLength, + bool(MOZ_BIG_ENDIAN)); +} + +NS_IMETHODIMP +nsUTF16ToUnicode::Reset() +{ + mEndian = kUnknown; + mFoundBOM = false; + return nsUTF16ToUnicodeBase::Reset(); +} + +NS_IMETHODIMP +nsUTF16ToUnicode::Convert(const char * aSrc, int32_t * aSrcLength, + char16_t * aDest, int32_t * aDestLength) +{ + if(STATE_FIRST_CALL == mState && *aSrcLength < 2) + { + nsresult res = (*aSrcLength == 0) ? NS_OK : NS_ERROR_ILLEGAL_INPUT; + *aSrcLength=0; + *aDestLength=0; + return res; + } + if(STATE_FIRST_CALL == mState) // first time called + { + // check if BOM (0xFEFF) is at the beginning, remove it if found, and + // set mEndian accordingly. + if(0xFF == uint8_t(aSrc[0]) && 0xFE == uint8_t(aSrc[1])) { + mEndian = kLittleEndian; + mFoundBOM = true; + } + else if(0xFE == uint8_t(aSrc[0]) && 0xFF == uint8_t(aSrc[1])) { + mEndian = kBigEndian; + mFoundBOM = true; + } + // BOM is not found, but we can use a simple heuristic to determine + // the endianness. Assume the first character is [U+0001, U+00FF]. + // Not always valid, but it's very likely to hold for html/xml/css. + else if(!aSrc[0] && aSrc[1]) { // 0x00 0xhh (hh != 00) + mState = STATE_NORMAL; + mEndian = kBigEndian; + } + else if(aSrc[0] && !aSrc[1]) { // 0xhh 0x00 (hh != 00) + mState = STATE_NORMAL; + mEndian = kLittleEndian; + } + else { // Neither BOM nor 'plausible' byte patterns at the beginning. + // Just assume it's BE (following Unicode standard) + // and let the garbage show up in the browser. (security concern?) + // (bug 246194) + mState = STATE_NORMAL; + mEndian = kBigEndian; + } + } + + nsresult rv = UTF16ConvertToUnicode(aSrc, aSrcLength, aDest, aDestLength, +#if MOZ_BIG_ENDIAN + (mEndian == kLittleEndian) +#else + (mEndian == kBigEndian) +#endif + ); + + // If BOM is not found and we're to return NS_OK, signal that BOM + // is not found. Otherwise, return |rv| from |UTF16ConvertToUnicode| + return (rv == NS_OK && !mFoundBOM) ? NS_OK_UDEC_NOBOMFOUND : rv; +} |