godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
28991a954e
godot/thirdparty/icu4c/common/ucnv_u16.cpp

1580 lines
48 KiB
C++
Raw Normal View History

[Complex Text Layouts] Add third-party TextServer dependencies (ICU, HarfBuzz, Graphite).
2020-08-11 09:10:23 +00:00
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
* Copyright (C) 2002-2015, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* file name: ucnv_u16.c
* encoding: UTF-8
* tab size: 8 (not used)
* indentation:4
*
* created on: 2002jul01
* created by: Markus W. Scherer
*
* UTF-16 converter implementation. Used to be in ucnv_utf.c.
*/
#include "unicode/utypes.h"
#if !UCONFIG_NO_CONVERSION
#include "unicode/ucnv.h"
#include "unicode/uversion.h"
#include "ucnv_bld.h"
#include "ucnv_cnv.h"
#include "cmemory.h"
enum {
UCNV_NEED_TO_WRITE_BOM=1
};
U_CDECL_BEGIN
/*
* The UTF-16 toUnicode implementation is also used for the Java-specific
* "with BOM" variants of UTF-16BE and UTF-16LE.
*/
static void U_CALLCONV
_UTF16ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode);
/* UTF-16BE ----------------------------------------------------------------- */
#if U_IS_BIG_ENDIAN
# define _UTF16PEFromUnicodeWithOffsets _UTF16BEFromUnicodeWithOffsets
#else
# define _UTF16PEFromUnicodeWithOffsets _UTF16LEFromUnicodeWithOffsets
#endif
static void U_CALLCONV
_UTF16BEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source;
char *target;
int32_t *offsets;
uint32_t targetCapacity, length, sourceIndex;
UChar c, trail;
char overflow[4];
source=pArgs->source;
length=(int32_t)(pArgs->sourceLimit-source);
if(length<=0) {
/* no input, nothing to do */
return;
}
cnv=pArgs->converter;
/* write the BOM if necessary */
if(cnv->fromUnicodeStatus==UCNV_NEED_TO_WRITE_BOM) {
static const char bom[]={ (char)0xfeu, (char)0xffu };
ucnv_fromUWriteBytes(cnv,
bom, 2,
&pArgs->target, pArgs->targetLimit,
&pArgs->offsets, -1,
pErrorCode);
cnv->fromUnicodeStatus=0;
}
target=pArgs->target;
if(target >= pArgs->targetLimit) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
return;
}
targetCapacity=(uint32_t)(pArgs->targetLimit-target);
offsets=pArgs->offsets;
sourceIndex=0;
/* c!=0 indicates in several places outside the main loops that a surrogate was found */
if((c=(UChar)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
/* the last buffer ended with a lead surrogate, output the surrogate pair */
++source;
--length;
target[0]=(uint8_t)(c>>8);
target[1]=(uint8_t)c;
target[2]=(uint8_t)(trail>>8);
target[3]=(uint8_t)trail;
target+=4;
targetCapacity-=4;
if(offsets!=NULL) {
*offsets++=-1;
*offsets++=-1;
*offsets++=-1;
*offsets++=-1;
}
sourceIndex=1;
cnv->fromUChar32=c=0;
}
if(c==0) {
/* copy an even number of bytes for complete UChars */
uint32_t count=2*length;
if(count>targetCapacity) {
count=targetCapacity&~1;
}
/* count is even */
targetCapacity-=count;
count>>=1;
length-=count;
if(offsets==NULL) {
while(count>0) {
c=*source++;
if(U16_IS_SINGLE(c)) {
target[0]=(uint8_t)(c>>8);
target[1]=(uint8_t)c;
target+=2;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
++source;
--count;
target[0]=(uint8_t)(c>>8);
target[1]=(uint8_t)c;
target[2]=(uint8_t)(trail>>8);
target[3]=(uint8_t)trail;
target+=4;
} else {
break;
}
--count;
}
} else {
while(count>0) {
c=*source++;
if(U16_IS_SINGLE(c)) {
target[0]=(uint8_t)(c>>8);
target[1]=(uint8_t)c;
target+=2;
*offsets++=sourceIndex;
*offsets++=sourceIndex++;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
++source;
--count;
target[0]=(uint8_t)(c>>8);
target[1]=(uint8_t)c;
target[2]=(uint8_t)(trail>>8);
target[3]=(uint8_t)trail;
target+=4;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
sourceIndex+=2;
} else {
break;
}
--count;
}
}
if(count==0) {
/* done with the loop for complete UChars */
if(length>0 && targetCapacity>0) {
/*
* there is more input and some target capacity -
* it must be targetCapacity==1 because otherwise
* the above would have copied more;
* prepare for overflow output
*/
if(U16_IS_SINGLE(c=*source++)) {
overflow[0]=(char)(c>>8);
overflow[1]=(char)c;
length=2; /* 2 bytes to output */
c=0;
/* } else { keep c for surrogate handling, length will be set there */
}
} else {
length=0;
c=0;
}
} else {
/* keep c for surrogate handling, length will be set there */
targetCapacity+=2*count;
}
} else {
length=0; /* from here on, length counts the bytes in overflow[] */
}
if(c!=0) {
/*
* c is a surrogate, and
* - source or target too short
* - or the surrogate is unmatched
*/
length=0;
if(U16_IS_SURROGATE_LEAD(c)) {
if(source<pArgs->sourceLimit) {
if(U16_IS_TRAIL(trail=*source)) {
/* output the surrogate pair, will overflow (see conditions comment above) */
++source;
overflow[0]=(char)(c>>8);
overflow[1]=(char)c;
overflow[2]=(char)(trail>>8);
overflow[3]=(char)trail;
length=4; /* 4 bytes to output */
c=0;
} else {
/* unmatched lead surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
} else {
/* see if the trail surrogate is in the next buffer */
}
} else {
/* unmatched trail surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
cnv->fromUChar32=c;
}
if(length>0) {
/* output length bytes with overflow (length>targetCapacity>0) */
ucnv_fromUWriteBytes(cnv,
overflow, length,
(char **)&target, pArgs->targetLimit,
&offsets, sourceIndex,
pErrorCode);
targetCapacity=(uint32_t)(pArgs->targetLimit-(char *)target);
}
if(U_SUCCESS(*pErrorCode) && source<pArgs->sourceLimit && targetCapacity==0) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
}
/* write back the updated pointers */
pArgs->source=source;
pArgs->target=(char *)target;
pArgs->offsets=offsets;
}
static void U_CALLCONV
_UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source;
UChar *target;
int32_t *offsets;
uint32_t targetCapacity, length, count, sourceIndex;
UChar c, trail;
if(pArgs->converter->mode<8) {
_UTF16ToUnicodeWithOffsets(pArgs, pErrorCode);
return;
}
cnv=pArgs->converter;
source=(const uint8_t *)pArgs->source;
length=(int32_t)((const uint8_t *)pArgs->sourceLimit-source);
if(length<=0 && cnv->toUnicodeStatus==0) {
/* no input, nothing to do */
return;
}
target=pArgs->target;
if(target >= pArgs->targetLimit) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
return;
}
targetCapacity=(uint32_t)(pArgs->targetLimit-target);
offsets=pArgs->offsets;
sourceIndex=0;
c=0;
/* complete a partial UChar or pair from the last call */
if(cnv->toUnicodeStatus!=0) {
/*
* special case: single byte from a previous buffer,
* where the byte turned out not to belong to a trail surrogate
* and the preceding, unmatched lead surrogate was put into toUBytes[]
* for error handling
*/
cnv->toUBytes[0]=(uint8_t)cnv->toUnicodeStatus;
cnv->toULength=1;
cnv->toUnicodeStatus=0;
}
if((count=cnv->toULength)!=0) {
uint8_t *p=cnv->toUBytes;
do {
p[count++]=*source++;
++sourceIndex;
--length;
if(count==2) {
c=((UChar)p[0]<<8)|p[1];
if(U16_IS_SINGLE(c)) {
/* output the BMP code point */
*target++=c;
if(offsets!=NULL) {
*offsets++=-1;
}
--targetCapacity;
count=0;
c=0;
break;
} else if(U16_IS_SURROGATE_LEAD(c)) {
/* continue collecting bytes for the trail surrogate */
c=0; /* avoid unnecessary surrogate handling below */
} else {
/* fall through to error handling for an unmatched trail surrogate */
break;
}
} else if(count==4) {
c=((UChar)p[0]<<8)|p[1];
trail=((UChar)p[2]<<8)|p[3];
if(U16_IS_TRAIL(trail)) {
/* output the surrogate pair */
*target++=c;
if(targetCapacity>=2) {
*target++=trail;
if(offsets!=NULL) {
*offsets++=-1;
*offsets++=-1;
}
targetCapacity-=2;
} else /* targetCapacity==1 */ {
targetCapacity=0;
cnv->UCharErrorBuffer[0]=trail;
cnv->UCharErrorBufferLength=1;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
}
count=0;
c=0;
break;
} else {
/* unmatched lead surrogate, handle here for consistent toUBytes[] */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
/* back out reading the code unit after it */
if(((const uint8_t *)pArgs->source-source)>=2) {
source-=2;
} else {
/*
* if the trail unit's first byte was in a previous buffer, then
* we need to put it into a special place because toUBytes[] will be
* used for the lead unit's bytes
*/
cnv->toUnicodeStatus=0x100|p[2];
--source;
}
cnv->toULength=2;
/* write back the updated pointers */
pArgs->source=(const char *)source;
pArgs->target=target;
pArgs->offsets=offsets;
return;
}
}
} while(length>0);
cnv->toULength=(int8_t)count;
}
/* copy an even number of bytes for complete UChars */
count=2*targetCapacity;
if(count>length) {
count=length&~1;
}
if(c==0 && count>0) {
length-=count;
count>>=1;
targetCapacity-=count;
if(offsets==NULL) {
do {
c=((UChar)source[0]<<8)|source[1];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])
) {
source+=2;
--count;
*target++=c;
*target++=trail;
} else {
break;
}
} while(--count>0);
} else {
do {
c=((UChar)source[0]<<8)|source[1];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
*offsets++=sourceIndex;
sourceIndex+=2;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])
) {
source+=2;
--count;
*target++=c;
*target++=trail;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
sourceIndex+=4;
} else {
break;
}
} while(--count>0);
}
if(count==0) {
/* done with the loop for complete UChars */
c=0;
} else {
/* keep c for surrogate handling, trail will be set there */
length+=2*(count-1); /* one more byte pair was consumed than count decremented */
targetCapacity+=count;
}
}
if(c!=0) {
/*
* c is a surrogate, and
* - source or target too short
* - or the surrogate is unmatched
*/
cnv->toUBytes[0]=(uint8_t)(c>>8);
cnv->toUBytes[1]=(uint8_t)c;
cnv->toULength=2;
if(U16_IS_SURROGATE_LEAD(c)) {
if(length>=2) {
if(U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])) {
/* output the surrogate pair, will overflow (see conditions comment above) */
source+=2;
length-=2;
*target++=c;
if(offsets!=NULL) {
*offsets++=sourceIndex;
}
cnv->UCharErrorBuffer[0]=trail;
cnv->UCharErrorBufferLength=1;
cnv->toULength=0;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
} else {
/* unmatched lead surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
} else {
/* see if the trail surrogate is in the next buffer */
}
} else {
/* unmatched trail surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
}
if(U_SUCCESS(*pErrorCode)) {
/* check for a remaining source byte */
if(length>0) {
if(targetCapacity==0) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
} else {
/* it must be length==1 because otherwise the above would have copied more */
cnv->toUBytes[cnv->toULength++]=*source++;
}
}
}
/* write back the updated pointers */
pArgs->source=(const char *)source;
pArgs->target=target;
pArgs->offsets=offsets;
}
static UChar32 U_CALLCONV
_UTF16BEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
const uint8_t *s, *sourceLimit;
UChar32 c;
if(pArgs->converter->mode<8) {
return UCNV_GET_NEXT_UCHAR_USE_TO_U;
}
s=(const uint8_t *)pArgs->source;
sourceLimit=(const uint8_t *)pArgs->sourceLimit;
if(s>=sourceLimit) {
/* no input */
*err=U_INDEX_OUTOFBOUNDS_ERROR;
return 0xffff;
}
if(s+2>sourceLimit) {
/* only one byte: truncated UChar */
pArgs->converter->toUBytes[0]=*s++;
pArgs->converter->toULength=1;
pArgs->source=(const char *)s;
*err = U_TRUNCATED_CHAR_FOUND;
return 0xffff;
}
/* get one UChar */
c=((UChar32)*s<<8)|s[1];
s+=2;
/* check for a surrogate pair */
if(U_IS_SURROGATE(c)) {
if(U16_IS_SURROGATE_LEAD(c)) {
if(s+2<=sourceLimit) {
UChar trail;
/* get a second UChar and see if it is a trail surrogate */
trail=((UChar)*s<<8)|s[1];
if(U16_IS_TRAIL(trail)) {
c=U16_GET_SUPPLEMENTARY(c, trail);
s+=2;
} else {
/* unmatched lead surrogate */
c=-2;
}
} else {
/* too few (2 or 3) bytes for a surrogate pair: truncated code point */
uint8_t *bytes=pArgs->converter->toUBytes;
s-=2;
pArgs->converter->toULength=(int8_t)(sourceLimit-s);
do {
*bytes++=*s++;
} while(s<sourceLimit);
c=0xffff;
*err=U_TRUNCATED_CHAR_FOUND;
}
} else {
/* unmatched trail surrogate */
c=-2;
}
if(c<0) {
/* write the unmatched surrogate */
uint8_t *bytes=pArgs->converter->toUBytes;
pArgs->converter->toULength=2;
*bytes=*(s-2);
bytes[1]=*(s-1);
c=0xffff;
*err=U_ILLEGAL_CHAR_FOUND;
}
}
pArgs->source=(const char *)s;
return c;
}
static void U_CALLCONV
_UTF16BEReset(UConverter *cnv, UConverterResetChoice choice) {
if(choice<=UCNV_RESET_TO_UNICODE) {
/* reset toUnicode state */
if(UCNV_GET_VERSION(cnv)==0) {
cnv->mode=8; /* no BOM handling */
} else {
cnv->mode=0; /* Java-specific "UnicodeBig" requires BE BOM or no BOM */
}
}
if(choice!=UCNV_RESET_TO_UNICODE && UCNV_GET_VERSION(cnv)==1) {
/* reset fromUnicode for "UnicodeBig": prepare to output the UTF-16BE BOM */
cnv->fromUnicodeStatus=UCNV_NEED_TO_WRITE_BOM;
}
}
static void U_CALLCONV
_UTF16BEOpen(UConverter *cnv,
UConverterLoadArgs *pArgs,
UErrorCode *pErrorCode) {
(void)pArgs;
if(UCNV_GET_VERSION(cnv)<=1) {
_UTF16BEReset(cnv, UCNV_RESET_BOTH);
} else {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
}
}
static const char * U_CALLCONV
_UTF16BEGetName(const UConverter *cnv) {
if(UCNV_GET_VERSION(cnv)==0) {
return "UTF-16BE";
} else {
return "UTF-16BE,version=1";
}
}
U_CDECL_END
static const UConverterImpl _UTF16BEImpl={
UCNV_UTF16_BigEndian,
NULL,
NULL,
_UTF16BEOpen,
NULL,
_UTF16BEReset,
_UTF16BEToUnicodeWithOffsets,
_UTF16BEToUnicodeWithOffsets,
_UTF16BEFromUnicodeWithOffsets,
_UTF16BEFromUnicodeWithOffsets,
_UTF16BEGetNextUChar,
NULL,
_UTF16BEGetName,
NULL,
NULL,
ucnv_getNonSurrogateUnicodeSet,
NULL,
NULL
};
static const UConverterStaticData _UTF16BEStaticData={
sizeof(UConverterStaticData),
"UTF-16BE",
1200, UCNV_IBM, UCNV_UTF16_BigEndian, 2, 2,
ICU: Update to version 72.1
2022-10-28 06:11:55 +00:00
{ 0xff, 0xfd, 0, 0 },2,false,false,
[Complex Text Layouts] Add third-party TextServer dependencies (ICU, HarfBuzz, Graphite).
2020-08-11 09:10:23 +00:00
0,
0,
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
};
const UConverterSharedData _UTF16BEData=
UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_UTF16BEStaticData, &_UTF16BEImpl);
/* UTF-16LE ----------------------------------------------------------------- */
U_CDECL_BEGIN
static void U_CALLCONV
_UTF16LEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source;
char *target;
int32_t *offsets;
uint32_t targetCapacity, length, sourceIndex;
UChar c, trail;
char overflow[4];
source=pArgs->source;
length=(int32_t)(pArgs->sourceLimit-source);
if(length<=0) {
/* no input, nothing to do */
return;
}
cnv=pArgs->converter;
/* write the BOM if necessary */
if(cnv->fromUnicodeStatus==UCNV_NEED_TO_WRITE_BOM) {
static const char bom[]={ (char)0xffu, (char)0xfeu };
ucnv_fromUWriteBytes(cnv,
bom, 2,
&pArgs->target, pArgs->targetLimit,
&pArgs->offsets, -1,
pErrorCode);
cnv->fromUnicodeStatus=0;
}
target=pArgs->target;
if(target >= pArgs->targetLimit) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
return;
}
targetCapacity=(uint32_t)(pArgs->targetLimit-pArgs->target);
offsets=pArgs->offsets;
sourceIndex=0;
/* c!=0 indicates in several places outside the main loops that a surrogate was found */
if((c=(UChar)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
/* the last buffer ended with a lead surrogate, output the surrogate pair */
++source;
--length;
target[0]=(uint8_t)c;
target[1]=(uint8_t)(c>>8);
target[2]=(uint8_t)trail;
target[3]=(uint8_t)(trail>>8);
target+=4;
targetCapacity-=4;
if(offsets!=NULL) {
*offsets++=-1;
*offsets++=-1;
*offsets++=-1;
*offsets++=-1;
}
sourceIndex=1;
cnv->fromUChar32=c=0;
}
if(c==0) {
/* copy an even number of bytes for complete UChars */
uint32_t count=2*length;
if(count>targetCapacity) {
count=targetCapacity&~1;
}
/* count is even */
targetCapacity-=count;
count>>=1;
length-=count;
if(offsets==NULL) {
while(count>0) {
c=*source++;
if(U16_IS_SINGLE(c)) {
target[0]=(uint8_t)c;
target[1]=(uint8_t)(c>>8);
target+=2;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
++source;
--count;
target[0]=(uint8_t)c;
target[1]=(uint8_t)(c>>8);
target[2]=(uint8_t)trail;
target[3]=(uint8_t)(trail>>8);
target+=4;
} else {
break;
}
--count;
}
} else {
while(count>0) {
c=*source++;
if(U16_IS_SINGLE(c)) {
target[0]=(uint8_t)c;
target[1]=(uint8_t)(c>>8);
target+=2;
*offsets++=sourceIndex;
*offsets++=sourceIndex++;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
++source;
--count;
target[0]=(uint8_t)c;
target[1]=(uint8_t)(c>>8);
target[2]=(uint8_t)trail;
target[3]=(uint8_t)(trail>>8);
target+=4;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
sourceIndex+=2;
} else {
break;
}
--count;
}
}
if(count==0) {
/* done with the loop for complete UChars */
if(length>0 && targetCapacity>0) {
/*
* there is more input and some target capacity -
* it must be targetCapacity==1 because otherwise
* the above would have copied more;
* prepare for overflow output
*/
if(U16_IS_SINGLE(c=*source++)) {
overflow[0]=(char)c;
overflow[1]=(char)(c>>8);
length=2; /* 2 bytes to output */
c=0;
/* } else { keep c for surrogate handling, length will be set there */
}
} else {
length=0;
c=0;
}
} else {
/* keep c for surrogate handling, length will be set there */
targetCapacity+=2*count;
}
} else {
length=0; /* from here on, length counts the bytes in overflow[] */
}
if(c!=0) {
/*
* c is a surrogate, and
* - source or target too short
* - or the surrogate is unmatched
*/
length=0;
if(U16_IS_SURROGATE_LEAD(c)) {
if(source<pArgs->sourceLimit) {
if(U16_IS_TRAIL(trail=*source)) {
/* output the surrogate pair, will overflow (see conditions comment above) */
++source;
overflow[0]=(char)c;
overflow[1]=(char)(c>>8);
overflow[2]=(char)trail;
overflow[3]=(char)(trail>>8);
length=4; /* 4 bytes to output */
c=0;
} else {
/* unmatched lead surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
} else {
/* see if the trail surrogate is in the next buffer */
}
} else {
/* unmatched trail surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
cnv->fromUChar32=c;
}
if(length>0) {
/* output length bytes with overflow (length>targetCapacity>0) */
ucnv_fromUWriteBytes(cnv,
overflow, length,
&target, pArgs->targetLimit,
&offsets, sourceIndex,
pErrorCode);
targetCapacity=(uint32_t)(pArgs->targetLimit-(char *)target);
}
if(U_SUCCESS(*pErrorCode) && source<pArgs->sourceLimit && targetCapacity==0) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
}
/* write back the updated pointers */
pArgs->source=source;
pArgs->target=target;
pArgs->offsets=offsets;
}
static void U_CALLCONV
_UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source;
UChar *target;
int32_t *offsets;
uint32_t targetCapacity, length, count, sourceIndex;
UChar c, trail;
if(pArgs->converter->mode<8) {
_UTF16ToUnicodeWithOffsets(pArgs, pErrorCode);
return;
}
cnv=pArgs->converter;
source=(const uint8_t *)pArgs->source;
length=(int32_t)((const uint8_t *)pArgs->sourceLimit-source);
if(length<=0 && cnv->toUnicodeStatus==0) {
/* no input, nothing to do */
return;
}
target=pArgs->target;
if(target >= pArgs->targetLimit) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
return;
}
targetCapacity=(uint32_t)(pArgs->targetLimit-pArgs->target);
offsets=pArgs->offsets;
sourceIndex=0;
c=0;
/* complete a partial UChar or pair from the last call */
if(cnv->toUnicodeStatus!=0) {
/*
* special case: single byte from a previous buffer,
* where the byte turned out not to belong to a trail surrogate
* and the preceding, unmatched lead surrogate was put into toUBytes[]
* for error handling
*/
cnv->toUBytes[0]=(uint8_t)cnv->toUnicodeStatus;
cnv->toULength=1;
cnv->toUnicodeStatus=0;
}
if((count=cnv->toULength)!=0) {
uint8_t *p=cnv->toUBytes;
do {
p[count++]=*source++;
++sourceIndex;
--length;
if(count==2) {
c=((UChar)p[1]<<8)|p[0];
if(U16_IS_SINGLE(c)) {
/* output the BMP code point */
*target++=c;
if(offsets!=NULL) {
*offsets++=-1;
}
--targetCapacity;
count=0;
c=0;
break;
} else if(U16_IS_SURROGATE_LEAD(c)) {
/* continue collecting bytes for the trail surrogate */
c=0; /* avoid unnecessary surrogate handling below */
} else {
/* fall through to error handling for an unmatched trail surrogate */
break;
}
} else if(count==4) {
c=((UChar)p[1]<<8)|p[0];
trail=((UChar)p[3]<<8)|p[2];
if(U16_IS_TRAIL(trail)) {
/* output the surrogate pair */
*target++=c;
if(targetCapacity>=2) {
*target++=trail;
if(offsets!=NULL) {
*offsets++=-1;
*offsets++=-1;
}
targetCapacity-=2;
} else /* targetCapacity==1 */ {
targetCapacity=0;
cnv->UCharErrorBuffer[0]=trail;
cnv->UCharErrorBufferLength=1;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
}
count=0;
c=0;
break;
} else {
/* unmatched lead surrogate, handle here for consistent toUBytes[] */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
/* back out reading the code unit after it */
if(((const uint8_t *)pArgs->source-source)>=2) {
source-=2;
} else {
/*
* if the trail unit's first byte was in a previous buffer, then
* we need to put it into a special place because toUBytes[] will be
* used for the lead unit's bytes
*/
cnv->toUnicodeStatus=0x100|p[2];
--source;
}
cnv->toULength=2;
/* write back the updated pointers */
pArgs->source=(const char *)source;
pArgs->target=target;
pArgs->offsets=offsets;
return;
}
}
} while(length>0);
cnv->toULength=(int8_t)count;
}
/* copy an even number of bytes for complete UChars */
count=2*targetCapacity;
if(count>length) {
count=length&~1;
}
if(c==0 && count>0) {
length-=count;
count>>=1;
targetCapacity-=count;
if(offsets==NULL) {
do {
c=((UChar)source[1]<<8)|source[0];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])
) {
source+=2;
--count;
*target++=c;
*target++=trail;
} else {
break;
}
} while(--count>0);
} else {
do {
c=((UChar)source[1]<<8)|source[0];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
*offsets++=sourceIndex;
sourceIndex+=2;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])
) {
source+=2;
--count;
*target++=c;
*target++=trail;
*offsets++=sourceIndex;
*offsets++=sourceIndex;
sourceIndex+=4;
} else {
break;
}
} while(--count>0);
}
if(count==0) {
/* done with the loop for complete UChars */
c=0;
} else {
/* keep c for surrogate handling, trail will be set there */
length+=2*(count-1); /* one more byte pair was consumed than count decremented */
targetCapacity+=count;
}
}
if(c!=0) {
/*
* c is a surrogate, and
* - source or target too short
* - or the surrogate is unmatched
*/
cnv->toUBytes[0]=(uint8_t)c;
cnv->toUBytes[1]=(uint8_t)(c>>8);
cnv->toULength=2;
if(U16_IS_SURROGATE_LEAD(c)) {
if(length>=2) {
if(U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])) {
/* output the surrogate pair, will overflow (see conditions comment above) */
source+=2;
length-=2;
*target++=c;
if(offsets!=NULL) {
*offsets++=sourceIndex;
}
cnv->UCharErrorBuffer[0]=trail;
cnv->UCharErrorBufferLength=1;
cnv->toULength=0;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
} else {
/* unmatched lead surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
} else {
/* see if the trail surrogate is in the next buffer */
}
} else {
/* unmatched trail surrogate */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
}
}
if(U_SUCCESS(*pErrorCode)) {
/* check for a remaining source byte */
if(length>0) {
if(targetCapacity==0) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
} else {
/* it must be length==1 because otherwise the above would have copied more */
cnv->toUBytes[cnv->toULength++]=*source++;
}
}
}
/* write back the updated pointers */
pArgs->source=(const char *)source;
pArgs->target=target;
pArgs->offsets=offsets;
}
static UChar32 U_CALLCONV
_UTF16LEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
const uint8_t *s, *sourceLimit;
UChar32 c;
if(pArgs->converter->mode<8) {
return UCNV_GET_NEXT_UCHAR_USE_TO_U;
}
s=(const uint8_t *)pArgs->source;
sourceLimit=(const uint8_t *)pArgs->sourceLimit;
if(s>=sourceLimit) {
/* no input */
*err=U_INDEX_OUTOFBOUNDS_ERROR;
return 0xffff;
}
if(s+2>sourceLimit) {
/* only one byte: truncated UChar */
pArgs->converter->toUBytes[0]=*s++;
pArgs->converter->toULength=1;
pArgs->source=(const char *)s;
*err = U_TRUNCATED_CHAR_FOUND;
return 0xffff;
}
/* get one UChar */
c=((UChar32)s[1]<<8)|*s;
s+=2;
/* check for a surrogate pair */
if(U_IS_SURROGATE(c)) {
if(U16_IS_SURROGATE_LEAD(c)) {
if(s+2<=sourceLimit) {
UChar trail;
/* get a second UChar and see if it is a trail surrogate */
trail=((UChar)s[1]<<8)|*s;
if(U16_IS_TRAIL(trail)) {
c=U16_GET_SUPPLEMENTARY(c, trail);
s+=2;
} else {
/* unmatched lead surrogate */
c=-2;
}
} else {
/* too few (2 or 3) bytes for a surrogate pair: truncated code point */
uint8_t *bytes=pArgs->converter->toUBytes;
s-=2;
pArgs->converter->toULength=(int8_t)(sourceLimit-s);
do {
*bytes++=*s++;
} while(s<sourceLimit);
c=0xffff;
*err=U_TRUNCATED_CHAR_FOUND;
}
} else {
/* unmatched trail surrogate */
c=-2;
}
if(c<0) {
/* write the unmatched surrogate */
uint8_t *bytes=pArgs->converter->toUBytes;
pArgs->converter->toULength=2;
*bytes=*(s-2);
bytes[1]=*(s-1);
c=0xffff;
*err=U_ILLEGAL_CHAR_FOUND;
}
}
pArgs->source=(const char *)s;
return c;
}
static void U_CALLCONV
_UTF16LEReset(UConverter *cnv, UConverterResetChoice choice) {
if(choice<=UCNV_RESET_TO_UNICODE) {
/* reset toUnicode state */
if(UCNV_GET_VERSION(cnv)==0) {
cnv->mode=8; /* no BOM handling */
} else {
cnv->mode=0; /* Java-specific "UnicodeLittle" requires LE BOM or no BOM */
}
}
if(choice!=UCNV_RESET_TO_UNICODE && UCNV_GET_VERSION(cnv)==1) {
/* reset fromUnicode for "UnicodeLittle": prepare to output the UTF-16LE BOM */
cnv->fromUnicodeStatus=UCNV_NEED_TO_WRITE_BOM;
}
}
static void U_CALLCONV
_UTF16LEOpen(UConverter *cnv,
UConverterLoadArgs *pArgs,
UErrorCode *pErrorCode) {
(void)pArgs;
if(UCNV_GET_VERSION(cnv)<=1) {
_UTF16LEReset(cnv, UCNV_RESET_BOTH);
} else {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
}
}
static const char * U_CALLCONV
_UTF16LEGetName(const UConverter *cnv) {
if(UCNV_GET_VERSION(cnv)==0) {
return "UTF-16LE";
} else {
return "UTF-16LE,version=1";
}
}
U_CDECL_END
static const UConverterImpl _UTF16LEImpl={
UCNV_UTF16_LittleEndian,
NULL,
NULL,
_UTF16LEOpen,
NULL,
_UTF16LEReset,
_UTF16LEToUnicodeWithOffsets,
_UTF16LEToUnicodeWithOffsets,
_UTF16LEFromUnicodeWithOffsets,
_UTF16LEFromUnicodeWithOffsets,
_UTF16LEGetNextUChar,
NULL,
_UTF16LEGetName,
NULL,
NULL,
ucnv_getNonSurrogateUnicodeSet,
NULL,
NULL
};
static const UConverterStaticData _UTF16LEStaticData={
sizeof(UConverterStaticData),
"UTF-16LE",
1202, UCNV_IBM, UCNV_UTF16_LittleEndian, 2, 2,
ICU: Update to version 72.1
2022-10-28 06:11:55 +00:00
{ 0xfd, 0xff, 0, 0 },2,false,false,
[Complex Text Layouts] Add third-party TextServer dependencies (ICU, HarfBuzz, Graphite).
2020-08-11 09:10:23 +00:00
0,
0,
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
};
const UConverterSharedData _UTF16LEData=
UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_UTF16LEStaticData, &_UTF16LEImpl);
/* UTF-16 (Detect BOM) ------------------------------------------------------ */
/*
* Detect a BOM at the beginning of the stream and select UTF-16BE or UTF-16LE
* accordingly.
* This is a simpler version of the UTF-32 converter, with
* fewer states for shorter BOMs.
*
* State values:
* 0 initial state
* 1 saw first byte
* 2..5 -
* 6..7 see _UTF16ToUnicodeWithOffsets() comments in state 1
* 8 UTF-16BE mode
* 9 UTF-16LE mode
*
* During detection: state==number of initial bytes seen so far.
*
* On output, emit U+FEFF as the first code point.
*
* Variants:
* - UTF-16,version=1 (Java "Unicode" encoding) treats a missing BOM as an error.
* - UTF-16BE,version=1 (Java "UnicodeBig" encoding) and
* UTF-16LE,version=1 (Java "UnicodeLittle" encoding) treat a reverse BOM as an error.
*/
U_CDECL_BEGIN
static void U_CALLCONV
_UTF16Reset(UConverter *cnv, UConverterResetChoice choice) {
if(choice<=UCNV_RESET_TO_UNICODE) {
/* reset toUnicode: state=0 */
cnv->mode=0;
}
if(choice!=UCNV_RESET_TO_UNICODE) {
/* reset fromUnicode: prepare to output the UTF-16PE BOM */
cnv->fromUnicodeStatus=UCNV_NEED_TO_WRITE_BOM;
}
}
U_CDECL_END
extern const UConverterSharedData _UTF16v2Data;
U_CDECL_BEGIN
static void U_CALLCONV
_UTF16Open(UConverter *cnv,
UConverterLoadArgs *pArgs,
UErrorCode *pErrorCode) {
if(UCNV_GET_VERSION(cnv)<=2) {
if(UCNV_GET_VERSION(cnv)==2 && !pArgs->onlyTestIsLoadable) {
/*
* Switch implementation, and switch the staticData that's different
* and was copied into the UConverter.
* (See ucnv_createConverterFromSharedData() in ucnv_bld.c.)
* UTF-16,version=2 fromUnicode() always writes a big-endian byte stream.
*/
cnv->sharedData=(UConverterSharedData*)&_UTF16v2Data;
uprv_memcpy(cnv->subChars, _UTF16v2Data.staticData->subChar, UCNV_MAX_SUBCHAR_LEN);
}
_UTF16Reset(cnv, UCNV_RESET_BOTH);
} else {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
}
}
static const char * U_CALLCONV
_UTF16GetName(const UConverter *cnv) {
if(UCNV_GET_VERSION(cnv)==0) {
return "UTF-16";
} else if(UCNV_GET_VERSION(cnv)==1) {
return "UTF-16,version=1";
} else {
return "UTF-16,version=2";
}
}
U_CDECL_END
extern const UConverterSharedData _UTF16Data;
static inline bool IS_UTF16BE(const UConverter *cnv) {
return ((cnv)->sharedData == &_UTF16BEData);
}
static inline bool IS_UTF16LE(const UConverter *cnv) {
return ((cnv)->sharedData == &_UTF16LEData);
}
static inline bool IS_UTF16(const UConverter *cnv) {
return ((cnv)->sharedData==&_UTF16Data) || ((cnv)->sharedData == &_UTF16v2Data);
}
U_CDECL_BEGIN
static void U_CALLCONV
_UTF16ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv=pArgs->converter;
const char *source=pArgs->source;
const char *sourceLimit=pArgs->sourceLimit;
int32_t *offsets=pArgs->offsets;
int32_t state, offsetDelta;
uint8_t b;
state=cnv->mode;
/*
* If we detect a BOM in this buffer, then we must add the BOM size to the
* offsets because the actual converter function will not see and count the BOM.
* offsetDelta will have the number of the BOM bytes that are in the current buffer.
*/
offsetDelta=0;
while(source<sourceLimit && U_SUCCESS(*pErrorCode)) {
switch(state) {
case 0:
cnv->toUBytes[0]=(uint8_t)*source++;
cnv->toULength=1;
state=1;
break;
case 1:
/*
* Only inside this switch case can the state variable
* temporarily take two additional values:
* 6: BOM error, continue with BE
* 7: BOM error, continue with LE
*/
b=*source;
if(cnv->toUBytes[0]==0xfe && b==0xff) {
if(IS_UTF16LE(cnv)) {
state=7; /* illegal reverse BOM for Java "UnicodeLittle" */
} else {
state=8; /* detect UTF-16BE */
}
} else if(cnv->toUBytes[0]==0xff && b==0xfe) {
if(IS_UTF16BE(cnv)) {
state=6; /* illegal reverse BOM for Java "UnicodeBig" */
} else {
state=9; /* detect UTF-16LE */
}
} else if((IS_UTF16(cnv) && UCNV_GET_VERSION(cnv)==1)) {
state=6; /* illegal missing BOM for Java "Unicode" */
}
if(state>=8) {
/* BOM detected, consume it */
++source;
cnv->toULength=0;
offsetDelta=(int32_t)(source-pArgs->source);
} else if(state<6) {
/* ok: no BOM, and not a reverse BOM */
if(source!=pArgs->source) {
/* reset the source for a correct first offset */
source=pArgs->source;
cnv->toULength=0;
}
if(IS_UTF16LE(cnv)) {
/* Make Java "UnicodeLittle" default to LE. */
state=9;
} else {
/* Make standard UTF-16 and Java "UnicodeBig" default to BE. */
state=8;
}
} else {
/*
* error: missing BOM, or reverse BOM
* UTF-16,version=1: Java-specific "Unicode" requires a BOM.
* UTF-16BE,version=1: Java-specific "UnicodeBig" requires a BE BOM or no BOM.
* UTF-16LE,version=1: Java-specific "UnicodeLittle" requires an LE BOM or no BOM.
*/
/* report the non-BOM or reverse BOM as an illegal sequence */
cnv->toUBytes[1]=b;
cnv->toULength=2;
pArgs->source=source+1;
/* continue with conversion if the callback resets the error */
/*
* Make Java "Unicode" default to BE like standard UTF-16.
* Make Java "UnicodeBig" and "UnicodeLittle" default
* to their normal endiannesses.
*/
cnv->mode=state+2;
*pErrorCode=U_ILLEGAL_ESCAPE_SEQUENCE;
return;
}
/* convert the rest of the stream */
cnv->mode=state;
continue;
case 8:
/* call UTF-16BE */
pArgs->source=source;
_UTF16BEToUnicodeWithOffsets(pArgs, pErrorCode);
source=pArgs->source;
break;
case 9:
/* call UTF-16LE */
pArgs->source=source;
_UTF16LEToUnicodeWithOffsets(pArgs, pErrorCode);
source=pArgs->source;
break;
default:
break; /* does not occur */
}
}
/* add BOM size to offsets - see comment at offsetDelta declaration */
if(offsets!=NULL && offsetDelta!=0) {
int32_t *offsetsLimit=pArgs->offsets;
while(offsets<offsetsLimit) {
*offsets++ += offsetDelta;
}
}
pArgs->source=source;
if(source==sourceLimit && pArgs->flush) {
/* handle truncated input */
switch(state) {
case 0:
break; /* no input at all, nothing to do */
case 8:
_UTF16BEToUnicodeWithOffsets(pArgs, pErrorCode);
break;
case 9:
_UTF16LEToUnicodeWithOffsets(pArgs, pErrorCode);
break;
default:
/* 0<state<8: framework will report truncation, nothing to do here */
break;
}
}
cnv->mode=state;
}
static UChar32 U_CALLCONV
_UTF16GetNextUChar(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
switch(pArgs->converter->mode) {
case 8:
return _UTF16BEGetNextUChar(pArgs, pErrorCode);
case 9:
return _UTF16LEGetNextUChar(pArgs, pErrorCode);
default:
return UCNV_GET_NEXT_UCHAR_USE_TO_U;
}
}
U_CDECL_END
static const UConverterImpl _UTF16Impl = {
UCNV_UTF16,
NULL,
NULL,
_UTF16Open,
NULL,
_UTF16Reset,
_UTF16ToUnicodeWithOffsets,
_UTF16ToUnicodeWithOffsets,
_UTF16PEFromUnicodeWithOffsets,
_UTF16PEFromUnicodeWithOffsets,
_UTF16GetNextUChar,
NULL, /* ### TODO implement getStarters for all Unicode encodings?! */
_UTF16GetName,
NULL,
NULL,
ucnv_getNonSurrogateUnicodeSet,
NULL,
NULL
};
static const UConverterStaticData _UTF16StaticData = {
sizeof(UConverterStaticData),
"UTF-16",
1204, /* CCSID for BOM sensitive UTF-16 */
UCNV_IBM, UCNV_UTF16, 2, 2,
#if U_IS_BIG_ENDIAN
{ 0xff, 0xfd, 0, 0 }, 2,
#else
{ 0xfd, 0xff, 0, 0 }, 2,
#endif
ICU: Update to version 72.1
2022-10-28 06:11:55 +00:00
false, false,
[Complex Text Layouts] Add third-party TextServer dependencies (ICU, HarfBuzz, Graphite).
2020-08-11 09:10:23 +00:00
0,
0,
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
};
const UConverterSharedData _UTF16Data =
UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_UTF16StaticData, &_UTF16Impl);
static const UConverterImpl _UTF16v2Impl = {
UCNV_UTF16,
NULL,
NULL,
_UTF16Open,
NULL,
_UTF16Reset,
_UTF16ToUnicodeWithOffsets,
_UTF16ToUnicodeWithOffsets,
_UTF16BEFromUnicodeWithOffsets,
_UTF16BEFromUnicodeWithOffsets,
_UTF16GetNextUChar,
NULL, /* ### TODO implement getStarters for all Unicode encodings?! */
_UTF16GetName,
NULL,
NULL,
ucnv_getNonSurrogateUnicodeSet,
NULL,
NULL
};
static const UConverterStaticData _UTF16v2StaticData = {
sizeof(UConverterStaticData),
"UTF-16,version=2",
1204, /* CCSID for BOM sensitive UTF-16 */
UCNV_IBM, UCNV_UTF16, 2, 2,
{ 0xff, 0xfd, 0, 0 }, 2,
ICU: Update to version 72.1
2022-10-28 06:11:55 +00:00
false, false,
[Complex Text Layouts] Add third-party TextServer dependencies (ICU, HarfBuzz, Graphite).
2020-08-11 09:10:23 +00:00
0,
0,
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
};
const UConverterSharedData _UTF16v2Data =
UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_UTF16v2StaticData, &_UTF16v2Impl);
#endif
Reference in New Issue Copy Permalink