/* ********************************************************************** * Copyright (C) 2000, International Business Machines * Corporation and others. All Rights Reserved. ********************************************************************** * file name: ucnv_utf.cpp * encoding: US-ASCII * tab size: 8 (not used) * indentation:4 * * created on: 2000feb03 * created by: Markus W. Scherer * * Change history: * * 06/29/2000 helena Major rewrite of the callback APIs. * 07/20/2000 george Change the coding style to conform to the coding guidelines, * and a few miscellaneous bug fixes. * 11/15/2000 george Added UTF-32 */ #include "cmemory.h" #include "unicode/utypes.h" #include "unicode/ucnv_err.h" #include "ucnv_bld.h" #include "unicode/ucnv.h" #include "ucnv_cnv.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); U_CFUNC void _UTF16PEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode); U_CFUNC void _UTF16PEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, UErrorCode *pErrorCode); U_CFUNC void _UTF16OEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode); U_CFUNC void _UTF16OEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, UErrorCode *pErrorCode); U_CFUNC UChar32 T_UConverter_getNextUChar_UTF16_BE(UConverterToUnicodeArgs* args, UErrorCode* err); U_CFUNC UChar32 T_UConverter_getNextUChar_UTF16_LE(UConverterToUnicodeArgs* args, UErrorCode* err); U_CFUNC void T_UConverter_toUnicode_UTF32_BE(UConverterToUnicodeArgs *args, UErrorCode *err); U_CFUNC void T_UConverter_toUnicode_UTF32_BE_OFFSET_LOGIC(UConverterToUnicodeArgs *args, UErrorCode *err); U_CFUNC void T_UConverter_fromUnicode_UTF32_BE(UConverterFromUnicodeArgs *args, UErrorCode *err); U_CFUNC void T_UConverter_fromUnicode_UTF32_BE_OFFSET_LOGIC(UConverterFromUnicodeArgs *args, UErrorCode *err); U_CFUNC UChar32 T_UConverter_getNextUChar_UTF32_BE(UConverterToUnicodeArgs *args, UErrorCode *err); U_CFUNC void T_UConverter_toUnicode_UTF32_LE(UConverterToUnicodeArgs *args, UErrorCode *err); U_CFUNC void T_UConverter_toUnicode_UTF32_LE_OFFSET_LOGIC(UConverterToUnicodeArgs *args, UErrorCode *err); U_CFUNC void T_UConverter_fromUnicode_UTF32_LE(UConverterFromUnicodeArgs *args, UErrorCode *err); U_CFUNC void T_UConverter_fromUnicode_UTF32_LE_OFFSET_LOGIC(UConverterFromUnicodeArgs *args, UErrorCode *err); U_CFUNC UChar32 T_UConverter_getNextUChar_UTF32_LE(UConverterToUnicodeArgs *args, UErrorCode *err); U_CFUNC void _UTF7Reset(UConverter *cnv, UConverterResetChoice choice); U_CFUNC void _UTF7Open(UConverter *cnv, const char *name, const char *locale, uint32_t options, UErrorCode *pErrorCode); U_CFUNC void _UTF7ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode); U_CFUNC UChar32 _UTF7GetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode); U_CFUNC void _UTF7FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, UErrorCode *pErrorCode); U_CFUNC const char * _UTF7GetName(const UConverter *cnv); /* 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 }; /* static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};*/ #define INVALID_UTF8_TAIL(utf8) (((utf8) & 0xC0) != 0x80) /** * 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, UErrorCode *err) { UConverter *converter = args->converter; if (U_SUCCESS(*err)) { *err = U_ILLEGAL_CHAR_FOUND; } /* copy the toUBytes to the invalidCharBuffer */ uprv_memcpy(converter->invalidCharBuffer, converter->toUBytes, converter->invalidCharLength); /* Call the ErrorFunction */ args->converter->fromCharErrorBehaviour(converter->toUContext, args, converter->invalidCharBuffer, converter->invalidCharLength, UCNV_ILLEGAL, err); return (UBool)U_FAILURE(*err); } static UBool T_UConverter_toUnicode_InvalidChar_OffsetCallback(UConverterToUnicodeArgs * args, int32_t currentOffset, UErrorCode *err) { int32_t *saveOffsets = args->offsets; UBool result; result = T_UConverter_toUnicode_InvalidChar_Callback(args, 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 invalidTailChar = FALSE; uint32_t ch, ch2 = 0, i; uint32_t inBytes; /* Total number of bytes in the current UTF8 sequence */ /* Restore size of current sequence */ if (args->converter->toUnicodeStatus && myTarget < targetLimit) { inBytes = args->converter->toULength; /* restore # of bytes to consume */ i = args->converter->invalidCharLength; /* 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 (INVALID_UTF8_TAIL(ch2)) { *err = U_TRUNCATED_CHAR_FOUND; invalidTailChar = TRUE; break; } ch = (ch << 6) + ch2; 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->toULength = (int8_t) inBytes; args->converter->invalidCharLength = (int8_t) i; } goto donefornow; } } /* Remove the acummulated high bits */ ch -= offsetsFromUTF8[inBytes]; if (i == inBytes && ch <= MAXIMUM_UTF) { /* 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->invalidCharLength = (int8_t)i; if (T_UConverter_toUnicode_InvalidChar_Callback(args, err)) { /* Stop if the error wasn't handled */ break; } args->converter->invalidCharLength = 0; mySource = (unsigned char *) args->source; myTarget = args->target; if (invalidTailChar) { /* Treat the tail as ASCII*/ if (myTarget < targetLimit) { *(myTarget++) = (UChar) ch2; invalidTailChar = FALSE; } else { /* Put in overflow buffer (not handled here) */ args->converter->UCharErrorBuffer[0] = (UChar) ch2; args->converter->UCharErrorBufferLength = 1; *err = U_BUFFER_OVERFLOW_ERROR; break; } } } } } donefornow: if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { /* End of target buffer */ *err = U_BUFFER_OVERFLOW_ERROR; } args->target = myTarget; args->source = (const char *) mySource; } 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 invalidTailChar = FALSE; uint32_t ch, ch2 = 0, i; uint32_t inBytes; /* Restore size of current sequence */ if (args->converter->toUnicodeStatus && myTarget < targetLimit) { inBytes = args->converter->toULength; /* restore # of bytes to consume */ i = args->converter->invalidCharLength; /* 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 (INVALID_UTF8_TAIL(ch2)) { *err = U_TRUNCATED_CHAR_FOUND; invalidTailChar = TRUE; break; } ch = (ch << 6) + ch2; 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->toULength = (int8_t)inBytes; args->converter->invalidCharLength = (int8_t)i; } goto donefornow; } } /* Remove the acummulated high bits */ ch -= offsetsFromUTF8[inBytes]; if (i == inBytes && ch <= MAXIMUM_UTF) { /* 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 */ *(myOffsets++) = offsetNum; ch -= HALF_BASE; *(myTarget++) = (UChar) ((ch >> HALF_SHIFT) + SURROGATE_HIGH_START); 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 { UBool useOffset; args->source = (const char *) mySource; args->target = myTarget; args->offsets = myOffsets; args->converter->invalidCharLength = (int8_t)i; if (T_UConverter_toUnicode_InvalidChar_OffsetCallback(args, offsetNum, err)) { /* Stop if the error wasn't handled */ break; } args->converter->invalidCharLength = 0; mySource = (unsigned char *) args->source; myTarget = args->target; useOffset = (UBool)(myOffsets != args->offsets); myOffsets = args->offsets; offsetNum += i; if (invalidTailChar) { /* Treat the tail as ASCII*/ if (myTarget < targetLimit) { *(myTarget++) = (UChar) ch2; *myOffsets = offsetNum++; if (useOffset) { /* Increment when the target was consumed */ myOffsets++; } invalidTailChar = FALSE; } else { /* Put in overflow buffer (not handled here) */ args->converter->UCharErrorBuffer[0] = (UChar) ch2; args->converter->UCharErrorBufferLength = 1; *err = U_BUFFER_OVERFLOW_ERROR; break; } } } } } donefornow: if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { /* End of target buffer */ *err = U_BUFFER_OVERFLOW_ERROR; } args->target = myTarget; args->source = (const char *) mySource; args->offsets = myOffsets; } U_CFUNC void T_UConverter_fromUnicode_UTF8 (UConverterFromUnicodeArgs * args, UErrorCode * err) { 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; uint32_t ch, ch2; int16_t indexToWrite; char temp[4]; if (args->converter->fromUnicodeStatus && myTarget < targetLimit) { ch = args->converter->fromUnicodeStatus; args->converter->fromUnicodeStatus = 0; goto lowsurogate; } 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 { args->converter->charErrorBuffer[0] = (char) ((ch & 0x3f) | 0x80); args->converter->charErrorBufferLength = 1; *err = U_BUFFER_OVERFLOW_ERROR; } } else /* Check for surogates */ { if ((ch >= SURROGATE_HIGH_START) && (ch <= SURROGATE_HIGH_END)) { lowsurogate: if (mySource < sourceLimit) { ch2 = *mySource; if ((ch2 >= SURROGATE_LOW_START) && (ch2 <= SURROGATE_LOW_END)) { /* If there were two surrogates, combine them otherwise treat them normally */ ch = ((ch - SURROGATE_HIGH_START) << HALF_SHIFT) + ch2 + SURROGATE_LOW_BASE; mySource++; } } else if (!args->flush) { args->converter->fromUnicodeStatus = ch; break; } } 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 { args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = temp[indexToWrite]; *err = U_BUFFER_OVERFLOW_ERROR; } } } } if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { *err = U_BUFFER_OVERFLOW_ERROR; } args->target = (char *) myTarget; args->source = mySource; } U_CFUNC void T_UConverter_fromUnicode_UTF8_OFFSETS_LOGIC (UConverterFromUnicodeArgs * args, UErrorCode * err) { 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; uint32_t ch, ch2; int32_t offsetNum = 0; int16_t indexToWrite; char temp[4]; if (args->converter->fromUnicodeStatus && myTarget < targetLimit) { ch = args->converter->fromUnicodeStatus; args->converter->fromUnicodeStatus = 0; goto lowsurogate; } 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 { args->converter->charErrorBuffer[0] = (char) ((ch & 0x3f) | 0x80); args->converter->charErrorBufferLength = 1; *err = U_BUFFER_OVERFLOW_ERROR; } } else /* Check for surogates */ { if ((ch >= SURROGATE_HIGH_START) && (ch <= SURROGATE_HIGH_END)) { lowsurogate: if (mySource < sourceLimit) { ch2 = *mySource; if ((ch2 >= SURROGATE_LOW_START) && (ch2 <= SURROGATE_LOW_END)) { /* If there were two surrogates, combine them otherwise treat them normally */ ch = ((ch - SURROGATE_HIGH_START) << HALF_SHIFT) + ch2 + SURROGATE_LOW_BASE; mySource++; } } else if (!args->flush) { args->converter->fromUnicodeStatus = ch; break; } } 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 { args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = temp[indexToWrite]; *err = U_BUFFER_OVERFLOW_ERROR; } } offsetNum += (ch >= 0x10000) + 1; } } if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { *err = U_BUFFER_OVERFLOW_ERROR; } args->target = (char *) myTarget; args->source = mySource; } U_CFUNC UChar32 T_UConverter_getNextUChar_UTF8(UConverterToUnicodeArgs *args, UErrorCode *err) { UChar buffer[2]; char const *sourceInitial; UChar* myUCharPtr; uint16_t extraBytesToWrite; uint8_t myByte; UChar32 ch; int8_t isLegalSequence; 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) { goto CALL_ERROR_FUNCTION; } /*The byte sequence is longer than the buffer area passed*/ if ((args->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 = (uint8_t)*(args->source++)); ch <<= 6; if ((myByte & 0xC0) != 0x80) { isLegalSequence = 0; break; } case 5: ch += (myByte = *(args->source++)); ch <<= 6; if ((myByte & 0xC0) != 0x80) { isLegalSequence = 0; break; } case 4: ch += (myByte = *(args->source++)); ch <<= 6; if ((myByte & 0xC0) != 0x80) { isLegalSequence = 0; break; } case 3: ch += (myByte = *(args->source++)); ch <<= 6; if ((myByte & 0xC0) != 0x80) { isLegalSequence = 0; break; } case 2: ch += (myByte = *(args->source++)); if ((myByte & 0xC0) != 0x80) { isLegalSequence = 0; } }; } ch -= offsetsFromUTF8[extraBytesToWrite]; if (isLegalSequence && extraBytesToWrite <= 4 && ch <= 0x10ffff) { return ch; /* return the code point */ } 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; } 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 }; /* Todo: verify that UTF-8 == (ccsid (ibm-codepage) 1208) for unicode version 2.0 and 3.0 */ const UConverterStaticData _UTF8StaticData={ sizeof(UConverterStaticData), "UTF8", 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 }; /* UTF-16 Platform Endian --------------------------------------------------- */ U_CFUNC void _UTF16PEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode) { UConverter *cnv = pArgs->converter; const uint8_t *source = (const uint8_t *)pArgs->source; UChar *target = pArgs->target; int32_t *offsets = pArgs->offsets; int32_t targetCapacity = pArgs->targetLimit - pArgs->target; int32_t length = (const uint8_t *)pArgs->sourceLimit - source; int32_t count; int32_t sourceIndex = 0; if(length <= 0) { /* no input, nothing to do */ return; } if(targetCapacity <= 0) { *pErrorCode=U_BUFFER_OVERFLOW_ERROR; return; } /* complete a partial UChar from the last call */ if(cnv->toUnicodeStatus != 0) { /* * copy the byte from the last call and the first one here into the target, * byte-wise to keep the platform endianness */ uint8_t *p = (uint8_t *)target++; *p++ = (uint8_t)cnv->toUnicodeStatus; cnv->toUnicodeStatus = 0; *p = *source++; --length; --targetCapacity; if(offsets != NULL) { *offsets++ = -1; } } /* copy an even number of bytes for complete UChars */ count = 2 * targetCapacity; if(count > length) { count = length & ~1; } if(count > 0) { uprv_memcpy(target, source, count); source += count; length -= count; count >>= 1; target += count; targetCapacity -= count; if(offsets != NULL) { while(count > 0) { *offsets++ = sourceIndex; sourceIndex += 2; --count; } } } /* check for a remaining source byte and store the status */ if(length >= 2) { /* it must be targetCapacity==0 because otherwise the above would have copied more */ *pErrorCode = U_BUFFER_OVERFLOW_ERROR; } else if(length == 1) { if(pArgs->flush) { /* a UChar remains incomplete */ *pErrorCode = U_TRUNCATED_CHAR_FOUND; } else { /* consume the last byte and store it, making sure that it will never set the status to 0 */ cnv->toUnicodeStatus = *source++ | 0x100; } /* } else length==0 { nothing to do */ } /* write back the updated pointers */ pArgs->source = (const char *)source; pArgs->target = target; pArgs->offsets = offsets; } U_CFUNC void _UTF16PEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, UErrorCode *pErrorCode) { UConverter *cnv = pArgs->converter; const UChar *source = pArgs->source; uint8_t *target = (uint8_t *)pArgs->target; int32_t *offsets = pArgs->offsets; int32_t targetCapacity = pArgs->targetLimit - pArgs->target; int32_t length = pArgs->sourceLimit - source; int32_t count; int32_t sourceIndex = 0; if(length <= 0 && cnv->fromUnicodeStatus == 0) { /* no input, nothing to do */ return; } if(targetCapacity <= 0) { *pErrorCode = U_BUFFER_OVERFLOW_ERROR; return; } /* complete a partial UChar from the last call */ if(cnv->fromUnicodeStatus != 0) { *target++ = (uint8_t)cnv->fromUnicodeStatus; cnv->fromUnicodeStatus = 0; --targetCapacity; if(offsets != NULL) { *offsets++ = -1; } } /* copy an even number of bytes for complete UChars */ count = 2 * length; if(count > targetCapacity) { count = targetCapacity & ~1; } if(count>0) { uprv_memcpy(target, source, count); target += count; targetCapacity -= count; count >>= 1; source += count; length -= count; if(offsets != NULL) { while(count > 0) { *offsets++ = sourceIndex; *offsets++ = sourceIndex++; --count; } } } if(length > 0) { /* it must be targetCapacity<=1 because otherwise the above would have copied more */ *pErrorCode = U_BUFFER_OVERFLOW_ERROR; if(targetCapacity > 0) /* targetCapacity==1 */ { /* copy one byte and keep the other in the status */ const uint8_t *p = (const uint8_t *)source++; *target++ = *p++; cnv->fromUnicodeStatus = *p | 0x100; if(offsets != NULL) { *offsets++ = sourceIndex; } } } /* write back the updated pointers */ pArgs->source = source; pArgs->target = (char *)target; pArgs->offsets = offsets; } /* UTF-16 Opposite Endian --------------------------------------------------- */ /* * For opposite-endian UTF-16, we keep a byte pointer to the UChars * and copy two bytes at a time and reverse them. */ U_CFUNC void _UTF16OEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode) { UConverter *cnv = pArgs->converter; const uint8_t *source = (const uint8_t *)pArgs->source; UChar *target = pArgs->target; uint8_t *target8 = (uint8_t *)target; /* byte pointer to the target */ int32_t *offsets = pArgs->offsets; int32_t targetCapacity = pArgs->targetLimit - pArgs->target; int32_t length = (const uint8_t *)pArgs->sourceLimit - source; int32_t count; int32_t sourceIndex = 0; if(length <= 0) { /* no input, nothing to do */ return; } if(targetCapacity <= 0) { *pErrorCode = U_BUFFER_OVERFLOW_ERROR; return; } /* complete a partial UChar from the last call */ if(cnv->toUnicodeStatus != 0) { /* * copy the byte from the last call and the first one here into the target, * byte-wise, reversing the platform endianness */ *target8++ = *source++; *target8++ = (uint8_t)cnv->toUnicodeStatus; cnv->toUnicodeStatus = 0; ++target; --length; --targetCapacity; if(offsets != NULL) { *offsets++ = -1; } } /* copy an even number of bytes for complete UChars */ count = 2 * targetCapacity; if(count > length) { count = length & ~1; } if(count>0) { length -= count; count >>= 1; targetCapacity -= count; if(offsets == NULL) { while(count > 0) { target8[1] = *source++; target8[0] = *source++; target8 += 2; --count; } } else { while(count>0) { target8[1] = *source++; target8[0] = *source++; target8 += 2; *offsets++ = sourceIndex; sourceIndex += 2; --count; } } target=(UChar *)target8; } /* check for a remaining source byte and store the status */ if(length >= 2) { /* it must be targetCapacity==0 because otherwise the above would have copied more */ *pErrorCode = U_BUFFER_OVERFLOW_ERROR; } else if(length == 1) { if(pArgs->flush) { /* a UChar remains incomplete */ *pErrorCode = U_TRUNCATED_CHAR_FOUND; } else { /* consume the last byte and store it, making sure that it will never set the status to 0 */ cnv->toUnicodeStatus = *source++ | 0x100; } /* } else length==0 { nothing to do */ } /* write back the updated pointers */ pArgs->source = (const char *)source; pArgs->target = target; pArgs->offsets = offsets; } U_CFUNC void _UTF16OEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, UErrorCode *pErrorCode) { UConverter *cnv = pArgs->converter; const UChar *source = pArgs->source; const uint8_t *source8 = (const uint8_t *)source; /* byte pointer to the source */ uint8_t *target = (uint8_t *)pArgs->target; int32_t *offsets = pArgs->offsets; int32_t targetCapacity = pArgs->targetLimit - pArgs->target; int32_t length = pArgs->sourceLimit - source; int32_t count; int32_t sourceIndex = 0; if(length <= 0 && cnv->fromUnicodeStatus == 0) { /* no input, nothing to do */ return; } if(targetCapacity <= 0) { *pErrorCode = U_BUFFER_OVERFLOW_ERROR; return; } /* complete a partial UChar from the last call */ if(cnv->fromUnicodeStatus != 0) { *target++ = (uint8_t)cnv->fromUnicodeStatus; cnv->fromUnicodeStatus = 0; --targetCapacity; if(offsets != NULL) { *offsets++ = -1; } } /* copy an even number of bytes for complete UChars */ count = 2 * length; if(count > targetCapacity) { count = targetCapacity & ~1; } if(count > 0) { targetCapacity -= count; count >>= 1; length -= count; if(offsets == NULL) { while(count > 0) { target[1] = *source8++; target[0] = *source8++; target += 2; --count; } } else { while(count>0) { target[1] = *source8++; target[0] = *source8++; target += 2; *offsets++ = sourceIndex; *offsets++ = sourceIndex++; --count; } } source=(const UChar *)source8; } if(length > 0) { /* it must be targetCapacity<=1 because otherwise the above would have copied more */ *pErrorCode = U_BUFFER_OVERFLOW_ERROR; if(targetCapacity > 0) /* targetCapacity==1 */ { /* copy one byte and keep the other in the status */ cnv->fromUnicodeStatus = *source8++ | 0x100; *target++ = *source8; ++source; if(offsets != NULL) { *offsets++ = sourceIndex; } } } /* write back the updated pointers */ pArgs->source = source; pArgs->target = (char *)target; pArgs->offsets = offsets; } /* UTF-16BE ----------------------------------------------------------------- */ U_CFUNC UChar32 T_UConverter_getNextUChar_UTF16_BE(UConverterToUnicodeArgs* args, UErrorCode* err) { UChar32 myUChar; uint16_t first; /*Checks boundaries and set appropriate error codes*/ if (args->source+2 > args->sourceLimit) { if (args->source >= args->sourceLimit) { /*Either caller has reached the end of the byte stream*/ *err = U_INDEX_OUTOFBOUNDS_ERROR; } else { /* a character was cut in half*/ *err = U_TRUNCATED_CHAR_FOUND; } return 0xffff; } /*Gets the corresponding codepoint*/ first = (uint16_t)(((uint16_t)(*(args->source)) << 8) |((uint8_t)*((args->source)+1))); myUChar = first; args->source += 2; if(UTF_IS_FIRST_SURROGATE(first)) { uint16_t second; if (args->source+2 > args->sourceLimit) { *err = U_TRUNCATED_CHAR_FOUND; return 0xffff; } /* get the second surrogate and assemble the code point */ second = (uint16_t)(((uint16_t)(*(args->source)) << 8) |((uint8_t)*(args->source+1))); /* ignore unmatched surrogates and just deliver the first one in such a case */ if(UTF_IS_SECOND_SURROGATE(second)) { /* matched pair, get pair value */ myUChar = UTF16_GET_PAIR_VALUE(first, second); args->source += 2; } } return myUChar; } static const UConverterImpl _UTF16BEImpl={ UCNV_UTF16_BigEndian, NULL, NULL, NULL, NULL, NULL, #if U_IS_BIG_ENDIAN _UTF16PEToUnicodeWithOffsets, _UTF16PEToUnicodeWithOffsets, _UTF16PEFromUnicodeWithOffsets, _UTF16PEFromUnicodeWithOffsets, #else _UTF16OEToUnicodeWithOffsets, _UTF16OEToUnicodeWithOffsets, _UTF16OEFromUnicodeWithOffsets, _UTF16OEFromUnicodeWithOffsets, #endif T_UConverter_getNextUChar_UTF16_BE, NULL, NULL }; /* Todo: verify that UTF-16BE == (ccsid (ibm-codepage) 1200) for unicode version 2.0 and 3.0 */ const UConverterStaticData _UTF16BEStaticData={ sizeof(UConverterStaticData), "UTF16_BigEndian", 1200, UCNV_IBM, UCNV_UTF16_BigEndian, 2, 2, { 0xff, 0xfd, 0, 0 },2,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 _UTF16BEData={ sizeof(UConverterSharedData), ~((uint32_t) 0), NULL, NULL, &_UTF16BEStaticData, FALSE, &_UTF16BEImpl, 0 }; /* UTF-16LE ----------------------------------------------------------------- */ U_CFUNC UChar32 T_UConverter_getNextUChar_UTF16_LE(UConverterToUnicodeArgs* args, UErrorCode* err) { UChar32 myUChar; uint16_t first; /*Checks boundaries and set appropriate error codes*/ if (args->source+2 > args->sourceLimit) { if (args->source >= args->sourceLimit) { /*Either caller has reached the end of the byte stream*/ *err = U_INDEX_OUTOFBOUNDS_ERROR; } else { /* a character was cut in half*/ *err = U_TRUNCATED_CHAR_FOUND; } return 0xffff; } /*Gets the corresponding codepoint*/ first = (uint16_t)(((uint16_t)*((args->source)+1) << 8) | ((uint8_t)(*(args->source)))); myUChar=first; /*updates the source*/ args->source += 2; if (UTF_IS_FIRST_SURROGATE(first)) { uint16_t second; if (args->source+2 > args->sourceLimit) { *err = U_TRUNCATED_CHAR_FOUND; return 0xffff; } /* get the second surrogate and assemble the code point */ second = (uint16_t)(((uint16_t)*(args->source+1) << 8) |((uint8_t)(*(args->source)))); /* ignore unmatched surrogates and just deliver the first one in such a case */ if(UTF_IS_SECOND_SURROGATE(second)) { /* matched pair, get pair value */ myUChar = UTF16_GET_PAIR_VALUE(first, second); args->source += 2; } } return myUChar; } static const UConverterImpl _UTF16LEImpl={ UCNV_UTF16_LittleEndian, NULL, NULL, NULL, NULL, NULL, #if !U_IS_BIG_ENDIAN _UTF16PEToUnicodeWithOffsets, _UTF16PEToUnicodeWithOffsets, _UTF16PEFromUnicodeWithOffsets, _UTF16PEFromUnicodeWithOffsets, #else _UTF16OEToUnicodeWithOffsets, _UTF16OEToUnicodeWithOffsets, _UTF16OEFromUnicodeWithOffsets, _UTF16OEFromUnicodeWithOffsets, #endif T_UConverter_getNextUChar_UTF16_LE, NULL, NULL }; /* Todo: verify that UTF-16LE == (ccsid (ibm-codepage) 1200) for unicode version 2.0 and 3.0 */ const UConverterStaticData _UTF16LEStaticData={ sizeof(UConverterStaticData), "UTF16_LittleEndian", 1200, UCNV_IBM, UCNV_UTF16_LittleEndian, 2, 2, { 0xfd, 0xff, 0, 0 },2,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 _UTF16LEData={ sizeof(UConverterSharedData), ~((uint32_t) 0), NULL, NULL, &_UTF16LEStaticData, FALSE, &_UTF16LEImpl, 0 }; /* UTF-32BE ----------------------------------------------------------------- */ U_CFUNC void T_UConverter_toUnicode_UTF32_BE(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; uint32_t ch, i; /* UTF-8 returns here for only non-offset, this needs to change.*/ if (args->converter->toUnicodeStatus && myTarget < targetLimit) { i = args->converter->toULength; /* restore # of bytes consumed */ ch = args->converter->toUnicodeStatus - 1;/*Stores the previously calculated ch from a previous call*/ args->converter->toUnicodeStatus = 0; goto morebytes; } while (mySource < sourceLimit && myTarget < targetLimit) { i = 0; ch = 0; morebytes: while (i < sizeof(uint32_t)) { if (mySource < sourceLimit) { ch = (ch << 8) | (uint8_t)(*mySource); toUBytes[i++] = (char) *(mySource++); } else { if (args->flush) { if (U_SUCCESS(*err)) { *err = U_TRUNCATED_CHAR_FOUND; args->converter->toUnicodeStatus = MAXIMUM_UCS4; } } else { /* stores a partially calculated target*/ /* + 1 to make 0 a valid character */ args->converter->toUnicodeStatus = ch + 1; args->converter->toULength = (int8_t) i; } goto donefornow; } } if (ch <= MAXIMUM_UTF) { /* 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->invalidCharLength = (int8_t)i; if (T_UConverter_toUnicode_InvalidChar_Callback(args, err)) { /* Stop if the error wasn't handled */ break; } args->converter->invalidCharLength = 0; mySource = (unsigned char *) args->source; myTarget = args->target; } } 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_UTF32_BE_OFFSET_LOGIC(UConverterToUnicodeArgs * args, UErrorCode * err) { const unsigned char *mySource = (unsigned char *) args->source; UChar *myTarget = args->target; int32_t *myOffsets = args->offsets; const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit; const UChar *targetLimit = args->targetLimit; unsigned char *toUBytes = args->converter->toUBytes; uint32_t ch, i; int32_t offsetNum = 0; if (args->converter->toUnicodeStatus && myTarget < targetLimit) { i = args->converter->toULength; /* restore # of bytes consumed */ ch = args->converter->toUnicodeStatus - 1;/*Stores the previously calculated ch from a previous call*/ args->converter->toUnicodeStatus = 0; goto morebytes; } while (mySource < sourceLimit && myTarget < targetLimit) { i = 0; ch = 0; morebytes: while (i < sizeof(uint32_t)) { if (mySource < sourceLimit) { ch = (ch << 8) | (uint8_t)(*mySource); toUBytes[i++] = (char) *(mySource++); } else { if (args->flush) { if (U_SUCCESS(*err)) { *err = U_TRUNCATED_CHAR_FOUND; args->converter->toUnicodeStatus = MAXIMUM_UCS4; } } else { /* stores a partially calculated target*/ /* + 1 to make 0 a valid character */ args->converter->toUnicodeStatus = ch + 1; args->converter->toULength = (int8_t) i; } goto donefornow; } } if (ch <= MAXIMUM_UTF) { /* 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 { /* 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->invalidCharLength = (int8_t)i; args->offsets = myOffsets; if (T_UConverter_toUnicode_InvalidChar_OffsetCallback(args, offsetNum, err)) { /* Stop if the error wasn't handled */ break; } args->converter->invalidCharLength = 0; mySource = (unsigned char *) args->source; myTarget = args->target; myOffsets = args->offsets; } offsetNum += i; } 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_fromUnicode_UTF32_BE(UConverterFromUnicodeArgs * args, UErrorCode * err) { 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; UChar32 ch, ch2; unsigned int indexToWrite; unsigned char temp[sizeof(uint32_t)]; temp[0] = 0; if (args->converter->fromUnicodeStatus) { ch = args->converter->fromUnicodeStatus; args->converter->fromUnicodeStatus = 0; goto lowsurogate; } while (mySource < sourceLimit && myTarget < targetLimit) { ch = *(mySource++); if (SURROGATE_HIGH_START <= ch && ch < SURROGATE_LOW_START) { lowsurogate: if (mySource < sourceLimit) { ch2 = *mySource; if (SURROGATE_LOW_START <= ch2 && ch2 <= SURROGATE_LOW_END) { ch = ((ch - SURROGATE_HIGH_START) << HALF_SHIFT) + ch2 + SURROGATE_LOW_BASE; mySource++; } } else if (!args->flush) { /* ran out of source */ args->converter->fromUnicodeStatus = ch; break; } } /* We cannot get any larger than 10FFFF because we are coming from UTF-16 */ temp[1] = (uint8_t) (ch >> 16 & 0x1F); temp[2] = (uint8_t) (ch >> 8); /* unsigned cast implicitly does (ch & FF) */ temp[3] = (uint8_t) (ch); /* unsigned cast implicitly does (ch & FF) */ for (indexToWrite = 0; indexToWrite <= sizeof(uint32_t) - 1; indexToWrite++) { if (myTarget < targetLimit) { *(myTarget++) = temp[indexToWrite]; } else { args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = temp[indexToWrite]; *err = U_BUFFER_OVERFLOW_ERROR; } } } if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { *err = U_BUFFER_OVERFLOW_ERROR; } args->target = (char *) myTarget; args->source = mySource; } U_CFUNC void T_UConverter_fromUnicode_UTF32_BE_OFFSET_LOGIC(UConverterFromUnicodeArgs * args, UErrorCode * err) { 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; UChar32 ch, ch2; int32_t offsetNum = 0; unsigned int indexToWrite; unsigned char temp[sizeof(uint32_t)]; temp[0] = 0; if (args->converter->fromUnicodeStatus) { ch = args->converter->fromUnicodeStatus; args->converter->fromUnicodeStatus = 0; goto lowsurogate; } while (mySource < sourceLimit && myTarget < targetLimit) { ch = *(mySource++); if (SURROGATE_HIGH_START <= ch && ch < SURROGATE_LOW_START) { lowsurogate: if (mySource < sourceLimit) { ch2 = *mySource; if (SURROGATE_LOW_START <= ch2 && ch2 <= SURROGATE_LOW_END) { ch = ((ch - SURROGATE_HIGH_START) << HALF_SHIFT) + ch2 + SURROGATE_LOW_BASE; mySource++; } } else if (!args->flush) { /* ran out of source */ args->converter->fromUnicodeStatus = ch; break; } } /* We cannot get any larger than 10FFFF because we are coming from UTF-16 */ temp[1] = (uint8_t) (ch >> 16 & 0x1F); temp[2] = (uint8_t) (ch >> 8); /* unsigned cast implicitly does (ch & FF) */ temp[3] = (uint8_t) (ch); /* unsigned cast implicitly does (ch & FF) */ for (indexToWrite = 0; indexToWrite <= sizeof(uint32_t) - 1; indexToWrite++) { if (myTarget < targetLimit) { *(myTarget++) = temp[indexToWrite]; *(myOffsets++) = offsetNum; } else { args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = temp[indexToWrite]; *err = U_BUFFER_OVERFLOW_ERROR; } } offsetNum++; } if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { *err = U_BUFFER_OVERFLOW_ERROR; } args->target = (char *) myTarget; args->source = mySource; } U_CFUNC UChar32 T_UConverter_getNextUChar_UTF32_BE(UConverterToUnicodeArgs* args, UErrorCode* err) { UChar myUCharBuf[2]; UChar *myUCharPtr; const unsigned char *mySource; UChar32 myUChar; int32_t length; while (args->source < args->sourceLimit) { if (args->source + 4 > args->sourceLimit) { /* got a partial character */ *err = U_TRUNCATED_CHAR_FOUND; return 0xffff; } /* Don't even try to do a direct cast because the value may be on an odd address. */ mySource = (unsigned char *) args->source; myUChar = (mySource[0] << 24) | (mySource[1] << 16) | (mySource[2] << 8) | (mySource[3]); args->source = (const char *)(mySource + 4); if (myUChar <= MAXIMUM_UTF && myUChar >= 0) { return myUChar; } uprv_memcpy(args->converter->invalidCharBuffer, mySource, 4); args->converter->invalidCharLength = 4; myUCharPtr = myUCharBuf; *err = U_ILLEGAL_CHAR_FOUND; args->target = myUCharPtr; args->targetLimit = myUCharBuf + 2; args->converter->fromCharErrorBehaviour(args->converter->toUContext, args, (const char *)mySource, 4, UCNV_ILLEGAL, err); if(U_SUCCESS(*err)) { length = (uint16_t)(args->target - myUCharBuf); if(length > 0) { return ucnv_getUChar32KeepOverflow(args->converter, myUCharBuf, length); } /* else (callback did not write anything) continue */ } else if(*err == U_BUFFER_OVERFLOW_ERROR) { *err = U_ZERO_ERROR; return ucnv_getUChar32KeepOverflow(args->converter, myUCharBuf, 2); } else { /* break on error */ /* ### what if a callback set an error but _also_ generated output?! */ return 0xffff; } } /* no input or only skipping callbacks */ *err = U_INDEX_OUTOFBOUNDS_ERROR; return 0xffff; } static const UConverterImpl _UTF32BEImpl = { UCNV_UTF32_BigEndian, NULL, NULL, NULL, NULL, NULL, T_UConverter_toUnicode_UTF32_BE, T_UConverter_toUnicode_UTF32_BE_OFFSET_LOGIC, T_UConverter_fromUnicode_UTF32_BE, T_UConverter_fromUnicode_UTF32_BE_OFFSET_LOGIC, T_UConverter_getNextUChar_UTF32_BE, NULL, NULL }; const UConverterStaticData _UTF32BEStaticData = { sizeof(UConverterStaticData), "UTF32_BigEndian", 0, /* TODO: Change this number to the UTF-32 CCSID which currently does not exist */ UCNV_IBM, UCNV_UTF32_BigEndian, 4, 4, { 0, 0, 0xff, 0xfd }, 4, 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 _UTF32BEData = { sizeof(UConverterSharedData), ~((uint32_t) 0), NULL, NULL, &_UTF32BEStaticData, FALSE, &_UTF32BEImpl, 0 }; /* UTF-32LE ---------------------------------------------------------- */ U_CFUNC void T_UConverter_toUnicode_UTF32_LE(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; uint32_t ch, i; /* UTF-8 returns here for only non-offset, this needs to change.*/ if (args->converter->toUnicodeStatus && myTarget < targetLimit) { i = args->converter->toULength; /* restore # of bytes consumed */ /* Stores the previously calculated ch from a previous call*/ ch = args->converter->toUnicodeStatus - 1; args->converter->toUnicodeStatus = 0; goto morebytes; } while (mySource < sourceLimit && myTarget < targetLimit) { i = 0; ch = 0; morebytes: while (i < sizeof(uint32_t)) { if (mySource < sourceLimit) { ch |= ((uint8_t)(*mySource)) << (i * 8); toUBytes[i++] = (char) *(mySource++); } else { if (args->flush) { if (U_SUCCESS(*err)) { *err = U_TRUNCATED_CHAR_FOUND; args->converter->toUnicodeStatus = 0; } } else { /* stores a partially calculated target*/ /* + 1 to make 0 a valid character */ args->converter->toUnicodeStatus = ch + 1; args->converter->toULength = (int8_t) i; } goto donefornow; } } if (ch <= MAXIMUM_UTF) { /* 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->invalidCharLength = (int8_t)i; if (T_UConverter_toUnicode_InvalidChar_Callback(args, err)) { /* Stop if the error wasn't handled */ break; } args->converter->invalidCharLength = 0; mySource = (unsigned char *) args->source; myTarget = args->target; } } 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_UTF32_LE_OFFSET_LOGIC(UConverterToUnicodeArgs * args, UErrorCode * err) { const unsigned char *mySource = (unsigned char *) args->source; UChar *myTarget = args->target; int32_t *myOffsets = args->offsets; const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit; const UChar *targetLimit = args->targetLimit; unsigned char *toUBytes = args->converter->toUBytes; uint32_t ch, i; int32_t offsetNum = 0; /* UTF-8 returns here for only non-offset, this needs to change.*/ if (args->converter->toUnicodeStatus && myTarget < targetLimit) { i = args->converter->toULength; /* restore # of bytes consumed */ /* Stores the previously calculated ch from a previous call*/ ch = args->converter->toUnicodeStatus - 1; args->converter->toUnicodeStatus = 0; goto morebytes; } while (mySource < sourceLimit && myTarget < targetLimit) { i = 0; ch = 0; morebytes: while (i < sizeof(uint32_t)) { if (mySource < sourceLimit) { ch |= ((uint8_t)(*mySource)) << (i * 8); toUBytes[i++] = (char) *(mySource++); } else { if (args->flush) { if (U_SUCCESS(*err)) { *err = U_TRUNCATED_CHAR_FOUND; args->converter->toUnicodeStatus = 0; } } else { /* stores a partially calculated target*/ /* + 1 to make 0 a valid character */ args->converter->toUnicodeStatus = ch + 1; args->converter->toULength = (int8_t) i; } goto donefornow; } } if (ch <= MAXIMUM_UTF) { /* 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); ch = (ch & HALF_MASK) + SURROGATE_LOW_START; if (myTarget < targetLimit) { *(myTarget++) = (UChar)ch; *(myOffsets++) = offsetNum; } 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->invalidCharLength = (int8_t)i; args->offsets = myOffsets; if (T_UConverter_toUnicode_InvalidChar_OffsetCallback(args, offsetNum, err)) { /* Stop if the error wasn't handled */ break; } args->converter->invalidCharLength = 0; mySource = (unsigned char *) args->source; myTarget = args->target; myOffsets = args->offsets; } offsetNum += i; } 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_fromUnicode_UTF32_LE(UConverterFromUnicodeArgs * args, UErrorCode * err) { 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; UChar32 ch, ch2; unsigned int indexToWrite; unsigned char temp[sizeof(uint32_t)]; temp[3] = 0; if (args->converter->fromUnicodeStatus) { ch = args->converter->fromUnicodeStatus; args->converter->fromUnicodeStatus = 0; goto lowsurogate; } while (mySource < sourceLimit && myTarget < targetLimit) { ch = *(mySource++); if (SURROGATE_HIGH_START <= ch && ch < SURROGATE_LOW_START) { lowsurogate: if (mySource < sourceLimit) { ch2 = *mySource; if (SURROGATE_LOW_START <= ch2 && ch2 <= SURROGATE_LOW_END) { ch = ((ch - SURROGATE_HIGH_START) << HALF_SHIFT) + ch2 + SURROGATE_LOW_BASE; mySource++; } } else if (!args->flush) { /* ran out of source */ args->converter->fromUnicodeStatus = ch; break; } } /* We cannot get any larger than 10FFFF because we are coming from UTF-16 */ temp[2] = (uint8_t) (ch >> 16 & 0x1F); temp[1] = (uint8_t) (ch >> 8); /* unsigned cast implicitly does (ch & FF) */ temp[0] = (uint8_t) (ch); /* unsigned cast implicitly does (ch & FF) */ for (indexToWrite = 0; indexToWrite <= sizeof(uint32_t) - 1; indexToWrite++) { if (myTarget < targetLimit) { *(myTarget++) = temp[indexToWrite]; } else { args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = temp[indexToWrite]; *err = U_BUFFER_OVERFLOW_ERROR; } } } if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { *err = U_BUFFER_OVERFLOW_ERROR; } args->target = (char *) myTarget; args->source = mySource; } U_CFUNC void T_UConverter_fromUnicode_UTF32_LE_OFFSET_LOGIC(UConverterFromUnicodeArgs * args, UErrorCode * err) { 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; UChar32 ch, ch2; unsigned int indexToWrite; unsigned char temp[sizeof(uint32_t)]; int32_t offsetNum = 0; temp[3] = 0; if (args->converter->fromUnicodeStatus) { ch = args->converter->fromUnicodeStatus; args->converter->fromUnicodeStatus = 0; goto lowsurogate; } while (mySource < sourceLimit && myTarget < targetLimit) { ch = *(mySource++); if (SURROGATE_HIGH_START <= ch && ch < SURROGATE_LOW_START) { lowsurogate: if (mySource < sourceLimit) { ch2 = *mySource; if (SURROGATE_LOW_START <= ch2 && ch2 <= SURROGATE_LOW_END) { ch = ((ch - SURROGATE_HIGH_START) << HALF_SHIFT) + ch2 + SURROGATE_LOW_BASE; mySource++; } } else if (!args->flush) { /* ran out of source */ args->converter->fromUnicodeStatus = ch; break; } } /* We cannot get any larger than 10FFFF because we are coming from UTF-16 */ temp[2] = (uint8_t) (ch >> 16 & 0x1F); temp[1] = (uint8_t) (ch >> 8); /* unsigned cast implicitly does (ch & FF) */ temp[0] = (uint8_t) (ch); /* unsigned cast implicitly does (ch & FF) */ for (indexToWrite = 0; indexToWrite <= sizeof(uint32_t) - 1; indexToWrite++) { if (myTarget < targetLimit) { *(myTarget++) = temp[indexToWrite]; *(myOffsets++) = offsetNum; } else { args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = temp[indexToWrite]; *err = U_BUFFER_OVERFLOW_ERROR; } } offsetNum++; } if (mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS(*err)) { *err = U_BUFFER_OVERFLOW_ERROR; } args->target = (char *) myTarget; args->source = mySource; } U_CFUNC UChar32 T_UConverter_getNextUChar_UTF32_LE(UConverterToUnicodeArgs* args, UErrorCode* err) { UChar myUCharBuf[2]; UChar *myUCharPtr; const unsigned char *mySource; UChar32 myUChar; int32_t length; while (args->source < args->sourceLimit) { if (args->source + 4 > args->sourceLimit) { /* got a partial character */ *err = U_TRUNCATED_CHAR_FOUND; return 0xffff; } /* Don't even try to do a direct cast because the value may be on an odd address. */ mySource = (unsigned char *) args->source; myUChar = (mySource[0]) | (mySource[1] << 8) | (mySource[2] << 16) | (mySource[3] << 24); args->source = (const char *)(mySource + 4); if (myUChar <= MAXIMUM_UTF && myUChar >= 0) { return myUChar; } uprv_memcpy(args->converter->invalidCharBuffer, mySource, 4); args->converter->invalidCharLength = 4; myUCharPtr = myUCharBuf; *err = U_ILLEGAL_CHAR_FOUND; args->target = myUCharPtr; args->targetLimit = myUCharBuf + 2; args->converter->fromCharErrorBehaviour(args->converter->toUContext, args, (const char *)mySource, 4, UCNV_ILLEGAL, err); if(U_SUCCESS(*err)) { length = (uint16_t)(args->target - myUCharBuf); if(length > 0) { return ucnv_getUChar32KeepOverflow(args->converter, myUCharBuf, length); } /* else (callback did not write anything) continue */ } else if(*err == U_BUFFER_OVERFLOW_ERROR) { *err = U_ZERO_ERROR; return ucnv_getUChar32KeepOverflow(args->converter, myUCharBuf, 2); } else { /* break on error */ /* ### what if a callback set an error but _also_ generated output?! */ return 0xffff; } } /* no input or only skipping callbacks */ *err = U_INDEX_OUTOFBOUNDS_ERROR; return 0xffff; } static const UConverterImpl _UTF32LEImpl = { UCNV_UTF32_LittleEndian, NULL, NULL, NULL, NULL, NULL, T_UConverter_toUnicode_UTF32_LE, T_UConverter_toUnicode_UTF32_LE_OFFSET_LOGIC, T_UConverter_fromUnicode_UTF32_LE, T_UConverter_fromUnicode_UTF32_LE_OFFSET_LOGIC, T_UConverter_getNextUChar_UTF32_LE, NULL, NULL }; const UConverterStaticData _UTF32LEStaticData = { sizeof(UConverterStaticData), "UTF32_LittleEndian", 0, /* TODO: Change this number to the UTF-32 CCSID which currently does not exist */ UCNV_IBM, UCNV_UTF32_BigEndian, 4, 4, { 0xfd, 0xff, 0, 0 }, 4, 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 _UTF32LEData = { sizeof(UConverterSharedData), ~((uint32_t) 0), NULL, NULL, &_UTF32LEStaticData, FALSE, &_UTF32LEImpl, 0 }; /* UTF-7 -------------------------------------------------------------------- */ /* ### TODO: in the and user guide, document version option (=1 for escaping set O characters) */ /* * UTF-7 is a stateful encoding of Unicode, somewhat like UTF7. * It is defined in RFC 2152 http://www.imc.org/rfc2152 . * It was intended for use in Internet email systems, using in its bytewise * encoding only a subset of 7-bit US-ASCII. * UTF-7 is deprecated in favor of UTF-8/16/32 and UTF7, but still * occasionally used. * * For converting Unicode to UTF-7, the RFC allows to encode some US-ASCII * characters directly or in base64. Especially, the characters in set O * as defined in the RFC (see below) may be encoded directly but are not * allowed in, e.g., email headers. * By default, the ICU UTF-7 converter encodes set O directly. * By choosing the option "version=1", set O will be escaped instead. * For example: * utf7Converter=ucnv_open("UTF-7,version=1"); */ /* * Tests for US-ASCII characters belonging to character classes * defined in UTF-7. * * Set D (directly encoded characters) consists of the following * characters: the upper and lower case letters A through Z * and a through z, the 10 digits 0-9, and the following nine special * characters (note that "+" and "=" are omitted): * '(),-./:? * * Set O (optional direct characters) consists of the following * characters (note that "\" and "~" are omitted): * !"#$%&*;<=>@[]^_`{|} * * According to the rules in RFC 2152, the byte values for the following * US-ASCII characters are not used in UTF-7 and are therefore illegal: * - all C0 control codes except for CR LF TAB * - BACKSLASH * - TILDE * - DEL * - all codes beyond US-ASCII, i.e. all >127 */ #define inSetD(c) \ ((uint8_t)((c)-97)<26 || (uint8_t)((c)-65)<26 || /* letters */ \ (uint8_t)((c)-48)<10 || /* digits */ \ (uint8_t)((c)-39)<3 || /* '() */ \ (uint8_t)((c)-44)<4 || /* ,-./ */ \ (c)==58 || (c)==63 /* :? */ \ ) #define inSetO(c) \ ((uint8_t)((c)-33)<6 || /* !"#$%& */ \ (uint8_t)((c)-59)<4 || /* ;<=> */ \ (uint8_t)((c)-93)<4 || /* ]^_` */ \ (uint8_t)((c)-123)<3 || /* {|} */ \ (c)==42 || (c)==64 || (c)==91 /* *@[ */ \ ) #define isCRLFTAB(c) ((c)==13 || (c)==10 || (c)==9) #define isCRLFSPTAB(c) ((c)==32 || (c)==13 || (c)==10 || (c)==9) #define PLUS 43 #define MINUS 45 #define BACKSLASH 92 #define TILDE 126 /* legal byte values: all US-ASCII graphic characters from space to before tilde, and CR LF TAB */ #define isLegalUTF7(c) (((uint8_t)((c)-32)<94 && (c)!=BACKSLASH) || isCRLFTAB(c)) /* encode directly sets D and O and CR LF SP TAB */ static const UBool encodeDirectlyMaximum[128]={ /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 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, 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 }; /* encode directly set D and CR LF SP TAB but not set O */ static const UBool encodeDirectlyRestricted[128]={ /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 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, 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 }; static const uint8_t toBase64[64]={ /* A-Z */ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, /* a-z */ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, /* 0-9 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, /* +/ */ 43, 47 }; static const int8_t fromBase64[128]={ /* C0 controls, -1 for legal ones (CR LF TAB), -3 for illegal ones */ -3, -3, -3, -3, -3, -3, -3, -3, -3, -1, -1, -3, -3, -1, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* general punctuation with + and / and a special value (-2) for - */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -2, -1, 63, /* digits */ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* A-Z */ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -3, -1, -1, -1, /* a-z */ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -3, -3 }; /* * converter status values: * * toUnicodeStatus: * 24 inDirectMode (boolean) * 23..16 base64Counter (-1..7) * 15..0 bits (up to 14 bits incoming base64) * * fromUnicodeStatus: * 31..28 version (0: set O direct 1: set O escaped) * 24 inDirectMode (boolean) * 23..16 base64Counter (0..2) * 7..0 bits (6 bits outgoing base64) * */ U_CFUNC void _UTF7Reset(UConverter *cnv, UConverterResetChoice choice) { if(choice<=UCNV_RESET_TO_UNICODE) { /* reset toUnicode */ cnv->toUnicodeStatus=0x1000000; /* inDirectMode=TRUE */ cnv->toULength=0; } if(choice!=UCNV_RESET_TO_UNICODE) { /* reset fromUnicode */ cnv->fromUnicodeStatus=(cnv->fromUnicodeStatus&0xf0000000)|0x1000000; /* keep version, inDirectMode=TRUE */ } } U_CFUNC void _UTF7Open(UConverter *cnv, const char *name, const char *locale, uint32_t options, UErrorCode *pErrorCode) { if((options&0xf)<=1) { cnv->fromUnicodeStatus=(options&0xf)<<28; _UTF7Reset(cnv, UCNV_RESET_BOTH); } else { *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; } } U_CFUNC void _UTF7ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode) { UConverter *cnv; const uint8_t *source, *sourceLimit; UChar *target; const UChar *targetLimit; int32_t *offsets; uint8_t *bytes; uint8_t byteIndex; int32_t length, targetCapacity; /* UTF-7 state */ uint16_t bits; int8_t base64Counter; UBool inDirectMode; int8_t base64Value; int32_t sourceIndex, nextSourceIndex; uint8_t b; /* set up the local pointers */ cnv=pArgs->converter; source=(const uint8_t *)pArgs->source; sourceLimit=(const uint8_t *)pArgs->sourceLimit; target=pArgs->target; targetLimit=pArgs->targetLimit; offsets=pArgs->offsets; /* get the state machine state */ { uint32_t status=cnv->toUnicodeStatus; inDirectMode=(UBool)((status>>24)&1); base64Counter=(int8_t)(status>>16); bits=(uint16_t)status; } bytes=cnv->toUBytes; byteIndex=cnv->toULength; /* sourceIndex=-1 if the current character began in the previous buffer */ sourceIndex=byteIndex==0 ? 0 : -1; nextSourceIndex=0; loop: if(inDirectMode) { directMode: /* * In Direct Mode, most US-ASCII characters are encoded directly, i.e., * with their US-ASCII byte values. * Backslash and Tilde and most control characters are not allowed in UTF-7. * A plus sign starts Unicode (or "escape") Mode. * * In Direct Mode, only the sourceIndex is used. */ byteIndex=0; length=sourceLimit-source; targetCapacity=targetLimit-target; if(length>targetCapacity) { length=targetCapacity; } while(length>0) { b=*source++; if(!isLegalUTF7(b)) { /* illegal */ bytes[0]=b; byteIndex=1; nextSourceIndex=sourceIndex+1; goto callback; } else if(b!=PLUS) { /* write directly encoded character */ *target++=b; if(offsets!=NULL) { *offsets++=sourceIndex++; } } else /* PLUS */ { /* switch to Unicode mode */ nextSourceIndex=++sourceIndex; inDirectMode=FALSE; byteIndex=0; bits=0; base64Counter=-1; goto unicodeMode; } --length; } if(source=targetLimit) { /* target is full */ *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } } else { unicodeMode: /* * In Unicode (or "escape") Mode, UTF-16BE is base64-encoded. * The base64 sequence ends with any character that is not in the base64 alphabet. * A terminating minus sign is consumed. * * In Unicode Mode, the sourceIndex has the index to the start of the current * base64 bytes, while nextSourceIndex is precisely parallel to source, * keeping the index to the following byte. * Note that in 2 out of 3 cases, UChars overlap within a base64 byte. */ while(source=126) { /* illegal - test other illegal US-ASCII values by base64Value==-3 */ inDirectMode=TRUE; goto callback; } else if((base64Value=fromBase64[b])>=0) { /* collect base64 bytes into UChars */ switch(base64Counter) { case -1: /* -1 is immediately after the + */ case 0: bits=base64Value; base64Counter=1; break; case 1: case 3: case 4: case 6: bits=(uint16_t)((bits<<6)|base64Value); ++base64Counter; break; case 2: *target++=(UChar)((bits<<4)|(base64Value>>2)); if(offsets!=NULL) { *offsets++=sourceIndex; sourceIndex=nextSourceIndex-1; } bytes[0]=b; /* keep this byte in case an error occurs */ byteIndex=1; bits=(uint16_t)(base64Value&3); base64Counter=3; break; case 5: *target++=(UChar)((bits<<2)|(base64Value>>4)); if(offsets!=NULL) { *offsets++=sourceIndex; sourceIndex=nextSourceIndex-1; } bytes[0]=b; /* keep this byte in case an error occurs */ byteIndex=1; bits=(uint16_t)(base64Value&15); base64Counter=6; break; case 7: *target++=(UChar)((bits<<6)|base64Value); if(offsets!=NULL) { *offsets++=sourceIndex; sourceIndex=nextSourceIndex; } byteIndex=0; bits=0; base64Counter=0; break; default: /* will never occur */ break; } } else if(base64Value==-2) { /* minus sign terminates the base64 sequence */ inDirectMode=TRUE; if(base64Counter==-1) { /* +- i.e. a minus immediately following a plus */ *target++=PLUS; if(offsets!=NULL) { *offsets++=sourceIndex-1; } } else { /* absorb the minus and leave the Unicode Mode */ if(bits!=0) { /* bits are illegally left over, a UChar is incomplete */ goto callback; } } sourceIndex=nextSourceIndex; goto directMode; } else if(base64Value==-1) /* for any legal character except base64 and minus sign */ { /* leave the Unicode Mode */ inDirectMode=TRUE; if(base64Counter==-1) { /* illegal: + immediately followed by something other than base64 or minus sign */ /* include the plus sign in the reported sequence */ --sourceIndex; bytes[0]=PLUS; bytes[1]=b; byteIndex=2; goto callback; } else if(bits==0) { /* un-read the character in case it is a plus sign */ --source; sourceIndex=nextSourceIndex-1; goto directMode; } else { /* bits are illegally left over, a UChar is incomplete */ goto callback; } } else /* base64Value==-3 for illegal characters */ { /* illegal */ inDirectMode=TRUE; goto callback; } } else { /* target is full */ *pErrorCode=U_BUFFER_OVERFLOW_ERROR; break; } } } endloop: if(pArgs->flush && source>=sourceLimit) { /* reset the state for the next conversion */ if(!inDirectMode && bits!=0 && U_SUCCESS(*pErrorCode)) { /* a character byte sequence remains incomplete */ *pErrorCode=U_TRUNCATED_CHAR_FOUND; } cnv->toUnicodeStatus=0x1000000; /* inDirectMode=TRUE */ cnv->toULength=0; } else { /* set the converter state back into UConverter */ cnv->toUnicodeStatus=((uint32_t)inDirectMode<<24)|((uint32_t)((uint8_t)base64Counter)<<16)|(uint32_t)bits; cnv->toULength=byteIndex; } finish: /* write back the updated pointers */ pArgs->source=(const char *)source; pArgs->target=target; pArgs->offsets=offsets; return; callback: /* call the callback function with all the preparations and post-processing */ /* update the arguments structure */ pArgs->source=(const char *)source; pArgs->target=target; pArgs->offsets=offsets; /* copy the current bytes to invalidCharBuffer */ for(b=0; b<(uint8_t)byteIndex; ++b) { cnv->invalidCharBuffer[b]=(char)bytes[b]; } cnv->invalidCharLength=byteIndex; /* set the converter state in UConverter to deal with the next character */ cnv->toUnicodeStatus=(uint32_t)inDirectMode<<24; cnv->toULength=0; /* call the callback function */ *pErrorCode=U_ILLEGAL_CHAR_FOUND; cnv->fromCharErrorBehaviour(cnv->toUContext, pArgs, cnv->invalidCharBuffer, cnv->invalidCharLength, UCNV_ILLEGAL, pErrorCode); /* get the converter state from UConverter */ { uint32_t status=cnv->toUnicodeStatus; inDirectMode=(UBool)((status>>24)&1); base64Counter=(int8_t)(status>>16); bits=(uint16_t)status; } byteIndex=cnv->toULength; /* update target and deal with offsets if necessary */ offsets=ucnv_updateCallbackOffsets(offsets, pArgs->target-target, sourceIndex); target=pArgs->target; /* update the source pointer and index */ sourceIndex=nextSourceIndex+((const uint8_t *)pArgs->source-source); source=(const uint8_t *)pArgs->source; /* * If the callback overflowed the target, then we need to * stop here with an overflow indication. */ if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) { goto endloop; } else if(cnv->UCharErrorBufferLength>0) { /* target is full */ *pErrorCode=U_BUFFER_OVERFLOW_ERROR; goto endloop; } else if(U_FAILURE(*pErrorCode)) { /* break on error */ cnv->toUnicodeStatus=0x1000000; /* inDirectMode=TRUE */ cnv->toULength=0; goto finish; } else { goto loop; } } U_CFUNC UChar32 _UTF7GetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *pErrorCode) { return ucnv_getNextUCharFromToUImpl(pArgs, _UTF7ToUnicodeWithOffsets, TRUE, pErrorCode); } U_CFUNC void _UTF7FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, UErrorCode *pErrorCode) { UConverter *cnv; const UChar *source, *sourceLimit; uint8_t *target, *targetLimit; int32_t *offsets; int32_t length, targetCapacity, sourceIndex; UChar c; /* UTF-7 state */ const UBool *encodeDirectly; uint8_t bits; int8_t base64Counter; UBool inDirectMode; /* set up the local pointers */ cnv=pArgs->converter; /* set up the local pointers */ source=pArgs->source; sourceLimit=pArgs->sourceLimit; target=(uint8_t *)pArgs->target; targetLimit=(uint8_t *)pArgs->targetLimit; offsets=pArgs->offsets; /* get the state machine state */ { uint32_t status=cnv->fromUnicodeStatus; encodeDirectly= status<0x10000000 ? encodeDirectlyMaximum : encodeDirectlyRestricted; inDirectMode=(UBool)((status>>24)&1); base64Counter=(int8_t)(status>>16); bits=(uint8_t)status; } /* UTF-7 always encodes UTF-16 code units, therefore we need only a simple sourceIndex */ sourceIndex=0; if(inDirectMode) { directMode: length=sourceLimit-source; targetCapacity=targetLimit-target; if(length>targetCapacity) { length=targetCapacity; } while(length>0) { c=*source++; /* currently always encode CR LF SP TAB directly */ if(c<=127 && encodeDirectly[c]) { /* encode directly */ *target++=(uint8_t)c; if(offsets!=NULL) { *offsets++=sourceIndex++; } } else if(c==PLUS) { /* output +- for + */ *target++=PLUS; if(targetcharErrorBuffer[0]=MINUS; cnv->charErrorBufferLength=1; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; break; } } else { /* un-read this character and switch to Unicode Mode */ --source; *target++=PLUS; if(offsets!=NULL) { *offsets++=sourceIndex; } inDirectMode=FALSE; base64Counter=0; goto unicodeMode; } --length; } if(source=targetLimit) { /* target is full */ *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } } else { unicodeMode: while(sourcecharErrorBuffer[0]=MINUS; cnv->charErrorBufferLength=1; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; break; } } goto directMode; } else { /* * base64 this character: * Output 2 or 3 base64 bytes for the remaining bits of the previous character * and the bits of this character, each implicitly in UTF-16BE. * * Here, bits is an 8-bit variable because only 6 bits need to be kept from one * character to the next. The actual 2 or 4 bits are shifted to the left edge * of the 6-bits field 5..0 to make the termination of the base64 sequence easier. */ switch(base64Counter) { case 0: *target++=toBase64[c>>10]; if(target>4)&0x3f]; if(offsets!=NULL) { *offsets++=sourceIndex; *offsets++=sourceIndex++; } } else { if(offsets!=NULL) { *offsets++=sourceIndex++; } cnv->charErrorBuffer[0]=toBase64[(c>>4)&0x3f]; cnv->charErrorBufferLength=1; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } bits=(uint8_t)((c&15)<<2); base64Counter=1; break; case 1: *target++=toBase64[bits|(c>>14)]; if(target>8)&0x3f]; if(target>2)&0x3f]; if(offsets!=NULL) { *offsets++=sourceIndex; *offsets++=sourceIndex; *offsets++=sourceIndex++; } } else { if(offsets!=NULL) { *offsets++=sourceIndex; *offsets++=sourceIndex++; } cnv->charErrorBuffer[0]=toBase64[(c>>2)&0x3f]; cnv->charErrorBufferLength=1; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } } else { if(offsets!=NULL) { *offsets++=sourceIndex++; } cnv->charErrorBuffer[0]=toBase64[(c>>8)&0x3f]; cnv->charErrorBuffer[1]=toBase64[(c>>2)&0x3f]; cnv->charErrorBufferLength=2; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } bits=(uint8_t)((c&3)<<4); base64Counter=2; break; case 2: *target++=toBase64[bits|(c>>12)]; if(target>6)&0x3f]; if(targetcharErrorBuffer[0]=toBase64[c&0x3f]; cnv->charErrorBufferLength=1; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } } else { if(offsets!=NULL) { *offsets++=sourceIndex++; } cnv->charErrorBuffer[0]=toBase64[(c>>6)&0x3f]; cnv->charErrorBuffer[1]=toBase64[c&0x3f]; cnv->charErrorBufferLength=2; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } bits=0; base64Counter=0; break; default: /* will never occur */ break; } } } else { /* target is full */ *pErrorCode=U_BUFFER_OVERFLOW_ERROR; break; } } } if(pArgs->flush && source>=sourceLimit) { /* flush remaining bits to the target */ if(!inDirectMode && base64Counter!=0) { if(targetcharErrorBuffer[0]=toBase64[bits]; cnv->charErrorBufferLength=1; *pErrorCode=U_BUFFER_OVERFLOW_ERROR; } } /* reset the state for the next conversion */ cnv->fromUnicodeStatus=(cnv->fromUnicodeStatus&0xf0000000)|0x1000000; /* keep version, inDirectMode=TRUE */ } else { /* set the converter state back into UConverter */ cnv->fromUnicodeStatus= (cnv->fromUnicodeStatus&0xf0000000)| /* keep version*/ ((uint32_t)inDirectMode<<24)|((uint32_t)base64Counter<<16)|(uint32_t)bits; } /* write back the updated pointers */ pArgs->source=source; pArgs->target=(char *)target; pArgs->offsets=offsets; return; } U_CFUNC const char * _UTF7GetName(const UConverter *cnv) { switch(cnv->fromUnicodeStatus>>28) { case 1: return "UTF-7,version=1"; default: return "UTF-7"; } } static const UConverterImpl _UTF7Impl={ UCNV_UTF7, NULL, NULL, _UTF7Open, NULL, _UTF7Reset, _UTF7ToUnicodeWithOffsets, _UTF7ToUnicodeWithOffsets, _UTF7FromUnicodeWithOffsets, _UTF7FromUnicodeWithOffsets, _UTF7GetNextUChar, NULL, _UTF7GetName, NULL /* we don't need writeSub() because we never call a callback at fromUnicode() */ }; static const UConverterStaticData _UTF7StaticData={ sizeof(UConverterStaticData), "UTF-7", 0, /* CCSID for UTF-7 */ UCNV_IBM, UCNV_UTF7, 1, 4, { 0x3f, 0, 0, 0 }, 1, /* the subchar is not used */ 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 _UTF7Data={ sizeof(UConverterSharedData), ~((uint32_t)0), NULL, NULL, &_UTF7StaticData, FALSE, &_UTF7Impl, 0 };