| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ****************************************************************************** |
| * |
| * Copyright (C) 2001-2016, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ****************************************************************************** |
| * |
| * File ustrtrns.cpp |
| * |
| * Modification History: |
| * |
| * Date Name Description |
| * 9/10/2001 Ram Creation. |
| ****************************************************************************** |
| */ |
| |
| /******************************************************************************* |
| * |
| * u_strTo* and u_strFrom* APIs |
| * WCS functions moved to ustr_wcs.c for better modularization |
| * |
| ******************************************************************************* |
| */ |
| |
| #if defined(STARBOARD) |
| #include "starboard/client_porting/poem/assert_poem.h" |
| #endif // defined(STARBOARD) |
| #include "unicode/putil.h" |
| #include "unicode/ustring.h" |
| #include "unicode/utf.h" |
| #include "unicode/utf8.h" |
| #include "unicode/utf16.h" |
| #include "cstring.h" |
| #include "cmemory.h" |
| #include "ustr_imp.h" |
| #include "uassert.h" |
| |
| U_CAPI UChar* U_EXPORT2 |
| u_strFromUTF32WithSub(UChar *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const UChar32 *src, |
| int32_t srcLength, |
| UChar32 subchar, int32_t *pNumSubstitutions, |
| UErrorCode *pErrorCode) { |
| const UChar32 *srcLimit; |
| UChar32 ch; |
| UChar *destLimit; |
| UChar *pDest; |
| int32_t reqLength; |
| int32_t numSubstitutions; |
| |
| /* args check */ |
| if(U_FAILURE(*pErrorCode)){ |
| return NULL; |
| } |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || |
| (destCapacity<0) || (dest == NULL && destCapacity > 0) || |
| subchar > 0x10ffff || U_IS_SURROGATE(subchar) |
| ) { |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if(pNumSubstitutions != NULL) { |
| *pNumSubstitutions = 0; |
| } |
| |
| pDest = dest; |
| destLimit = (dest!=NULL)?(dest + destCapacity):NULL; |
| reqLength = 0; |
| numSubstitutions = 0; |
| |
| if(srcLength < 0) { |
| /* simple loop for conversion of a NUL-terminated BMP string */ |
| while((ch=*src) != 0 && |
| ((uint32_t)ch < 0xd800 || (0xe000 <= ch && ch <= 0xffff))) { |
| ++src; |
| if(pDest < destLimit) { |
| *pDest++ = (UChar)ch; |
| } else { |
| ++reqLength; |
| } |
| } |
| srcLimit = src; |
| if(ch != 0) { |
| /* "complicated" case, find the end of the remaining string */ |
| while(*++srcLimit != 0) {} |
| } |
| } else { |
| srcLimit = (src!=NULL)?(src + srcLength):NULL; |
| } |
| |
| /* convert with length */ |
| while(src < srcLimit) { |
| ch = *src++; |
| do { |
| /* usually "loops" once; twice only for writing subchar */ |
| if((uint32_t)ch < 0xd800 || (0xe000 <= ch && ch <= 0xffff)) { |
| if(pDest < destLimit) { |
| *pDest++ = (UChar)ch; |
| } else { |
| ++reqLength; |
| } |
| break; |
| } else if(0x10000 <= ch && ch <= 0x10ffff) { |
| if(pDest!=NULL && ((pDest + 2) <= destLimit)) { |
| *pDest++ = U16_LEAD(ch); |
| *pDest++ = U16_TRAIL(ch); |
| } else { |
| reqLength += 2; |
| } |
| break; |
| } else if((ch = subchar) < 0) { |
| /* surrogate code point, or not a Unicode code point at all */ |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else { |
| ++numSubstitutions; |
| } |
| } while(TRUE); |
| } |
| |
| reqLength += (int32_t)(pDest - dest); |
| if(pDestLength) { |
| *pDestLength = reqLength; |
| } |
| if(pNumSubstitutions != NULL) { |
| *pNumSubstitutions = numSubstitutions; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateUChars(dest, destCapacity, reqLength, pErrorCode); |
| |
| return dest; |
| } |
| |
| U_CAPI UChar* U_EXPORT2 |
| u_strFromUTF32(UChar *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const UChar32 *src, |
| int32_t srcLength, |
| UErrorCode *pErrorCode) { |
| return u_strFromUTF32WithSub( |
| dest, destCapacity, pDestLength, |
| src, srcLength, |
| U_SENTINEL, NULL, |
| pErrorCode); |
| } |
| |
| U_CAPI UChar32* U_EXPORT2 |
| u_strToUTF32WithSub(UChar32 *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const UChar *src, |
| int32_t srcLength, |
| UChar32 subchar, int32_t *pNumSubstitutions, |
| UErrorCode *pErrorCode) { |
| const UChar *srcLimit; |
| UChar32 ch; |
| UChar ch2; |
| UChar32 *destLimit; |
| UChar32 *pDest; |
| int32_t reqLength; |
| int32_t numSubstitutions; |
| |
| /* args check */ |
| if(U_FAILURE(*pErrorCode)){ |
| return NULL; |
| } |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || |
| (destCapacity<0) || (dest == NULL && destCapacity > 0) || |
| subchar > 0x10ffff || U_IS_SURROGATE(subchar) |
| ) { |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if(pNumSubstitutions != NULL) { |
| *pNumSubstitutions = 0; |
| } |
| |
| pDest = dest; |
| destLimit = (dest!=NULL)?(dest + destCapacity):NULL; |
| reqLength = 0; |
| numSubstitutions = 0; |
| |
| if(srcLength < 0) { |
| /* simple loop for conversion of a NUL-terminated BMP string */ |
| while((ch=*src) != 0 && !U16_IS_SURROGATE(ch)) { |
| ++src; |
| if(pDest < destLimit) { |
| *pDest++ = ch; |
| } else { |
| ++reqLength; |
| } |
| } |
| srcLimit = src; |
| if(ch != 0) { |
| /* "complicated" case, find the end of the remaining string */ |
| while(*++srcLimit != 0) {} |
| } |
| } else { |
| srcLimit = (src!=NULL)?(src + srcLength):NULL; |
| } |
| |
| /* convert with length */ |
| while(src < srcLimit) { |
| ch = *src++; |
| if(!U16_IS_SURROGATE(ch)) { |
| /* write or count ch below */ |
| } else if(U16_IS_SURROGATE_LEAD(ch) && src < srcLimit && U16_IS_TRAIL(ch2 = *src)) { |
| ++src; |
| ch = U16_GET_SUPPLEMENTARY(ch, ch2); |
| } else if((ch = subchar) < 0) { |
| /* unpaired surrogate */ |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else { |
| ++numSubstitutions; |
| } |
| if(pDest < destLimit) { |
| *pDest++ = ch; |
| } else { |
| ++reqLength; |
| } |
| } |
| |
| reqLength += (int32_t)(pDest - dest); |
| if(pDestLength) { |
| *pDestLength = reqLength; |
| } |
| if(pNumSubstitutions != NULL) { |
| *pNumSubstitutions = numSubstitutions; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateUChar32s(dest, destCapacity, reqLength, pErrorCode); |
| |
| return dest; |
| } |
| |
| U_CAPI UChar32* U_EXPORT2 |
| u_strToUTF32(UChar32 *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const UChar *src, |
| int32_t srcLength, |
| UErrorCode *pErrorCode) { |
| return u_strToUTF32WithSub( |
| dest, destCapacity, pDestLength, |
| src, srcLength, |
| U_SENTINEL, NULL, |
| pErrorCode); |
| } |
| |
| U_CAPI UChar* U_EXPORT2 |
| u_strFromUTF8WithSub(UChar *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const char* src, |
| int32_t srcLength, |
| UChar32 subchar, int32_t *pNumSubstitutions, |
| UErrorCode *pErrorCode){ |
| /* args check */ |
| if(U_FAILURE(*pErrorCode)) { |
| return NULL; |
| } |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || |
| (destCapacity<0) || (dest == NULL && destCapacity > 0) || |
| subchar > 0x10ffff || U_IS_SURROGATE(subchar) |
| ) { |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if(pNumSubstitutions!=NULL) { |
| *pNumSubstitutions=0; |
| } |
| UChar *pDest = dest; |
| UChar *pDestLimit = dest+destCapacity; |
| int32_t reqLength = 0; |
| int32_t numSubstitutions=0; |
| |
| /* |
| * Inline processing of UTF-8 byte sequences: |
| * |
| * Byte sequences for the most common characters are handled inline in |
| * the conversion loops. In order to reduce the path lengths for those |
| * characters, the tests are arranged in a kind of binary search. |
| * ASCII (<=0x7f) is checked first, followed by the dividing point |
| * between 2- and 3-byte sequences (0xe0). |
| * The 3-byte branch is tested first to speed up CJK text. |
| * The compiler should combine the subtractions for the two tests for 0xe0. |
| * Each branch then tests for the other end of its range. |
| */ |
| |
| if(srcLength < 0){ |
| /* |
| * Transform a NUL-terminated string. |
| * The code explicitly checks for NULs only in the lead byte position. |
| * A NUL byte in the trail byte position fails the trail byte range check anyway. |
| */ |
| int32_t i; |
| UChar32 c; |
| for(i = 0; (c = (uint8_t)src[i]) != 0 && (pDest < pDestLimit);) { |
| // modified copy of U8_NEXT() |
| ++i; |
| if(U8_IS_SINGLE(c)) { |
| *pDest++=(UChar)c; |
| } else { |
| uint8_t __t1, __t2; |
| if( /* handle U+0800..U+FFFF inline */ |
| (0xe0<=(c) && (c)<0xf0) && |
| U8_IS_VALID_LEAD3_AND_T1((c), src[i]) && |
| (__t2=src[(i)+1]-0x80)<=0x3f) { |
| *pDest++ = (((c)&0xf)<<12)|((src[i]&0x3f)<<6)|__t2; |
| i+=2; |
| } else if( /* handle U+0080..U+07FF inline */ |
| ((c)<0xe0 && (c)>=0xc2) && |
| (__t1=src[i]-0x80)<=0x3f) { |
| *pDest++ = (((c)&0x1f)<<6)|__t1; |
| ++(i); |
| } else { |
| /* function call for "complicated" and error cases */ |
| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), -1, c, -1); |
| if(c<0 && (++numSubstitutions, c = subchar) < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else if(c<=0xFFFF) { |
| *(pDest++)=(UChar)c; |
| } else { |
| *(pDest++)=U16_LEAD(c); |
| if(pDest<pDestLimit) { |
| *(pDest++)=U16_TRAIL(c); |
| } else { |
| reqLength++; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /* Pre-flight the rest of the string. */ |
| while((c = (uint8_t)src[i]) != 0) { |
| // modified copy of U8_NEXT() |
| ++i; |
| if(U8_IS_SINGLE(c)) { |
| ++reqLength; |
| } else { |
| uint8_t __t1, __t2; |
| if( /* handle U+0800..U+FFFF inline */ |
| (0xe0<=(c) && (c)<0xf0) && |
| U8_IS_VALID_LEAD3_AND_T1((c), src[i]) && |
| (__t2=src[(i)+1]-0x80)<=0x3f) { |
| ++reqLength; |
| i+=2; |
| } else if( /* handle U+0080..U+07FF inline */ |
| ((c)<0xe0 && (c)>=0xc2) && |
| (__t1=src[i]-0x80)<=0x3f) { |
| ++reqLength; |
| ++(i); |
| } else { |
| /* function call for "complicated" and error cases */ |
| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), -1, c, -1); |
| if(c<0 && (++numSubstitutions, c = subchar) < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } |
| reqLength += U16_LENGTH(c); |
| } |
| } |
| } |
| } else /* srcLength >= 0 */ { |
| /* Faster loop without ongoing checking for srcLength and pDestLimit. */ |
| int32_t i = 0; |
| UChar32 c; |
| for(;;) { |
| /* |
| * Each iteration of the inner loop progresses by at most 3 UTF-8 |
| * bytes and one UChar, for most characters. |
| * For supplementary code points (4 & 2), which are rare, |
| * there is an additional adjustment. |
| */ |
| int32_t count = (int32_t)(pDestLimit - pDest); |
| int32_t count2 = (srcLength - i) / 3; |
| if(count > count2) { |
| count = count2; /* min(remaining dest, remaining src/3) */ |
| } |
| if(count < 3) { |
| /* |
| * Too much overhead if we get near the end of the string, |
| * continue with the next loop. |
| */ |
| break; |
| } |
| |
| do { |
| // modified copy of U8_NEXT() |
| c = (uint8_t)src[i++]; |
| if(U8_IS_SINGLE(c)) { |
| *pDest++=(UChar)c; |
| } else { |
| uint8_t __t1, __t2; |
| if( /* handle U+0800..U+FFFF inline */ |
| (0xe0<=(c) && (c)<0xf0) && |
| ((i)+1)<srcLength && |
| U8_IS_VALID_LEAD3_AND_T1((c), src[i]) && |
| (__t2=src[(i)+1]-0x80)<=0x3f) { |
| *pDest++ = (((c)&0xf)<<12)|((src[i]&0x3f)<<6)|__t2; |
| i+=2; |
| } else if( /* handle U+0080..U+07FF inline */ |
| ((c)<0xe0 && (c)>=0xc2) && |
| ((i)!=srcLength) && |
| (__t1=src[i]-0x80)<=0x3f) { |
| *pDest++ = (((c)&0x1f)<<6)|__t1; |
| ++(i); |
| } else { |
| if(c >= 0xf0 || subchar > 0xffff) { |
| // We may read up to four bytes and write up to two UChars, |
| // which we didn't account for with computing count, |
| // so we adjust it here. |
| if(--count == 0) { |
| --i; // back out byte c |
| break; |
| } |
| } |
| |
| /* function call for "complicated" and error cases */ |
| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, c, -1); |
| if(c<0 && (++numSubstitutions, c = subchar) < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else if(c<=0xFFFF) { |
| *(pDest++)=(UChar)c; |
| } else { |
| *(pDest++)=U16_LEAD(c); |
| *(pDest++)=U16_TRAIL(c); |
| } |
| } |
| } |
| } while(--count > 0); |
| } |
| |
| while(i < srcLength && (pDest < pDestLimit)) { |
| // modified copy of U8_NEXT() |
| c = (uint8_t)src[i++]; |
| if(U8_IS_SINGLE(c)) { |
| *pDest++=(UChar)c; |
| } else { |
| uint8_t __t1, __t2; |
| if( /* handle U+0800..U+FFFF inline */ |
| (0xe0<=(c) && (c)<0xf0) && |
| ((i)+1)<srcLength && |
| U8_IS_VALID_LEAD3_AND_T1((c), src[i]) && |
| (__t2=src[(i)+1]-0x80)<=0x3f) { |
| *pDest++ = (((c)&0xf)<<12)|((src[i]&0x3f)<<6)|__t2; |
| i+=2; |
| } else if( /* handle U+0080..U+07FF inline */ |
| ((c)<0xe0 && (c)>=0xc2) && |
| ((i)!=srcLength) && |
| (__t1=src[i]-0x80)<=0x3f) { |
| *pDest++ = (((c)&0x1f)<<6)|__t1; |
| ++(i); |
| } else { |
| /* function call for "complicated" and error cases */ |
| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, c, -1); |
| if(c<0 && (++numSubstitutions, c = subchar) < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else if(c<=0xFFFF) { |
| *(pDest++)=(UChar)c; |
| } else { |
| *(pDest++)=U16_LEAD(c); |
| if(pDest<pDestLimit) { |
| *(pDest++)=U16_TRAIL(c); |
| } else { |
| reqLength++; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /* Pre-flight the rest of the string. */ |
| while(i < srcLength) { |
| // modified copy of U8_NEXT() |
| c = (uint8_t)src[i++]; |
| if(U8_IS_SINGLE(c)) { |
| ++reqLength; |
| } else { |
| uint8_t __t1, __t2; |
| if( /* handle U+0800..U+FFFF inline */ |
| (0xe0<=(c) && (c)<0xf0) && |
| ((i)+1)<srcLength && |
| U8_IS_VALID_LEAD3_AND_T1((c), src[i]) && |
| (__t2=src[(i)+1]-0x80)<=0x3f) { |
| ++reqLength; |
| i+=2; |
| } else if( /* handle U+0080..U+07FF inline */ |
| ((c)<0xe0 && (c)>=0xc2) && |
| ((i)!=srcLength) && |
| (__t1=src[i]-0x80)<=0x3f) { |
| ++reqLength; |
| ++(i); |
| } else { |
| /* function call for "complicated" and error cases */ |
| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, c, -1); |
| if(c<0 && (++numSubstitutions, c = subchar) < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } |
| reqLength += U16_LENGTH(c); |
| } |
| } |
| } |
| } |
| |
| reqLength+=(int32_t)(pDest - dest); |
| |
| if(pNumSubstitutions!=NULL) { |
| *pNumSubstitutions=numSubstitutions; |
| } |
| |
| if(pDestLength){ |
| *pDestLength = reqLength; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateUChars(dest,destCapacity,reqLength,pErrorCode); |
| |
| return dest; |
| } |
| |
| U_CAPI UChar* U_EXPORT2 |
| u_strFromUTF8(UChar *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const char* src, |
| int32_t srcLength, |
| UErrorCode *pErrorCode){ |
| return u_strFromUTF8WithSub( |
| dest, destCapacity, pDestLength, |
| src, srcLength, |
| U_SENTINEL, NULL, |
| pErrorCode); |
| } |
| |
| U_CAPI UChar * U_EXPORT2 |
| u_strFromUTF8Lenient(UChar *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const char *src, |
| int32_t srcLength, |
| UErrorCode *pErrorCode) { |
| UChar *pDest = dest; |
| UChar32 ch; |
| int32_t reqLength = 0; |
| uint8_t* pSrc = (uint8_t*) src; |
| |
| /* args check */ |
| if(U_FAILURE(*pErrorCode)){ |
| return NULL; |
| } |
| |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || |
| (destCapacity<0) || (dest == NULL && destCapacity > 0) |
| ) { |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if(srcLength < 0) { |
| /* Transform a NUL-terminated string. */ |
| UChar *pDestLimit = (dest!=NULL)?(dest+destCapacity):NULL; |
| uint8_t t1, t2, t3; /* trail bytes */ |
| |
| while(((ch = *pSrc) != 0) && (pDest < pDestLimit)) { |
| if(ch < 0xc0) { |
| /* |
| * ASCII, or a trail byte in lead position which is treated like |
| * a single-byte sequence for better character boundary |
| * resynchronization after illegal sequences. |
| */ |
| *pDest++=(UChar)ch; |
| ++pSrc; |
| continue; |
| } else if(ch < 0xe0) { /* U+0080..U+07FF */ |
| if((t1 = pSrc[1]) != 0) { |
| /* 0x3080 = (0xc0 << 6) + 0x80 */ |
| *pDest++ = (UChar)((ch << 6) + t1 - 0x3080); |
| pSrc += 2; |
| continue; |
| } |
| } else if(ch < 0xf0) { /* U+0800..U+FFFF */ |
| if((t1 = pSrc[1]) != 0 && (t2 = pSrc[2]) != 0) { |
| /* no need for (ch & 0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */ |
| /* 0x2080 = (0x80 << 6) + 0x80 */ |
| *pDest++ = (UChar)((ch << 12) + (t1 << 6) + t2 - 0x2080); |
| pSrc += 3; |
| continue; |
| } |
| } else /* f0..f4 */ { /* U+10000..U+10FFFF */ |
| if((t1 = pSrc[1]) != 0 && (t2 = pSrc[2]) != 0 && (t3 = pSrc[3]) != 0) { |
| pSrc += 4; |
| /* 0x3c82080 = (0xf0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80 */ |
| ch = (ch << 18) + (t1 << 12) + (t2 << 6) + t3 - 0x3c82080; |
| *(pDest++) = U16_LEAD(ch); |
| if(pDest < pDestLimit) { |
| *(pDest++) = U16_TRAIL(ch); |
| } else { |
| reqLength = 1; |
| break; |
| } |
| continue; |
| } |
| } |
| |
| /* truncated character at the end */ |
| *pDest++ = 0xfffd; |
| while(*++pSrc != 0) {} |
| break; |
| } |
| |
| /* Pre-flight the rest of the string. */ |
| while((ch = *pSrc) != 0) { |
| if(ch < 0xc0) { |
| /* |
| * ASCII, or a trail byte in lead position which is treated like |
| * a single-byte sequence for better character boundary |
| * resynchronization after illegal sequences. |
| */ |
| ++reqLength; |
| ++pSrc; |
| continue; |
| } else if(ch < 0xe0) { /* U+0080..U+07FF */ |
| if(pSrc[1] != 0) { |
| ++reqLength; |
| pSrc += 2; |
| continue; |
| } |
| } else if(ch < 0xf0) { /* U+0800..U+FFFF */ |
| if(pSrc[1] != 0 && pSrc[2] != 0) { |
| ++reqLength; |
| pSrc += 3; |
| continue; |
| } |
| } else /* f0..f4 */ { /* U+10000..U+10FFFF */ |
| if(pSrc[1] != 0 && pSrc[2] != 0 && pSrc[3] != 0) { |
| reqLength += 2; |
| pSrc += 4; |
| continue; |
| } |
| } |
| |
| /* truncated character at the end */ |
| ++reqLength; |
| break; |
| } |
| } else /* srcLength >= 0 */ { |
| const uint8_t *pSrcLimit = (pSrc!=NULL)?(pSrc + srcLength):NULL; |
| |
| /* |
| * This function requires that if srcLength is given, then it must be |
| * destCapatity >= srcLength so that we need not check for |
| * destination buffer overflow in the loop. |
| */ |
| if(destCapacity < srcLength) { |
| if(pDestLength != NULL) { |
| *pDestLength = srcLength; /* this likely overestimates the true destLength! */ |
| } |
| *pErrorCode = U_BUFFER_OVERFLOW_ERROR; |
| return NULL; |
| } |
| |
| if((pSrcLimit - pSrc) >= 4) { |
| pSrcLimit -= 3; /* temporarily reduce pSrcLimit */ |
| |
| /* in this loop, we can always access at least 4 bytes, up to pSrc+3 */ |
| do { |
| ch = *pSrc++; |
| if(ch < 0xc0) { |
| /* |
| * ASCII, or a trail byte in lead position which is treated like |
| * a single-byte sequence for better character boundary |
| * resynchronization after illegal sequences. |
| */ |
| *pDest++=(UChar)ch; |
| } else if(ch < 0xe0) { /* U+0080..U+07FF */ |
| /* 0x3080 = (0xc0 << 6) + 0x80 */ |
| *pDest++ = (UChar)((ch << 6) + *pSrc++ - 0x3080); |
| } else if(ch < 0xf0) { /* U+0800..U+FFFF */ |
| /* no need for (ch & 0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */ |
| /* 0x2080 = (0x80 << 6) + 0x80 */ |
| ch = (ch << 12) + (*pSrc++ << 6); |
| *pDest++ = (UChar)(ch + *pSrc++ - 0x2080); |
| } else /* f0..f4 */ { /* U+10000..U+10FFFF */ |
| /* 0x3c82080 = (0xf0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80 */ |
| ch = (ch << 18) + (*pSrc++ << 12); |
| ch += *pSrc++ << 6; |
| ch += *pSrc++ - 0x3c82080; |
| *(pDest++) = U16_LEAD(ch); |
| *(pDest++) = U16_TRAIL(ch); |
| } |
| } while(pSrc < pSrcLimit); |
| |
| pSrcLimit += 3; /* restore original pSrcLimit */ |
| } |
| |
| while(pSrc < pSrcLimit) { |
| ch = *pSrc++; |
| if(ch < 0xc0) { |
| /* |
| * ASCII, or a trail byte in lead position which is treated like |
| * a single-byte sequence for better character boundary |
| * resynchronization after illegal sequences. |
| */ |
| *pDest++=(UChar)ch; |
| continue; |
| } else if(ch < 0xe0) { /* U+0080..U+07FF */ |
| if(pSrc < pSrcLimit) { |
| /* 0x3080 = (0xc0 << 6) + 0x80 */ |
| *pDest++ = (UChar)((ch << 6) + *pSrc++ - 0x3080); |
| continue; |
| } |
| } else if(ch < 0xf0) { /* U+0800..U+FFFF */ |
| if((pSrcLimit - pSrc) >= 2) { |
| /* no need for (ch & 0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */ |
| /* 0x2080 = (0x80 << 6) + 0x80 */ |
| ch = (ch << 12) + (*pSrc++ << 6); |
| *pDest++ = (UChar)(ch + *pSrc++ - 0x2080); |
| pSrc += 3; |
| continue; |
| } |
| } else /* f0..f4 */ { /* U+10000..U+10FFFF */ |
| if((pSrcLimit - pSrc) >= 3) { |
| /* 0x3c82080 = (0xf0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80 */ |
| ch = (ch << 18) + (*pSrc++ << 12); |
| ch += *pSrc++ << 6; |
| ch += *pSrc++ - 0x3c82080; |
| *(pDest++) = U16_LEAD(ch); |
| *(pDest++) = U16_TRAIL(ch); |
| pSrc += 4; |
| continue; |
| } |
| } |
| |
| /* truncated character at the end */ |
| *pDest++ = 0xfffd; |
| break; |
| } |
| } |
| |
| reqLength+=(int32_t)(pDest - dest); |
| |
| if(pDestLength){ |
| *pDestLength = reqLength; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateUChars(dest,destCapacity,reqLength,pErrorCode); |
| |
| return dest; |
| } |
| |
| static inline uint8_t * |
| _appendUTF8(uint8_t *pDest, UChar32 c) { |
| /* it is 0<=c<=0x10ffff and not a surrogate if called by a validating function */ |
| if((c)<=0x7f) { |
| *pDest++=(uint8_t)c; |
| } else if(c<=0x7ff) { |
| *pDest++=(uint8_t)((c>>6)|0xc0); |
| *pDest++=(uint8_t)((c&0x3f)|0x80); |
| } else if(c<=0xffff) { |
| *pDest++=(uint8_t)((c>>12)|0xe0); |
| *pDest++=(uint8_t)(((c>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)(((c)&0x3f)|0x80); |
| } else /* if((uint32_t)(c)<=0x10ffff) */ { |
| *pDest++=(uint8_t)(((c)>>18)|0xf0); |
| *pDest++=(uint8_t)((((c)>>12)&0x3f)|0x80); |
| *pDest++=(uint8_t)((((c)>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)(((c)&0x3f)|0x80); |
| } |
| return pDest; |
| } |
| |
| |
| U_CAPI char* U_EXPORT2 |
| u_strToUTF8WithSub(char *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const UChar *pSrc, |
| int32_t srcLength, |
| UChar32 subchar, int32_t *pNumSubstitutions, |
| UErrorCode *pErrorCode){ |
| int32_t reqLength=0; |
| uint32_t ch=0,ch2=0; |
| uint8_t *pDest = (uint8_t *)dest; |
| uint8_t *pDestLimit = (pDest!=NULL)?(pDest + destCapacity):NULL; |
| int32_t numSubstitutions; |
| |
| /* args check */ |
| if(U_FAILURE(*pErrorCode)){ |
| return NULL; |
| } |
| |
| if( (pSrc==NULL && srcLength!=0) || srcLength < -1 || |
| (destCapacity<0) || (dest == NULL && destCapacity > 0) || |
| subchar > 0x10ffff || U_IS_SURROGATE(subchar) |
| ) { |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if(pNumSubstitutions!=NULL) { |
| *pNumSubstitutions=0; |
| } |
| numSubstitutions=0; |
| |
| if(srcLength==-1) { |
| while((ch=*pSrc)!=0) { |
| ++pSrc; |
| if(ch <= 0x7f) { |
| if(pDest<pDestLimit) { |
| *pDest++ = (uint8_t)ch; |
| } else { |
| reqLength = 1; |
| break; |
| } |
| } else if(ch <= 0x7ff) { |
| if((pDestLimit - pDest) >= 2) { |
| *pDest++=(uint8_t)((ch>>6)|0xc0); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| reqLength = 2; |
| break; |
| } |
| } else if(ch <= 0xd7ff || ch >= 0xe000) { |
| if((pDestLimit - pDest) >= 3) { |
| *pDest++=(uint8_t)((ch>>12)|0xe0); |
| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| reqLength = 3; |
| break; |
| } |
| } else /* ch is a surrogate */ { |
| int32_t length; |
| |
| /*need not check for NUL because NUL fails U16_IS_TRAIL() anyway*/ |
| if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { |
| ++pSrc; |
| ch=U16_GET_SUPPLEMENTARY(ch, ch2); |
| } else if(subchar>=0) { |
| ch=subchar; |
| ++numSubstitutions; |
| } else { |
| /* Unicode 3.2 forbids surrogate code points in UTF-8 */ |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } |
| |
| length = U8_LENGTH(ch); |
| if((pDestLimit - pDest) >= length) { |
| /* convert and append*/ |
| pDest=_appendUTF8(pDest, ch); |
| } else { |
| reqLength = length; |
| break; |
| } |
| } |
| } |
| while((ch=*pSrc++)!=0) { |
| if(ch<=0x7f) { |
| ++reqLength; |
| } else if(ch<=0x7ff) { |
| reqLength+=2; |
| } else if(!U16_IS_SURROGATE(ch)) { |
| reqLength+=3; |
| } else if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { |
| ++pSrc; |
| reqLength+=4; |
| } else if(subchar>=0) { |
| reqLength+=U8_LENGTH(subchar); |
| ++numSubstitutions; |
| } else { |
| /* Unicode 3.2 forbids surrogate code points in UTF-8 */ |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } |
| } |
| } else { |
| const UChar *pSrcLimit = (pSrc!=NULL)?(pSrc+srcLength):NULL; |
| int32_t count; |
| |
| /* Faster loop without ongoing checking for pSrcLimit and pDestLimit. */ |
| for(;;) { |
| /* |
| * Each iteration of the inner loop progresses by at most 3 UTF-8 |
| * bytes and one UChar, for most characters. |
| * For supplementary code points (4 & 2), which are rare, |
| * there is an additional adjustment. |
| */ |
| count = (int32_t)((pDestLimit - pDest) / 3); |
| srcLength = (int32_t)(pSrcLimit - pSrc); |
| if(count > srcLength) { |
| count = srcLength; /* min(remaining dest/3, remaining src) */ |
| } |
| if(count < 3) { |
| /* |
| * Too much overhead if we get near the end of the string, |
| * continue with the next loop. |
| */ |
| break; |
| } |
| do { |
| ch=*pSrc++; |
| if(ch <= 0x7f) { |
| *pDest++ = (uint8_t)ch; |
| } else if(ch <= 0x7ff) { |
| *pDest++=(uint8_t)((ch>>6)|0xc0); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else if(ch <= 0xd7ff || ch >= 0xe000) { |
| *pDest++=(uint8_t)((ch>>12)|0xe0); |
| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else /* ch is a surrogate */ { |
| /* |
| * We will read two UChars and probably output four bytes, |
| * which we didn't account for with computing count, |
| * so we adjust it here. |
| */ |
| if(--count == 0) { |
| --pSrc; /* undo ch=*pSrc++ for the lead surrogate */ |
| break; /* recompute count */ |
| } |
| |
| if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { |
| ++pSrc; |
| ch=U16_GET_SUPPLEMENTARY(ch, ch2); |
| |
| /* writing 4 bytes per 2 UChars is ok */ |
| *pDest++=(uint8_t)((ch>>18)|0xf0); |
| *pDest++=(uint8_t)(((ch>>12)&0x3f)|0x80); |
| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| /* Unicode 3.2 forbids surrogate code points in UTF-8 */ |
| if(subchar>=0) { |
| ch=subchar; |
| ++numSubstitutions; |
| } else { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } |
| |
| /* convert and append*/ |
| pDest=_appendUTF8(pDest, ch); |
| } |
| } |
| } while(--count > 0); |
| } |
| |
| while(pSrc<pSrcLimit) { |
| ch=*pSrc++; |
| if(ch <= 0x7f) { |
| if(pDest<pDestLimit) { |
| *pDest++ = (uint8_t)ch; |
| } else { |
| reqLength = 1; |
| break; |
| } |
| } else if(ch <= 0x7ff) { |
| if((pDestLimit - pDest) >= 2) { |
| *pDest++=(uint8_t)((ch>>6)|0xc0); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| reqLength = 2; |
| break; |
| } |
| } else if(ch <= 0xd7ff || ch >= 0xe000) { |
| if((pDestLimit - pDest) >= 3) { |
| *pDest++=(uint8_t)((ch>>12)|0xe0); |
| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| reqLength = 3; |
| break; |
| } |
| } else /* ch is a surrogate */ { |
| int32_t length; |
| |
| if(U16_IS_SURROGATE_LEAD(ch) && pSrc<pSrcLimit && U16_IS_TRAIL(ch2=*pSrc)) { |
| ++pSrc; |
| ch=U16_GET_SUPPLEMENTARY(ch, ch2); |
| } else if(subchar>=0) { |
| ch=subchar; |
| ++numSubstitutions; |
| } else { |
| /* Unicode 3.2 forbids surrogate code points in UTF-8 */ |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } |
| |
| length = U8_LENGTH(ch); |
| if((pDestLimit - pDest) >= length) { |
| /* convert and append*/ |
| pDest=_appendUTF8(pDest, ch); |
| } else { |
| reqLength = length; |
| break; |
| } |
| } |
| } |
| while(pSrc<pSrcLimit) { |
| ch=*pSrc++; |
| if(ch<=0x7f) { |
| ++reqLength; |
| } else if(ch<=0x7ff) { |
| reqLength+=2; |
| } else if(!U16_IS_SURROGATE(ch)) { |
| reqLength+=3; |
| } else if(U16_IS_SURROGATE_LEAD(ch) && pSrc<pSrcLimit && U16_IS_TRAIL(ch2=*pSrc)) { |
| ++pSrc; |
| reqLength+=4; |
| } else if(subchar>=0) { |
| reqLength+=U8_LENGTH(subchar); |
| ++numSubstitutions; |
| } else { |
| /* Unicode 3.2 forbids surrogate code points in UTF-8 */ |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } |
| } |
| } |
| |
| reqLength+=(int32_t)(pDest - (uint8_t *)dest); |
| |
| if(pNumSubstitutions!=NULL) { |
| *pNumSubstitutions=numSubstitutions; |
| } |
| |
| if(pDestLength){ |
| *pDestLength = reqLength; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateChars(dest, destCapacity, reqLength, pErrorCode); |
| return dest; |
| } |
| |
| U_CAPI char* U_EXPORT2 |
| u_strToUTF8(char *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const UChar *pSrc, |
| int32_t srcLength, |
| UErrorCode *pErrorCode){ |
| return u_strToUTF8WithSub( |
| dest, destCapacity, pDestLength, |
| pSrc, srcLength, |
| U_SENTINEL, NULL, |
| pErrorCode); |
| } |
| |
| U_CAPI UChar* U_EXPORT2 |
| u_strFromJavaModifiedUTF8WithSub( |
| UChar *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const char *src, |
| int32_t srcLength, |
| UChar32 subchar, int32_t *pNumSubstitutions, |
| UErrorCode *pErrorCode) { |
| /* args check */ |
| if(U_FAILURE(*pErrorCode)) { |
| return NULL; |
| } |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || |
| (dest==NULL && destCapacity!=0) || destCapacity<0 || |
| subchar > 0x10ffff || U_IS_SURROGATE(subchar) |
| ) { |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if(pNumSubstitutions!=NULL) { |
| *pNumSubstitutions=0; |
| } |
| UChar *pDest = dest; |
| UChar *pDestLimit = dest+destCapacity; |
| int32_t reqLength = 0; |
| int32_t numSubstitutions=0; |
| |
| if(srcLength < 0) { |
| /* |
| * Transform a NUL-terminated ASCII string. |
| * Handle non-ASCII strings with slower code. |
| */ |
| UChar32 c; |
| while(((c = (uint8_t)*src) != 0) && c <= 0x7f && (pDest < pDestLimit)) { |
| *pDest++=(UChar)c; |
| ++src; |
| } |
| if(c == 0) { |
| reqLength=(int32_t)(pDest - dest); |
| if(pDestLength) { |
| *pDestLength = reqLength; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateUChars(dest, destCapacity, reqLength, pErrorCode); |
| return dest; |
| } |
| srcLength = static_cast<int32_t>(uprv_strlen(src)); |
| } |
| |
| /* Faster loop without ongoing checking for srcLength and pDestLimit. */ |
| UChar32 ch; |
| uint8_t t1, t2; |
| int32_t i = 0; |
| for(;;) { |
| int32_t count = (int32_t)(pDestLimit - pDest); |
| int32_t count2 = srcLength - i; |
| if(count >= count2 && srcLength > 0 && U8_IS_SINGLE(*src)) { |
| /* fast ASCII loop */ |
| int32_t start = i; |
| uint8_t b; |
| while(i < srcLength && U8_IS_SINGLE(b = src[i])) { |
| *pDest++=b; |
| ++i; |
| } |
| int32_t delta = i - start; |
| count -= delta; |
| count2 -= delta; |
| } |
| /* |
| * Each iteration of the inner loop progresses by at most 3 UTF-8 |
| * bytes and one UChar. |
| */ |
| if(subchar > 0xFFFF) { |
| break; |
| } |
| count2 /= 3; |
| if(count > count2) { |
| count = count2; /* min(remaining dest, remaining src/3) */ |
| } |
| if(count < 3) { |
| /* |
| * Too much overhead if we get near the end of the string, |
| * continue with the next loop. |
| */ |
| break; |
| } |
| do { |
| ch = (uint8_t)src[i++]; |
| if(U8_IS_SINGLE(ch)) { |
| *pDest++=(UChar)ch; |
| } else { |
| if(ch >= 0xe0) { |
| if( /* handle U+0000..U+FFFF inline */ |
| ch <= 0xef && |
| (t1 = (uint8_t)(src[i] - 0x80)) <= 0x3f && |
| (t2 = (uint8_t)(src[i+1] - 0x80)) <= 0x3f |
| ) { |
| /* no need for (ch & 0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */ |
| *pDest++ = (UChar)((ch << 12) | (t1 << 6) | t2); |
| i += 2; |
| continue; |
| } |
| } else { |
| if( /* handle U+0000..U+07FF inline */ |
| ch >= 0xc0 && |
| (t1 = (uint8_t)(src[i] - 0x80)) <= 0x3f |
| ) { |
| *pDest++ = (UChar)(((ch & 0x1f) << 6) | t1); |
| ++i; |
| continue; |
| } |
| } |
| |
| if(subchar < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else if(subchar > 0xffff && --count == 0) { |
| /* |
| * We need to write two UChars, adjusted count for that, |
| * and ran out of space. |
| */ |
| --i; // back out byte ch |
| break; |
| } else { |
| /* function call for error cases */ |
| utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, ch, -1); |
| ++numSubstitutions; |
| *(pDest++)=(UChar)subchar; |
| } |
| } |
| } while(--count > 0); |
| } |
| |
| while(i < srcLength && (pDest < pDestLimit)) { |
| ch = (uint8_t)src[i++]; |
| if(U8_IS_SINGLE(ch)){ |
| *pDest++=(UChar)ch; |
| } else { |
| if(ch >= 0xe0) { |
| if( /* handle U+0000..U+FFFF inline */ |
| ch <= 0xef && |
| (i+1) < srcLength && |
| (t1 = (uint8_t)(src[i] - 0x80)) <= 0x3f && |
| (t2 = (uint8_t)(src[i+1] - 0x80)) <= 0x3f |
| ) { |
| /* no need for (ch & 0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */ |
| *pDest++ = (UChar)((ch << 12) | (t1 << 6) | t2); |
| i += 2; |
| continue; |
| } |
| } else { |
| if( /* handle U+0000..U+07FF inline */ |
| ch >= 0xc0 && |
| i < srcLength && |
| (t1 = (uint8_t)(src[i] - 0x80)) <= 0x3f |
| ) { |
| *pDest++ = (UChar)(((ch & 0x1f) << 6) | t1); |
| ++i; |
| continue; |
| } |
| } |
| |
| if(subchar < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else { |
| /* function call for error cases */ |
| utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, ch, -1); |
| ++numSubstitutions; |
| if(subchar<=0xFFFF) { |
| *(pDest++)=(UChar)subchar; |
| } else { |
| *(pDest++)=U16_LEAD(subchar); |
| if(pDest<pDestLimit) { |
| *(pDest++)=U16_TRAIL(subchar); |
| } else { |
| reqLength++; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /* Pre-flight the rest of the string. */ |
| while(i < srcLength) { |
| ch = (uint8_t)src[i++]; |
| if(U8_IS_SINGLE(ch)) { |
| reqLength++; |
| } else { |
| if(ch >= 0xe0) { |
| if( /* handle U+0000..U+FFFF inline */ |
| ch <= 0xef && |
| (i+1) < srcLength && |
| (uint8_t)(src[i] - 0x80) <= 0x3f && |
| (uint8_t)(src[i+1] - 0x80) <= 0x3f |
| ) { |
| reqLength++; |
| i += 2; |
| continue; |
| } |
| } else { |
| if( /* handle U+0000..U+07FF inline */ |
| ch >= 0xc0 && |
| i < srcLength && |
| (uint8_t)(src[i] - 0x80) <= 0x3f |
| ) { |
| reqLength++; |
| ++i; |
| continue; |
| } |
| } |
| |
| if(subchar < 0) { |
| *pErrorCode = U_INVALID_CHAR_FOUND; |
| return NULL; |
| } else { |
| /* function call for error cases */ |
| utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, ch, -1); |
| ++numSubstitutions; |
| reqLength+=U16_LENGTH(ch); |
| } |
| } |
| } |
| |
| if(pNumSubstitutions!=NULL) { |
| *pNumSubstitutions=numSubstitutions; |
| } |
| |
| reqLength+=(int32_t)(pDest - dest); |
| if(pDestLength) { |
| *pDestLength = reqLength; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateUChars(dest, destCapacity, reqLength, pErrorCode); |
| return dest; |
| } |
| |
| U_CAPI char* U_EXPORT2 |
| u_strToJavaModifiedUTF8( |
| char *dest, |
| int32_t destCapacity, |
| int32_t *pDestLength, |
| const UChar *src, |
| int32_t srcLength, |
| UErrorCode *pErrorCode) { |
| int32_t reqLength=0; |
| uint32_t ch=0; |
| uint8_t *pDest = (uint8_t *)dest; |
| uint8_t *pDestLimit = pDest + destCapacity; |
| const UChar *pSrcLimit; |
| int32_t count; |
| |
| /* args check */ |
| if(U_FAILURE(*pErrorCode)){ |
| return NULL; |
| } |
| if( (src==NULL && srcLength!=0) || srcLength < -1 || |
| (dest==NULL && destCapacity!=0) || destCapacity<0 |
| ) { |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if(srcLength==-1) { |
| /* Convert NUL-terminated ASCII, then find the string length. */ |
| while((ch=*src)<=0x7f && ch != 0 && pDest<pDestLimit) { |
| *pDest++ = (uint8_t)ch; |
| ++src; |
| } |
| if(ch == 0) { |
| reqLength=(int32_t)(pDest - (uint8_t *)dest); |
| if(pDestLength) { |
| *pDestLength = reqLength; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateChars(dest, destCapacity, reqLength, pErrorCode); |
| return dest; |
| } |
| srcLength = u_strlen(src); |
| } |
| |
| /* Faster loop without ongoing checking for pSrcLimit and pDestLimit. */ |
| pSrcLimit = (src!=NULL)?(src+srcLength):NULL; |
| for(;;) { |
| count = (int32_t)(pDestLimit - pDest); |
| srcLength = (int32_t)(pSrcLimit - src); |
| if(count >= srcLength && srcLength > 0 && *src <= 0x7f) { |
| /* fast ASCII loop */ |
| const UChar *prevSrc = src; |
| int32_t delta; |
| while(src < pSrcLimit && (ch = *src) <= 0x7f && ch != 0) { |
| *pDest++=(uint8_t)ch; |
| ++src; |
| } |
| delta = (int32_t)(src - prevSrc); |
| count -= delta; |
| srcLength -= delta; |
| } |
| /* |
| * Each iteration of the inner loop progresses by at most 3 UTF-8 |
| * bytes and one UChar. |
| */ |
| count /= 3; |
| if(count > srcLength) { |
| count = srcLength; /* min(remaining dest/3, remaining src) */ |
| } |
| if(count < 3) { |
| /* |
| * Too much overhead if we get near the end of the string, |
| * continue with the next loop. |
| */ |
| break; |
| } |
| do { |
| ch=*src++; |
| if(ch <= 0x7f && ch != 0) { |
| *pDest++ = (uint8_t)ch; |
| } else if(ch <= 0x7ff) { |
| *pDest++=(uint8_t)((ch>>6)|0xc0); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| *pDest++=(uint8_t)((ch>>12)|0xe0); |
| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } |
| } while(--count > 0); |
| } |
| |
| while(src<pSrcLimit) { |
| ch=*src++; |
| if(ch <= 0x7f && ch != 0) { |
| if(pDest<pDestLimit) { |
| *pDest++ = (uint8_t)ch; |
| } else { |
| reqLength = 1; |
| break; |
| } |
| } else if(ch <= 0x7ff) { |
| if((pDestLimit - pDest) >= 2) { |
| *pDest++=(uint8_t)((ch>>6)|0xc0); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| reqLength = 2; |
| break; |
| } |
| } else { |
| if((pDestLimit - pDest) >= 3) { |
| *pDest++=(uint8_t)((ch>>12)|0xe0); |
| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); |
| *pDest++=(uint8_t)((ch&0x3f)|0x80); |
| } else { |
| reqLength = 3; |
| break; |
| } |
| } |
| } |
| while(src<pSrcLimit) { |
| ch=*src++; |
| if(ch <= 0x7f && ch != 0) { |
| ++reqLength; |
| } else if(ch<=0x7ff) { |
| reqLength+=2; |
| } else { |
| reqLength+=3; |
| } |
| } |
| |
| reqLength+=(int32_t)(pDest - (uint8_t *)dest); |
| if(pDestLength){ |
| *pDestLength = reqLength; |
| } |
| |
| /* Terminate the buffer */ |
| u_terminateChars(dest, destCapacity, reqLength, pErrorCode); |
| return dest; |
| } |
