Home | History | Annotate | Download | only in common
      1 /*
      2 ******************************************************************************
      3 *
      4 *   Copyright (C) 1998-2015, International Business Machines
      5 *   Corporation and others.  All Rights Reserved.
      6 *
      7 ******************************************************************************
      8 *
      9 *  ucnv.c:
     10 *  Implements APIs for the ICU's codeset conversion library;
     11 *  mostly calls through internal functions;
     12 *  created by Bertrand A. Damiba
     13 *
     14 * Modification History:
     15 *
     16 *   Date        Name        Description
     17 *   04/04/99    helena      Fixed internal header inclusion.
     18 *   05/09/00    helena      Added implementation to handle fallback mappings.
     19 *   06/20/2000  helena      OS/400 port changes; mostly typecast.
     20 */
     21 
     22 #include "unicode/utypes.h"
     23 
     24 #if !UCONFIG_NO_CONVERSION
     25 
     26 #include "unicode/ustring.h"
     27 #include "unicode/ucnv.h"
     28 #include "unicode/ucnv_err.h"
     29 #include "unicode/uset.h"
     30 #include "unicode/utf.h"
     31 #include "unicode/utf16.h"
     32 #include "putilimp.h"
     33 #include "cmemory.h"
     34 #include "cstring.h"
     35 #include "uassert.h"
     36 #include "utracimp.h"
     37 #include "ustr_imp.h"
     38 #include "ucnv_imp.h"
     39 #include "ucnv_cnv.h"
     40 #include "ucnv_bld.h"
     41 
     42 /* size of intermediate and preflighting buffers in ucnv_convert() */
     43 #define CHUNK_SIZE 1024
     44 
     45 typedef struct UAmbiguousConverter {
     46     const char *name;
     47     const UChar variant5c;
     48 } UAmbiguousConverter;
     49 
     50 static const UAmbiguousConverter ambiguousConverters[]={
     51     { "ibm-897_P100-1995", 0xa5 },
     52     { "ibm-942_P120-1999", 0xa5 },
     53     { "ibm-943_P130-1999", 0xa5 },
     54     { "ibm-946_P100-1995", 0xa5 },
     55     { "ibm-33722_P120-1999", 0xa5 },
     56     { "ibm-1041_P100-1995", 0xa5 },
     57     /*{ "ibm-54191_P100-2006", 0xa5 },*/
     58     /*{ "ibm-62383_P100-2007", 0xa5 },*/
     59     /*{ "ibm-891_P100-1995", 0x20a9 },*/
     60     { "ibm-944_P100-1995", 0x20a9 },
     61     { "ibm-949_P110-1999", 0x20a9 },
     62     { "ibm-1363_P110-1997", 0x20a9 },
     63     { "ISO_2022,locale=ko,version=0", 0x20a9 },
     64     { "ibm-1088_P100-1995", 0x20a9 }
     65 };
     66 
     67 /*Calls through createConverter */
     68 U_CAPI UConverter* U_EXPORT2
     69 ucnv_open (const char *name,
     70                        UErrorCode * err)
     71 {
     72     UConverter *r;
     73 
     74     if (err == NULL || U_FAILURE (*err)) {
     75         return NULL;
     76     }
     77 
     78     r =  ucnv_createConverter(NULL, name, err);
     79     return r;
     80 }
     81 
     82 U_CAPI UConverter* U_EXPORT2
     83 ucnv_openPackage   (const char *packageName, const char *converterName, UErrorCode * err)
     84 {
     85     return ucnv_createConverterFromPackage(packageName, converterName,  err);
     86 }
     87 
     88 /*Extracts the UChar* to a char* and calls through createConverter */
     89 U_CAPI UConverter*   U_EXPORT2
     90 ucnv_openU (const UChar * name,
     91                          UErrorCode * err)
     92 {
     93     char asciiName[UCNV_MAX_CONVERTER_NAME_LENGTH];
     94 
     95     if (err == NULL || U_FAILURE(*err))
     96         return NULL;
     97     if (name == NULL)
     98         return ucnv_open (NULL, err);
     99     if (u_strlen(name) >= UCNV_MAX_CONVERTER_NAME_LENGTH)
    100     {
    101         *err = U_ILLEGAL_ARGUMENT_ERROR;
    102         return NULL;
    103     }
    104     return ucnv_open(u_austrcpy(asciiName, name), err);
    105 }
    106 
    107 /* Copy the string that is represented by the UConverterPlatform enum
    108  * @param platformString An output buffer
    109  * @param platform An enum representing a platform
    110  * @return the length of the copied string.
    111  */
    112 static int32_t
    113 ucnv_copyPlatformString(char *platformString, UConverterPlatform pltfrm)
    114 {
    115     switch (pltfrm)
    116     {
    117     case UCNV_IBM:
    118         uprv_strcpy(platformString, "ibm-");
    119         return 4;
    120     case UCNV_UNKNOWN:
    121         break;
    122     }
    123 
    124     /* default to empty string */
    125     *platformString = 0;
    126     return 0;
    127 }
    128 
    129 /*Assumes a $platform-#codepage.$CONVERTER_FILE_EXTENSION scheme and calls
    130  *through createConverter*/
    131 U_CAPI UConverter*   U_EXPORT2
    132 ucnv_openCCSID (int32_t codepage,
    133                 UConverterPlatform platform,
    134                 UErrorCode * err)
    135 {
    136     char myName[UCNV_MAX_CONVERTER_NAME_LENGTH];
    137     int32_t myNameLen;
    138 
    139     if (err == NULL || U_FAILURE (*err))
    140         return NULL;
    141 
    142     /* ucnv_copyPlatformString could return "ibm-" or "cp" */
    143     myNameLen = ucnv_copyPlatformString(myName, platform);
    144     T_CString_integerToString(myName + myNameLen, codepage, 10);
    145 
    146     return ucnv_createConverter(NULL, myName, err);
    147 }
    148 
    149 /* Creating a temporary stack-based object that can be used in one thread,
    150 and created from a converter that is shared across threads.
    151 */
    152 
    153 U_CAPI UConverter* U_EXPORT2
    154 ucnv_safeClone(const UConverter* cnv, void *stackBuffer, int32_t *pBufferSize, UErrorCode *status)
    155 {
    156     UConverter *localConverter, *allocatedConverter;
    157     int32_t stackBufferSize;
    158     int32_t bufferSizeNeeded;
    159     char *stackBufferChars = (char *)stackBuffer;
    160     UErrorCode cbErr;
    161     UConverterToUnicodeArgs toUArgs = {
    162         sizeof(UConverterToUnicodeArgs),
    163             TRUE,
    164             NULL,
    165             NULL,
    166             NULL,
    167             NULL,
    168             NULL,
    169             NULL
    170     };
    171     UConverterFromUnicodeArgs fromUArgs = {
    172         sizeof(UConverterFromUnicodeArgs),
    173             TRUE,
    174             NULL,
    175             NULL,
    176             NULL,
    177             NULL,
    178             NULL,
    179             NULL
    180     };
    181 
    182     UTRACE_ENTRY_OC(UTRACE_UCNV_CLONE);
    183 
    184     if (status == NULL || U_FAILURE(*status)){
    185         UTRACE_EXIT_STATUS(status? *status: U_ILLEGAL_ARGUMENT_ERROR);
    186         return NULL;
    187     }
    188 
    189     if (cnv == NULL) {
    190         *status = U_ILLEGAL_ARGUMENT_ERROR;
    191         UTRACE_EXIT_STATUS(*status);
    192         return NULL;
    193     }
    194 
    195     UTRACE_DATA3(UTRACE_OPEN_CLOSE, "clone converter %s at %p into stackBuffer %p",
    196                                     ucnv_getName(cnv, status), cnv, stackBuffer);
    197 
    198     if (cnv->sharedData->impl->safeClone != NULL) {
    199         /* call the custom safeClone function for sizing */
    200         bufferSizeNeeded = 0;
    201         cnv->sharedData->impl->safeClone(cnv, NULL, &bufferSizeNeeded, status);
    202         if (U_FAILURE(*status)) {
    203             UTRACE_EXIT_STATUS(*status);
    204             return NULL;
    205         }
    206     }
    207     else
    208     {
    209         /* inherent sizing */
    210         bufferSizeNeeded = sizeof(UConverter);
    211     }
    212 
    213     if (pBufferSize == NULL) {
    214         stackBufferSize = 1;
    215         pBufferSize = &stackBufferSize;
    216     } else {
    217         stackBufferSize = *pBufferSize;
    218         if (stackBufferSize <= 0){ /* 'preflighting' request - set needed size into *pBufferSize */
    219             *pBufferSize = bufferSizeNeeded;
    220             UTRACE_EXIT_VALUE(bufferSizeNeeded);
    221             return NULL;
    222         }
    223     }
    224 
    225 
    226     /* Pointers on 64-bit platforms need to be aligned
    227      * on a 64-bit boundary in memory.
    228      */
    229     if (U_ALIGNMENT_OFFSET(stackBuffer) != 0) {
    230         int32_t offsetUp = (int32_t)U_ALIGNMENT_OFFSET_UP(stackBufferChars);
    231         if(stackBufferSize > offsetUp) {
    232             stackBufferSize -= offsetUp;
    233             stackBufferChars += offsetUp;
    234         } else {
    235             /* prevent using the stack buffer but keep the size > 0 so that we do not just preflight */
    236             stackBufferSize = 1;
    237         }
    238     }
    239 
    240     stackBuffer = (void *)stackBufferChars;
    241 
    242     /* Now, see if we must allocate any memory */
    243     if (stackBufferSize < bufferSizeNeeded || stackBuffer == NULL)
    244     {
    245         /* allocate one here...*/
    246         localConverter = allocatedConverter = (UConverter *) uprv_malloc (bufferSizeNeeded);
    247 
    248         if(localConverter == NULL) {
    249             *status = U_MEMORY_ALLOCATION_ERROR;
    250             UTRACE_EXIT_STATUS(*status);
    251             return NULL;
    252         }
    253         *status = U_SAFECLONE_ALLOCATED_WARNING;
    254 
    255         /* record the fact that memory was allocated */
    256         *pBufferSize = bufferSizeNeeded;
    257     } else {
    258         /* just use the stack buffer */
    259         localConverter = (UConverter*) stackBuffer;
    260         allocatedConverter = NULL;
    261     }
    262 
    263     uprv_memset(localConverter, 0, bufferSizeNeeded);
    264 
    265     /* Copy initial state */
    266     uprv_memcpy(localConverter, cnv, sizeof(UConverter));
    267     localConverter->isCopyLocal = localConverter->isExtraLocal = FALSE;
    268 
    269     /* copy the substitution string */
    270     if (cnv->subChars == (uint8_t *)cnv->subUChars) {
    271         localConverter->subChars = (uint8_t *)localConverter->subUChars;
    272     } else {
    273         localConverter->subChars = (uint8_t *)uprv_malloc(UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
    274         if (localConverter->subChars == NULL) {
    275             uprv_free(allocatedConverter);
    276             UTRACE_EXIT_STATUS(*status);
    277             return NULL;
    278         }
    279         uprv_memcpy(localConverter->subChars, cnv->subChars, UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
    280     }
    281 
    282     /* now either call the safeclone fcn or not */
    283     if (cnv->sharedData->impl->safeClone != NULL) {
    284         /* call the custom safeClone function */
    285         localConverter = cnv->sharedData->impl->safeClone(cnv, localConverter, pBufferSize, status);
    286     }
    287 
    288     if(localConverter==NULL || U_FAILURE(*status)) {
    289         if (allocatedConverter != NULL && allocatedConverter->subChars != (uint8_t *)allocatedConverter->subUChars) {
    290             uprv_free(allocatedConverter->subChars);
    291         }
    292         uprv_free(allocatedConverter);
    293         UTRACE_EXIT_STATUS(*status);
    294         return NULL;
    295     }
    296 
    297     /* increment refcount of shared data if needed */
    298     if (cnv->sharedData->isReferenceCounted) {
    299         ucnv_incrementRefCount(cnv->sharedData);
    300     }
    301 
    302     if(localConverter == (UConverter*)stackBuffer) {
    303         /* we're using user provided data - set to not destroy */
    304         localConverter->isCopyLocal = TRUE;
    305     }
    306 
    307     /* allow callback functions to handle any memory allocation */
    308     toUArgs.converter = fromUArgs.converter = localConverter;
    309     cbErr = U_ZERO_ERROR;
    310     cnv->fromCharErrorBehaviour(cnv->toUContext, &toUArgs, NULL, 0, UCNV_CLONE, &cbErr);
    311     cbErr = U_ZERO_ERROR;
    312     cnv->fromUCharErrorBehaviour(cnv->fromUContext, &fromUArgs, NULL, 0, 0, UCNV_CLONE, &cbErr);
    313 
    314     UTRACE_EXIT_PTR_STATUS(localConverter, *status);
    315     return localConverter;
    316 }
    317 
    318 
    319 
    320 /*Decreases the reference counter in the shared immutable section of the object
    321  *and frees the mutable part*/
    322 
    323 U_CAPI void  U_EXPORT2
    324 ucnv_close (UConverter * converter)
    325 {
    326     UErrorCode errorCode = U_ZERO_ERROR;
    327 
    328     UTRACE_ENTRY_OC(UTRACE_UCNV_CLOSE);
    329 
    330     if (converter == NULL)
    331     {
    332         UTRACE_EXIT();
    333         return;
    334     }
    335 
    336     UTRACE_DATA3(UTRACE_OPEN_CLOSE, "close converter %s at %p, isCopyLocal=%b",
    337         ucnv_getName(converter, &errorCode), converter, converter->isCopyLocal);
    338 
    339     /* In order to speed up the close, only call the callbacks when they have been changed.
    340     This performance check will only work when the callbacks are set within a shared library
    341     or from user code that statically links this code. */
    342     /* first, notify the callback functions that the converter is closed */
    343     if (converter->fromCharErrorBehaviour != UCNV_TO_U_DEFAULT_CALLBACK) {
    344         UConverterToUnicodeArgs toUArgs = {
    345             sizeof(UConverterToUnicodeArgs),
    346                 TRUE,
    347                 NULL,
    348                 NULL,
    349                 NULL,
    350                 NULL,
    351                 NULL,
    352                 NULL
    353         };
    354 
    355         toUArgs.converter = converter;
    356         errorCode = U_ZERO_ERROR;
    357         converter->fromCharErrorBehaviour(converter->toUContext, &toUArgs, NULL, 0, UCNV_CLOSE, &errorCode);
    358     }
    359     if (converter->fromUCharErrorBehaviour != UCNV_FROM_U_DEFAULT_CALLBACK) {
    360         UConverterFromUnicodeArgs fromUArgs = {
    361             sizeof(UConverterFromUnicodeArgs),
    362                 TRUE,
    363                 NULL,
    364                 NULL,
    365                 NULL,
    366                 NULL,
    367                 NULL,
    368                 NULL
    369         };
    370         fromUArgs.converter = converter;
    371         errorCode = U_ZERO_ERROR;
    372         converter->fromUCharErrorBehaviour(converter->fromUContext, &fromUArgs, NULL, 0, 0, UCNV_CLOSE, &errorCode);
    373     }
    374 
    375     if (converter->sharedData->impl->close != NULL) {
    376         converter->sharedData->impl->close(converter);
    377     }
    378 
    379     if (converter->subChars != (uint8_t *)converter->subUChars) {
    380         uprv_free(converter->subChars);
    381     }
    382 
    383     if (converter->sharedData->isReferenceCounted) {
    384         ucnv_unloadSharedDataIfReady(converter->sharedData);
    385     }
    386 
    387     if(!converter->isCopyLocal){
    388         uprv_free(converter);
    389     }
    390 
    391     UTRACE_EXIT();
    392 }
    393 
    394 /*returns a single Name from the list, will return NULL if out of bounds
    395  */
    396 U_CAPI const char*   U_EXPORT2
    397 ucnv_getAvailableName (int32_t n)
    398 {
    399     if (0 <= n && n <= 0xffff) {
    400         UErrorCode err = U_ZERO_ERROR;
    401         const char *name = ucnv_bld_getAvailableConverter((uint16_t)n, &err);
    402         if (U_SUCCESS(err)) {
    403             return name;
    404         }
    405     }
    406     return NULL;
    407 }
    408 
    409 U_CAPI int32_t   U_EXPORT2
    410 ucnv_countAvailable ()
    411 {
    412     UErrorCode err = U_ZERO_ERROR;
    413     return ucnv_bld_countAvailableConverters(&err);
    414 }
    415 
    416 U_CAPI void    U_EXPORT2
    417 ucnv_getSubstChars (const UConverter * converter,
    418                     char *mySubChar,
    419                     int8_t * len,
    420                     UErrorCode * err)
    421 {
    422     if (U_FAILURE (*err))
    423         return;
    424 
    425     if (converter->subCharLen <= 0) {
    426         /* Unicode string or empty string from ucnv_setSubstString(). */
    427         *len = 0;
    428         return;
    429     }
    430 
    431     if (*len < converter->subCharLen) /*not enough space in subChars */
    432     {
    433         *err = U_INDEX_OUTOFBOUNDS_ERROR;
    434         return;
    435     }
    436 
    437     uprv_memcpy (mySubChar, converter->subChars, converter->subCharLen);   /*fills in the subchars */
    438     *len = converter->subCharLen; /*store # of bytes copied to buffer */
    439 }
    440 
    441 U_CAPI void    U_EXPORT2
    442 ucnv_setSubstChars (UConverter * converter,
    443                     const char *mySubChar,
    444                     int8_t len,
    445                     UErrorCode * err)
    446 {
    447     if (U_FAILURE (*err))
    448         return;
    449 
    450     /*Makes sure that the subChar is within the codepages char length boundaries */
    451     if ((len > converter->sharedData->staticData->maxBytesPerChar)
    452      || (len < converter->sharedData->staticData->minBytesPerChar))
    453     {
    454         *err = U_ILLEGAL_ARGUMENT_ERROR;
    455         return;
    456     }
    457 
    458     uprv_memcpy (converter->subChars, mySubChar, len); /*copies the subchars */
    459     converter->subCharLen = len;  /*sets the new len */
    460 
    461     /*
    462     * There is currently (2001Feb) no separate API to set/get subChar1.
    463     * In order to always have subChar written after it is explicitly set,
    464     * we set subChar1 to 0.
    465     */
    466     converter->subChar1 = 0;
    467 
    468     return;
    469 }
    470 
    471 U_CAPI void U_EXPORT2
    472 ucnv_setSubstString(UConverter *cnv,
    473                     const UChar *s,
    474                     int32_t length,
    475                     UErrorCode *err) {
    476     UAlignedMemory cloneBuffer[U_CNV_SAFECLONE_BUFFERSIZE / sizeof(UAlignedMemory) + 1];
    477     char chars[UCNV_ERROR_BUFFER_LENGTH];
    478 
    479     UConverter *clone;
    480     uint8_t *subChars;
    481     int32_t cloneSize, length8;
    482 
    483     /* Let the following functions check all arguments. */
    484     cloneSize = sizeof(cloneBuffer);
    485     clone = ucnv_safeClone(cnv, cloneBuffer, &cloneSize, err);
    486     ucnv_setFromUCallBack(clone, UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, err);
    487     length8 = ucnv_fromUChars(clone, chars, (int32_t)sizeof(chars), s, length, err);
    488     ucnv_close(clone);
    489     if (U_FAILURE(*err)) {
    490         return;
    491     }
    492 
    493     if (cnv->sharedData->impl->writeSub == NULL
    494 #if !UCONFIG_NO_LEGACY_CONVERSION
    495         || (cnv->sharedData->staticData->conversionType == UCNV_MBCS &&
    496          ucnv_MBCSGetType(cnv) != UCNV_EBCDIC_STATEFUL)
    497 #endif
    498     ) {
    499         /* The converter is not stateful. Store the charset bytes as a fixed string. */
    500         subChars = (uint8_t *)chars;
    501     } else {
    502         /*
    503          * The converter has a non-default writeSub() function, indicating
    504          * that it is stateful.
    505          * Store the Unicode string for on-the-fly conversion for correct
    506          * state handling.
    507          */
    508         if (length > UCNV_ERROR_BUFFER_LENGTH) {
    509             /*
    510              * Should not occur. The converter should output at least one byte
    511              * per UChar, which means that ucnv_fromUChars() should catch all
    512              * overflows.
    513              */
    514             *err = U_BUFFER_OVERFLOW_ERROR;
    515             return;
    516         }
    517         subChars = (uint8_t *)s;
    518         if (length < 0) {
    519             length = u_strlen(s);
    520         }
    521         length8 = length * U_SIZEOF_UCHAR;
    522     }
    523 
    524     /*
    525      * For storing the substitution string, select either the small buffer inside
    526      * UConverter or allocate a subChars buffer.
    527      */
    528     if (length8 > UCNV_MAX_SUBCHAR_LEN) {
    529         /* Use a separate buffer for the string. Outside UConverter to not make it too large. */
    530         if (cnv->subChars == (uint8_t *)cnv->subUChars) {
    531             /* Allocate a new buffer for the string. */
    532             cnv->subChars = (uint8_t *)uprv_malloc(UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
    533             if (cnv->subChars == NULL) {
    534                 cnv->subChars = (uint8_t *)cnv->subUChars;
    535                 *err = U_MEMORY_ALLOCATION_ERROR;
    536                 return;
    537             }
    538             uprv_memset(cnv->subChars, 0, UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR);
    539         }
    540     }
    541 
    542     /* Copy the substitution string into the UConverter or its subChars buffer. */
    543     if (length8 == 0) {
    544         cnv->subCharLen = 0;
    545     } else {
    546         uprv_memcpy(cnv->subChars, subChars, length8);
    547         if (subChars == (uint8_t *)chars) {
    548             cnv->subCharLen = (int8_t)length8;
    549         } else /* subChars == s */ {
    550             cnv->subCharLen = (int8_t)-length;
    551         }
    552     }
    553 
    554     /* See comment in ucnv_setSubstChars(). */
    555     cnv->subChar1 = 0;
    556 }
    557 
    558 /*resets the internal states of a converter
    559  *goal : have the same behaviour than a freshly created converter
    560  */
    561 static void _reset(UConverter *converter, UConverterResetChoice choice,
    562                    UBool callCallback) {
    563     if(converter == NULL) {
    564         return;
    565     }
    566 
    567     if(callCallback) {
    568         /* first, notify the callback functions that the converter is reset */
    569         UErrorCode errorCode;
    570 
    571         if(choice<=UCNV_RESET_TO_UNICODE && converter->fromCharErrorBehaviour != UCNV_TO_U_DEFAULT_CALLBACK) {
    572             UConverterToUnicodeArgs toUArgs = {
    573                 sizeof(UConverterToUnicodeArgs),
    574                 TRUE,
    575                 NULL,
    576                 NULL,
    577                 NULL,
    578                 NULL,
    579                 NULL,
    580                 NULL
    581             };
    582             toUArgs.converter = converter;
    583             errorCode = U_ZERO_ERROR;
    584             converter->fromCharErrorBehaviour(converter->toUContext, &toUArgs, NULL, 0, UCNV_RESET, &errorCode);
    585         }
    586         if(choice!=UCNV_RESET_TO_UNICODE && converter->fromUCharErrorBehaviour != UCNV_FROM_U_DEFAULT_CALLBACK) {
    587             UConverterFromUnicodeArgs fromUArgs = {
    588                 sizeof(UConverterFromUnicodeArgs),
    589                 TRUE,
    590                 NULL,
    591                 NULL,
    592                 NULL,
    593                 NULL,
    594                 NULL,
    595                 NULL
    596             };
    597             fromUArgs.converter = converter;
    598             errorCode = U_ZERO_ERROR;
    599             converter->fromUCharErrorBehaviour(converter->fromUContext, &fromUArgs, NULL, 0, 0, UCNV_RESET, &errorCode);
    600         }
    601     }
    602 
    603     /* now reset the converter itself */
    604     if(choice<=UCNV_RESET_TO_UNICODE) {
    605         converter->toUnicodeStatus = converter->sharedData->toUnicodeStatus;
    606         converter->mode = 0;
    607         converter->toULength = 0;
    608         converter->invalidCharLength = converter->UCharErrorBufferLength = 0;
    609         converter->preToULength = 0;
    610     }
    611     if(choice!=UCNV_RESET_TO_UNICODE) {
    612         converter->fromUnicodeStatus = 0;
    613         converter->fromUChar32 = 0;
    614         converter->invalidUCharLength = converter->charErrorBufferLength = 0;
    615         converter->preFromUFirstCP = U_SENTINEL;
    616         converter->preFromULength = 0;
    617     }
    618 
    619     if (converter->sharedData->impl->reset != NULL) {
    620         /* call the custom reset function */
    621         converter->sharedData->impl->reset(converter, choice);
    622     }
    623 }
    624 
    625 U_CAPI void  U_EXPORT2
    626 ucnv_reset(UConverter *converter)
    627 {
    628     _reset(converter, UCNV_RESET_BOTH, TRUE);
    629 }
    630 
    631 U_CAPI void  U_EXPORT2
    632 ucnv_resetToUnicode(UConverter *converter)
    633 {
    634     _reset(converter, UCNV_RESET_TO_UNICODE, TRUE);
    635 }
    636 
    637 U_CAPI void  U_EXPORT2
    638 ucnv_resetFromUnicode(UConverter *converter)
    639 {
    640     _reset(converter, UCNV_RESET_FROM_UNICODE, TRUE);
    641 }
    642 
    643 U_CAPI int8_t   U_EXPORT2
    644 ucnv_getMaxCharSize (const UConverter * converter)
    645 {
    646     return converter->maxBytesPerUChar;
    647 }
    648 
    649 
    650 U_CAPI int8_t   U_EXPORT2
    651 ucnv_getMinCharSize (const UConverter * converter)
    652 {
    653     return converter->sharedData->staticData->minBytesPerChar;
    654 }
    655 
    656 U_CAPI const char*   U_EXPORT2
    657 ucnv_getName (const UConverter * converter, UErrorCode * err)
    658 
    659 {
    660     if (U_FAILURE (*err))
    661         return NULL;
    662     if(converter->sharedData->impl->getName){
    663         const char* temp= converter->sharedData->impl->getName(converter);
    664         if(temp)
    665             return temp;
    666     }
    667     return converter->sharedData->staticData->name;
    668 }
    669 
    670 U_CAPI int32_t U_EXPORT2
    671 ucnv_getCCSID(const UConverter * converter,
    672               UErrorCode * err)
    673 {
    674     int32_t ccsid;
    675     if (U_FAILURE (*err))
    676         return -1;
    677 
    678     ccsid = converter->sharedData->staticData->codepage;
    679     if (ccsid == 0) {
    680         /* Rare case. This is for cases like gb18030,
    681         which doesn't have an IBM canonical name, but does have an IBM alias. */
    682         const char *standardName = ucnv_getStandardName(ucnv_getName(converter, err), "IBM", err);
    683         if (U_SUCCESS(*err) && standardName) {
    684             const char *ccsidStr = uprv_strchr(standardName, '-');
    685             if (ccsidStr) {
    686                 ccsid = (int32_t)atol(ccsidStr+1);  /* +1 to skip '-' */
    687             }
    688         }
    689     }
    690     return ccsid;
    691 }
    692 
    693 
    694 U_CAPI UConverterPlatform   U_EXPORT2
    695 ucnv_getPlatform (const UConverter * converter,
    696                                       UErrorCode * err)
    697 {
    698     if (U_FAILURE (*err))
    699         return UCNV_UNKNOWN;
    700 
    701     return (UConverterPlatform)converter->sharedData->staticData->platform;
    702 }
    703 
    704 U_CAPI void U_EXPORT2
    705     ucnv_getToUCallBack (const UConverter * converter,
    706                          UConverterToUCallback *action,
    707                          const void **context)
    708 {
    709     *action = converter->fromCharErrorBehaviour;
    710     *context = converter->toUContext;
    711 }
    712 
    713 U_CAPI void U_EXPORT2
    714     ucnv_getFromUCallBack (const UConverter * converter,
    715                            UConverterFromUCallback *action,
    716                            const void **context)
    717 {
    718     *action = converter->fromUCharErrorBehaviour;
    719     *context = converter->fromUContext;
    720 }
    721 
    722 U_CAPI void    U_EXPORT2
    723 ucnv_setToUCallBack (UConverter * converter,
    724                             UConverterToUCallback newAction,
    725                             const void* newContext,
    726                             UConverterToUCallback *oldAction,
    727                             const void** oldContext,
    728                             UErrorCode * err)
    729 {
    730     if (U_FAILURE (*err))
    731         return;
    732     if (oldAction) *oldAction = converter->fromCharErrorBehaviour;
    733     converter->fromCharErrorBehaviour = newAction;
    734     if (oldContext) *oldContext = converter->toUContext;
    735     converter->toUContext = newContext;
    736 }
    737 
    738 U_CAPI void  U_EXPORT2
    739 ucnv_setFromUCallBack (UConverter * converter,
    740                             UConverterFromUCallback newAction,
    741                             const void* newContext,
    742                             UConverterFromUCallback *oldAction,
    743                             const void** oldContext,
    744                             UErrorCode * err)
    745 {
    746     if (U_FAILURE (*err))
    747         return;
    748     if (oldAction) *oldAction = converter->fromUCharErrorBehaviour;
    749     converter->fromUCharErrorBehaviour = newAction;
    750     if (oldContext) *oldContext = converter->fromUContext;
    751     converter->fromUContext = newContext;
    752 }
    753 
    754 static void
    755 _updateOffsets(int32_t *offsets, int32_t length,
    756                int32_t sourceIndex, int32_t errorInputLength) {
    757     int32_t *limit;
    758     int32_t delta, offset;
    759 
    760     if(sourceIndex>=0) {
    761         /*
    762          * adjust each offset by adding the previous sourceIndex
    763          * minus the length of the input sequence that caused an
    764          * error, if any
    765          */
    766         delta=sourceIndex-errorInputLength;
    767     } else {
    768         /*
    769          * set each offset to -1 because this conversion function
    770          * does not handle offsets
    771          */
    772         delta=-1;
    773     }
    774 
    775     limit=offsets+length;
    776     if(delta==0) {
    777         /* most common case, nothing to do */
    778     } else if(delta>0) {
    779         /* add the delta to each offset (but not if the offset is <0) */
    780         while(offsets<limit) {
    781             offset=*offsets;
    782             if(offset>=0) {
    783                 *offsets=offset+delta;
    784             }
    785             ++offsets;
    786         }
    787     } else /* delta<0 */ {
    788         /*
    789          * set each offset to -1 because this conversion function
    790          * does not handle offsets
    791          * or the error input sequence started in a previous buffer
    792          */
    793         while(offsets<limit) {
    794             *offsets++=-1;
    795         }
    796     }
    797 }
    798 
    799 /* ucnv_fromUnicode --------------------------------------------------------- */
    800 
    801 /*
    802  * Implementation note for m:n conversions
    803  *
    804  * While collecting source units to find the longest match for m:n conversion,
    805  * some source units may need to be stored for a partial match.
    806  * When a second buffer does not yield a match on all of the previously stored
    807  * source units, then they must be "replayed", i.e., fed back into the converter.
    808  *
    809  * The code relies on the fact that replaying will not nest -
    810  * converting a replay buffer will not result in a replay.
    811  * This is because a replay is necessary only after the _continuation_ of a
    812  * partial match failed, but a replay buffer is converted as a whole.
    813  * It may result in some of its units being stored again for a partial match,
    814  * but there will not be a continuation _during_ the replay which could fail.
    815  *
    816  * It is conceivable that a callback function could call the converter
    817  * recursively in a way that causes another replay to be stored, but that
    818  * would be an error in the callback function.
    819  * Such violations will cause assertion failures in a debug build,
    820  * and wrong output, but they will not cause a crash.
    821  */
    822 
    823 static void
    824 _fromUnicodeWithCallback(UConverterFromUnicodeArgs *pArgs, UErrorCode *err) {
    825     UConverterFromUnicode fromUnicode;
    826     UConverter *cnv;
    827     const UChar *s;
    828     char *t;
    829     int32_t *offsets;
    830     int32_t sourceIndex;
    831     int32_t errorInputLength;
    832     UBool converterSawEndOfInput, calledCallback;
    833 
    834     /* variables for m:n conversion */
    835     UChar replay[UCNV_EXT_MAX_UCHARS];
    836     const UChar *realSource, *realSourceLimit;
    837     int32_t realSourceIndex;
    838     UBool realFlush;
    839 
    840     cnv=pArgs->converter;
    841     s=pArgs->source;
    842     t=pArgs->target;
    843     offsets=pArgs->offsets;
    844 
    845     /* get the converter implementation function */
    846     sourceIndex=0;
    847     if(offsets==NULL) {
    848         fromUnicode=cnv->sharedData->impl->fromUnicode;
    849     } else {
    850         fromUnicode=cnv->sharedData->impl->fromUnicodeWithOffsets;
    851         if(fromUnicode==NULL) {
    852             /* there is no WithOffsets implementation */
    853             fromUnicode=cnv->sharedData->impl->fromUnicode;
    854             /* we will write -1 for each offset */
    855             sourceIndex=-1;
    856         }
    857     }
    858 
    859     if(cnv->preFromULength>=0) {
    860         /* normal mode */
    861         realSource=NULL;
    862 
    863         /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
    864         realSourceLimit=NULL;
    865         realFlush=FALSE;
    866         realSourceIndex=0;
    867     } else {
    868         /*
    869          * Previous m:n conversion stored source units from a partial match
    870          * and failed to consume all of them.
    871          * We need to "replay" them from a temporary buffer and convert them first.
    872          */
    873         realSource=pArgs->source;
    874         realSourceLimit=pArgs->sourceLimit;
    875         realFlush=pArgs->flush;
    876         realSourceIndex=sourceIndex;
    877 
    878         uprv_memcpy(replay, cnv->preFromU, -cnv->preFromULength*U_SIZEOF_UCHAR);
    879         pArgs->source=replay;
    880         pArgs->sourceLimit=replay-cnv->preFromULength;
    881         pArgs->flush=FALSE;
    882         sourceIndex=-1;
    883 
    884         cnv->preFromULength=0;
    885     }
    886 
    887     /*
    888      * loop for conversion and error handling
    889      *
    890      * loop {
    891      *   convert
    892      *   loop {
    893      *     update offsets
    894      *     handle end of input
    895      *     handle errors/call callback
    896      *   }
    897      * }
    898      */
    899     for(;;) {
    900         if(U_SUCCESS(*err)) {
    901             /* convert */
    902             fromUnicode(pArgs, err);
    903 
    904             /*
    905              * set a flag for whether the converter
    906              * successfully processed the end of the input
    907              *
    908              * need not check cnv->preFromULength==0 because a replay (<0) will cause
    909              * s<sourceLimit before converterSawEndOfInput is checked
    910              */
    911             converterSawEndOfInput=
    912                 (UBool)(U_SUCCESS(*err) &&
    913                         pArgs->flush && pArgs->source==pArgs->sourceLimit &&
    914                         cnv->fromUChar32==0);
    915         } else {
    916             /* handle error from ucnv_convertEx() */
    917             converterSawEndOfInput=FALSE;
    918         }
    919 
    920         /* no callback called yet for this iteration */
    921         calledCallback=FALSE;
    922 
    923         /* no sourceIndex adjustment for conversion, only for callback output */
    924         errorInputLength=0;
    925 
    926         /*
    927          * loop for offsets and error handling
    928          *
    929          * iterates at most 3 times:
    930          * 1. to clean up after the conversion function
    931          * 2. after the callback
    932          * 3. after the callback again if there was truncated input
    933          */
    934         for(;;) {
    935             /* update offsets if we write any */
    936             if(offsets!=NULL) {
    937                 int32_t length=(int32_t)(pArgs->target-t);
    938                 if(length>0) {
    939                     _updateOffsets(offsets, length, sourceIndex, errorInputLength);
    940 
    941                     /*
    942                      * if a converter handles offsets and updates the offsets
    943                      * pointer at the end, then pArgs->offset should not change
    944                      * here;
    945                      * however, some converters do not handle offsets at all
    946                      * (sourceIndex<0) or may not update the offsets pointer
    947                      */
    948                     pArgs->offsets=offsets+=length;
    949                 }
    950 
    951                 if(sourceIndex>=0) {
    952                     sourceIndex+=(int32_t)(pArgs->source-s);
    953                 }
    954             }
    955 
    956             if(cnv->preFromULength<0) {
    957                 /*
    958                  * switch the source to new replay units (cannot occur while replaying)
    959                  * after offset handling and before end-of-input and callback handling
    960                  */
    961                 if(realSource==NULL) {
    962                     realSource=pArgs->source;
    963                     realSourceLimit=pArgs->sourceLimit;
    964                     realFlush=pArgs->flush;
    965                     realSourceIndex=sourceIndex;
    966 
    967                     uprv_memcpy(replay, cnv->preFromU, -cnv->preFromULength*U_SIZEOF_UCHAR);
    968                     pArgs->source=replay;
    969                     pArgs->sourceLimit=replay-cnv->preFromULength;
    970                     pArgs->flush=FALSE;
    971                     if((sourceIndex+=cnv->preFromULength)<0) {
    972                         sourceIndex=-1;
    973                     }
    974 
    975                     cnv->preFromULength=0;
    976                 } else {
    977                     /* see implementation note before _fromUnicodeWithCallback() */
    978                     U_ASSERT(realSource==NULL);
    979                     *err=U_INTERNAL_PROGRAM_ERROR;
    980                 }
    981             }
    982 
    983             /* update pointers */
    984             s=pArgs->source;
    985             t=pArgs->target;
    986 
    987             if(U_SUCCESS(*err)) {
    988                 if(s<pArgs->sourceLimit) {
    989                     /*
    990                      * continue with the conversion loop while there is still input left
    991                      * (continue converting by breaking out of only the inner loop)
    992                      */
    993                     break;
    994                 } else if(realSource!=NULL) {
    995                     /* switch back from replaying to the real source and continue */
    996                     pArgs->source=realSource;
    997                     pArgs->sourceLimit=realSourceLimit;
    998                     pArgs->flush=realFlush;
    999                     sourceIndex=realSourceIndex;
   1000 
   1001                     realSource=NULL;
   1002                     break;
   1003                 } else if(pArgs->flush && cnv->fromUChar32!=0) {
   1004                     /*
   1005                      * the entire input stream is consumed
   1006                      * and there is a partial, truncated input sequence left
   1007                      */
   1008 
   1009                     /* inject an error and continue with callback handling */
   1010                     *err=U_TRUNCATED_CHAR_FOUND;
   1011                     calledCallback=FALSE; /* new error condition */
   1012                 } else {
   1013                     /* input consumed */
   1014                     if(pArgs->flush) {
   1015                         /*
   1016                          * return to the conversion loop once more if the flush
   1017                          * flag is set and the conversion function has not
   1018                          * successfully processed the end of the input yet
   1019                          *
   1020                          * (continue converting by breaking out of only the inner loop)
   1021                          */
   1022                         if(!converterSawEndOfInput) {
   1023                             break;
   1024                         }
   1025 
   1026                         /* reset the converter without calling the callback function */
   1027                         _reset(cnv, UCNV_RESET_FROM_UNICODE, FALSE);
   1028                     }
   1029 
   1030                     /* done successfully */
   1031                     return;
   1032                 }
   1033             }
   1034 
   1035             /* U_FAILURE(*err) */
   1036             {
   1037                 UErrorCode e;
   1038 
   1039                 if( calledCallback ||
   1040                     (e=*err)==U_BUFFER_OVERFLOW_ERROR ||
   1041                     (e!=U_INVALID_CHAR_FOUND &&
   1042                      e!=U_ILLEGAL_CHAR_FOUND &&
   1043                      e!=U_TRUNCATED_CHAR_FOUND)
   1044                 ) {
   1045                     /*
   1046                      * the callback did not or cannot resolve the error:
   1047                      * set output pointers and return
   1048                      *
   1049                      * the check for buffer overflow is redundant but it is
   1050                      * a high-runner case and hopefully documents the intent
   1051                      * well
   1052                      *
   1053                      * if we were replaying, then the replay buffer must be
   1054                      * copied back into the UConverter
   1055                      * and the real arguments must be restored
   1056                      */
   1057                     if(realSource!=NULL) {
   1058                         int32_t length;
   1059 
   1060                         U_ASSERT(cnv->preFromULength==0);
   1061 
   1062                         length=(int32_t)(pArgs->sourceLimit-pArgs->source);
   1063                         if(length>0) {
   1064                             uprv_memcpy(cnv->preFromU, pArgs->source, length*U_SIZEOF_UCHAR);
   1065                             cnv->preFromULength=(int8_t)-length;
   1066                         }
   1067 
   1068                         pArgs->source=realSource;
   1069                         pArgs->sourceLimit=realSourceLimit;
   1070                         pArgs->flush=realFlush;
   1071                     }
   1072 
   1073                     return;
   1074                 }
   1075             }
   1076 
   1077             /* callback handling */
   1078             {
   1079                 UChar32 codePoint;
   1080 
   1081                 /* get and write the code point */
   1082                 codePoint=cnv->fromUChar32;
   1083                 errorInputLength=0;
   1084                 U16_APPEND_UNSAFE(cnv->invalidUCharBuffer, errorInputLength, codePoint);
   1085                 cnv->invalidUCharLength=(int8_t)errorInputLength;
   1086 
   1087                 /* set the converter state to deal with the next character */
   1088                 cnv->fromUChar32=0;
   1089 
   1090                 /* call the callback function */
   1091                 cnv->fromUCharErrorBehaviour(cnv->fromUContext, pArgs,
   1092                     cnv->invalidUCharBuffer, errorInputLength, codePoint,
   1093                     *err==U_INVALID_CHAR_FOUND ? UCNV_UNASSIGNED : UCNV_ILLEGAL,
   1094                     err);
   1095             }
   1096 
   1097             /*
   1098              * loop back to the offset handling
   1099              *
   1100              * this flag will indicate after offset handling
   1101              * that a callback was called;
   1102              * if the callback did not resolve the error, then we return
   1103              */
   1104             calledCallback=TRUE;
   1105         }
   1106     }
   1107 }
   1108 
   1109 /*
   1110  * Output the fromUnicode overflow buffer.
   1111  * Call this function if(cnv->charErrorBufferLength>0).
   1112  * @return TRUE if overflow
   1113  */
   1114 static UBool
   1115 ucnv_outputOverflowFromUnicode(UConverter *cnv,
   1116                                char **target, const char *targetLimit,
   1117                                int32_t **pOffsets,
   1118                                UErrorCode *err) {
   1119     int32_t *offsets;
   1120     char *overflow, *t;
   1121     int32_t i, length;
   1122 
   1123     t=*target;
   1124     if(pOffsets!=NULL) {
   1125         offsets=*pOffsets;
   1126     } else {
   1127         offsets=NULL;
   1128     }
   1129 
   1130     overflow=(char *)cnv->charErrorBuffer;
   1131     length=cnv->charErrorBufferLength;
   1132     i=0;
   1133     while(i<length) {
   1134         if(t==targetLimit) {
   1135             /* the overflow buffer contains too much, keep the rest */
   1136             int32_t j=0;
   1137 
   1138             do {
   1139                 overflow[j++]=overflow[i++];
   1140             } while(i<length);
   1141 
   1142             cnv->charErrorBufferLength=(int8_t)j;
   1143             *target=t;
   1144             if(offsets!=NULL) {
   1145                 *pOffsets=offsets;
   1146             }
   1147             *err=U_BUFFER_OVERFLOW_ERROR;
   1148             return TRUE;
   1149         }
   1150 
   1151         /* copy the overflow contents to the target */
   1152         *t++=overflow[i++];
   1153         if(offsets!=NULL) {
   1154             *offsets++=-1; /* no source index available for old output */
   1155         }
   1156     }
   1157 
   1158     /* the overflow buffer is completely copied to the target */
   1159     cnv->charErrorBufferLength=0;
   1160     *target=t;
   1161     if(offsets!=NULL) {
   1162         *pOffsets=offsets;
   1163     }
   1164     return FALSE;
   1165 }
   1166 
   1167 U_CAPI void U_EXPORT2
   1168 ucnv_fromUnicode(UConverter *cnv,
   1169                  char **target, const char *targetLimit,
   1170                  const UChar **source, const UChar *sourceLimit,
   1171                  int32_t *offsets,
   1172                  UBool flush,
   1173                  UErrorCode *err) {
   1174     UConverterFromUnicodeArgs args;
   1175     const UChar *s;
   1176     char *t;
   1177 
   1178     /* check parameters */
   1179     if(err==NULL || U_FAILURE(*err)) {
   1180         return;
   1181     }
   1182 
   1183     if(cnv==NULL || target==NULL || source==NULL) {
   1184         *err=U_ILLEGAL_ARGUMENT_ERROR;
   1185         return;
   1186     }
   1187 
   1188     s=*source;
   1189     t=*target;
   1190 
   1191     if ((const void *)U_MAX_PTR(sourceLimit) == (const void *)sourceLimit) {
   1192         /*
   1193         Prevent code from going into an infinite loop in case we do hit this
   1194         limit. The limit pointer is expected to be on a UChar * boundary.
   1195         This also prevents the next argument check from failing.
   1196         */
   1197         sourceLimit = (const UChar *)(((const char *)sourceLimit) - 1);
   1198     }
   1199 
   1200     /*
   1201      * All these conditions should never happen.
   1202      *
   1203      * 1) Make sure that the limits are >= to the address source or target
   1204      *
   1205      * 2) Make sure that the buffer sizes do not exceed the number range for
   1206      * int32_t because some functions use the size (in units or bytes)
   1207      * rather than comparing pointers, and because offsets are int32_t values.
   1208      *
   1209      * size_t is guaranteed to be unsigned and large enough for the job.
   1210      *
   1211      * Return with an error instead of adjusting the limits because we would
   1212      * not be able to maintain the semantics that either the source must be
   1213      * consumed or the target filled (unless an error occurs).
   1214      * An adjustment would be targetLimit=t+0x7fffffff; for example.
   1215      *
   1216      * 3) Make sure that the user didn't incorrectly cast a UChar * pointer
   1217      * to a char * pointer and provide an incomplete UChar code unit.
   1218      */
   1219     if (sourceLimit<s || targetLimit<t ||
   1220         ((size_t)(sourceLimit-s)>(size_t)0x3fffffff && sourceLimit>s) ||
   1221         ((size_t)(targetLimit-t)>(size_t)0x7fffffff && targetLimit>t) ||
   1222         (((const char *)sourceLimit-(const char *)s) & 1) != 0)
   1223     {
   1224         *err=U_ILLEGAL_ARGUMENT_ERROR;
   1225         return;
   1226     }
   1227 
   1228     /* output the target overflow buffer */
   1229     if( cnv->charErrorBufferLength>0 &&
   1230         ucnv_outputOverflowFromUnicode(cnv, target, targetLimit, &offsets, err)
   1231     ) {
   1232         /* U_BUFFER_OVERFLOW_ERROR */
   1233         return;
   1234     }
   1235     /* *target may have moved, therefore stop using t */
   1236 
   1237     if(!flush && s==sourceLimit && cnv->preFromULength>=0) {
   1238         /* the overflow buffer is emptied and there is no new input: we are done */
   1239         return;
   1240     }
   1241 
   1242     /*
   1243      * Do not simply return with a buffer overflow error if
   1244      * !flush && t==targetLimit
   1245      * because it is possible that the source will not generate any output.
   1246      * For example, the skip callback may be called;
   1247      * it does not output anything.
   1248      */
   1249 
   1250     /* prepare the converter arguments */
   1251     args.converter=cnv;
   1252     args.flush=flush;
   1253     args.offsets=offsets;
   1254     args.source=s;
   1255     args.sourceLimit=sourceLimit;
   1256     args.target=*target;
   1257     args.targetLimit=targetLimit;
   1258     args.size=sizeof(args);
   1259 
   1260     _fromUnicodeWithCallback(&args, err);
   1261 
   1262     *source=args.source;
   1263     *target=args.target;
   1264 }
   1265 
   1266 /* ucnv_toUnicode() --------------------------------------------------------- */
   1267 
   1268 static void
   1269 _toUnicodeWithCallback(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
   1270     UConverterToUnicode toUnicode;
   1271     UConverter *cnv;
   1272     const char *s;
   1273     UChar *t;
   1274     int32_t *offsets;
   1275     int32_t sourceIndex;
   1276     int32_t errorInputLength;
   1277     UBool converterSawEndOfInput, calledCallback;
   1278 
   1279     /* variables for m:n conversion */
   1280     char replay[UCNV_EXT_MAX_BYTES];
   1281     const char *realSource, *realSourceLimit;
   1282     int32_t realSourceIndex;
   1283     UBool realFlush;
   1284 
   1285     cnv=pArgs->converter;
   1286     s=pArgs->source;
   1287     t=pArgs->target;
   1288     offsets=pArgs->offsets;
   1289 
   1290     /* get the converter implementation function */
   1291     sourceIndex=0;
   1292     if(offsets==NULL) {
   1293         toUnicode=cnv->sharedData->impl->toUnicode;
   1294     } else {
   1295         toUnicode=cnv->sharedData->impl->toUnicodeWithOffsets;
   1296         if(toUnicode==NULL) {
   1297             /* there is no WithOffsets implementation */
   1298             toUnicode=cnv->sharedData->impl->toUnicode;
   1299             /* we will write -1 for each offset */
   1300             sourceIndex=-1;
   1301         }
   1302     }
   1303 
   1304     if(cnv->preToULength>=0) {
   1305         /* normal mode */
   1306         realSource=NULL;
   1307 
   1308         /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
   1309         realSourceLimit=NULL;
   1310         realFlush=FALSE;
   1311         realSourceIndex=0;
   1312     } else {
   1313         /*
   1314          * Previous m:n conversion stored source units from a partial match
   1315          * and failed to consume all of them.
   1316          * We need to "replay" them from a temporary buffer and convert them first.
   1317          */
   1318         realSource=pArgs->source;
   1319         realSourceLimit=pArgs->sourceLimit;
   1320         realFlush=pArgs->flush;
   1321         realSourceIndex=sourceIndex;
   1322 
   1323         uprv_memcpy(replay, cnv->preToU, -cnv->preToULength);
   1324         pArgs->source=replay;
   1325         pArgs->sourceLimit=replay-cnv->preToULength;
   1326         pArgs->flush=FALSE;
   1327         sourceIndex=-1;
   1328 
   1329         cnv->preToULength=0;
   1330     }
   1331 
   1332     /*
   1333      * loop for conversion and error handling
   1334      *
   1335      * loop {
   1336      *   convert
   1337      *   loop {
   1338      *     update offsets
   1339      *     handle end of input
   1340      *     handle errors/call callback
   1341      *   }
   1342      * }
   1343      */
   1344     for(;;) {
   1345         if(U_SUCCESS(*err)) {
   1346             /* convert */
   1347             toUnicode(pArgs, err);
   1348 
   1349             /*
   1350              * set a flag for whether the converter
   1351              * successfully processed the end of the input
   1352              *
   1353              * need not check cnv->preToULength==0 because a replay (<0) will cause
   1354              * s<sourceLimit before converterSawEndOfInput is checked
   1355              */
   1356             converterSawEndOfInput=
   1357                 (UBool)(U_SUCCESS(*err) &&
   1358                         pArgs->flush && pArgs->source==pArgs->sourceLimit &&
   1359                         cnv->toULength==0);
   1360         } else {
   1361             /* handle error from getNextUChar() or ucnv_convertEx() */
   1362             converterSawEndOfInput=FALSE;
   1363         }
   1364 
   1365         /* no callback called yet for this iteration */
   1366         calledCallback=FALSE;
   1367 
   1368         /* no sourceIndex adjustment for conversion, only for callback output */
   1369         errorInputLength=0;
   1370 
   1371         /*
   1372          * loop for offsets and error handling
   1373          *
   1374          * iterates at most 3 times:
   1375          * 1. to clean up after the conversion function
   1376          * 2. after the callback
   1377          * 3. after the callback again if there was truncated input
   1378          */
   1379         for(;;) {
   1380             /* update offsets if we write any */
   1381             if(offsets!=NULL) {
   1382                 int32_t length=(int32_t)(pArgs->target-t);
   1383                 if(length>0) {
   1384                     _updateOffsets(offsets, length, sourceIndex, errorInputLength);
   1385 
   1386                     /*
   1387                      * if a converter handles offsets and updates the offsets
   1388                      * pointer at the end, then pArgs->offset should not change
   1389                      * here;
   1390                      * however, some converters do not handle offsets at all
   1391                      * (sourceIndex<0) or may not update the offsets pointer
   1392                      */
   1393                     pArgs->offsets=offsets+=length;
   1394                 }
   1395 
   1396                 if(sourceIndex>=0) {
   1397                     sourceIndex+=(int32_t)(pArgs->source-s);
   1398                 }
   1399             }
   1400 
   1401             if(cnv->preToULength<0) {
   1402                 /*
   1403                  * switch the source to new replay units (cannot occur while replaying)
   1404                  * after offset handling and before end-of-input and callback handling
   1405                  */
   1406                 if(realSource==NULL) {
   1407                     realSource=pArgs->source;
   1408                     realSourceLimit=pArgs->sourceLimit;
   1409                     realFlush=pArgs->flush;
   1410                     realSourceIndex=sourceIndex;
   1411 
   1412                     uprv_memcpy(replay, cnv->preToU, -cnv->preToULength);
   1413                     pArgs->source=replay;
   1414                     pArgs->sourceLimit=replay-cnv->preToULength;
   1415                     pArgs->flush=FALSE;
   1416                     if((sourceIndex+=cnv->preToULength)<0) {
   1417                         sourceIndex=-1;
   1418                     }
   1419 
   1420                     cnv->preToULength=0;
   1421                 } else {
   1422                     /* see implementation note before _fromUnicodeWithCallback() */
   1423                     U_ASSERT(realSource==NULL);
   1424                     *err=U_INTERNAL_PROGRAM_ERROR;
   1425                 }
   1426             }
   1427 
   1428             /* update pointers */
   1429             s=pArgs->source;
   1430             t=pArgs->target;
   1431 
   1432             if(U_SUCCESS(*err)) {
   1433                 if(s<pArgs->sourceLimit) {
   1434                     /*
   1435                      * continue with the conversion loop while there is still input left
   1436                      * (continue converting by breaking out of only the inner loop)
   1437                      */
   1438                     break;
   1439                 } else if(realSource!=NULL) {
   1440                     /* switch back from replaying to the real source and continue */
   1441                     pArgs->source=realSource;
   1442                     pArgs->sourceLimit=realSourceLimit;
   1443                     pArgs->flush=realFlush;
   1444                     sourceIndex=realSourceIndex;
   1445 
   1446                     realSource=NULL;
   1447                     break;
   1448                 } else if(pArgs->flush && cnv->toULength>0) {
   1449                     /*
   1450                      * the entire input stream is consumed
   1451                      * and there is a partial, truncated input sequence left
   1452                      */
   1453 
   1454                     /* inject an error and continue with callback handling */
   1455                     *err=U_TRUNCATED_CHAR_FOUND;
   1456                     calledCallback=FALSE; /* new error condition */
   1457                 } else {
   1458                     /* input consumed */
   1459                     if(pArgs->flush) {
   1460                         /*
   1461                          * return to the conversion loop once more if the flush
   1462                          * flag is set and the conversion function has not
   1463                          * successfully processed the end of the input yet
   1464                          *
   1465                          * (continue converting by breaking out of only the inner loop)
   1466                          */
   1467                         if(!converterSawEndOfInput) {
   1468                             break;
   1469                         }
   1470 
   1471                         /* reset the converter without calling the callback function */
   1472                         _reset(cnv, UCNV_RESET_TO_UNICODE, FALSE);
   1473                     }
   1474 
   1475                     /* done successfully */
   1476                     return;
   1477                 }
   1478             }
   1479 
   1480             /* U_FAILURE(*err) */
   1481             {
   1482                 UErrorCode e;
   1483 
   1484                 if( calledCallback ||
   1485                     (e=*err)==U_BUFFER_OVERFLOW_ERROR ||
   1486                     (e!=U_INVALID_CHAR_FOUND &&
   1487                      e!=U_ILLEGAL_CHAR_FOUND &&
   1488                      e!=U_TRUNCATED_CHAR_FOUND &&
   1489                      e!=U_ILLEGAL_ESCAPE_SEQUENCE &&
   1490                      e!=U_UNSUPPORTED_ESCAPE_SEQUENCE)
   1491                 ) {
   1492                     /*
   1493                      * the callback did not or cannot resolve the error:
   1494                      * set output pointers and return
   1495                      *
   1496                      * the check for buffer overflow is redundant but it is
   1497                      * a high-runner case and hopefully documents the intent
   1498                      * well
   1499                      *
   1500                      * if we were replaying, then the replay buffer must be
   1501                      * copied back into the UConverter
   1502                      * and the real arguments must be restored
   1503                      */
   1504                     if(realSource!=NULL) {
   1505                         int32_t length;
   1506 
   1507                         U_ASSERT(cnv->preToULength==0);
   1508 
   1509                         length=(int32_t)(pArgs->sourceLimit-pArgs->source);
   1510                         if(length>0) {
   1511                             uprv_memcpy(cnv->preToU, pArgs->source, length);
   1512                             cnv->preToULength=(int8_t)-length;
   1513                         }
   1514 
   1515                         pArgs->source=realSource;
   1516                         pArgs->sourceLimit=realSourceLimit;
   1517                         pArgs->flush=realFlush;
   1518                     }
   1519 
   1520                     return;
   1521                 }
   1522             }
   1523 
   1524             /* copy toUBytes[] to invalidCharBuffer[] */
   1525             errorInputLength=cnv->invalidCharLength=cnv->toULength;
   1526             if(errorInputLength>0) {
   1527                 uprv_memcpy(cnv->invalidCharBuffer, cnv->toUBytes, errorInputLength);
   1528             }
   1529 
   1530             /* set the converter state to deal with the next character */
   1531             cnv->toULength=0;
   1532 
   1533             /* call the callback function */
   1534             if(cnv->toUCallbackReason==UCNV_ILLEGAL && *err==U_INVALID_CHAR_FOUND) {
   1535                 cnv->toUCallbackReason = UCNV_UNASSIGNED;
   1536             }
   1537             cnv->fromCharErrorBehaviour(cnv->toUContext, pArgs,
   1538                 cnv->invalidCharBuffer, errorInputLength,
   1539                 cnv->toUCallbackReason,
   1540                 err);
   1541             cnv->toUCallbackReason = UCNV_ILLEGAL; /* reset to default value */
   1542 
   1543             /*
   1544              * loop back to the offset handling
   1545              *
   1546              * this flag will indicate after offset handling
   1547              * that a callback was called;
   1548              * if the callback did not resolve the error, then we return
   1549              */
   1550             calledCallback=TRUE;
   1551         }
   1552     }
   1553 }
   1554 
   1555 /*
   1556  * Output the toUnicode overflow buffer.
   1557  * Call this function if(cnv->UCharErrorBufferLength>0).
   1558  * @return TRUE if overflow
   1559  */
   1560 static UBool
   1561 ucnv_outputOverflowToUnicode(UConverter *cnv,
   1562                              UChar **target, const UChar *targetLimit,
   1563                              int32_t **pOffsets,
   1564                              UErrorCode *err) {
   1565     int32_t *offsets;
   1566     UChar *overflow, *t;
   1567     int32_t i, length;
   1568 
   1569     t=*target;
   1570     if(pOffsets!=NULL) {
   1571         offsets=*pOffsets;
   1572     } else {
   1573         offsets=NULL;
   1574     }
   1575 
   1576     overflow=cnv->UCharErrorBuffer;
   1577     length=cnv->UCharErrorBufferLength;
   1578     i=0;
   1579     while(i<length) {
   1580         if(t==targetLimit) {
   1581             /* the overflow buffer contains too much, keep the rest */
   1582             int32_t j=0;
   1583 
   1584             do {
   1585                 overflow[j++]=overflow[i++];
   1586             } while(i<length);
   1587 
   1588             cnv->UCharErrorBufferLength=(int8_t)j;
   1589             *target=t;
   1590             if(offsets!=NULL) {
   1591                 *pOffsets=offsets;
   1592             }
   1593             *err=U_BUFFER_OVERFLOW_ERROR;
   1594             return TRUE;
   1595         }
   1596 
   1597         /* copy the overflow contents to the target */
   1598         *t++=overflow[i++];
   1599         if(offsets!=NULL) {
   1600             *offsets++=-1; /* no source index available for old output */
   1601         }
   1602     }
   1603 
   1604     /* the overflow buffer is completely copied to the target */
   1605     cnv->UCharErrorBufferLength=0;
   1606     *target=t;
   1607     if(offsets!=NULL) {
   1608         *pOffsets=offsets;
   1609     }
   1610     return FALSE;
   1611 }
   1612 
   1613 U_CAPI void U_EXPORT2
   1614 ucnv_toUnicode(UConverter *cnv,
   1615                UChar **target, const UChar *targetLimit,
   1616                const char **source, const char *sourceLimit,
   1617                int32_t *offsets,
   1618                UBool flush,
   1619                UErrorCode *err) {
   1620     UConverterToUnicodeArgs args;
   1621     const char *s;
   1622     UChar *t;
   1623 
   1624     /* check parameters */
   1625     if(err==NULL || U_FAILURE(*err)) {
   1626         return;
   1627     }
   1628 
   1629     if(cnv==NULL || target==NULL || source==NULL) {
   1630         *err=U_ILLEGAL_ARGUMENT_ERROR;
   1631         return;
   1632     }
   1633 
   1634     s=*source;
   1635     t=*target;
   1636 
   1637     if ((const void *)U_MAX_PTR(targetLimit) == (const void *)targetLimit) {
   1638         /*
   1639         Prevent code from going into an infinite loop in case we do hit this
   1640         limit. The limit pointer is expected to be on a UChar * boundary.
   1641         This also prevents the next argument check from failing.
   1642         */
   1643         targetLimit = (const UChar *)(((const char *)targetLimit) - 1);
   1644     }
   1645 
   1646     /*
   1647      * All these conditions should never happen.
   1648      *
   1649      * 1) Make sure that the limits are >= to the address source or target
   1650      *
   1651      * 2) Make sure that the buffer sizes do not exceed the number range for
   1652      * int32_t because some functions use the size (in units or bytes)
   1653      * rather than comparing pointers, and because offsets are int32_t values.
   1654      *
   1655      * size_t is guaranteed to be unsigned and large enough for the job.
   1656      *
   1657      * Return with an error instead of adjusting the limits because we would
   1658      * not be able to maintain the semantics that either the source must be
   1659      * consumed or the target filled (unless an error occurs).
   1660      * An adjustment would be sourceLimit=t+0x7fffffff; for example.
   1661      *
   1662      * 3) Make sure that the user didn't incorrectly cast a UChar * pointer
   1663      * to a char * pointer and provide an incomplete UChar code unit.
   1664      */
   1665     if (sourceLimit<s || targetLimit<t ||
   1666         ((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s) ||
   1667         ((size_t)(targetLimit-t)>(size_t)0x3fffffff && targetLimit>t) ||
   1668         (((const char *)targetLimit-(const char *)t) & 1) != 0
   1669     ) {
   1670         *err=U_ILLEGAL_ARGUMENT_ERROR;
   1671         return;
   1672     }
   1673 
   1674     /* output the target overflow buffer */
   1675     if( cnv->UCharErrorBufferLength>0 &&
   1676         ucnv_outputOverflowToUnicode(cnv, target, targetLimit, &offsets, err)
   1677     ) {
   1678         /* U_BUFFER_OVERFLOW_ERROR */
   1679         return;
   1680     }
   1681     /* *target may have moved, therefore stop using t */
   1682 
   1683     if(!flush && s==sourceLimit && cnv->preToULength>=0) {
   1684         /* the overflow buffer is emptied and there is no new input: we are done */
   1685         return;
   1686     }
   1687 
   1688     /*
   1689      * Do not simply return with a buffer overflow error if
   1690      * !flush && t==targetLimit
   1691      * because it is possible that the source will not generate any output.
   1692      * For example, the skip callback may be called;
   1693      * it does not output anything.
   1694      */
   1695 
   1696     /* prepare the converter arguments */
   1697     args.converter=cnv;
   1698     args.flush=flush;
   1699     args.offsets=offsets;
   1700     args.source=s;
   1701     args.sourceLimit=sourceLimit;
   1702     args.target=*target;
   1703     args.targetLimit=targetLimit;
   1704     args.size=sizeof(args);
   1705 
   1706     _toUnicodeWithCallback(&args, err);
   1707 
   1708     *source=args.source;
   1709     *target=args.target;
   1710 }
   1711 
   1712 /* ucnv_to/fromUChars() ----------------------------------------------------- */
   1713 
   1714 U_CAPI int32_t U_EXPORT2
   1715 ucnv_fromUChars(UConverter *cnv,
   1716                 char *dest, int32_t destCapacity,
   1717                 const UChar *src, int32_t srcLength,
   1718                 UErrorCode *pErrorCode) {
   1719     const UChar *srcLimit;
   1720     char *originalDest, *destLimit;
   1721     int32_t destLength;
   1722 
   1723     /* check arguments */
   1724     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
   1725         return 0;
   1726     }
   1727 
   1728     if( cnv==NULL ||
   1729         destCapacity<0 || (destCapacity>0 && dest==NULL) ||
   1730         srcLength<-1 || (srcLength!=0 && src==NULL)
   1731     ) {
   1732         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   1733         return 0;
   1734     }
   1735 
   1736     /* initialize */
   1737     ucnv_resetFromUnicode(cnv);
   1738     originalDest=dest;
   1739     if(srcLength==-1) {
   1740         srcLength=u_strlen(src);
   1741     }
   1742     if(srcLength>0) {
   1743         srcLimit=src+srcLength;
   1744         destLimit=dest+destCapacity;
   1745 
   1746         /* pin the destination limit to U_MAX_PTR; NULL check is for OS/400 */
   1747         if(destLimit<dest || (destLimit==NULL && dest!=NULL)) {
   1748             destLimit=(char *)U_MAX_PTR(dest);
   1749         }
   1750 
   1751         /* perform the conversion */
   1752         ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
   1753         destLength=(int32_t)(dest-originalDest);
   1754 
   1755         /* if an overflow occurs, then get the preflighting length */
   1756         if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
   1757             char buffer[1024];
   1758 
   1759             destLimit=buffer+sizeof(buffer);
   1760             do {
   1761                 dest=buffer;
   1762                 *pErrorCode=U_ZERO_ERROR;
   1763                 ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
   1764                 destLength+=(int32_t)(dest-buffer);
   1765             } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
   1766         }
   1767     } else {
   1768         destLength=0;
   1769     }
   1770 
   1771     return u_terminateChars(originalDest, destCapacity, destLength, pErrorCode);
   1772 }
   1773 
   1774 U_CAPI int32_t U_EXPORT2
   1775 ucnv_toUChars(UConverter *cnv,
   1776               UChar *dest, int32_t destCapacity,
   1777               const char *src, int32_t srcLength,
   1778               UErrorCode *pErrorCode) {
   1779     const char *srcLimit;
   1780     UChar *originalDest, *destLimit;
   1781     int32_t destLength;
   1782 
   1783     /* check arguments */
   1784     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
   1785         return 0;
   1786     }
   1787 
   1788     if( cnv==NULL ||
   1789         destCapacity<0 || (destCapacity>0 && dest==NULL) ||
   1790         srcLength<-1 || (srcLength!=0 && src==NULL))
   1791     {
   1792         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   1793         return 0;
   1794     }
   1795 
   1796     /* initialize */
   1797     ucnv_resetToUnicode(cnv);
   1798     originalDest=dest;
   1799     if(srcLength==-1) {
   1800         srcLength=(int32_t)uprv_strlen(src);
   1801     }
   1802     if(srcLength>0) {
   1803         srcLimit=src+srcLength;
   1804         destLimit=dest+destCapacity;
   1805 
   1806         /* pin the destination limit to U_MAX_PTR; NULL check is for OS/400 */
   1807         if(destLimit<dest || (destLimit==NULL && dest!=NULL)) {
   1808             destLimit=(UChar *)U_MAX_PTR(dest);
   1809         }
   1810 
   1811         /* perform the conversion */
   1812         ucnv_toUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
   1813         destLength=(int32_t)(dest-originalDest);
   1814 
   1815         /* if an overflow occurs, then get the preflighting length */
   1816         if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR)
   1817         {
   1818             UChar buffer[1024];
   1819 
   1820             destLimit=buffer+sizeof(buffer)/U_SIZEOF_UCHAR;
   1821             do {
   1822                 dest=buffer;
   1823                 *pErrorCode=U_ZERO_ERROR;
   1824                 ucnv_toUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, pErrorCode);
   1825                 destLength+=(int32_t)(dest-buffer);
   1826             }
   1827             while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
   1828         }
   1829     } else {
   1830         destLength=0;
   1831     }
   1832 
   1833     return u_terminateUChars(originalDest, destCapacity, destLength, pErrorCode);
   1834 }
   1835 
   1836 /* ucnv_getNextUChar() ------------------------------------------------------ */
   1837 
   1838 U_CAPI UChar32 U_EXPORT2
   1839 ucnv_getNextUChar(UConverter *cnv,
   1840                   const char **source, const char *sourceLimit,
   1841                   UErrorCode *err) {
   1842     UConverterToUnicodeArgs args;
   1843     UChar buffer[U16_MAX_LENGTH];
   1844     const char *s;
   1845     UChar32 c;
   1846     int32_t i, length;
   1847 
   1848     /* check parameters */
   1849     if(err==NULL || U_FAILURE(*err)) {
   1850         return 0xffff;
   1851     }
   1852 
   1853     if(cnv==NULL || source==NULL) {
   1854         *err=U_ILLEGAL_ARGUMENT_ERROR;
   1855         return 0xffff;
   1856     }
   1857 
   1858     s=*source;
   1859     if(sourceLimit<s) {
   1860         *err=U_ILLEGAL_ARGUMENT_ERROR;
   1861         return 0xffff;
   1862     }
   1863 
   1864     /*
   1865      * Make sure that the buffer sizes do not exceed the number range for
   1866      * int32_t because some functions use the size (in units or bytes)
   1867      * rather than comparing pointers, and because offsets are int32_t values.
   1868      *
   1869      * size_t is guaranteed to be unsigned and large enough for the job.
   1870      *
   1871      * Return with an error instead of adjusting the limits because we would
   1872      * not be able to maintain the semantics that either the source must be
   1873      * consumed or the target filled (unless an error occurs).
   1874      * An adjustment would be sourceLimit=t+0x7fffffff; for example.
   1875      */
   1876     if(((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s)) {
   1877         *err=U_ILLEGAL_ARGUMENT_ERROR;
   1878         return 0xffff;
   1879     }
   1880 
   1881     c=U_SENTINEL;
   1882 
   1883     /* flush the target overflow buffer */
   1884     if(cnv->UCharErrorBufferLength>0) {
   1885         UChar *overflow;
   1886 
   1887         overflow=cnv->UCharErrorBuffer;
   1888         i=0;
   1889         length=cnv->UCharErrorBufferLength;
   1890         U16_NEXT(overflow, i, length, c);
   1891 
   1892         /* move the remaining overflow contents up to the beginning */
   1893         if((cnv->UCharErrorBufferLength=(int8_t)(length-i))>0) {
   1894             uprv_memmove(cnv->UCharErrorBuffer, cnv->UCharErrorBuffer+i,
   1895                          cnv->UCharErrorBufferLength*U_SIZEOF_UCHAR);
   1896         }
   1897 
   1898         if(!U16_IS_LEAD(c) || i<length) {
   1899             return c;
   1900         }
   1901         /*
   1902          * Continue if the overflow buffer contained only a lead surrogate,
   1903          * in case the converter outputs single surrogates from complete
   1904          * input sequences.
   1905          */
   1906     }
   1907 
   1908     /*
   1909      * flush==TRUE is implied for ucnv_getNextUChar()
   1910      *
   1911      * do not simply return even if s==sourceLimit because the converter may
   1912      * not have seen flush==TRUE before
   1913      */
   1914 
   1915     /* prepare the converter arguments */
   1916     args.converter=cnv;
   1917     args.flush=TRUE;
   1918     args.offsets=NULL;
   1919     args.source=s;
   1920     args.sourceLimit=sourceLimit;
   1921     args.target=buffer;
   1922     args.targetLimit=buffer+1;
   1923     args.size=sizeof(args);
   1924 
   1925     if(c<0) {
   1926         /*
   1927          * call the native getNextUChar() implementation if we are
   1928          * at a character boundary (toULength==0)
   1929          *
   1930          * unlike with _toUnicode(), getNextUChar() implementations must set
   1931          * U_TRUNCATED_CHAR_FOUND for truncated input,
   1932          * in addition to setting toULength/toUBytes[]
   1933          */
   1934         if(cnv->toULength==0 && cnv->sharedData->impl->getNextUChar!=NULL) {
   1935             c=cnv->sharedData->impl->getNextUChar(&args, err);
   1936             *source=s=args.source;
   1937             if(*err==U_INDEX_OUTOFBOUNDS_ERROR) {
   1938                 /* reset the converter without calling the callback function */
   1939                 _reset(cnv, UCNV_RESET_TO_UNICODE, FALSE);
   1940                 return 0xffff; /* no output */
   1941             } else if(U_SUCCESS(*err) && c>=0) {
   1942                 return c;
   1943             /*
   1944              * else fall through to use _toUnicode() because
   1945              *   UCNV_GET_NEXT_UCHAR_USE_TO_U: the native function did not want to handle it after all
   1946              *   U_FAILURE: call _toUnicode() for callback handling (do not output c)
   1947              */
   1948             }
   1949         }
   1950 
   1951         /* convert to one UChar in buffer[0], or handle getNextUChar() errors */
   1952         _toUnicodeWithCallback(&args, err);
   1953 
   1954         if(*err==U_BUFFER_OVERFLOW_ERROR) {
   1955             *err=U_ZERO_ERROR;
   1956         }
   1957 
   1958         i=0;
   1959         length=(int32_t)(args.target-buffer);
   1960     } else {
   1961         /* write the lead surrogate from the overflow buffer */
   1962         buffer[0]=(UChar)c;
   1963         args.target=buffer+1;
   1964         i=0;
   1965         length=1;
   1966     }
   1967 
   1968     /* buffer contents starts at i and ends before length */
   1969 
   1970     if(U_FAILURE(*err)) {
   1971         c=0xffff; /* no output */
   1972     } else if(length==0) {
   1973         /* no input or only state changes */
   1974         *err=U_INDEX_OUTOFBOUNDS_ERROR;
   1975         /* no need to reset explicitly because _toUnicodeWithCallback() did it */
   1976         c=0xffff; /* no output */
   1977     } else {
   1978         c=buffer[0];
   1979         i=1;
   1980         if(!U16_IS_LEAD(c)) {
   1981             /* consume c=buffer[0], done */
   1982         } else {
   1983             /* got a lead surrogate, see if a trail surrogate follows */
   1984             UChar c2;
   1985 
   1986             if(cnv->UCharErrorBufferLength>0) {
   1987                 /* got overflow output from the conversion */
   1988                 if(U16_IS_TRAIL(c2=cnv->UCharErrorBuffer[0])) {
   1989                     /* got a trail surrogate, too */
   1990                     c=U16_GET_SUPPLEMENTARY(c, c2);
   1991 
   1992                     /* move the remaining overflow contents up to the beginning */
   1993                     if((--cnv->UCharErrorBufferLength)>0) {
   1994                         uprv_memmove(cnv->UCharErrorBuffer, cnv->UCharErrorBuffer+1,
   1995                                      cnv->UCharErrorBufferLength*U_SIZEOF_UCHAR);
   1996                     }
   1997                 } else {
   1998                     /* c is an unpaired lead surrogate, just return it */
   1999                 }
   2000             } else if(args.source<sourceLimit) {
   2001                 /* convert once more, to buffer[1] */
   2002                 args.targetLimit=buffer+2;
   2003                 _toUnicodeWithCallback(&args, err);
   2004                 if(*err==U_BUFFER_OVERFLOW_ERROR) {
   2005                     *err=U_ZERO_ERROR;
   2006                 }
   2007 
   2008                 length=(int32_t)(args.target-buffer);
   2009                 if(U_SUCCESS(*err) && length==2 && U16_IS_TRAIL(c2=buffer[1])) {
   2010                     /* got a trail surrogate, too */
   2011                     c=U16_GET_SUPPLEMENTARY(c, c2);
   2012                     i=2;
   2013                 }
   2014             }
   2015         }
   2016     }
   2017 
   2018     /*
   2019      * move leftover output from buffer[i..length[
   2020      * into the beginning of the overflow buffer
   2021      */
   2022     if(i<length) {
   2023         /* move further overflow back */
   2024         int32_t delta=length-i;
   2025         if((length=cnv->UCharErrorBufferLength)>0) {
   2026             uprv_memmove(cnv->UCharErrorBuffer+delta, cnv->UCharErrorBuffer,
   2027                          length*U_SIZEOF_UCHAR);
   2028         }
   2029         cnv->UCharErrorBufferLength=(int8_t)(length+delta);
   2030 
   2031         cnv->UCharErrorBuffer[0]=buffer[i++];
   2032         if(delta>1) {
   2033             cnv->UCharErrorBuffer[1]=buffer[i];
   2034         }
   2035     }
   2036 
   2037     *source=args.source;
   2038     return c;
   2039 }
   2040 
   2041 /* ucnv_convert() and siblings ---------------------------------------------- */
   2042 
   2043 U_CAPI void U_EXPORT2
   2044 ucnv_convertEx(UConverter *targetCnv, UConverter *sourceCnv,
   2045                char **target, const char *targetLimit,
   2046                const char **source, const char *sourceLimit,
   2047                UChar *pivotStart, UChar **pivotSource,
   2048                UChar **pivotTarget, const UChar *pivotLimit,
   2049                UBool reset, UBool flush,
   2050                UErrorCode *pErrorCode) {
   2051     UChar pivotBuffer[CHUNK_SIZE];
   2052     const UChar *myPivotSource;
   2053     UChar *myPivotTarget;
   2054     const char *s;
   2055     char *t;
   2056 
   2057     UConverterToUnicodeArgs toUArgs;
   2058     UConverterFromUnicodeArgs fromUArgs;
   2059     UConverterConvert convert;
   2060 
   2061     /* error checking */
   2062     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
   2063         return;
   2064     }
   2065 
   2066     if( targetCnv==NULL || sourceCnv==NULL ||
   2067         source==NULL || *source==NULL ||
   2068         target==NULL || *target==NULL || targetLimit==NULL
   2069     ) {
   2070         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   2071         return;
   2072     }
   2073 
   2074     s=*source;
   2075     t=*target;
   2076     if((sourceLimit!=NULL && sourceLimit<s) || targetLimit<t) {
   2077         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   2078         return;
   2079     }
   2080 
   2081     /*
   2082      * Make sure that the buffer sizes do not exceed the number range for
   2083      * int32_t. See ucnv_toUnicode() for a more detailed comment.
   2084      */
   2085     if(
   2086         (sourceLimit!=NULL && ((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s)) ||
   2087         ((size_t)(targetLimit-t)>(size_t)0x7fffffff && targetLimit>t)
   2088     ) {
   2089         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   2090         return;
   2091     }
   2092 
   2093     if(pivotStart==NULL) {
   2094         if(!flush) {
   2095             /* streaming conversion requires an explicit pivot buffer */
   2096             *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   2097             return;
   2098         }
   2099 
   2100         /* use the stack pivot buffer */
   2101         myPivotSource=myPivotTarget=pivotStart=pivotBuffer;
   2102         pivotSource=(UChar **)&myPivotSource;
   2103         pivotTarget=&myPivotTarget;
   2104         pivotLimit=pivotBuffer+CHUNK_SIZE;
   2105     } else if(  pivotStart>=pivotLimit ||
   2106                 pivotSource==NULL || *pivotSource==NULL ||
   2107                 pivotTarget==NULL || *pivotTarget==NULL ||
   2108                 pivotLimit==NULL
   2109     ) {
   2110         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   2111         return;
   2112     }
   2113 
   2114     if(sourceLimit==NULL) {
   2115         /* get limit of single-byte-NUL-terminated source string */
   2116         sourceLimit=uprv_strchr(*source, 0);
   2117     }
   2118 
   2119     if(reset) {
   2120         ucnv_resetToUnicode(sourceCnv);
   2121         ucnv_resetFromUnicode(targetCnv);
   2122         *pivotSource=*pivotTarget=pivotStart;
   2123     } else if(targetCnv->charErrorBufferLength>0) {
   2124         /* output the targetCnv overflow buffer */
   2125         if(ucnv_outputOverflowFromUnicode(targetCnv, target, targetLimit, NULL, pErrorCode)) {
   2126             /* U_BUFFER_OVERFLOW_ERROR */
   2127             return;
   2128         }
   2129         /* *target has moved, therefore stop using t */
   2130 
   2131         if( !flush &&
   2132             targetCnv->preFromULength>=0 && *pivotSource==*pivotTarget &&
   2133             sourceCnv->UCharErrorBufferLength==0 && sourceCnv->preToULength>=0 && s==sourceLimit
   2134         ) {
   2135             /* the fromUnicode overflow buffer is emptied and there is no new input: we are done */
   2136             return;
   2137         }
   2138     }
   2139 
   2140     /* Is direct-UTF-8 conversion available? */
   2141     if( sourceCnv->sharedData->staticData->conversionType==UCNV_UTF8 &&
   2142         targetCnv->sharedData->impl->fromUTF8!=NULL
   2143     ) {
   2144         convert=targetCnv->sharedData->impl->fromUTF8;
   2145     } else if( targetCnv->sharedData->staticData->conversionType==UCNV_UTF8 &&
   2146                sourceCnv->sharedData->impl->toUTF8!=NULL
   2147     ) {
   2148         convert=sourceCnv->sharedData->impl->toUTF8;
   2149     } else {
   2150         convert=NULL;
   2151     }
   2152 
   2153     /*
   2154      * If direct-UTF-8 conversion is available, then we use a smaller
   2155      * pivot buffer for error handling and partial matches
   2156      * so that we quickly return to direct conversion.
   2157      *
   2158      * 32 is large enough for UCNV_EXT_MAX_UCHARS and UCNV_ERROR_BUFFER_LENGTH.
   2159      *
   2160      * We could reduce the pivot buffer size further, at the cost of
   2161      * buffer overflows from callbacks.
   2162      * The pivot buffer should not be smaller than the maximum number of
   2163      * fromUnicode extension table input UChars
   2164      * (for m:n conversion, see
   2165      * targetCnv->sharedData->mbcs.extIndexes[UCNV_EXT_COUNT_UCHARS])
   2166      * or 2 for surrogate pairs.
   2167      *
   2168      * Too small a buffer can cause thrashing between pivoting and direct
   2169      * conversion, with function call overhead outweighing the benefits
   2170      * of direct conversion.
   2171      */
   2172     if(convert!=NULL && (pivotLimit-pivotStart)>32) {
   2173         pivotLimit=pivotStart+32;
   2174     }
   2175 
   2176     /* prepare the converter arguments */
   2177     fromUArgs.converter=targetCnv;
   2178     fromUArgs.flush=FALSE;
   2179     fromUArgs.offsets=NULL;
   2180     fromUArgs.target=*target;
   2181     fromUArgs.targetLimit=targetLimit;
   2182     fromUArgs.size=sizeof(fromUArgs);
   2183 
   2184     toUArgs.converter=sourceCnv;
   2185     toUArgs.flush=flush;
   2186     toUArgs.offsets=NULL;
   2187     toUArgs.source=s;
   2188     toUArgs.sourceLimit=sourceLimit;
   2189     toUArgs.targetLimit=pivotLimit;
   2190     toUArgs.size=sizeof(toUArgs);
   2191 
   2192     /*
   2193      * TODO: Consider separating this function into two functions,
   2194      * extracting exactly the conversion loop,
   2195      * for readability and to reduce the set of visible variables.
   2196      *
   2197      * Otherwise stop using s and t from here on.
   2198      */
   2199     s=t=NULL;
   2200 
   2201     /*
   2202      * conversion loop
   2203      *
   2204      * The sequence of steps in the loop may appear backward,
   2205      * but the principle is simple:
   2206      * In the chain of
   2207      *   source - sourceCnv overflow - pivot - targetCnv overflow - target
   2208      * empty out later buffers before refilling them from earlier ones.
   2209      *
   2210      * The targetCnv overflow buffer is flushed out only once before the loop.
   2211      */
   2212     for(;;) {
   2213         /*
   2214          * if(pivot not empty or error or replay or flush fromUnicode) {
   2215          *   fromUnicode(pivot -> target);
   2216          * }
   2217          *
   2218          * For pivoting conversion; and for direct conversion for
   2219          * error callback handling and flushing the replay buffer.
   2220          */
   2221         if( *pivotSource<*pivotTarget ||
   2222             U_FAILURE(*pErrorCode) ||
   2223             targetCnv->preFromULength<0 ||
   2224             fromUArgs.flush
   2225         ) {
   2226             fromUArgs.source=*pivotSource;
   2227             fromUArgs.sourceLimit=*pivotTarget;
   2228             _fromUnicodeWithCallback(&fromUArgs, pErrorCode);
   2229             if(U_FAILURE(*pErrorCode)) {
   2230                 /* target overflow, or conversion error */
   2231                 *pivotSource=(UChar *)fromUArgs.source;
   2232                 break;
   2233             }
   2234 
   2235             /*
   2236              * _fromUnicodeWithCallback() must have consumed the pivot contents
   2237              * (*pivotSource==*pivotTarget) since it returned with U_SUCCESS()
   2238              */
   2239         }
   2240 
   2241         /* The pivot buffer is empty; reset it so we start at pivotStart. */
   2242         *pivotSource=*pivotTarget=pivotStart;
   2243 
   2244         /*
   2245          * if(sourceCnv overflow buffer not empty) {
   2246          *     move(sourceCnv overflow buffer -> pivot);
   2247          *     continue;
   2248          * }
   2249          */
   2250         /* output the sourceCnv overflow buffer */
   2251         if(sourceCnv->UCharErrorBufferLength>0) {
   2252             if(ucnv_outputOverflowToUnicode(sourceCnv, pivotTarget, pivotLimit, NULL, pErrorCode)) {
   2253                 /* U_BUFFER_OVERFLOW_ERROR */
   2254                 *pErrorCode=U_ZERO_ERROR;
   2255             }
   2256             continue;
   2257         }
   2258 
   2259         /*
   2260          * check for end of input and break if done
   2261          *
   2262          * Checking both flush and fromUArgs.flush ensures that the converters
   2263          * have been called with the flush flag set if the ucnv_convertEx()
   2264          * caller set it.
   2265          */
   2266         if( toUArgs.source==sourceLimit &&
   2267             sourceCnv->preToULength>=0 && sourceCnv->toULength==0 &&
   2268             (!flush || fromUArgs.flush)
   2269         ) {
   2270             /* done successfully */
   2271             break;
   2272         }
   2273 
   2274         /*
   2275          * use direct conversion if available
   2276          * but not if continuing a partial match
   2277          * or flushing the toUnicode replay buffer
   2278          */
   2279         if(convert!=NULL && targetCnv->preFromUFirstCP<0 && sourceCnv->preToULength==0) {
   2280             if(*pErrorCode==U_USING_DEFAULT_WARNING) {
   2281                 /* remove a warning that may be set by this function */
   2282                 *pErrorCode=U_ZERO_ERROR;
   2283             }
   2284             convert(&fromUArgs, &toUArgs, pErrorCode);
   2285             if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
   2286                 break;
   2287             } else if(U_FAILURE(*pErrorCode)) {
   2288                 if(sourceCnv->toULength>0) {
   2289                     /*
   2290                      * Fall through to calling _toUnicodeWithCallback()
   2291                      * for callback handling.
   2292                      *
   2293                      * The pivot buffer will be reset with
   2294                      *   *pivotSource=*pivotTarget=pivotStart;
   2295                      * which indicates a toUnicode error to the caller
   2296                      * (*pivotSource==pivotStart shows no pivot UChars consumed).
   2297                      */
   2298                 } else {
   2299                     /*
   2300                      * Indicate a fromUnicode error to the caller
   2301                      * (*pivotSource>pivotStart shows some pivot UChars consumed).
   2302                      */
   2303                     *pivotSource=*pivotTarget=pivotStart+1;
   2304                     /*
   2305                      * Loop around to calling _fromUnicodeWithCallbacks()
   2306                      * for callback handling.
   2307                      */
   2308                     continue;
   2309                 }
   2310             } else if(*pErrorCode==U_USING_DEFAULT_WARNING) {
   2311                 /*
   2312                  * No error, but the implementation requested to temporarily
   2313                  * fall back to pivoting.
   2314                  */
   2315                 *pErrorCode=U_ZERO_ERROR;
   2316             /*
   2317              * The following else branches are almost identical to the end-of-input
   2318              * handling in _toUnicodeWithCallback().
   2319              * Avoid calling it just for the end of input.
   2320              */
   2321             } else if(flush && sourceCnv->toULength>0) { /* flush==toUArgs.flush */
   2322                 /*
   2323                  * the entire input stream is consumed
   2324                  * and there is a partial, truncated input sequence left
   2325                  */
   2326 
   2327                 /* inject an error and continue with callback handling */
   2328                 *pErrorCode=U_TRUNCATED_CHAR_FOUND;
   2329             } else {
   2330                 /* input consumed */
   2331                 if(flush) {
   2332                     /* reset the converters without calling the callback functions */
   2333                     _reset(sourceCnv, UCNV_RESET_TO_UNICODE, FALSE);
   2334                     _reset(targetCnv, UCNV_RESET_FROM_UNICODE, FALSE);
   2335                 }
   2336 
   2337                 /* done successfully */
   2338                 break;
   2339             }
   2340         }
   2341 
   2342         /*
   2343          * toUnicode(source -> pivot);
   2344          *
   2345          * For pivoting conversion; and for direct conversion for
   2346          * error callback handling, continuing partial matches
   2347          * and flushing the replay buffer.
   2348          *
   2349          * The pivot buffer is empty and reset.
   2350          */
   2351         toUArgs.target=pivotStart; /* ==*pivotTarget */
   2352         /* toUArgs.targetLimit=pivotLimit; already set before the loop */
   2353         _toUnicodeWithCallback(&toUArgs, pErrorCode);
   2354         *pivotTarget=toUArgs.target;
   2355         if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
   2356             /* pivot overflow: continue with the conversion loop */
   2357             *pErrorCode=U_ZERO_ERROR;
   2358         } else if(U_FAILURE(*pErrorCode) || (!flush && *pivotTarget==pivotStart)) {
   2359             /* conversion error, or there was nothing left to convert */
   2360             break;
   2361         }
   2362         /*
   2363          * else:
   2364          * _toUnicodeWithCallback() wrote into the pivot buffer,
   2365          * continue with fromUnicode conversion.
   2366          *
   2367          * Set the fromUnicode flush flag if we flush and if toUnicode has
   2368          * processed the end of the input.
   2369          */
   2370         if( flush && toUArgs.source==sourceLimit &&
   2371             sourceCnv->preToULength>=0 &&
   2372             sourceCnv->UCharErrorBufferLength==0
   2373         ) {
   2374             fromUArgs.flush=TRUE;
   2375         }
   2376     }
   2377 
   2378     /*
   2379      * The conversion loop is exited when one of the following is true:
   2380      * - the entire source text has been converted successfully to the target buffer
   2381      * - a target buffer overflow occurred
   2382      * - a conversion error occurred
   2383      */
   2384 
   2385     *source=toUArgs.source;
   2386     *target=fromUArgs.target;
   2387 
   2388     /* terminate the target buffer if possible */
   2389     if(flush && U_SUCCESS(*pErrorCode)) {
   2390         if(*target!=targetLimit) {
   2391             **target=0;
   2392             if(*pErrorCode==U_STRING_NOT_TERMINATED_WARNING) {
   2393                 *pErrorCode=U_ZERO_ERROR;
   2394             }
   2395         } else {
   2396             *pErrorCode=U_STRING_NOT_TERMINATED_WARNING;
   2397         }
   2398     }
   2399 }
   2400 
   2401 /* internal implementation of ucnv_convert() etc. with preflighting */
   2402 static int32_t
   2403 ucnv_internalConvert(UConverter *outConverter, UConverter *inConverter,
   2404                      char *target, int32_t targetCapacity,
   2405                      const char *source, int32_t sourceLength,
   2406                      UErrorCode *pErrorCode) {
   2407     UChar pivotBuffer[CHUNK_SIZE];
   2408     UChar *pivot, *pivot2;
   2409 
   2410     char *myTarget;
   2411     const char *sourceLimit;
   2412     const char *targetLimit;
   2413     int32_t targetLength=0;
   2414 
   2415     /* set up */
   2416     if(sourceLength<0) {
   2417         sourceLimit=uprv_strchr(source, 0);
   2418     } else {
   2419         sourceLimit=source+sourceLength;
   2420     }
   2421 
   2422     /* if there is no input data, we're done */
   2423     if(source==sourceLimit) {
   2424         return u_terminateChars(target, targetCapacity, 0, pErrorCode);
   2425     }
   2426 
   2427     pivot=pivot2=pivotBuffer;
   2428     myTarget=target;
   2429     targetLength=0;
   2430 
   2431     if(targetCapacity>0) {
   2432         /* perform real conversion */
   2433         targetLimit=target+targetCapacity;
   2434         ucnv_convertEx(outConverter, inConverter,
   2435                        &myTarget, targetLimit,
   2436                        &source, sourceLimit,
   2437                        pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE,
   2438                        FALSE,
   2439                        TRUE,
   2440                        pErrorCode);
   2441         targetLength=(int32_t)(myTarget-target);
   2442     }
   2443 
   2444     /*
   2445      * If the output buffer is exhausted (or we are only "preflighting"), we need to stop writing
   2446      * to it but continue the conversion in order to store in targetCapacity
   2447      * the number of bytes that was required.
   2448      */
   2449     if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR || targetCapacity==0)
   2450     {
   2451         char targetBuffer[CHUNK_SIZE];
   2452 
   2453         targetLimit=targetBuffer+CHUNK_SIZE;
   2454         do {
   2455             *pErrorCode=U_ZERO_ERROR;
   2456             myTarget=targetBuffer;
   2457             ucnv_convertEx(outConverter, inConverter,
   2458                            &myTarget, targetLimit,
   2459                            &source, sourceLimit,
   2460                            pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE,
   2461                            FALSE,
   2462                            TRUE,
   2463                            pErrorCode);
   2464             targetLength+=(int32_t)(myTarget-targetBuffer);
   2465         } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
   2466 
   2467         /* done with preflighting, set warnings and errors as appropriate */
   2468         return u_terminateChars(target, targetCapacity, targetLength, pErrorCode);
   2469     }
   2470 
   2471     /* no need to call u_terminateChars() because ucnv_convertEx() took care of that */
   2472     return targetLength;
   2473 }
   2474 
   2475 U_CAPI int32_t U_EXPORT2
   2476 ucnv_convert(const char *toConverterName, const char *fromConverterName,
   2477              char *target, int32_t targetCapacity,
   2478              const char *source, int32_t sourceLength,
   2479              UErrorCode *pErrorCode) {
   2480     UConverter in, out; /* stack-allocated */
   2481     UConverter *inConverter, *outConverter;
   2482     int32_t targetLength;
   2483 
   2484     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
   2485         return 0;
   2486     }
   2487 
   2488     if( source==NULL || sourceLength<-1 ||
   2489         targetCapacity<0 || (targetCapacity>0 && target==NULL)
   2490     ) {
   2491         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   2492         return 0;
   2493     }
   2494 
   2495     /* if there is no input data, we're done */
   2496     if(sourceLength==0 || (sourceLength<0 && *source==0)) {
   2497         return u_terminateChars(target, targetCapacity, 0, pErrorCode);
   2498     }
   2499 
   2500     /* create the converters */
   2501     inConverter=ucnv_createConverter(&in, fromConverterName, pErrorCode);
   2502     if(U_FAILURE(*pErrorCode)) {
   2503         return 0;
   2504     }
   2505 
   2506     outConverter=ucnv_createConverter(&out, toConverterName, pErrorCode);
   2507     if(U_FAILURE(*pErrorCode)) {
   2508         ucnv_close(inConverter);
   2509         return 0;
   2510     }
   2511 
   2512     targetLength=ucnv_internalConvert(outConverter, inConverter,
   2513                                       target, targetCapacity,
   2514                                       source, sourceLength,
   2515                                       pErrorCode);
   2516 
   2517     ucnv_close(inConverter);
   2518     ucnv_close(outConverter);
   2519 
   2520     return targetLength;
   2521 }
   2522 
   2523 /* @internal */
   2524 static int32_t
   2525 ucnv_convertAlgorithmic(UBool convertToAlgorithmic,
   2526                         UConverterType algorithmicType,
   2527                         UConverter *cnv,
   2528                         char *target, int32_t targetCapacity,
   2529                         const char *source, int32_t sourceLength,
   2530                         UErrorCode *pErrorCode) {
   2531     UConverter algoConverterStatic; /* stack-allocated */
   2532     UConverter *algoConverter, *to, *from;
   2533     int32_t targetLength;
   2534 
   2535     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
   2536         return 0;
   2537     }
   2538 
   2539     if( cnv==NULL || source==NULL || sourceLength<-1 ||
   2540         targetCapacity<0 || (targetCapacity>0 && target==NULL)
   2541     ) {
   2542         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
   2543         return 0;
   2544     }
   2545 
   2546     /* if there is no input data, we're done */
   2547     if(sourceLength==0 || (sourceLength<0 && *source==0)) {
   2548         return u_terminateChars(target, targetCapacity, 0, pErrorCode);
   2549     }
   2550 
   2551     /* create the algorithmic converter */
   2552     algoConverter=ucnv_createAlgorithmicConverter(&algoConverterStatic, algorithmicType,
   2553                                                   "", 0, pErrorCode);
   2554     if(U_FAILURE(*pErrorCode)) {
   2555         return 0;
   2556     }
   2557 
   2558     /* reset the other converter */
   2559     if(convertToAlgorithmic) {
   2560         /* cnv->Unicode->algo */
   2561         ucnv_resetToUnicode(cnv);
   2562         to=algoConverter;
   2563         from=cnv;
   2564     } else {
   2565         /* algo->Unicode->cnv */
   2566         ucnv_resetFromUnicode(cnv);
   2567         from=algoConverter;
   2568         to=cnv;
   2569     }
   2570 
   2571     targetLength=ucnv_internalConvert(to, from,
   2572                                       target, targetCapacity,
   2573                                       source, sourceLength,
   2574                                       pErrorCode);
   2575 
   2576     ucnv_close(algoConverter);
   2577 
   2578     return targetLength;
   2579 }
   2580 
   2581 U_CAPI int32_t U_EXPORT2
   2582 ucnv_toAlgorithmic(UConverterType algorithmicType,
   2583                    UConverter *cnv,
   2584                    char *target, int32_t targetCapacity,
   2585                    const char *source, int32_t sourceLength,
   2586                    UErrorCode *pErrorCode) {
   2587     return ucnv_convertAlgorithmic(TRUE, algorithmicType, cnv,
   2588                                    target, targetCapacity,
   2589                                    source, sourceLength,
   2590                                    pErrorCode);
   2591 }
   2592 
   2593 U_CAPI int32_t U_EXPORT2
   2594 ucnv_fromAlgorithmic(UConverter *cnv,
   2595                      UConverterType algorithmicType,
   2596                      char *target, int32_t targetCapacity,
   2597                      const char *source, int32_t sourceLength,
   2598                      UErrorCode *pErrorCode) {
   2599     return ucnv_convertAlgorithmic(FALSE, algorithmicType, cnv,
   2600                                    target, targetCapacity,
   2601                                    source, sourceLength,
   2602                                    pErrorCode);
   2603 }
   2604 
   2605 U_CAPI UConverterType  U_EXPORT2
   2606 ucnv_getType(const UConverter* converter)
   2607 {
   2608     int8_t type = converter->sharedData->staticData->conversionType;
   2609 #if !UCONFIG_NO_LEGACY_CONVERSION
   2610     if(type == UCNV_MBCS) {
   2611         return ucnv_MBCSGetType(converter);
   2612     }
   2613 #endif
   2614     return (UConverterType)type;
   2615 }
   2616 
   2617 U_CAPI void  U_EXPORT2
   2618 ucnv_getStarters(const UConverter* converter,
   2619                  UBool starters[256],
   2620                  UErrorCode* err)
   2621 {
   2622     if (err == NULL || U_FAILURE(*err)) {
   2623         return;
   2624     }
   2625 
   2626     if(converter->sharedData->impl->getStarters != NULL) {
   2627         converter->sharedData->impl->getStarters(converter, starters, err);
   2628     } else {
   2629         *err = U_ILLEGAL_ARGUMENT_ERROR;
   2630     }
   2631 }
   2632 
   2633 static const UAmbiguousConverter *ucnv_getAmbiguous(const UConverter *cnv)
   2634 {
   2635     UErrorCode errorCode;
   2636     const char *name;
   2637     int32_t i;
   2638 
   2639     if(cnv==NULL) {
   2640         return NULL;
   2641     }
   2642 
   2643     errorCode=U_ZERO_ERROR;
   2644     name=ucnv_getName(cnv, &errorCode);
   2645     if(U_FAILURE(errorCode)) {
   2646         return NULL;
   2647     }
   2648 
   2649     for(i=0; i<(int32_t)(sizeof(ambiguousConverters)/sizeof(UAmbiguousConverter)); ++i)
   2650     {
   2651         if(0==uprv_strcmp(name, ambiguousConverters[i].name))
   2652         {
   2653             return ambiguousConverters+i;
   2654         }
   2655     }
   2656 
   2657     return NULL;
   2658 }
   2659 
   2660 U_CAPI void  U_EXPORT2
   2661 ucnv_fixFileSeparator(const UConverter *cnv,
   2662                       UChar* source,
   2663                       int32_t sourceLength) {
   2664     const UAmbiguousConverter *a;
   2665     int32_t i;
   2666     UChar variant5c;
   2667 
   2668     if(cnv==NULL || source==NULL || sourceLength<=0 || (a=ucnv_getAmbiguous(cnv))==NULL)
   2669     {
   2670         return;
   2671     }
   2672 
   2673     variant5c=a->variant5c;
   2674     for(i=0; i<sourceLength; ++i) {
   2675         if(source[i]==variant5c) {
   2676             source[i]=0x5c;
   2677         }
   2678     }
   2679 }
   2680 
   2681 U_CAPI UBool  U_EXPORT2
   2682 ucnv_isAmbiguous(const UConverter *cnv) {
   2683     return (UBool)(ucnv_getAmbiguous(cnv)!=NULL);
   2684 }
   2685 
   2686 U_CAPI void  U_EXPORT2
   2687 ucnv_setFallback(UConverter *cnv, UBool usesFallback)
   2688 {
   2689     cnv->useFallback = usesFallback;
   2690 }
   2691 
   2692 U_CAPI UBool  U_EXPORT2
   2693 ucnv_usesFallback(const UConverter *cnv)
   2694 {
   2695     return cnv->useFallback;
   2696 }
   2697 
   2698 U_CAPI void  U_EXPORT2
   2699 ucnv_getInvalidChars (const UConverter * converter,
   2700                       char *errBytes,
   2701                       int8_t * len,
   2702                       UErrorCode * err)
   2703 {
   2704     if (err == NULL || U_FAILURE(*err))
   2705     {
   2706         return;
   2707     }
   2708     if (len == NULL || errBytes == NULL || converter == NULL)
   2709     {
   2710         *err = U_ILLEGAL_ARGUMENT_ERROR;
   2711         return;
   2712     }
   2713     if (*len < converter->invalidCharLength)
   2714     {
   2715         *err = U_INDEX_OUTOFBOUNDS_ERROR;
   2716         return;
   2717     }
   2718     if ((*len = converter->invalidCharLength) > 0)
   2719     {
   2720         uprv_memcpy (errBytes, converter->invalidCharBuffer, *len);
   2721     }
   2722 }
   2723 
   2724 U_CAPI void  U_EXPORT2
   2725 ucnv_getInvalidUChars (const UConverter * converter,
   2726                        UChar *errChars,
   2727                        int8_t * len,
   2728                        UErrorCode * err)
   2729 {
   2730     if (err == NULL || U_FAILURE(*err))
   2731     {
   2732         return;
   2733     }
   2734     if (len == NULL || errChars == NULL || converter == NULL)
   2735     {
   2736         *err = U_ILLEGAL_ARGUMENT_ERROR;
   2737         return;
   2738     }
   2739     if (*len < converter->invalidUCharLength)
   2740     {
   2741         *err = U_INDEX_OUTOFBOUNDS_ERROR;
   2742         return;
   2743     }
   2744     if ((*len = converter->invalidUCharLength) > 0)
   2745     {
   2746         uprv_memcpy (errChars, converter->invalidUCharBuffer, sizeof(UChar) * (*len));
   2747     }
   2748 }
   2749 
   2750 #define SIG_MAX_LEN 5
   2751 
   2752 U_CAPI const char* U_EXPORT2
   2753 ucnv_detectUnicodeSignature( const char* source,
   2754                              int32_t sourceLength,
   2755                              int32_t* signatureLength,
   2756                              UErrorCode* pErrorCode) {
   2757     int32_t dummy;
   2758 
   2759     /* initial 0xa5 bytes: make sure that if we read <SIG_MAX_LEN
   2760      * bytes we don't misdetect something
   2761      */
   2762     char start[SIG_MAX_LEN]={ '\xa5', '\xa5', '\xa5', '\xa5', '\xa5' };
   2763     int i = 0;
   2764 
   2765     if((pErrorCode==NULL) || U_FAILURE(*pErrorCode)){
   2766         return NULL;
   2767     }
   2768 
   2769     if(source == NULL || sourceLength < -1){
   2770         *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
   2771         return NULL;
   2772     }
   2773 
   2774     if(signatureLength == NULL) {
   2775         signatureLength = &dummy;
   2776     }
   2777 
   2778     if(sourceLength==-1){
   2779         sourceLength=(int32_t)uprv_strlen(source);
   2780     }
   2781 
   2782 
   2783     while(i<sourceLength&& i<SIG_MAX_LEN){
   2784         start[i]=source[i];
   2785         i++;
   2786     }
   2787 
   2788     if(start[0] == '\xFE' && start[1] == '\xFF') {
   2789         *signatureLength=2;
   2790         return  "UTF-16BE";
   2791     } else if(start[0] == '\xFF' && start[1] == '\xFE') {
   2792         if(start[2] == '\x00' && start[3] =='\x00') {
   2793             *signatureLength=4;
   2794             return "UTF-32LE";
   2795         } else {
   2796             *signatureLength=2;
   2797             return  "UTF-16LE";
   2798         }
   2799     } else if(start[0] == '\xEF' && start[1] == '\xBB' && start[2] == '\xBF') {
   2800         *signatureLength=3;
   2801         return  "UTF-8";
   2802     } else if(start[0] == '\x00' && start[1] == '\x00' &&
   2803               start[2] == '\xFE' && start[3]=='\xFF') {
   2804         *signatureLength=4;
   2805         return  "UTF-32BE";
   2806     } else if(start[0] == '\x0E' && start[1] == '\xFE' && start[2] == '\xFF') {
   2807         *signatureLength=3;
   2808         return "SCSU";
   2809     } else if(start[0] == '\xFB' && start[1] == '\xEE' && start[2] == '\x28') {
   2810         *signatureLength=3;
   2811         return "BOCU-1";
   2812     } else if(start[0] == '\x2B' && start[1] == '\x2F' && start[2] == '\x76') {
   2813         /*
   2814          * UTF-7: Initial U+FEFF is encoded as +/v8  or  +/v9  or  +/v+  or  +/v/
   2815          * depending on the second UTF-16 code unit.
   2816          * Detect the entire, closed Unicode mode sequence +/v8- for only U+FEFF
   2817          * if it occurs.
   2818          *
   2819          * So far we have +/v
   2820          */
   2821         if(start[3] == '\x38' && start[4] == '\x2D') {
   2822             /* 5 bytes +/v8- */
   2823             *signatureLength=5;
   2824             return "UTF-7";
   2825         } else if(start[3] == '\x38' || start[3] == '\x39' || start[3] == '\x2B' || start[3] == '\x2F') {
   2826             /* 4 bytes +/v8  or  +/v9  or  +/v+  or  +/v/ */
   2827             *signatureLength=4;
   2828             return "UTF-7";
   2829         }
   2830     }else if(start[0]=='\xDD' && start[1]== '\x73'&& start[2]=='\x66' && start[3]=='\x73'){
   2831         *signatureLength=4;
   2832         return "UTF-EBCDIC";
   2833     }
   2834 
   2835 
   2836     /* no known Unicode signature byte sequence recognized */
   2837     *signatureLength=0;
   2838     return NULL;
   2839 }
   2840 
   2841 U_CAPI int32_t U_EXPORT2
   2842 ucnv_fromUCountPending(const UConverter* cnv, UErrorCode* status)
   2843 {
   2844     if(status == NULL || U_FAILURE(*status)){
   2845         return -1;
   2846     }
   2847     if(cnv == NULL){
   2848         *status = U_ILLEGAL_ARGUMENT_ERROR;
   2849         return -1;
   2850     }
   2851 
   2852     if(cnv->preFromUFirstCP >= 0){
   2853         return U16_LENGTH(cnv->preFromUFirstCP)+cnv->preFromULength ;
   2854     }else if(cnv->preFromULength < 0){
   2855         return -cnv->preFromULength ;
   2856     }else if(cnv->fromUChar32 > 0){
   2857         return 1;
   2858     }
   2859     return 0;
   2860 
   2861 }
   2862 
   2863 U_CAPI int32_t U_EXPORT2
   2864 ucnv_toUCountPending(const UConverter* cnv, UErrorCode* status){
   2865 
   2866     if(status == NULL || U_FAILURE(*status)){
   2867         return -1;
   2868     }
   2869     if(cnv == NULL){
   2870         *status = U_ILLEGAL_ARGUMENT_ERROR;
   2871         return -1;
   2872     }
   2873 
   2874     if(cnv->preToULength > 0){
   2875         return cnv->preToULength ;
   2876     }else if(cnv->preToULength < 0){
   2877         return -cnv->preToULength;
   2878     }else if(cnv->toULength > 0){
   2879         return cnv->toULength;
   2880     }
   2881     return 0;
   2882 }
   2883 
   2884 U_CAPI UBool U_EXPORT2
   2885 ucnv_isFixedWidth(UConverter *cnv, UErrorCode *status){
   2886     if (U_FAILURE(*status)) {
   2887         return FALSE;
   2888     }
   2889 
   2890     if (cnv == NULL) {
   2891         *status = U_ILLEGAL_ARGUMENT_ERROR;
   2892         return FALSE;
   2893     }
   2894 
   2895     switch (ucnv_getType(cnv)) {
   2896         case UCNV_SBCS:
   2897         case UCNV_DBCS:
   2898         case UCNV_UTF32_BigEndian:
   2899         case UCNV_UTF32_LittleEndian:
   2900         case UCNV_UTF32:
   2901         case UCNV_US_ASCII:
   2902             return TRUE;
   2903         default:
   2904             return FALSE;
   2905     }
   2906 }
   2907 #endif
   2908 
   2909 /*
   2910  * Hey, Emacs, please set the following:
   2911  *
   2912  * Local Variables:
   2913  * indent-tabs-mode: nil
   2914  * End:
   2915  *
   2916  */
   2917