1013 lines
36 KiB
C
1013 lines
36 KiB
C
/*
|
|
**********************************************************************
|
|
* Copyright (C) 2002, 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"
|
|
#include "unicode/ucnv.h"
|
|
#include "unicode/ucnv_err.h"
|
|
#include "ucnv_bld.h"
|
|
#include "ucnv_cnv.h"
|
|
#include "cmemory.h"
|
|
|
|
/* Prototypes --------------------------------------------------------------- */
|
|
|
|
/* Keep these here to make finicky compilers happy */
|
|
|
|
U_CFUNC void T_UConverter_toUnicode_UTF8(UConverterToUnicodeArgs *args,
|
|
UErrorCode *err);
|
|
U_CFUNC void T_UConverter_toUnicode_UTF8_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
|
|
UErrorCode *err);
|
|
U_CFUNC void T_UConverter_fromUnicode_UTF8(UConverterFromUnicodeArgs *args,
|
|
UErrorCode *err);
|
|
U_CFUNC void T_UConverter_fromUnicode_UTF8_OFFSETS_LOGIC(UConverterFromUnicodeArgs *args,
|
|
UErrorCode *err);
|
|
U_CFUNC UChar32 T_UConverter_getNextUChar_UTF8(UConverterToUnicodeArgs *args,
|
|
UErrorCode *err);
|
|
|
|
|
|
/* UTF-8 -------------------------------------------------------------------- */
|
|
|
|
/* UTF-8 Conversion DATA
|
|
* for more information see Unicode Strandard 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 };
|
|
|
|
/**
|
|
* Calls invalid char callback when an invalid character sequence is encountered.
|
|
* It presumes that the converter has a callback to call.
|
|
*
|
|
* @returns true when callback fails
|
|
*/
|
|
static UBool
|
|
T_UConverter_toUnicode_InvalidChar_Callback(UConverterToUnicodeArgs * args,
|
|
UConverterCallbackReason reason,
|
|
UErrorCode *err)
|
|
{
|
|
UConverter *converter = args->converter;
|
|
|
|
if (U_SUCCESS(*err))
|
|
{
|
|
if (reason == UCNV_ILLEGAL) {
|
|
*err = U_ILLEGAL_CHAR_FOUND;
|
|
} else {
|
|
*err = U_INVALID_CHAR_FOUND;
|
|
}
|
|
}
|
|
|
|
/* copy the toUBytes to the invalidCharBuffer */
|
|
uprv_memcpy(converter->invalidCharBuffer,
|
|
converter->toUBytes,
|
|
converter->toULength);
|
|
converter->invalidCharLength = converter->toULength;
|
|
|
|
/* Call the ErrorFunction */
|
|
args->converter->fromCharErrorBehaviour(converter->toUContext,
|
|
args,
|
|
converter->invalidCharBuffer,
|
|
converter->invalidCharLength,
|
|
reason,
|
|
err);
|
|
|
|
return (UBool)U_FAILURE(*err);
|
|
}
|
|
|
|
static UBool
|
|
T_UConverter_toUnicode_InvalidChar_OffsetCallback(UConverterToUnicodeArgs * args,
|
|
int32_t currentOffset,
|
|
UConverterCallbackReason reason,
|
|
UErrorCode *err)
|
|
{
|
|
int32_t *saveOffsets = args->offsets;
|
|
UBool result;
|
|
|
|
result = T_UConverter_toUnicode_InvalidChar_Callback(args, reason, err);
|
|
|
|
while (saveOffsets < args->offsets)
|
|
{
|
|
*(saveOffsets++) = currentOffset;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
U_CFUNC void T_UConverter_toUnicode_UTF8 (UConverterToUnicodeArgs * args,
|
|
UErrorCode * err)
|
|
{
|
|
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 = args->converter->toUBytes;
|
|
UBool isCESU8 = (UBool)(args->converter->sharedData == &_CESU8Data);
|
|
uint32_t ch, ch2 = 0;
|
|
int32_t i, inBytes;
|
|
|
|
/* Restore size of current sequence */
|
|
start:
|
|
if (args->converter->toUnicodeStatus && myTarget < targetLimit)
|
|
{
|
|
inBytes = args->converter->mode; /* restore # of bytes to consume */
|
|
i = args->converter->toULength; /* restore # of bytes consumed */
|
|
|
|
ch = args->converter->toUnicodeStatus;/*Stores the previously calculated ch from a previous call*/
|
|
args->converter->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 (!UTF8_IS_TRAIL(ch2))
|
|
{
|
|
break; /* i < inBytes */
|
|
}
|
|
ch = (ch << 6) + ch2;
|
|
++mySource;
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
if (args->flush)
|
|
{
|
|
if (U_SUCCESS(*err))
|
|
{
|
|
*err = U_TRUNCATED_CHAR_FOUND;
|
|
}
|
|
}
|
|
else
|
|
{ /* stores a partially calculated target*/
|
|
args->converter->toUnicodeStatus = ch;
|
|
args->converter->mode = inBytes;
|
|
args->converter->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[])
|
|
*
|
|
* Starting with Unicode 3.2, surrogate code points must not be encoded in UTF-8.
|
|
* There are no irregular sequences any more.
|
|
* In CESU-8, only surrogates, not supplementary code points, are encoded directly.
|
|
*/
|
|
if (i == inBytes && ch <= MAXIMUM_UTF && ch >= utf8_minChar32[i] &&
|
|
(isCESU8 ? i <= 3 : !UTF_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) */
|
|
args->converter->UCharErrorBuffer[0] = (UChar) ch;
|
|
args->converter->UCharErrorBufferLength = 1;
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
args->source = (const char *) mySource;
|
|
args->target = myTarget;
|
|
|
|
args->converter->toULength = (int8_t)i;
|
|
if (T_UConverter_toUnicode_InvalidChar_Callback(args, UCNV_ILLEGAL, err))
|
|
{
|
|
/* Stop if the error wasn't handled */
|
|
break;
|
|
}
|
|
|
|
mySource = (unsigned char *) args->source;
|
|
myTarget = args->target;
|
|
|
|
/* goto the start to handle state left behind by the callback */
|
|
goto start;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
U_CFUNC void T_UConverter_toUnicode_UTF8_OFFSETS_LOGIC (UConverterToUnicodeArgs * args,
|
|
UErrorCode * err)
|
|
{
|
|
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 = args->converter->toUBytes;
|
|
UBool isCESU8 = (UBool)(args->converter->sharedData == &_CESU8Data);
|
|
uint32_t ch, ch2 = 0;
|
|
int32_t i, inBytes;
|
|
|
|
/* Restore size of current sequence */
|
|
start:
|
|
if (args->converter->toUnicodeStatus && myTarget < targetLimit)
|
|
{
|
|
inBytes = args->converter->mode; /* restore # of bytes to consume */
|
|
i = args->converter->toULength; /* restore # of bytes consumed */
|
|
|
|
ch = args->converter->toUnicodeStatus;/*Stores the previously calculated ch from a previous call*/
|
|
args->converter->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 (!UTF8_IS_TRAIL(ch2))
|
|
{
|
|
break; /* i < inBytes */
|
|
}
|
|
ch = (ch << 6) + ch2;
|
|
++mySource;
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
if (args->flush)
|
|
{
|
|
if (U_SUCCESS(*err))
|
|
{
|
|
*err = U_TRUNCATED_CHAR_FOUND;
|
|
args->converter->toUnicodeStatus = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
args->converter->toUnicodeStatus = ch;
|
|
args->converter->mode = inBytes;
|
|
args->converter->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[])
|
|
*
|
|
* Starting with Unicode 3.2, surrogate code points must not be encoded in UTF-8.
|
|
* There are no irregular sequences any more.
|
|
* In CESU-8, only surrogates, not supplementary code points, are encoded directly.
|
|
*/
|
|
if (i == inBytes && ch <= MAXIMUM_UTF && ch >= utf8_minChar32[i] &&
|
|
(isCESU8 ? i <= 3 : !UTF_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
|
|
{
|
|
args->converter->UCharErrorBuffer[0] = (UChar) ch;
|
|
args->converter->UCharErrorBufferLength = 1;
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
}
|
|
offsetNum += i;
|
|
}
|
|
else
|
|
{
|
|
args->source = (const char *) mySource;
|
|
args->target = myTarget;
|
|
args->offsets = myOffsets;
|
|
|
|
args->converter->toULength = (int8_t)i;
|
|
if (T_UConverter_toUnicode_InvalidChar_OffsetCallback(args,
|
|
offsetNum, UCNV_ILLEGAL, err))
|
|
{
|
|
/* Stop if the error wasn't handled */
|
|
break;
|
|
}
|
|
|
|
offsetNum += i + ((unsigned char *) args->source - mySource);
|
|
mySource = (unsigned char *) args->source;
|
|
myTarget = args->target;
|
|
myOffsets = args->offsets;
|
|
|
|
/* goto the start to handle state left behind by the callback */
|
|
goto start;
|
|
}
|
|
}
|
|
}
|
|
|
|
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 T_UConverter_fromUnicode_UTF8 (UConverterFromUnicodeArgs * args,
|
|
UErrorCode * err)
|
|
{
|
|
UConverter *cnv = args->converter;
|
|
const UChar *mySource = args->source;
|
|
unsigned char *myTarget = (unsigned char *) args->target;
|
|
const UChar *sourceLimit = args->sourceLimit;
|
|
const unsigned char *targetLimit = (unsigned char *) args->targetLimit;
|
|
UBool isCESU8 = (UBool)(args->converter->sharedData == &_CESU8Data);
|
|
uint32_t ch, ch2;
|
|
int16_t indexToWrite;
|
|
char temp[4];
|
|
|
|
if (cnv->fromUSurrogateLead && myTarget < targetLimit)
|
|
{
|
|
ch = cnv->fromUSurrogateLead;
|
|
cnv->fromUSurrogateLead = 0;
|
|
goto lowsurrogate;
|
|
}
|
|
|
|
while (mySource < sourceLimit && myTarget < targetLimit)
|
|
{
|
|
ch = *(mySource++);
|
|
|
|
if (ch < 0x80) /* Single byte */
|
|
{
|
|
*(myTarget++) = (char) ch;
|
|
}
|
|
else if (ch < 0x800) /* Double byte */
|
|
{
|
|
*(myTarget++) = (char) ((ch >> 6) | 0xc0);
|
|
if (myTarget < targetLimit)
|
|
{
|
|
*(myTarget++) = (char) ((ch & 0x3f) | 0x80);
|
|
}
|
|
else
|
|
{
|
|
cnv->charErrorBuffer[0] = (char) ((ch & 0x3f) | 0x80);
|
|
cnv->charErrorBufferLength = 1;
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
}
|
|
else
|
|
/* Check for surrogates */
|
|
{
|
|
if(UTF_IS_SURROGATE(ch) && !isCESU8) {
|
|
if(UTF_IS_SURROGATE_FIRST(ch)) {
|
|
lowsurrogate:
|
|
if (mySource < sourceLimit) {
|
|
/* test the following code unit */
|
|
UChar trail=*mySource;
|
|
if(UTF_IS_SECOND_SURROGATE(trail)) {
|
|
++mySource;
|
|
ch=UTF16_GET_PAIR_VALUE(ch, trail);
|
|
ch2 = 0;
|
|
/* convert this supplementary code point */
|
|
/* exit this condition tree */
|
|
} else {
|
|
/* this is an unmatched lead code unit (1st surrogate) */
|
|
/* callback(illegal) */
|
|
ch2 = ch;
|
|
}
|
|
} else {
|
|
/* no more input */
|
|
cnv->fromUSurrogateLead = (UChar)ch;
|
|
break;
|
|
}
|
|
} else {
|
|
/* this is an unmatched trail code unit (2nd surrogate) */
|
|
/* callback(illegal) */
|
|
ch2 = ch;
|
|
}
|
|
|
|
if(ch2 != 0) {
|
|
/* call the callback function with all the preparations and post-processing */
|
|
*err = U_ILLEGAL_CHAR_FOUND;
|
|
|
|
/* update the arguments structure */
|
|
args->source=mySource;
|
|
args->target=(char *)myTarget;
|
|
|
|
/* write the code point as code units */
|
|
cnv->invalidUCharBuffer[0] = (UChar)ch2;
|
|
cnv->invalidUCharLength = 1;
|
|
|
|
/* call the callback function */
|
|
cnv->fromUCharErrorBehaviour(cnv->fromUContext, args, cnv->invalidUCharBuffer, 1, ch2, UCNV_ILLEGAL, err);
|
|
|
|
/* get the converter state from UConverter */
|
|
ch = cnv->fromUSurrogateLead;
|
|
cnv->fromUSurrogateLead = 0;
|
|
|
|
myTarget=(uint8_t *)args->target;
|
|
mySource=args->source;
|
|
|
|
/*
|
|
* If the callback overflowed the target, then we need to
|
|
* stop here with an overflow indication.
|
|
*/
|
|
if(*err==U_BUFFER_OVERFLOW_ERROR) {
|
|
break;
|
|
} else if(U_FAILURE(*err)) {
|
|
/* break on error */
|
|
break;
|
|
} else if(cnv->charErrorBufferLength>0) {
|
|
/* target is full */
|
|
*err=U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
/*
|
|
* } else if(ch != 0) { ...
|
|
* ### TODO 2002jul01 markus: It looks like this code (from ucnvmbcs.c)
|
|
* does not handle the case where the callback leaves ch=fromUSurrogateLead!=0 .
|
|
* We would have to check myTarget<targetLimit and goto lowsurrogate?!
|
|
*/
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (ch < 0x10000)
|
|
{
|
|
indexToWrite = 2;
|
|
temp[2] = (char) ((ch >> 12) | 0xe0);
|
|
}
|
|
else
|
|
{
|
|
indexToWrite = 3;
|
|
temp[3] = (char) ((ch >> 18) | 0xf0);
|
|
temp[2] = (char) (((ch >> 12) & 0x3f) | 0x80);
|
|
}
|
|
temp[1] = (char) (((ch >> 6) & 0x3f) | 0x80);
|
|
temp[0] = (char) ((ch & 0x3f) | 0x80);
|
|
|
|
for (; indexToWrite >= 0; indexToWrite--)
|
|
{
|
|
if (myTarget < targetLimit)
|
|
{
|
|
*(myTarget++) = temp[indexToWrite];
|
|
}
|
|
else
|
|
{
|
|
cnv->charErrorBuffer[cnv->charErrorBufferLength++] = temp[indexToWrite];
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err))
|
|
{
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
if(args->flush && mySource >= sourceLimit && cnv->fromUSurrogateLead != 0 && U_SUCCESS(*err)) {
|
|
/* a Unicode code point remains incomplete (only a first surrogate) */
|
|
*err = U_TRUNCATED_CHAR_FOUND;
|
|
cnv->fromUSurrogateLead = 0;
|
|
}
|
|
|
|
args->target = (char *) myTarget;
|
|
args->source = mySource;
|
|
}
|
|
|
|
U_CFUNC void T_UConverter_fromUnicode_UTF8_OFFSETS_LOGIC (UConverterFromUnicodeArgs * args,
|
|
UErrorCode * err)
|
|
{
|
|
UConverter *cnv = args->converter;
|
|
const UChar *mySource = args->source;
|
|
unsigned char *myTarget = (unsigned char *) args->target;
|
|
int32_t *myOffsets = args->offsets;
|
|
const UChar *sourceLimit = args->sourceLimit;
|
|
const unsigned char *targetLimit = (unsigned char *) args->targetLimit;
|
|
UBool isCESU8 = (UBool)(args->converter->sharedData == &_CESU8Data);
|
|
uint32_t ch, ch2;
|
|
int32_t offsetNum = 0, nextSourceIndex;
|
|
int16_t indexToWrite;
|
|
char temp[4];
|
|
|
|
if (cnv->fromUSurrogateLead && myTarget < targetLimit)
|
|
{
|
|
ch = cnv->fromUSurrogateLead;
|
|
cnv->fromUSurrogateLead = 0;
|
|
goto lowsurrogate;
|
|
}
|
|
|
|
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++) = (char) ((ch >> 6) | 0xc0);
|
|
if (myTarget < targetLimit)
|
|
{
|
|
*(myOffsets++) = offsetNum++;
|
|
*(myTarget++) = (char) ((ch & 0x3f) | 0x80);
|
|
}
|
|
else
|
|
{
|
|
cnv->charErrorBuffer[0] = (char) ((ch & 0x3f) | 0x80);
|
|
cnv->charErrorBufferLength = 1;
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
}
|
|
else
|
|
/* Check for surrogates */
|
|
{
|
|
nextSourceIndex = offsetNum + 1;
|
|
|
|
if(UTF_IS_SURROGATE(ch) && !isCESU8) {
|
|
if(UTF_IS_SURROGATE_FIRST(ch)) {
|
|
lowsurrogate:
|
|
if (mySource < sourceLimit) {
|
|
/* test the following code unit */
|
|
UChar trail=*mySource;
|
|
if(UTF_IS_SECOND_SURROGATE(trail)) {
|
|
++mySource;
|
|
++nextSourceIndex;
|
|
ch=UTF16_GET_PAIR_VALUE(ch, trail);
|
|
ch2 = 0;
|
|
/* convert this supplementary code point */
|
|
/* exit this condition tree */
|
|
} else {
|
|
/* this is an unmatched lead code unit (1st surrogate) */
|
|
/* callback(illegal) */
|
|
ch2 = ch;
|
|
}
|
|
} else {
|
|
/* no more input */
|
|
cnv->fromUSurrogateLead = (UChar)ch;
|
|
break;
|
|
}
|
|
} else {
|
|
/* this is an unmatched trail code unit (2nd surrogate) */
|
|
/* callback(illegal) */
|
|
ch2 = ch;
|
|
}
|
|
|
|
if(ch2 != 0) {
|
|
/* call the callback function with all the preparations and post-processing */
|
|
*err = U_ILLEGAL_CHAR_FOUND;
|
|
|
|
/* update the arguments structure */
|
|
args->source=mySource;
|
|
args->target=(char *)myTarget;
|
|
args->offsets=myOffsets;
|
|
|
|
/* write the code point as code units */
|
|
cnv->invalidUCharBuffer[0] = (UChar)ch2;
|
|
cnv->invalidUCharLength = 1;
|
|
|
|
/* call the callback function */
|
|
cnv->fromUCharErrorBehaviour(cnv->fromUContext, args, cnv->invalidUCharBuffer, 1, ch2, UCNV_ILLEGAL, err);
|
|
|
|
/* get the converter state from UConverter */
|
|
ch = cnv->fromUSurrogateLead;
|
|
cnv->fromUSurrogateLead = 0;
|
|
|
|
/* update target and deal with offsets if necessary */
|
|
myOffsets=ucnv_updateCallbackOffsets(myOffsets, ((uint8_t *)args->target)-myTarget, offsetNum);
|
|
myTarget=(uint8_t *)args->target;
|
|
|
|
/* update the source pointer and index */
|
|
offsetNum=nextSourceIndex+(args->source-mySource);
|
|
mySource=args->source;
|
|
|
|
/*
|
|
* If the callback overflowed the target, then we need to
|
|
* stop here with an overflow indication.
|
|
*/
|
|
if(*err==U_BUFFER_OVERFLOW_ERROR) {
|
|
break;
|
|
} else if(U_FAILURE(*err)) {
|
|
/* break on error */
|
|
break;
|
|
} else if(cnv->charErrorBufferLength>0) {
|
|
/* target is full */
|
|
*err=U_BUFFER_OVERFLOW_ERROR;
|
|
break;
|
|
/*
|
|
* } else if(ch != 0) { ...
|
|
* ### TODO 2002jul01 markus: It looks like this code (from ucnvmbcs.c)
|
|
* does not handle the case where the callback leaves ch=fromUSurrogateLead!=0 .
|
|
* We would have to check myTarget<targetLimit and goto lowsurrogate?!
|
|
*/
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (ch < 0x10000)
|
|
{
|
|
indexToWrite = 2;
|
|
temp[2] = (char) ((ch >> 12) | 0xe0);
|
|
}
|
|
else
|
|
{
|
|
indexToWrite = 3;
|
|
temp[3] = (char) ((ch >> 18) | 0xf0);
|
|
temp[2] = (char) (((ch >> 12) & 0x3f) | 0x80);
|
|
}
|
|
temp[1] = (char) (((ch >> 6) & 0x3f) | 0x80);
|
|
temp[0] = (char) ((ch & 0x3f) | 0x80);
|
|
|
|
for (; indexToWrite >= 0; indexToWrite--)
|
|
{
|
|
if (myTarget < targetLimit)
|
|
{
|
|
*(myOffsets++) = offsetNum;
|
|
*(myTarget++) = temp[indexToWrite];
|
|
}
|
|
else
|
|
{
|
|
cnv->charErrorBuffer[cnv->charErrorBufferLength++] = temp[indexToWrite];
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
}
|
|
offsetNum = nextSourceIndex;
|
|
}
|
|
}
|
|
|
|
if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err))
|
|
{
|
|
*err = U_BUFFER_OVERFLOW_ERROR;
|
|
}
|
|
if(args->flush && mySource >= sourceLimit && cnv->fromUSurrogateLead != 0 && U_SUCCESS(*err)) {
|
|
/* a Unicode code point remains incomplete (only a first surrogate) */
|
|
*err = U_TRUNCATED_CHAR_FOUND;
|
|
cnv->fromUSurrogateLead = 0;
|
|
}
|
|
|
|
args->target = (char *) myTarget;
|
|
args->source = mySource;
|
|
args->offsets = myOffsets;
|
|
}
|
|
|
|
U_CFUNC UChar32 T_UConverter_getNextUChar_UTF8(UConverterToUnicodeArgs *args,
|
|
UErrorCode *err) {
|
|
UChar buffer[2];
|
|
const char *sourceInitial;
|
|
const uint8_t *source;
|
|
UChar* myUCharPtr;
|
|
uint16_t extraBytesToWrite;
|
|
uint8_t myByte;
|
|
UChar32 ch;
|
|
int8_t isLegalSequence;
|
|
UBool isCESU8 = (UBool)(args->converter->sharedData == &_CESU8Data);
|
|
|
|
while (args->source < args->sourceLimit)
|
|
{
|
|
sourceInitial = args->source;
|
|
myByte = (uint8_t)*(args->source++);
|
|
if (myByte < 0x80)
|
|
{
|
|
return (UChar32)myByte;
|
|
}
|
|
|
|
extraBytesToWrite = (uint16_t)bytesFromUTF8[myByte];
|
|
if (extraBytesToWrite == 0) {
|
|
isLegalSequence = FALSE;
|
|
ch = 0;
|
|
goto CALL_ERROR_FUNCTION;
|
|
}
|
|
|
|
/*The byte sequence is longer than the buffer area passed*/
|
|
source = (const uint8_t *)args->source;
|
|
if (((const char *)source + extraBytesToWrite - 1) > args->sourceLimit)
|
|
{
|
|
*err = U_TRUNCATED_CHAR_FOUND;
|
|
return 0xffff;
|
|
}
|
|
else
|
|
{
|
|
isLegalSequence = 1;
|
|
ch = myByte << 6;
|
|
switch(extraBytesToWrite)
|
|
{
|
|
/* note: code falls through cases! (sic)*/
|
|
case 6:
|
|
ch += (myByte = *source++);
|
|
ch <<= 6;
|
|
if (!UTF8_IS_TRAIL(myByte))
|
|
{
|
|
isLegalSequence = 0;
|
|
break;
|
|
}
|
|
case 5:
|
|
ch += (myByte = *source++);
|
|
ch <<= 6;
|
|
if (!UTF8_IS_TRAIL(myByte))
|
|
{
|
|
isLegalSequence = 0;
|
|
break;
|
|
}
|
|
case 4:
|
|
ch += (myByte = *source++);
|
|
ch <<= 6;
|
|
if (!UTF8_IS_TRAIL(myByte))
|
|
{
|
|
isLegalSequence = 0;
|
|
break;
|
|
}
|
|
case 3:
|
|
ch += (myByte = *source++);
|
|
ch <<= 6;
|
|
if (!UTF8_IS_TRAIL(myByte))
|
|
{
|
|
isLegalSequence = 0;
|
|
break;
|
|
}
|
|
case 2:
|
|
ch += (myByte = *source++);
|
|
if (!UTF8_IS_TRAIL(myByte))
|
|
{
|
|
isLegalSequence = 0;
|
|
}
|
|
};
|
|
}
|
|
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[])
|
|
*
|
|
* Starting with Unicode 3.2, surrogate code points must not be encoded in UTF-8.
|
|
* There are no irregular sequences any more.
|
|
* In CESU-8, only surrogates, not supplementary code points, are encoded directly.
|
|
*/
|
|
if (isLegalSequence && (uint32_t)ch <= MAXIMUM_UTF && (uint32_t)ch >= utf8_minChar32[extraBytesToWrite]) {
|
|
if(isCESU8) {
|
|
if(extraBytesToWrite <= 3) {
|
|
if( UTF_IS_FIRST_SURROGATE(ch) &&
|
|
(const char *)(source + 3) <= args->sourceLimit &&
|
|
source[0] == 0xed && (source[1] & 0xf0) == 0xb0 && (source[2] & 0xc0) == 0x80
|
|
) {
|
|
/* ch is a lead surrogate followed by a trail surrogate */
|
|
ch = (ch << 10) +
|
|
((source[1] & 0xf) << 6) + (source[2] & 0x3f) -
|
|
((0xd800 << 10) - 0x10000);
|
|
args->source = (const char *)(source + 3);
|
|
}
|
|
return ch; /* return the code point */
|
|
}
|
|
/* illegal CESU-8 */
|
|
} else {
|
|
if(!UTF_IS_SURROGATE(ch)) {
|
|
return ch; /* return the code point */
|
|
}
|
|
/* illegal UTF-8 */
|
|
}
|
|
}
|
|
|
|
CALL_ERROR_FUNCTION:
|
|
extraBytesToWrite = (uint16_t)(args->source - sourceInitial);
|
|
args->converter->invalidCharLength = (uint8_t)extraBytesToWrite;
|
|
uprv_memcpy(args->converter->invalidCharBuffer, sourceInitial, extraBytesToWrite);
|
|
|
|
myUCharPtr = buffer;
|
|
*err = U_ILLEGAL_CHAR_FOUND;
|
|
args->target = myUCharPtr;
|
|
args->targetLimit = buffer + 2;
|
|
args->converter->fromCharErrorBehaviour(args->converter->toUContext,
|
|
args,
|
|
sourceInitial,
|
|
extraBytesToWrite,
|
|
UCNV_ILLEGAL,
|
|
err);
|
|
|
|
if(U_SUCCESS(*err)) {
|
|
extraBytesToWrite = (uint16_t)(args->target - buffer);
|
|
if(extraBytesToWrite > 0) {
|
|
return ucnv_getUChar32KeepOverflow(args->converter, buffer, extraBytesToWrite);
|
|
}
|
|
/* else (callback did not write anything) continue */
|
|
} else if(*err == U_BUFFER_OVERFLOW_ERROR) {
|
|
*err = U_ZERO_ERROR;
|
|
return ucnv_getUChar32KeepOverflow(args->converter, buffer, 2);
|
|
} else {
|
|
/* break on error */
|
|
/* ### what if a callback set an error but _also_ generated output?! */
|
|
return 0xffff;
|
|
}
|
|
}
|
|
|
|
/* no input or only skipping callback calls */
|
|
*err = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return 0xffff;
|
|
}
|
|
|
|
/* UTF-8 converter data ----------------------------------------------------- */
|
|
|
|
static const UConverterImpl _UTF8Impl={
|
|
UCNV_UTF8,
|
|
|
|
NULL,
|
|
NULL,
|
|
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
|
|
T_UConverter_toUnicode_UTF8,
|
|
T_UConverter_toUnicode_UTF8_OFFSETS_LOGIC,
|
|
T_UConverter_fromUnicode_UTF8,
|
|
T_UConverter_fromUnicode_UTF8_OFFSETS_LOGIC,
|
|
T_UConverter_getNextUChar_UTF8,
|
|
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
/* 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, 4,
|
|
{ 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 UConverterStaticData _CESU8StaticData={
|
|
sizeof(UConverterStaticData),
|
|
"CESU-8",
|
|
0, 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, &_UTF8Impl,
|
|
0
|
|
};
|