path: root/intl/uconv/ucvlatin/nsUTF16ToUnicode.cpp

/* -*- 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;
}