/* ********************************************************************** * Copyright (C) 2002-2011, International Business Machines * Corporation and others. All Rights Reserved. ********************************************************************** * file name: ucnv_u8.c * encoding: US-ASCII * 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 "ucnv_bld.h" #include "ucnv_cnv.h" #include "cmemory.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 -------------------------------------------------------------------- */ /* UTF-8 Conversion DATA * for more information see Unicode Standard 2.0, Transformation Formats Appendix A-9 */ /*static const uint32_t REPLACEMENT_CHARACTER = 0x0000FFFD;*/ #define MAXIMUM_UCS2 0x0000FFFF #define MAXIMUM_UTF 0x0010FFFF #define MAXIMUM_UCS4 0x7FFFFFFF #define HALF_SHIFT 10 #define HALF_BASE 0x0010000 #define HALF_MASK 0x3FF #define SURROGATE_HIGH_START 0xD800 #define SURROGATE_HIGH_END 0xDBFF #define SURROGATE_LOW_START 0xDC00 #define SURROGATE_LOW_END 0xDFFF /* -SURROGATE_LOW_START + HALF_BASE */ #define SURROGATE_LOW_BASE 9216 static const uint32_t offsetsFromUTF8[7] = {0, (uint32_t) 0x00000000, (uint32_t) 0x00003080, (uint32_t) 0x000E2080, (uint32_t) 0x03C82080, (uint32_t) 0xFA082080, (uint32_t) 0x82082080 }; /* END OF UTF-8 Conversion DATA */ static const int8_t bytesFromUTF8[256] = { 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, 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, 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, 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, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 0, 0 }; /* * Starting with Unicode 3.0.1: * UTF-8 byte sequences of length N _must_ encode code points of or above utf8_minChar32[N]; * byte sequences with more than 4 bytes are illegal in UTF-8, * which is tested with impossible values for them */ static const uint32_t utf8_minChar32[7]={ 0, 0, 0x80, 0x800, 0x10000, 0xffffffff, 0xffffffff }; static void 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 = (UBool)(cnv->sharedData == &_CESU8Data); uint32_t ch, ch2 = 0; int32_t i, inBytes; /* Restore size of current sequence */ if (cnv->toUnicodeStatus && 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 (ch < 0x80) /* Simple case */ { *(myTarget++) = (UChar) ch; } else { /* store the first char */ toUBytes[0] = (char)ch; inBytes = bytesFromUTF8[ch]; /* lookup current sequence length */ i = 1; morebytes: while (i < inBytes) { if (mySource < sourceLimit) { toUBytes[i] = (char) (ch2 = *mySource); if (!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; } } /* Remove the accumulated high bits */ ch -= offsetsFromUTF8[inBytes]; /* * Legal UTF-8 byte sequences in Unicode 3.0.1 and up: * - use only trail bytes after a lead byte (checked above) * - use the right number of trail bytes for a given lead byte * - encode a code point <= U+10ffff * - use the fewest possible number of bytes for their code points * - use at most 4 bytes (for i>=5 it is 0x10ffff= utf8_minChar32[i] && (isCESU8 ? i <= 3 : !U_IS_SURROGATE(ch))) { /* 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 */ ch -= HALF_BASE; *(myTarget++) = (UChar) ((ch >> HALF_SHIFT) + SURROGATE_HIGH_START); ch = (ch & HALF_MASK) + SURROGATE_LOW_START; 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 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 = (UBool)(cnv->sharedData == &_CESU8Data); uint32_t ch, ch2 = 0; int32_t i, inBytes; /* Restore size of current sequence */ if (cnv->toUnicodeStatus && 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 (ch < 0x80) /* Simple case */ { *(myTarget++) = (UChar) ch; *(myOffsets++) = offsetNum++; } else { toUBytes[0] = (char)ch; inBytes = bytesFromUTF8[ch]; i = 1; morebytes: while (i < inBytes) { if (mySource < sourceLimit) { toUBytes[i] = (char) (ch2 = *mySource); if (!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; } } /* Remove the accumulated high bits */ ch -= offsetsFromUTF8[inBytes]; /* * Legal UTF-8 byte sequences in Unicode 3.0.1 and up: * - use only trail bytes after a lead byte (checked above) * - use the right number of trail bytes for a given lead byte * - encode a code point <= U+10ffff * - use the fewest possible number of bytes for their code points * - use at most 4 bytes (for i>=5 it is 0x10ffff= utf8_minChar32[i] && (isCESU8 ? i <= 3 : !U_IS_SURROGATE(ch))) { /* 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 */ ch -= HALF_BASE; *(myTarget++) = (UChar) ((ch >> HALF_SHIFT) + SURROGATE_HIGH_START); *(myOffsets++) = offsetNum; ch = (ch & HALF_MASK) + SURROGATE_LOW_START; 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_CFUNC void 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 = (UBool)(cnv->sharedData != &_CESU8Data); 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 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 = (UBool)(cnv->sharedData != &_CESU8Data); 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; } static UChar32 ucnv_getNextUChar_UTF8(UConverterToUnicodeArgs *args, UErrorCode *err) { UConverter *cnv; const uint8_t *sourceInitial; const uint8_t *source; uint16_t extraBytesToWrite; uint8_t myByte; UChar32 ch; int8_t i, isLegalSequence; /* 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 (myByte < 0x80) { args->source = (const char *)source; return (UChar32)myByte; } extraBytesToWrite = (uint16_t)bytesFromUTF8[myByte]; if (extraBytesToWrite == 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 + extraBytesToWrite - 1) > args->sourceLimit) { /* check if all of the remaining bytes are trail bytes */ cnv->toUBytes[0] = myByte; i = 1; *err = U_TRUNCATED_CHAR_FOUND; while(source < (const uint8_t *)args->sourceLimit) { if(U8_IS_TRAIL(myByte = *source)) { cnv->toUBytes[i++] = myByte; ++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; } isLegalSequence = 1; ch = myByte << 6; switch(extraBytesToWrite) { /* note: code falls through cases! (sic)*/ case 6: ch += (myByte = *source); ch <<= 6; if (!U8_IS_TRAIL(myByte)) { isLegalSequence = 0; break; } ++source; case 5: /*fall through*/ ch += (myByte = *source); ch <<= 6; if (!U8_IS_TRAIL(myByte)) { isLegalSequence = 0; break; } ++source; case 4: /*fall through*/ ch += (myByte = *source); ch <<= 6; if (!U8_IS_TRAIL(myByte)) { isLegalSequence = 0; break; } ++source; case 3: /*fall through*/ ch += (myByte = *source); ch <<= 6; if (!U8_IS_TRAIL(myByte)) { isLegalSequence = 0; break; } ++source; case 2: /*fall through*/ ch += (myByte = *source); if (!U8_IS_TRAIL(myByte)) { isLegalSequence = 0; break; } ++source; }; ch -= offsetsFromUTF8[extraBytesToWrite]; args->source = (const char *)source; /* * Legal UTF-8 byte sequences in Unicode 3.0.1 and up: * - use only trail bytes after a lead byte (checked above) * - use the right number of trail bytes for a given lead byte * - encode a code point <= U+10ffff * - use the fewest possible number of bytes for their code points * - use at most 4 bytes (for i>=5 it is 0x10ffff= utf8_minChar32[extraBytesToWrite] && !U_IS_SURROGATE(ch) ) { return ch; /* return the code point */ } for(i = 0; sourceInitial < source; ++i) { cnv->toUBytes[i] = *sourceInitial++; } cnv->toULength = i; *err = U_ILLEGAL_CHAR_FOUND; return 0xffff; } /* UTF-8-from-UTF-8 conversion functions ------------------------------------ */ /* minimum code point values for n-byte UTF-8 sequences, n=0..4 */ static const UChar32 utf8_minLegal[5]={ 0, 0, 0x80, 0x800, 0x10000 }; /* offsets for n-byte UTF-8 sequences that were calculated with ((lead<<6)+trail)<<6+trail... */ static const UChar32 utf8_offsets[7]={ 0, 0, 0x3080, 0xE2080, 0x3C82080 }; /* "Convert" UTF-8 to UTF-8: Validate and copy. Modified from ucnv_DBCSFromUTF8(). */ static void ucnv_UTF8FromUTF8(UConverterFromUnicodeArgs *pFromUArgs, UConverterToUnicodeArgs *pToUArgs, UErrorCode *pErrorCode) { UConverter *utf8, *cnv; 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; cnv=pFromUArgs->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 */ c=(UChar32)utf8->toUnicodeStatus; if(c!=0) { toULength=oldToULength=utf8->toULength; toULimit=(int8_t)utf8->mode; } else { toULength=oldToULength=toULimit=0; } count=(int32_t)(sourceLimit-source)+oldToULength; if(counttargetCapacity) { count=targetCapacity; } i=0; while(i<3 && i<(count-toULimit)) { b=source[count-oldToULength-i-1]; if(U8_IS_TRAIL(b)) { ++i; } else { if(itoUnicodeStatus=0; utf8->toULength=0; goto moreBytes; /* See note in ucnv_SBCSFromUTF8() about this goto. */ } /* conversion loop */ while(count>0) { b=*source++; if((int8_t)b>=0) { /* convert ASCII */ *target++=b; --count; continue; } else { if(b>0xe0) { if( /* handle U+1000..U+D7FF inline */ (t1=source[0]) >= 0x80 && ((b<0xed && (t1 <= 0xbf)) || (b==0xed && (t1 <= 0x9f))) && (t2=source[1]) >= 0x80 && t2 <= 0xbf ) { source+=2; *target++=b; *target++=t1; *target++=t2; count-=3; continue; } } else if(b<0xe0) { if( /* handle U+0080..U+07FF inline */ b>=0xc2 && (t1=*source) >= 0x80 && t1 <= 0xbf ) { ++source; *target++=b; *target++=t1; count-=2; continue; } } else if(b==0xe0) { if( /* handle U+0800..U+0FFF inline */ (t1=source[0]) >= 0xa0 && t1 <= 0xbf && (t2=source[1]) >= 0x80 && t2 <= 0xbf ) { source+=2; *target++=b; *target++=t1; *target++=t2; count-=3; continue; } } /* handle "complicated" and error cases, and continuing partial characters */ oldToULength=0; toULength=1; toULimit=utf8_countTrailBytes[b]+1; c=b; moreBytes: while(toULengthtoUBytes[oldToULength++]=*source++; } utf8->toUnicodeStatus=c; utf8->toULength=toULength; utf8->mode=toULimit; pToUArgs->source=(char *)source; pFromUArgs->target=(char *)target; return; } } if( toULength==toULimit && /* consumed all trail bytes */ (toULength==3 || toULength==2) && /* BMP */ (c-=utf8_offsets[toULength])>=utf8_minLegal[toULength] && (c<=0xd7ff || 0xe000<=c) /* not a surrogate */ ) { /* legal byte sequence for BMP code point */ } else if( toULength==toULimit && toULength==4 && (0x10000<=(c-=utf8_offsets[4]) && c<=0x10ffff) ) { /* legal byte sequence for supplementary code point */ } else { /* error handling: illegal UTF-8 byte sequence */ source-=(toULength-oldToULength); while(oldToULengthtoUBytes[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; itoUBytes[i]; } source-=(toULength-oldToULength); for(; itargetLimit) { *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } else { b=*source; toULimit=utf8_countTrailBytes[b]+1; 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(!U8_IS_TRAIL(b=*source)) { /* lead byte in trail byte position */ 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; } /* 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={ sizeof(UConverterSharedData), ~((uint32_t) 0), NULL, NULL, &_UTF8StaticData, FALSE, &_UTF8Impl, 0 }; /* 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 }; 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={ sizeof(UConverterSharedData), ~((uint32_t) 0), NULL, NULL, &_CESU8StaticData, FALSE, &_CESU8Impl, 0 }; #endif