| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ********************************************************************** | |
| * Copyright (C) 2002-2016, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ********************************************************************** | |
| * file name: ucnv_u8.c | |
| * encoding: UTF-8 | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2002jul01 | |
| * created by: Markus W. Scherer | |
| * | |
| * UTF-8 converter implementation. Used to be in ucnv_utf.c. | |
| * | |
| * Also, CESU-8 implementation, see UTR 26. | |
| * The CESU-8 converter uses all the same functions as the | |
| * UTF-8 converter, with a branch for converting supplementary code points. | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_CONVERSION | |
| #include "unicode/ucnv.h" | |
| #include "unicode/utf.h" | |
| #include "unicode/utf8.h" | |
| #include "unicode/utf16.h" | |
| #include "uassert.h" | |
| #include "ucnv_bld.h" | |
| #include "ucnv_cnv.h" | |
| #include "cmemory.h" | |
| #include "ustr_imp.h" | |
| /* Prototypes --------------------------------------------------------------- */ | |
| /* Keep these here to make finicky compilers happy */ | |
| U_CFUNC void ucnv_fromUnicode_UTF8(UConverterFromUnicodeArgs *args, | |
| UErrorCode *err); | |
| U_CFUNC void ucnv_fromUnicode_UTF8_OFFSETS_LOGIC(UConverterFromUnicodeArgs *args, | |
| UErrorCode *err); | |
| /* UTF-8 -------------------------------------------------------------------- */ | |
| #define MAXIMUM_UCS2 0x0000FFFF | |
| static const uint32_t offsetsFromUTF8[5] = {0, | |
| (uint32_t) 0x00000000, (uint32_t) 0x00003080, (uint32_t) 0x000E2080, | |
| (uint32_t) 0x03C82080 | |
| }; | |
| static UBool hasCESU8Data(const UConverter *cnv) | |
| { | |
| #if UCONFIG_ONLY_HTML_CONVERSION | |
| return FALSE; | |
| #else | |
| return (UBool)(cnv->sharedData == &_CESU8Data); | |
| #endif | |
| } | |
| U_CDECL_BEGIN | |
| static void U_CALLCONV ucnv_toUnicode_UTF8 (UConverterToUnicodeArgs * args, | |
| UErrorCode * err) | |
| { | |
| UConverter *cnv = args->converter; | |
| const unsigned char *mySource = (unsigned char *) args->source; | |
| UChar *myTarget = args->target; | |
| const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit; | |
| const UChar *targetLimit = args->targetLimit; | |
| unsigned char *toUBytes = cnv->toUBytes; | |
| UBool isCESU8 = hasCESU8Data(cnv); | |
| uint32_t ch, ch2 = 0; | |
| int32_t i, inBytes; | |
| /* Restore size of current sequence */ | |
| if (cnv->toULength > 0 && myTarget < targetLimit) | |
| { | |
| inBytes = cnv->mode; /* restore # of bytes to consume */ | |
| i = cnv->toULength; /* restore # of bytes consumed */ | |
| cnv->toULength = 0; | |
| ch = cnv->toUnicodeStatus;/*Stores the previously calculated ch from a previous call*/ | |
| cnv->toUnicodeStatus = 0; | |
| goto morebytes; | |
| } | |
| while (mySource < sourceLimit && myTarget < targetLimit) | |
| { | |
| ch = *(mySource++); | |
| if (U8_IS_SINGLE(ch)) /* Simple case */ | |
| { | |
| *(myTarget++) = (UChar) ch; | |
| } | |
| else | |
| { | |
| /* store the first char */ | |
| toUBytes[0] = (char)ch; | |
| inBytes = U8_COUNT_BYTES_NON_ASCII(ch); /* lookup current sequence length */ | |
| i = 1; | |
| morebytes: | |
| while (i < inBytes) | |
| { | |
| if (mySource < sourceLimit) | |
| { | |
| toUBytes[i] = (char) (ch2 = *mySource); | |
| if (!icu::UTF8::isValidTrail(ch, static_cast<uint8_t>(ch2), i, inBytes) && | |
| !(isCESU8 && i == 1 && ch == 0xed && U8_IS_TRAIL(ch2))) | |
| { | |
| break; /* i < inBytes */ | |
| } | |
| ch = (ch << 6) + ch2; | |
| ++mySource; | |
| i++; | |
| } | |
| else | |
| { | |
| /* stores a partially calculated target*/ | |
| cnv->toUnicodeStatus = ch; | |
| cnv->mode = inBytes; | |
| cnv->toULength = (int8_t) i; | |
| goto donefornow; | |
| } | |
| } | |
| // In CESU-8, only surrogates, not supplementary code points, are encoded directly. | |
| if (i == inBytes && (!isCESU8 || i <= 3)) | |
| { | |
| /* Remove the accumulated high bits */ | |
| ch -= offsetsFromUTF8[inBytes]; | |
| /* Normal valid byte when the loop has not prematurely terminated (i < inBytes) */ | |
| if (ch <= MAXIMUM_UCS2) | |
| { | |
| /* fits in 16 bits */ | |
| *(myTarget++) = (UChar) ch; | |
| } | |
| else | |
| { | |
| /* write out the surrogates */ | |
| *(myTarget++) = U16_LEAD(ch); | |
| ch = U16_TRAIL(ch); | |
| if (myTarget < targetLimit) | |
| { | |
| *(myTarget++) = (UChar)ch; | |
| } | |
| else | |
| { | |
| /* Put in overflow buffer (not handled here) */ | |
| cnv->UCharErrorBuffer[0] = (UChar) ch; | |
| cnv->UCharErrorBufferLength = 1; | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| break; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| cnv->toULength = (int8_t)i; | |
| *err = U_ILLEGAL_CHAR_FOUND; | |
| break; | |
| } | |
| } | |
| } | |
| donefornow: | |
| if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) | |
| { | |
| /* End of target buffer */ | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| args->target = myTarget; | |
| args->source = (const char *) mySource; | |
| } | |
| static void U_CALLCONV ucnv_toUnicode_UTF8_OFFSETS_LOGIC (UConverterToUnicodeArgs * args, | |
| UErrorCode * err) | |
| { | |
| UConverter *cnv = args->converter; | |
| const unsigned char *mySource = (unsigned char *) args->source; | |
| UChar *myTarget = args->target; | |
| int32_t *myOffsets = args->offsets; | |
| int32_t offsetNum = 0; | |
| const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit; | |
| const UChar *targetLimit = args->targetLimit; | |
| unsigned char *toUBytes = cnv->toUBytes; | |
| UBool isCESU8 = hasCESU8Data(cnv); | |
| uint32_t ch, ch2 = 0; | |
| int32_t i, inBytes; | |
| /* Restore size of current sequence */ | |
| if (cnv->toULength > 0 && myTarget < targetLimit) | |
| { | |
| inBytes = cnv->mode; /* restore # of bytes to consume */ | |
| i = cnv->toULength; /* restore # of bytes consumed */ | |
| cnv->toULength = 0; | |
| ch = cnv->toUnicodeStatus;/*Stores the previously calculated ch from a previous call*/ | |
| cnv->toUnicodeStatus = 0; | |
| goto morebytes; | |
| } | |
| while (mySource < sourceLimit && myTarget < targetLimit) | |
| { | |
| ch = *(mySource++); | |
| if (U8_IS_SINGLE(ch)) /* Simple case */ | |
| { | |
| *(myTarget++) = (UChar) ch; | |
| *(myOffsets++) = offsetNum++; | |
| } | |
| else | |
| { | |
| toUBytes[0] = (char)ch; | |
| inBytes = U8_COUNT_BYTES_NON_ASCII(ch); | |
| i = 1; | |
| morebytes: | |
| while (i < inBytes) | |
| { | |
| if (mySource < sourceLimit) | |
| { | |
| toUBytes[i] = (char) (ch2 = *mySource); | |
| if (!icu::UTF8::isValidTrail(ch, static_cast<uint8_t>(ch2), i, inBytes) && | |
| !(isCESU8 && i == 1 && ch == 0xed && U8_IS_TRAIL(ch2))) | |
| { | |
| break; /* i < inBytes */ | |
| } | |
| ch = (ch << 6) + ch2; | |
| ++mySource; | |
| i++; | |
| } | |
| else | |
| { | |
| cnv->toUnicodeStatus = ch; | |
| cnv->mode = inBytes; | |
| cnv->toULength = (int8_t)i; | |
| goto donefornow; | |
| } | |
| } | |
| // In CESU-8, only surrogates, not supplementary code points, are encoded directly. | |
| if (i == inBytes && (!isCESU8 || i <= 3)) | |
| { | |
| /* Remove the accumulated high bits */ | |
| ch -= offsetsFromUTF8[inBytes]; | |
| /* Normal valid byte when the loop has not prematurely terminated (i < inBytes) */ | |
| if (ch <= MAXIMUM_UCS2) | |
| { | |
| /* fits in 16 bits */ | |
| *(myTarget++) = (UChar) ch; | |
| *(myOffsets++) = offsetNum; | |
| } | |
| else | |
| { | |
| /* write out the surrogates */ | |
| *(myTarget++) = U16_LEAD(ch); | |
| *(myOffsets++) = offsetNum; | |
| ch = U16_TRAIL(ch); | |
| if (myTarget < targetLimit) | |
| { | |
| *(myTarget++) = (UChar)ch; | |
| *(myOffsets++) = offsetNum; | |
| } | |
| else | |
| { | |
| cnv->UCharErrorBuffer[0] = (UChar) ch; | |
| cnv->UCharErrorBufferLength = 1; | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| } | |
| offsetNum += i; | |
| } | |
| else | |
| { | |
| cnv->toULength = (int8_t)i; | |
| *err = U_ILLEGAL_CHAR_FOUND; | |
| break; | |
| } | |
| } | |
| } | |
| donefornow: | |
| if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) | |
| { /* End of target buffer */ | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| args->target = myTarget; | |
| args->source = (const char *) mySource; | |
| args->offsets = myOffsets; | |
| } | |
| U_CDECL_END | |
| U_CFUNC void U_CALLCONV ucnv_fromUnicode_UTF8 (UConverterFromUnicodeArgs * args, | |
| UErrorCode * err) | |
| { | |
| UConverter *cnv = args->converter; | |
| const UChar *mySource = args->source; | |
| const UChar *sourceLimit = args->sourceLimit; | |
| uint8_t *myTarget = (uint8_t *) args->target; | |
| const uint8_t *targetLimit = (uint8_t *) args->targetLimit; | |
| uint8_t *tempPtr; | |
| UChar32 ch; | |
| uint8_t tempBuf[4]; | |
| int32_t indexToWrite; | |
| UBool isNotCESU8 = !hasCESU8Data(cnv); | |
| if (cnv->fromUChar32 && myTarget < targetLimit) | |
| { | |
| ch = cnv->fromUChar32; | |
| cnv->fromUChar32 = 0; | |
| goto lowsurrogate; | |
| } | |
| while (mySource < sourceLimit && myTarget < targetLimit) | |
| { | |
| ch = *(mySource++); | |
| if (ch < 0x80) /* Single byte */ | |
| { | |
| *(myTarget++) = (uint8_t) ch; | |
| } | |
| else if (ch < 0x800) /* Double byte */ | |
| { | |
| *(myTarget++) = (uint8_t) ((ch >> 6) | 0xc0); | |
| if (myTarget < targetLimit) | |
| { | |
| *(myTarget++) = (uint8_t) ((ch & 0x3f) | 0x80); | |
| } | |
| else | |
| { | |
| cnv->charErrorBuffer[0] = (uint8_t) ((ch & 0x3f) | 0x80); | |
| cnv->charErrorBufferLength = 1; | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| } | |
| else { | |
| /* Check for surrogates */ | |
| if(U16_IS_SURROGATE(ch) && isNotCESU8) { | |
| lowsurrogate: | |
| if (mySource < sourceLimit) { | |
| /* test both code units */ | |
| if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(*mySource)) { | |
| /* convert and consume this supplementary code point */ | |
| ch=U16_GET_SUPPLEMENTARY(ch, *mySource); | |
| ++mySource; | |
| /* exit this condition tree */ | |
| } | |
| else { | |
| /* this is an unpaired trail or lead code unit */ | |
| /* callback(illegal) */ | |
| cnv->fromUChar32 = ch; | |
| *err = U_ILLEGAL_CHAR_FOUND; | |
| break; | |
| } | |
| } | |
| else { | |
| /* no more input */ | |
| cnv->fromUChar32 = ch; | |
| break; | |
| } | |
| } | |
| /* Do we write the buffer directly for speed, | |
| or do we have to be careful about target buffer space? */ | |
| tempPtr = (((targetLimit - myTarget) >= 4) ? myTarget : tempBuf); | |
| if (ch <= MAXIMUM_UCS2) { | |
| indexToWrite = 2; | |
| tempPtr[0] = (uint8_t) ((ch >> 12) | 0xe0); | |
| } | |
| else { | |
| indexToWrite = 3; | |
| tempPtr[0] = (uint8_t) ((ch >> 18) | 0xf0); | |
| tempPtr[1] = (uint8_t) (((ch >> 12) & 0x3f) | 0x80); | |
| } | |
| tempPtr[indexToWrite-1] = (uint8_t) (((ch >> 6) & 0x3f) | 0x80); | |
| tempPtr[indexToWrite] = (uint8_t) ((ch & 0x3f) | 0x80); | |
| if (tempPtr == myTarget) { | |
| /* There was enough space to write the codepoint directly. */ | |
| myTarget += (indexToWrite + 1); | |
| } | |
| else { | |
| /* We might run out of room soon. Write it slowly. */ | |
| for (; tempPtr <= (tempBuf + indexToWrite); tempPtr++) { | |
| if (myTarget < targetLimit) { | |
| *(myTarget++) = *tempPtr; | |
| } | |
| else { | |
| cnv->charErrorBuffer[cnv->charErrorBufferLength++] = *tempPtr; | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) | |
| { | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| args->target = (char *) myTarget; | |
| args->source = mySource; | |
| } | |
| U_CFUNC void U_CALLCONV ucnv_fromUnicode_UTF8_OFFSETS_LOGIC (UConverterFromUnicodeArgs * args, | |
| UErrorCode * err) | |
| { | |
| UConverter *cnv = args->converter; | |
| const UChar *mySource = args->source; | |
| int32_t *myOffsets = args->offsets; | |
| const UChar *sourceLimit = args->sourceLimit; | |
| uint8_t *myTarget = (uint8_t *) args->target; | |
| const uint8_t *targetLimit = (uint8_t *) args->targetLimit; | |
| uint8_t *tempPtr; | |
| UChar32 ch; | |
| int32_t offsetNum, nextSourceIndex; | |
| int32_t indexToWrite; | |
| uint8_t tempBuf[4]; | |
| UBool isNotCESU8 = !hasCESU8Data(cnv); | |
| if (cnv->fromUChar32 && myTarget < targetLimit) | |
| { | |
| ch = cnv->fromUChar32; | |
| cnv->fromUChar32 = 0; | |
| offsetNum = -1; | |
| nextSourceIndex = 0; | |
| goto lowsurrogate; | |
| } else { | |
| offsetNum = 0; | |
| } | |
| while (mySource < sourceLimit && myTarget < targetLimit) | |
| { | |
| ch = *(mySource++); | |
| if (ch < 0x80) /* Single byte */ | |
| { | |
| *(myOffsets++) = offsetNum++; | |
| *(myTarget++) = (char) ch; | |
| } | |
| else if (ch < 0x800) /* Double byte */ | |
| { | |
| *(myOffsets++) = offsetNum; | |
| *(myTarget++) = (uint8_t) ((ch >> 6) | 0xc0); | |
| if (myTarget < targetLimit) | |
| { | |
| *(myOffsets++) = offsetNum++; | |
| *(myTarget++) = (uint8_t) ((ch & 0x3f) | 0x80); | |
| } | |
| else | |
| { | |
| cnv->charErrorBuffer[0] = (uint8_t) ((ch & 0x3f) | 0x80); | |
| cnv->charErrorBufferLength = 1; | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| } | |
| else | |
| /* Check for surrogates */ | |
| { | |
| nextSourceIndex = offsetNum + 1; | |
| if(U16_IS_SURROGATE(ch) && isNotCESU8) { | |
| lowsurrogate: | |
| if (mySource < sourceLimit) { | |
| /* test both code units */ | |
| if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(*mySource)) { | |
| /* convert and consume this supplementary code point */ | |
| ch=U16_GET_SUPPLEMENTARY(ch, *mySource); | |
| ++mySource; | |
| ++nextSourceIndex; | |
| /* exit this condition tree */ | |
| } | |
| else { | |
| /* this is an unpaired trail or lead code unit */ | |
| /* callback(illegal) */ | |
| cnv->fromUChar32 = ch; | |
| *err = U_ILLEGAL_CHAR_FOUND; | |
| break; | |
| } | |
| } | |
| else { | |
| /* no more input */ | |
| cnv->fromUChar32 = ch; | |
| break; | |
| } | |
| } | |
| /* Do we write the buffer directly for speed, | |
| or do we have to be careful about target buffer space? */ | |
| tempPtr = (((targetLimit - myTarget) >= 4) ? myTarget : tempBuf); | |
| if (ch <= MAXIMUM_UCS2) { | |
| indexToWrite = 2; | |
| tempPtr[0] = (uint8_t) ((ch >> 12) | 0xe0); | |
| } | |
| else { | |
| indexToWrite = 3; | |
| tempPtr[0] = (uint8_t) ((ch >> 18) | 0xf0); | |
| tempPtr[1] = (uint8_t) (((ch >> 12) & 0x3f) | 0x80); | |
| } | |
| tempPtr[indexToWrite-1] = (uint8_t) (((ch >> 6) & 0x3f) | 0x80); | |
| tempPtr[indexToWrite] = (uint8_t) ((ch & 0x3f) | 0x80); | |
| if (tempPtr == myTarget) { | |
| /* There was enough space to write the codepoint directly. */ | |
| myTarget += (indexToWrite + 1); | |
| myOffsets[0] = offsetNum; | |
| myOffsets[1] = offsetNum; | |
| myOffsets[2] = offsetNum; | |
| if (indexToWrite >= 3) { | |
| myOffsets[3] = offsetNum; | |
| } | |
| myOffsets += (indexToWrite + 1); | |
| } | |
| else { | |
| /* We might run out of room soon. Write it slowly. */ | |
| for (; tempPtr <= (tempBuf + indexToWrite); tempPtr++) { | |
| if (myTarget < targetLimit) | |
| { | |
| *(myOffsets++) = offsetNum; | |
| *(myTarget++) = *tempPtr; | |
| } | |
| else | |
| { | |
| cnv->charErrorBuffer[cnv->charErrorBufferLength++] = *tempPtr; | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| } | |
| } | |
| offsetNum = nextSourceIndex; | |
| } | |
| } | |
| if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) | |
| { | |
| *err = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| args->target = (char *) myTarget; | |
| args->source = mySource; | |
| args->offsets = myOffsets; | |
| } | |
| U_CDECL_BEGIN | |
| static UChar32 U_CALLCONV ucnv_getNextUChar_UTF8(UConverterToUnicodeArgs *args, | |
| UErrorCode *err) { | |
| UConverter *cnv; | |
| const uint8_t *sourceInitial; | |
| const uint8_t *source; | |
| uint8_t myByte; | |
| UChar32 ch; | |
| int8_t i; | |
| /* UTF-8 only here, the framework handles CESU-8 to combine surrogate pairs */ | |
| cnv = args->converter; | |
| sourceInitial = source = (const uint8_t *)args->source; | |
| if (source >= (const uint8_t *)args->sourceLimit) | |
| { | |
| /* no input */ | |
| *err = U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0xffff; | |
| } | |
| myByte = (uint8_t)*(source++); | |
| if (U8_IS_SINGLE(myByte)) | |
| { | |
| args->source = (const char *)source; | |
| return (UChar32)myByte; | |
| } | |
| uint16_t countTrailBytes = U8_COUNT_TRAIL_BYTES(myByte); | |
| if (countTrailBytes == 0) { | |
| cnv->toUBytes[0] = myByte; | |
| cnv->toULength = 1; | |
| *err = U_ILLEGAL_CHAR_FOUND; | |
| args->source = (const char *)source; | |
| return 0xffff; | |
| } | |
| /*The byte sequence is longer than the buffer area passed*/ | |
| if (((const char *)source + countTrailBytes) > args->sourceLimit) | |
| { | |
| /* check if all of the remaining bytes are trail bytes */ | |
| uint16_t extraBytesToWrite = countTrailBytes + 1; | |
| cnv->toUBytes[0] = myByte; | |
| i = 1; | |
| *err = U_TRUNCATED_CHAR_FOUND; | |
| while(source < (const uint8_t *)args->sourceLimit) { | |
| uint8_t b = *source; | |
| if(icu::UTF8::isValidTrail(myByte, b, i, extraBytesToWrite)) { | |
| cnv->toUBytes[i++] = b; | |
| ++source; | |
| } else { | |
| /* error even before we run out of input */ | |
| *err = U_ILLEGAL_CHAR_FOUND; | |
| break; | |
| } | |
| } | |
| cnv->toULength = i; | |
| args->source = (const char *)source; | |
| return 0xffff; | |
| } | |
| ch = myByte << 6; | |
| if(countTrailBytes == 2) { | |
| uint8_t t1 = *source, t2; | |
| if(U8_IS_VALID_LEAD3_AND_T1(myByte, t1) && U8_IS_TRAIL(t2 = *++source)) { | |
| args->source = (const char *)(source + 1); | |
| return (((ch + t1) << 6) + t2) - offsetsFromUTF8[3]; | |
| } | |
| } else if(countTrailBytes == 1) { | |
| uint8_t t1 = *source; | |
| if(U8_IS_TRAIL(t1)) { | |
| args->source = (const char *)(source + 1); | |
| return (ch + t1) - offsetsFromUTF8[2]; | |
| } | |
| } else { // countTrailBytes == 3 | |
| uint8_t t1 = *source, t2, t3; | |
| if(U8_IS_VALID_LEAD4_AND_T1(myByte, t1) && U8_IS_TRAIL(t2 = *++source) && | |
| U8_IS_TRAIL(t3 = *++source)) { | |
| args->source = (const char *)(source + 1); | |
| return (((((ch + t1) << 6) + t2) << 6) + t3) - offsetsFromUTF8[4]; | |
| } | |
| } | |
| args->source = (const char *)source; | |
| for(i = 0; sourceInitial < source; ++i) { | |
| cnv->toUBytes[i] = *sourceInitial++; | |
| } | |
| cnv->toULength = i; | |
| *err = U_ILLEGAL_CHAR_FOUND; | |
| return 0xffff; | |
| } | |
| U_CDECL_END | |
| /* UTF-8-from-UTF-8 conversion functions ------------------------------------ */ | |
| U_CDECL_BEGIN | |
| /* "Convert" UTF-8 to UTF-8: Validate and copy. Modified from ucnv_DBCSFromUTF8(). */ | |
| static void U_CALLCONV | |
| ucnv_UTF8FromUTF8(UConverterFromUnicodeArgs *pFromUArgs, | |
| UConverterToUnicodeArgs *pToUArgs, | |
| UErrorCode *pErrorCode) { | |
| UConverter *utf8; | |
| const uint8_t *source, *sourceLimit; | |
| uint8_t *target; | |
| int32_t targetCapacity; | |
| int32_t count; | |
| int8_t oldToULength, toULength, toULimit; | |
| UChar32 c; | |
| uint8_t b, t1, t2; | |
| /* set up the local pointers */ | |
| utf8=pToUArgs->converter; | |
| source=(uint8_t *)pToUArgs->source; | |
| sourceLimit=(uint8_t *)pToUArgs->sourceLimit; | |
| target=(uint8_t *)pFromUArgs->target; | |
| targetCapacity=(int32_t)(pFromUArgs->targetLimit-pFromUArgs->target); | |
| /* get the converter state from the UTF-8 UConverter */ | |
| if(utf8->toULength > 0) { | |
| toULength=oldToULength=utf8->toULength; | |
| toULimit=(int8_t)utf8->mode; | |
| c=(UChar32)utf8->toUnicodeStatus; | |
| } else { | |
| toULength=oldToULength=toULimit=0; | |
| c = 0; | |
| } | |
| count=(int32_t)(sourceLimit-source)+oldToULength; | |
| if(count<toULimit) { | |
| /* | |
| * Not enough input to complete the partial character. | |
| * Jump to moreBytes below - it will not output to target. | |
| */ | |
| } else if(targetCapacity<toULimit) { | |
| /* | |
| * Not enough target capacity to output the partial character. | |
| * Let the standard converter handle this. | |
| */ | |
| *pErrorCode=U_USING_DEFAULT_WARNING; | |
| return; | |
| } else { | |
| // Use a single counter for source and target, counting the minimum of | |
| // the source length and the target capacity. | |
| // Let the standard converter handle edge cases. | |
| if(count>targetCapacity) { | |
| count=targetCapacity; | |
| } | |
| // The conversion loop checks count>0 only once per character. | |
| // If the buffer ends with a truncated sequence, | |
| // then we reduce the count to stop before that, | |
| // and collect the remaining bytes after the conversion loop. | |
| // Do not go back into the bytes that will be read for finishing a partial | |
| // sequence from the previous buffer. | |
| int32_t length=count-toULength; | |
| U8_TRUNCATE_IF_INCOMPLETE(source, 0, length); | |
| count=toULength+length; | |
| } | |
| if(c!=0) { | |
| utf8->toUnicodeStatus=0; | |
| utf8->toULength=0; | |
| goto moreBytes; | |
| /* See note in ucnv_SBCSFromUTF8() about this goto. */ | |
| } | |
| /* conversion loop */ | |
| while(count>0) { | |
| b=*source++; | |
| if(U8_IS_SINGLE(b)) { | |
| /* convert ASCII */ | |
| *target++=b; | |
| --count; | |
| continue; | |
| } else { | |
| if(b>=0xe0) { | |
| if( /* handle U+0800..U+FFFF inline */ | |
| b<0xf0 && | |
| U8_IS_VALID_LEAD3_AND_T1(b, t1=source[0]) && | |
| U8_IS_TRAIL(t2=source[1]) | |
| ) { | |
| source+=2; | |
| *target++=b; | |
| *target++=t1; | |
| *target++=t2; | |
| count-=3; | |
| continue; | |
| } | |
| } else { | |
| if( /* handle U+0080..U+07FF inline */ | |
| b>=0xc2 && | |
| U8_IS_TRAIL(t1=*source) | |
| ) { | |
| ++source; | |
| *target++=b; | |
| *target++=t1; | |
| count-=2; | |
| continue; | |
| } | |
| } | |
| /* handle "complicated" and error cases, and continuing partial characters */ | |
| oldToULength=0; | |
| toULength=1; | |
| toULimit=U8_COUNT_BYTES_NON_ASCII(b); | |
| c=b; | |
| moreBytes: | |
| while(toULength<toULimit) { | |
| if(source<sourceLimit) { | |
| b=*source; | |
| if(icu::UTF8::isValidTrail(c, b, toULength, toULimit)) { | |
| ++source; | |
| ++toULength; | |
| c=(c<<6)+b; | |
| } else { | |
| break; /* sequence too short, stop with toULength<toULimit */ | |
| } | |
| } else { | |
| /* store the partial UTF-8 character, compatible with the regular UTF-8 converter */ | |
| source-=(toULength-oldToULength); | |
| while(oldToULength<toULength) { | |
| utf8->toUBytes[oldToULength++]=*source++; | |
| } | |
| utf8->toUnicodeStatus=c; | |
| utf8->toULength=toULength; | |
| utf8->mode=toULimit; | |
| pToUArgs->source=(char *)source; | |
| pFromUArgs->target=(char *)target; | |
| return; | |
| } | |
| } | |
| if(toULength!=toULimit) { | |
| /* error handling: illegal UTF-8 byte sequence */ | |
| source-=(toULength-oldToULength); | |
| while(oldToULength<toULength) { | |
| utf8->toUBytes[oldToULength++]=*source++; | |
| } | |
| utf8->toULength=toULength; | |
| pToUArgs->source=(char *)source; | |
| pFromUArgs->target=(char *)target; | |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; | |
| return; | |
| } | |
| /* copy the legal byte sequence to the target */ | |
| { | |
| int8_t i; | |
| for(i=0; i<oldToULength; ++i) { | |
| *target++=utf8->toUBytes[i]; | |
| } | |
| source-=(toULength-oldToULength); | |
| for(; i<toULength; ++i) { | |
| *target++=*source++; | |
| } | |
| count-=toULength; | |
| } | |
| } | |
| } | |
| U_ASSERT(count>=0); | |
| if(U_SUCCESS(*pErrorCode) && source<sourceLimit) { | |
| if(target==(const uint8_t *)pFromUArgs->targetLimit) { | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| } else { | |
| b=*source; | |
| toULimit=U8_COUNT_BYTES(b); | |
| if(toULimit>(sourceLimit-source)) { | |
| /* collect a truncated byte sequence */ | |
| toULength=0; | |
| c=b; | |
| for(;;) { | |
| utf8->toUBytes[toULength++]=b; | |
| if(++source==sourceLimit) { | |
| /* partial byte sequence at end of source */ | |
| utf8->toUnicodeStatus=c; | |
| utf8->toULength=toULength; | |
| utf8->mode=toULimit; | |
| break; | |
| } else if(!icu::UTF8::isValidTrail(c, b=*source, toULength, toULimit)) { | |
| utf8->toULength=toULength; | |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; | |
| break; | |
| } | |
| c=(c<<6)+b; | |
| } | |
| } else { | |
| /* partial-sequence target overflow: fall back to the pivoting implementation */ | |
| *pErrorCode=U_USING_DEFAULT_WARNING; | |
| } | |
| } | |
| } | |
| /* write back the updated pointers */ | |
| pToUArgs->source=(char *)source; | |
| pFromUArgs->target=(char *)target; | |
| } | |
| U_CDECL_END | |
| /* UTF-8 converter data ----------------------------------------------------- */ | |
| static const UConverterImpl _UTF8Impl={ | |
| UCNV_UTF8, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| ucnv_toUnicode_UTF8, | |
| ucnv_toUnicode_UTF8_OFFSETS_LOGIC, | |
| ucnv_fromUnicode_UTF8, | |
| ucnv_fromUnicode_UTF8_OFFSETS_LOGIC, | |
| ucnv_getNextUChar_UTF8, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| ucnv_getNonSurrogateUnicodeSet, | |
| ucnv_UTF8FromUTF8, | |
| ucnv_UTF8FromUTF8 | |
| }; | |
| /* The 1208 CCSID refers to any version of Unicode of UTF-8 */ | |
| static const UConverterStaticData _UTF8StaticData={ | |
| sizeof(UConverterStaticData), | |
| "UTF-8", | |
| 1208, UCNV_IBM, UCNV_UTF8, | |
| 1, 3, /* max 3 bytes per UChar from UTF-8 (4 bytes from surrogate _pair_) */ | |
| { 0xef, 0xbf, 0xbd, 0 },3,FALSE,FALSE, | |
| 0, | |
| 0, | |
| { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */ | |
| }; | |
| const UConverterSharedData _UTF8Data= | |
| UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_UTF8StaticData, &_UTF8Impl); | |
| /* CESU-8 converter data ---------------------------------------------------- */ | |
| static const UConverterImpl _CESU8Impl={ | |
| UCNV_CESU8, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| ucnv_toUnicode_UTF8, | |
| ucnv_toUnicode_UTF8_OFFSETS_LOGIC, | |
| ucnv_fromUnicode_UTF8, | |
| ucnv_fromUnicode_UTF8_OFFSETS_LOGIC, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| ucnv_getCompleteUnicodeSet, | |
| NULL, | |
| NULL | |
| }; | |
| static const UConverterStaticData _CESU8StaticData={ | |
| sizeof(UConverterStaticData), | |
| "CESU-8", | |
| 9400, /* CCSID for CESU-8 */ | |
| UCNV_UNKNOWN, UCNV_CESU8, 1, 3, | |
| { 0xef, 0xbf, 0xbd, 0 },3,FALSE,FALSE, | |
| 0, | |
| 0, | |
| { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */ | |
| }; | |
| const UConverterSharedData _CESU8Data= | |
| UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_CESU8StaticData, &_CESU8Impl); | |
| #endif |