Home | History | Annotate | Download | only in common
      1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 /*
      4  ********************************************************************
      5  * COPYRIGHT:
      6  * Copyright (c) 1996-2016, International Business Machines Corporation and
      7  * others. All Rights Reserved.
      8  ********************************************************************
      9  *
     10  *  ucnv_bld.cpp:
     11  *
     12  *  Defines functions that are used in the creation/initialization/deletion
     13  *  of converters and related structures.
     14  *  uses uconv_io.h routines to access disk information
     15  *  is used by ucnv.h to implement public API create/delete/flushCache routines
     16  * Modification History:
     17  *
     18  *   Date        Name        Description
     19  *
     20  *   06/20/2000  helena      OS/400 port changes; mostly typecast.
     21  *   06/29/2000  helena      Major rewrite of the callback interface.
     22 */
     23 
     24 #include "unicode/utypes.h"
     25 
     26 #if !UCONFIG_NO_CONVERSION
     27 
     28 #include "unicode/putil.h"
     29 #include "unicode/udata.h"
     30 #include "unicode/ucnv.h"
     31 #include "unicode/uloc.h"
     32 #include "mutex.h"
     33 #include "putilimp.h"
     34 #include "uassert.h"
     35 #include "utracimp.h"
     36 #include "ucnv_io.h"
     37 #include "ucnv_bld.h"
     38 #include "ucnvmbcs.h"
     39 #include "ucnv_ext.h"
     40 #include "ucnv_cnv.h"
     41 #include "ucnv_imp.h"
     42 #include "uhash.h"
     43 #include "umutex.h"
     44 #include "cstring.h"
     45 #include "cmemory.h"
     46 #include "ucln_cmn.h"
     47 #include "ustr_cnv.h"
     48 
     49 
     50 #if 0
     51 #include <stdio.h>
     52 extern void UCNV_DEBUG_LOG(char *what, char *who, void *p, int l);
     53 #define UCNV_DEBUG_LOG(x,y,z) UCNV_DEBUG_LOG(x,y,z,__LINE__)
     54 #else
     55 # define UCNV_DEBUG_LOG(x,y,z)
     56 #endif
     57 
     58 static const UConverterSharedData * const
     59 converterData[UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES]={
     60     NULL, NULL,
     61 
     62 #if UCONFIG_NO_LEGACY_CONVERSION
     63     NULL,
     64 #else
     65     &_MBCSData,
     66 #endif
     67 
     68     &_Latin1Data,
     69     &_UTF8Data, &_UTF16BEData, &_UTF16LEData,
     70 #if UCONFIG_ONLY_HTML_CONVERSION
     71     NULL, NULL,
     72 #else
     73     &_UTF32BEData, &_UTF32LEData,
     74 #endif
     75     NULL,
     76 
     77 #if UCONFIG_NO_LEGACY_CONVERSION
     78     NULL,
     79 #else
     80     &_ISO2022Data,
     81 #endif
     82 
     83 #if UCONFIG_NO_LEGACY_CONVERSION || UCONFIG_ONLY_HTML_CONVERSION
     84     NULL, NULL, NULL, NULL, NULL, NULL,
     85     NULL, NULL, NULL, NULL, NULL, NULL,
     86     NULL,
     87 #else
     88     &_LMBCSData1,&_LMBCSData2, &_LMBCSData3, &_LMBCSData4, &_LMBCSData5, &_LMBCSData6,
     89     &_LMBCSData8,&_LMBCSData11,&_LMBCSData16,&_LMBCSData17,&_LMBCSData18,&_LMBCSData19,
     90     &_HZData,
     91 #endif
     92 
     93 #if UCONFIG_ONLY_HTML_CONVERSION
     94     NULL,
     95 #else
     96     &_SCSUData,
     97 #endif
     98 
     99 
    100 #if UCONFIG_NO_LEGACY_CONVERSION || UCONFIG_ONLY_HTML_CONVERSION
    101     NULL,
    102 #else
    103     &_ISCIIData,
    104 #endif
    105 
    106     &_ASCIIData,
    107 #if UCONFIG_ONLY_HTML_CONVERSION
    108     NULL, NULL, &_UTF16Data, NULL, NULL, NULL,
    109 #else
    110     &_UTF7Data, &_Bocu1Data, &_UTF16Data, &_UTF32Data, &_CESU8Data, &_IMAPData,
    111 #endif
    112 
    113 #if UCONFIG_NO_LEGACY_CONVERSION || UCONFIG_ONLY_HTML_CONVERSION
    114     NULL,
    115 #else
    116     &_CompoundTextData
    117 #endif
    118 };
    119 
    120 /* Please keep this in binary sorted order for getAlgorithmicTypeFromName.
    121    Also the name should be in lower case and all spaces, dashes and underscores
    122    removed
    123 */
    124 static struct {
    125   const char *name;
    126   const UConverterType type;
    127 } const cnvNameType[] = {
    128 #if !UCONFIG_ONLY_HTML_CONVERSION
    129   { "bocu1", UCNV_BOCU1 },
    130   { "cesu8", UCNV_CESU8 },
    131 #endif
    132 #if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION
    133   { "hz",UCNV_HZ },
    134 #endif
    135 #if !UCONFIG_ONLY_HTML_CONVERSION
    136   { "imapmailboxname", UCNV_IMAP_MAILBOX },
    137 #endif
    138 #if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION
    139   { "iscii", UCNV_ISCII },
    140 #endif
    141 #if !UCONFIG_NO_LEGACY_CONVERSION
    142   { "iso2022", UCNV_ISO_2022 },
    143 #endif
    144   { "iso88591", UCNV_LATIN_1 },
    145 #if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION
    146   { "lmbcs1", UCNV_LMBCS_1 },
    147   { "lmbcs11",UCNV_LMBCS_11 },
    148   { "lmbcs16",UCNV_LMBCS_16 },
    149   { "lmbcs17",UCNV_LMBCS_17 },
    150   { "lmbcs18",UCNV_LMBCS_18 },
    151   { "lmbcs19",UCNV_LMBCS_19 },
    152   { "lmbcs2", UCNV_LMBCS_2 },
    153   { "lmbcs3", UCNV_LMBCS_3 },
    154   { "lmbcs4", UCNV_LMBCS_4 },
    155   { "lmbcs5", UCNV_LMBCS_5 },
    156   { "lmbcs6", UCNV_LMBCS_6 },
    157   { "lmbcs8", UCNV_LMBCS_8 },
    158 #endif
    159 #if !UCONFIG_ONLY_HTML_CONVERSION
    160   { "scsu", UCNV_SCSU },
    161 #endif
    162   { "usascii", UCNV_US_ASCII },
    163   { "utf16", UCNV_UTF16 },
    164   { "utf16be", UCNV_UTF16_BigEndian },
    165   { "utf16le", UCNV_UTF16_LittleEndian },
    166 #if U_IS_BIG_ENDIAN
    167   { "utf16oppositeendian", UCNV_UTF16_LittleEndian },
    168   { "utf16platformendian", UCNV_UTF16_BigEndian },
    169 #else
    170   { "utf16oppositeendian", UCNV_UTF16_BigEndian},
    171   { "utf16platformendian", UCNV_UTF16_LittleEndian },
    172 #endif
    173 #if !UCONFIG_ONLY_HTML_CONVERSION
    174   { "utf32", UCNV_UTF32 },
    175   { "utf32be", UCNV_UTF32_BigEndian },
    176   { "utf32le", UCNV_UTF32_LittleEndian },
    177 #if U_IS_BIG_ENDIAN
    178   { "utf32oppositeendian", UCNV_UTF32_LittleEndian },
    179   { "utf32platformendian", UCNV_UTF32_BigEndian },
    180 #else
    181   { "utf32oppositeendian", UCNV_UTF32_BigEndian },
    182   { "utf32platformendian", UCNV_UTF32_LittleEndian },
    183 #endif
    184 #endif
    185 #if !UCONFIG_ONLY_HTML_CONVERSION
    186   { "utf7", UCNV_UTF7 },
    187 #endif
    188   { "utf8", UCNV_UTF8 },
    189 #if !UCONFIG_ONLY_HTML_CONVERSION
    190   { "x11compoundtext", UCNV_COMPOUND_TEXT}
    191 #endif
    192 };
    193 
    194 
    195 /*initializes some global variables */
    196 static UHashtable *SHARED_DATA_HASHTABLE = NULL;
    197 static UMutex cnvCacheMutex = U_MUTEX_INITIALIZER;  /* Mutex for synchronizing cnv cache access. */
    198                                                     /*  Note:  the global mutex is used for      */
    199                                                     /*         reference count updates.          */
    200 
    201 static const char **gAvailableConverters = NULL;
    202 static uint16_t gAvailableConverterCount = 0;
    203 static icu::UInitOnce gAvailableConvertersInitOnce = U_INITONCE_INITIALIZER;
    204 
    205 #if !U_CHARSET_IS_UTF8
    206 
    207 /* This contains the resolved converter name. So no further alias lookup is needed again. */
    208 static char gDefaultConverterNameBuffer[UCNV_MAX_CONVERTER_NAME_LENGTH + 1]; /* +1 for NULL */
    209 static const char *gDefaultConverterName = NULL;
    210 
    211 /*
    212 If the default converter is an algorithmic converter, this is the cached value.
    213 We don't cache a full UConverter and clone it because ucnv_clone doesn't have
    214 less overhead than an algorithmic open. We don't cache non-algorithmic converters
    215 because ucnv_flushCache must be able to unload the default converter and its table.
    216 */
    217 static const UConverterSharedData *gDefaultAlgorithmicSharedData = NULL;
    218 
    219 /* Does gDefaultConverterName have a converter option and require extra parsing? */
    220 static UBool gDefaultConverterContainsOption;
    221 
    222 #endif  /* !U_CHARSET_IS_UTF8 */
    223 
    224 static const char DATA_TYPE[] = "cnv";
    225 
    226 /* ucnv_flushAvailableConverterCache. This is only called from ucnv_cleanup().
    227  *                       If it is ever to be called from elsewhere, synchronization
    228  *                       will need to be considered.
    229  */
    230 static void
    231 ucnv_flushAvailableConverterCache() {
    232     gAvailableConverterCount = 0;
    233     if (gAvailableConverters) {
    234         uprv_free((char **)gAvailableConverters);
    235         gAvailableConverters = NULL;
    236     }
    237     gAvailableConvertersInitOnce.reset();
    238 }
    239 
    240 /* ucnv_cleanup - delete all storage held by the converter cache, except any  */
    241 /*                in use by open converters.                                  */
    242 /*                Not thread safe.                                            */
    243 /*                Not supported API.                                          */
    244 static UBool U_CALLCONV ucnv_cleanup(void) {
    245     ucnv_flushCache();
    246     if (SHARED_DATA_HASHTABLE != NULL && uhash_count(SHARED_DATA_HASHTABLE) == 0) {
    247         uhash_close(SHARED_DATA_HASHTABLE);
    248         SHARED_DATA_HASHTABLE = NULL;
    249     }
    250 
    251     /* Isn't called from flushCache because other threads may have preexisting references to the table. */
    252     ucnv_flushAvailableConverterCache();
    253 
    254 #if !U_CHARSET_IS_UTF8
    255     gDefaultConverterName = NULL;
    256     gDefaultConverterNameBuffer[0] = 0;
    257     gDefaultConverterContainsOption = FALSE;
    258     gDefaultAlgorithmicSharedData = NULL;
    259 #endif
    260 
    261     return (SHARED_DATA_HASHTABLE == NULL);
    262 }
    263 
    264 static UBool U_CALLCONV
    265 isCnvAcceptable(void * /*context*/,
    266                 const char * /*type*/, const char * /*name*/,
    267                 const UDataInfo *pInfo) {
    268     return (UBool)(
    269         pInfo->size>=20 &&
    270         pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
    271         pInfo->charsetFamily==U_CHARSET_FAMILY &&
    272         pInfo->sizeofUChar==U_SIZEOF_UCHAR &&
    273         pInfo->dataFormat[0]==0x63 &&   /* dataFormat="cnvt" */
    274         pInfo->dataFormat[1]==0x6e &&
    275         pInfo->dataFormat[2]==0x76 &&
    276         pInfo->dataFormat[3]==0x74 &&
    277         pInfo->formatVersion[0]==6);  /* Everything will be version 6 */
    278 }
    279 
    280 /**
    281  * Un flatten shared data from a UDATA..
    282  */
    283 static UConverterSharedData*
    284 ucnv_data_unFlattenClone(UConverterLoadArgs *pArgs, UDataMemory *pData, UErrorCode *status)
    285 {
    286     /* UDataInfo info; -- necessary only if some converters have different formatVersion */
    287     const uint8_t *raw = (const uint8_t *)udata_getMemory(pData);
    288     const UConverterStaticData *source = (const UConverterStaticData *) raw;
    289     UConverterSharedData *data;
    290     UConverterType type = (UConverterType)source->conversionType;
    291 
    292     if(U_FAILURE(*status))
    293         return NULL;
    294 
    295     if( (uint16_t)type >= UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES ||
    296         converterData[type] == NULL ||
    297         !converterData[type]->isReferenceCounted ||
    298         converterData[type]->referenceCounter != 1 ||
    299         source->structSize != sizeof(UConverterStaticData))
    300     {
    301         *status = U_INVALID_TABLE_FORMAT;
    302         return NULL;
    303     }
    304 
    305     data = (UConverterSharedData *)uprv_malloc(sizeof(UConverterSharedData));
    306     if(data == NULL) {
    307         *status = U_MEMORY_ALLOCATION_ERROR;
    308         return NULL;
    309     }
    310 
    311     /* copy initial values from the static structure for this type */
    312     uprv_memcpy(data, converterData[type], sizeof(UConverterSharedData));
    313 
    314     data->staticData = source;
    315 
    316     data->sharedDataCached = FALSE;
    317 
    318     /* fill in fields from the loaded data */
    319     data->dataMemory = (void*)pData; /* for future use */
    320 
    321     if(data->impl->load != NULL) {
    322         data->impl->load(data, pArgs, raw + source->structSize, status);
    323         if(U_FAILURE(*status)) {
    324             uprv_free(data);
    325             return NULL;
    326         }
    327     }
    328     return data;
    329 }
    330 
    331 /*Takes an alias name gets an actual converter file name
    332  *goes to disk and opens it.
    333  *allocates the memory and returns a new UConverter object
    334  */
    335 static UConverterSharedData *createConverterFromFile(UConverterLoadArgs *pArgs, UErrorCode * err)
    336 {
    337     UDataMemory *data;
    338     UConverterSharedData *sharedData;
    339 
    340     UTRACE_ENTRY_OC(UTRACE_UCNV_LOAD);
    341 
    342     if (U_FAILURE (*err)) {
    343         UTRACE_EXIT_STATUS(*err);
    344         return NULL;
    345     }
    346 
    347     UTRACE_DATA2(UTRACE_OPEN_CLOSE, "load converter %s from package %s", pArgs->name, pArgs->pkg);
    348 
    349     data = udata_openChoice(pArgs->pkg, DATA_TYPE, pArgs->name, isCnvAcceptable, NULL, err);
    350     if(U_FAILURE(*err))
    351     {
    352         UTRACE_EXIT_STATUS(*err);
    353         return NULL;
    354     }
    355 
    356     sharedData = ucnv_data_unFlattenClone(pArgs, data, err);
    357     if(U_FAILURE(*err))
    358     {
    359         udata_close(data);
    360         UTRACE_EXIT_STATUS(*err);
    361         return NULL;
    362     }
    363 
    364     /*
    365      * TODO Store pkg in a field in the shared data so that delta-only converters
    366      * can load base converters from the same package.
    367      * If the pkg name is longer than the field, then either do not load the converter
    368      * in the first place, or just set the pkg field to "".
    369      */
    370 
    371     UTRACE_EXIT_PTR_STATUS(sharedData, *err);
    372     return sharedData;
    373 }
    374 
    375 /*returns a converter type from a string
    376  */
    377 static const UConverterSharedData *
    378 getAlgorithmicTypeFromName(const char *realName)
    379 {
    380     uint32_t mid, start, limit;
    381     uint32_t lastMid;
    382     int result;
    383     char strippedName[UCNV_MAX_CONVERTER_NAME_LENGTH];
    384 
    385     /* Lower case and remove ignoreable characters. */
    386     ucnv_io_stripForCompare(strippedName, realName);
    387 
    388     /* do a binary search for the alias */
    389     start = 0;
    390     limit = UPRV_LENGTHOF(cnvNameType);
    391     mid = limit;
    392     lastMid = UINT32_MAX;
    393 
    394     for (;;) {
    395         mid = (uint32_t)((start + limit) / 2);
    396         if (lastMid == mid) {   /* Have we moved? */
    397             break;  /* We haven't moved, and it wasn't found. */
    398         }
    399         lastMid = mid;
    400         result = uprv_strcmp(strippedName, cnvNameType[mid].name);
    401 
    402         if (result < 0) {
    403             limit = mid;
    404         } else if (result > 0) {
    405             start = mid;
    406         } else {
    407             return converterData[cnvNameType[mid].type];
    408         }
    409     }
    410 
    411     return NULL;
    412 }
    413 
    414 /*
    415 * Based on the number of known converters, this determines how many times larger
    416 * the shared data hash table should be. When on small platforms, or just a couple
    417 * of converters are used, this number should be 2. When memory is plentiful, or
    418 * when ucnv_countAvailable is ever used with a lot of available converters,
    419 * this should be 4.
    420 * Larger numbers reduce the number of hash collisions, but use more memory.
    421 */
    422 #define UCNV_CACHE_LOAD_FACTOR 2
    423 
    424 /* Puts the shared data in the static hashtable SHARED_DATA_HASHTABLE */
    425 /*   Will always be called with the cnvCacheMutex alrady being held   */
    426 /*     by the calling function.                                       */
    427 /* Stores the shared data in the SHARED_DATA_HASHTABLE
    428  * @param data The shared data
    429  */
    430 static void
    431 ucnv_shareConverterData(UConverterSharedData * data)
    432 {
    433     UErrorCode err = U_ZERO_ERROR;
    434     /*Lazy evaluates the Hashtable itself */
    435     /*void *sanity = NULL;*/
    436 
    437     if (SHARED_DATA_HASHTABLE == NULL)
    438     {
    439         SHARED_DATA_HASHTABLE = uhash_openSize(uhash_hashChars, uhash_compareChars, NULL,
    440                             ucnv_io_countKnownConverters(&err)*UCNV_CACHE_LOAD_FACTOR,
    441                             &err);
    442         ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
    443 
    444         if (U_FAILURE(err))
    445             return;
    446     }
    447 
    448     /* ### check to see if the element is not already there! */
    449 
    450     /*
    451     sanity =   ucnv_getSharedConverterData (data->staticData->name);
    452     if(sanity != NULL)
    453     {
    454     UCNV_DEBUG_LOG("put:overwrite!",data->staticData->name,sanity);
    455     }
    456     UCNV_DEBUG_LOG("put:chk",data->staticData->name,sanity);
    457     */
    458 
    459     /* Mark it shared */
    460     data->sharedDataCached = TRUE;
    461 
    462     uhash_put(SHARED_DATA_HASHTABLE,
    463             (void*) data->staticData->name, /* Okay to cast away const as long as
    464             keyDeleter == NULL */
    465             data,
    466             &err);
    467     UCNV_DEBUG_LOG("put", data->staticData->name,data);
    468 
    469 }
    470 
    471 /*  Look up a converter name in the shared data cache.                    */
    472 /*    cnvCacheMutex must be held by the caller to protect the hash table. */
    473 /* gets the shared data from the SHARED_DATA_HASHTABLE (might return NULL if it isn't there)
    474  * @param name The name of the shared data
    475  * @return the shared data from the SHARED_DATA_HASHTABLE
    476  */
    477 static UConverterSharedData *
    478 ucnv_getSharedConverterData(const char *name)
    479 {
    480     /*special case when no Table has yet been created we return NULL */
    481     if (SHARED_DATA_HASHTABLE == NULL)
    482     {
    483         return NULL;
    484     }
    485     else
    486     {
    487         UConverterSharedData *rc;
    488 
    489         rc = (UConverterSharedData*)uhash_get(SHARED_DATA_HASHTABLE, name);
    490         UCNV_DEBUG_LOG("get",name,rc);
    491         return rc;
    492     }
    493 }
    494 
    495 /*frees the string of memory blocks associates with a sharedConverter
    496  *if and only if the referenceCounter == 0
    497  */
    498 /* Deletes (frees) the Shared data it's passed. first it checks the referenceCounter to
    499  * see if anyone is using it, if not it frees all the memory stemming from sharedConverterData and
    500  * returns TRUE,
    501  * otherwise returns FALSE
    502  * @param sharedConverterData The shared data
    503  * @return if not it frees all the memory stemming from sharedConverterData and
    504  * returns TRUE, otherwise returns FALSE
    505  */
    506 static UBool
    507 ucnv_deleteSharedConverterData(UConverterSharedData * deadSharedData)
    508 {
    509     UTRACE_ENTRY_OC(UTRACE_UCNV_UNLOAD);
    510     UTRACE_DATA2(UTRACE_OPEN_CLOSE, "unload converter %s shared data %p", deadSharedData->staticData->name, deadSharedData);
    511 
    512     if (deadSharedData->referenceCounter > 0) {
    513         UTRACE_EXIT_VALUE((int32_t)FALSE);
    514         return FALSE;
    515     }
    516 
    517     if (deadSharedData->impl->unload != NULL) {
    518         deadSharedData->impl->unload(deadSharedData);
    519     }
    520 
    521     if(deadSharedData->dataMemory != NULL)
    522     {
    523         UDataMemory *data = (UDataMemory*)deadSharedData->dataMemory;
    524         udata_close(data);
    525     }
    526 
    527     uprv_free(deadSharedData);
    528 
    529     UTRACE_EXIT_VALUE((int32_t)TRUE);
    530     return TRUE;
    531 }
    532 
    533 /**
    534  * Load a non-algorithmic converter.
    535  * If pkg==NULL, then this function must be called inside umtx_lock(&cnvCacheMutex).
    536  */
    537 UConverterSharedData *
    538 ucnv_load(UConverterLoadArgs *pArgs, UErrorCode *err) {
    539     UConverterSharedData *mySharedConverterData;
    540 
    541     if(err == NULL || U_FAILURE(*err)) {
    542         return NULL;
    543     }
    544 
    545     if(pArgs->pkg != NULL && *pArgs->pkg != 0) {
    546         /* application-provided converters are not currently cached */
    547         return createConverterFromFile(pArgs, err);
    548     }
    549 
    550     mySharedConverterData = ucnv_getSharedConverterData(pArgs->name);
    551     if (mySharedConverterData == NULL)
    552     {
    553         /*Not cached, we need to stream it in from file */
    554         mySharedConverterData = createConverterFromFile(pArgs, err);
    555         if (U_FAILURE (*err) || (mySharedConverterData == NULL))
    556         {
    557             return NULL;
    558         }
    559         else if (!pArgs->onlyTestIsLoadable)
    560         {
    561             /* share it with other library clients */
    562             ucnv_shareConverterData(mySharedConverterData);
    563         }
    564     }
    565     else
    566     {
    567         /* The data for this converter was already in the cache.            */
    568         /* Update the reference counter on the shared data: one more client */
    569         mySharedConverterData->referenceCounter++;
    570     }
    571 
    572     return mySharedConverterData;
    573 }
    574 
    575 /**
    576  * Unload a non-algorithmic converter.
    577  * It must be sharedData->isReferenceCounted
    578  * and this function must be called inside umtx_lock(&cnvCacheMutex).
    579  */
    580 U_CAPI void
    581 ucnv_unload(UConverterSharedData *sharedData) {
    582     if(sharedData != NULL) {
    583         if (sharedData->referenceCounter > 0) {
    584             sharedData->referenceCounter--;
    585         }
    586 
    587         if((sharedData->referenceCounter <= 0)&&(sharedData->sharedDataCached == FALSE)) {
    588             ucnv_deleteSharedConverterData(sharedData);
    589         }
    590     }
    591 }
    592 
    593 U_CFUNC void
    594 ucnv_unloadSharedDataIfReady(UConverterSharedData *sharedData)
    595 {
    596     if(sharedData != NULL && sharedData->isReferenceCounted) {
    597         umtx_lock(&cnvCacheMutex);
    598         ucnv_unload(sharedData);
    599         umtx_unlock(&cnvCacheMutex);
    600     }
    601 }
    602 
    603 U_CFUNC void
    604 ucnv_incrementRefCount(UConverterSharedData *sharedData)
    605 {
    606     if(sharedData != NULL && sharedData->isReferenceCounted) {
    607         umtx_lock(&cnvCacheMutex);
    608         sharedData->referenceCounter++;
    609         umtx_unlock(&cnvCacheMutex);
    610     }
    611 }
    612 
    613 /*
    614  * *pPieces must be initialized.
    615  * The name without options will be copied to pPieces->cnvName.
    616  * The locale and options will be copied to pPieces only if present in inName,
    617  * otherwise the existing values in pPieces remain.
    618  * *pArgs will be set to the pPieces values.
    619  */
    620 static void
    621 parseConverterOptions(const char *inName,
    622                       UConverterNamePieces *pPieces,
    623                       UConverterLoadArgs *pArgs,
    624                       UErrorCode *err)
    625 {
    626     char *cnvName = pPieces->cnvName;
    627     char c;
    628     int32_t len = 0;
    629 
    630     pArgs->name=inName;
    631     pArgs->locale=pPieces->locale;
    632     pArgs->options=pPieces->options;
    633 
    634     /* copy the converter name itself to cnvName */
    635     while((c=*inName)!=0 && c!=UCNV_OPTION_SEP_CHAR) {
    636         if (++len>=UCNV_MAX_CONVERTER_NAME_LENGTH) {
    637             *err = U_ILLEGAL_ARGUMENT_ERROR;    /* bad name */
    638             pPieces->cnvName[0]=0;
    639             return;
    640         }
    641         *cnvName++=c;
    642         inName++;
    643     }
    644     *cnvName=0;
    645     pArgs->name=pPieces->cnvName;
    646 
    647     /* parse options. No more name copying should occur. */
    648     while((c=*inName)!=0) {
    649         if(c==UCNV_OPTION_SEP_CHAR) {
    650             ++inName;
    651         }
    652 
    653         /* inName is behind an option separator */
    654         if(uprv_strncmp(inName, "locale=", 7)==0) {
    655             /* do not modify locale itself in case we have multiple locale options */
    656             char *dest=pPieces->locale;
    657 
    658             /* copy the locale option value */
    659             inName+=7;
    660             len=0;
    661             while((c=*inName)!=0 && c!=UCNV_OPTION_SEP_CHAR) {
    662                 ++inName;
    663 
    664                 if(++len>=ULOC_FULLNAME_CAPACITY) {
    665                     *err=U_ILLEGAL_ARGUMENT_ERROR;    /* bad name */
    666                     pPieces->locale[0]=0;
    667                     return;
    668                 }
    669 
    670                 *dest++=c;
    671             }
    672             *dest=0;
    673         } else if(uprv_strncmp(inName, "version=", 8)==0) {
    674             /* copy the version option value into bits 3..0 of pPieces->options */
    675             inName+=8;
    676             c=*inName;
    677             if(c==0) {
    678                 pArgs->options=(pPieces->options&=~UCNV_OPTION_VERSION);
    679                 return;
    680             } else if((uint8_t)(c-'0')<10) {
    681                 pArgs->options=pPieces->options=(pPieces->options&~UCNV_OPTION_VERSION)|(uint32_t)(c-'0');
    682                 ++inName;
    683             }
    684         } else if(uprv_strncmp(inName, "swaplfnl", 8)==0) {
    685             inName+=8;
    686             pArgs->options=(pPieces->options|=UCNV_OPTION_SWAP_LFNL);
    687         /* add processing for new options here with another } else if(uprv_strncmp(inName, "option-name=", XX)==0) { */
    688         } else {
    689             /* ignore any other options until we define some */
    690             while(((c = *inName++) != 0) && (c != UCNV_OPTION_SEP_CHAR)) {
    691             }
    692             if(c==0) {
    693                 return;
    694             }
    695         }
    696     }
    697 }
    698 
    699 /*Logic determines if the converter is Algorithmic AND/OR cached
    700  *depending on that:
    701  * -we either go to get data from disk and cache it (Data=TRUE, Cached=False)
    702  * -Get it from a Hashtable (Data=X, Cached=TRUE)
    703  * -Call dataConverter initializer (Data=TRUE, Cached=TRUE)
    704  * -Call AlgorithmicConverter initializer (Data=FALSE, Cached=TRUE)
    705  */
    706 U_CFUNC UConverterSharedData *
    707 ucnv_loadSharedData(const char *converterName,
    708                     UConverterNamePieces *pPieces,
    709                     UConverterLoadArgs *pArgs,
    710                     UErrorCode * err) {
    711     UConverterNamePieces stackPieces;
    712     UConverterLoadArgs stackArgs;
    713     UConverterSharedData *mySharedConverterData = NULL;
    714     UErrorCode internalErrorCode = U_ZERO_ERROR;
    715     UBool mayContainOption = TRUE;
    716     UBool checkForAlgorithmic = TRUE;
    717 
    718     if (U_FAILURE (*err)) {
    719         return NULL;
    720     }
    721 
    722     if(pPieces == NULL) {
    723         if(pArgs != NULL) {
    724             /*
    725              * Bad: We may set pArgs pointers to stackPieces fields
    726              * which will be invalid after this function returns.
    727              */
    728             *err = U_INTERNAL_PROGRAM_ERROR;
    729             return NULL;
    730         }
    731         pPieces = &stackPieces;
    732     }
    733     if(pArgs == NULL) {
    734         uprv_memset(&stackArgs, 0, sizeof(stackArgs));
    735         stackArgs.size = (int32_t)sizeof(stackArgs);
    736         pArgs = &stackArgs;
    737     }
    738 
    739     pPieces->cnvName[0] = 0;
    740     pPieces->locale[0] = 0;
    741     pPieces->options = 0;
    742 
    743     pArgs->name = converterName;
    744     pArgs->locale = pPieces->locale;
    745     pArgs->options = pPieces->options;
    746 
    747     /* In case "name" is NULL we want to open the default converter. */
    748     if (converterName == NULL) {
    749 #if U_CHARSET_IS_UTF8
    750         pArgs->name = "UTF-8";
    751         return (UConverterSharedData *)converterData[UCNV_UTF8];
    752 #else
    753         /* Call ucnv_getDefaultName first to query the name from the OS. */
    754         pArgs->name = ucnv_getDefaultName();
    755         if (pArgs->name == NULL) {
    756             *err = U_MISSING_RESOURCE_ERROR;
    757             return NULL;
    758         }
    759         mySharedConverterData = (UConverterSharedData *)gDefaultAlgorithmicSharedData;
    760         checkForAlgorithmic = FALSE;
    761         mayContainOption = gDefaultConverterContainsOption;
    762         /* the default converter name is already canonical */
    763 #endif
    764     }
    765     else if(UCNV_FAST_IS_UTF8(converterName)) {
    766         /* fastpath for UTF-8 */
    767         pArgs->name = "UTF-8";
    768         return (UConverterSharedData *)converterData[UCNV_UTF8];
    769     }
    770     else {
    771         /* separate the converter name from the options */
    772         parseConverterOptions(converterName, pPieces, pArgs, err);
    773         if (U_FAILURE(*err)) {
    774             /* Very bad name used. */
    775             return NULL;
    776         }
    777 
    778         /* get the canonical converter name */
    779         pArgs->name = ucnv_io_getConverterName(pArgs->name, &mayContainOption, &internalErrorCode);
    780         if (U_FAILURE(internalErrorCode) || pArgs->name == NULL) {
    781             /*
    782             * set the input name in case the converter was added
    783             * without updating the alias table, or when there is no alias table
    784             */
    785             pArgs->name = pPieces->cnvName;
    786         } else if (internalErrorCode == U_AMBIGUOUS_ALIAS_WARNING) {
    787             *err = U_AMBIGUOUS_ALIAS_WARNING;
    788         }
    789     }
    790 
    791     /* separate the converter name from the options */
    792     if(mayContainOption && pArgs->name != pPieces->cnvName) {
    793         parseConverterOptions(pArgs->name, pPieces, pArgs, err);
    794     }
    795 
    796     /* get the shared data for an algorithmic converter, if it is one */
    797     if (checkForAlgorithmic) {
    798         mySharedConverterData = (UConverterSharedData *)getAlgorithmicTypeFromName(pArgs->name);
    799     }
    800     if (mySharedConverterData == NULL)
    801     {
    802         /* it is a data-based converter, get its shared data.               */
    803         /* Hold the cnvCacheMutex through the whole process of checking the */
    804         /*   converter data cache, and adding new entries to the cache      */
    805         /*   to prevent other threads from modifying the cache during the   */
    806         /*   process.                                                       */
    807         pArgs->nestedLoads=1;
    808         pArgs->pkg=NULL;
    809 
    810         umtx_lock(&cnvCacheMutex);
    811         mySharedConverterData = ucnv_load(pArgs, err);
    812         umtx_unlock(&cnvCacheMutex);
    813         if (U_FAILURE (*err) || (mySharedConverterData == NULL))
    814         {
    815             return NULL;
    816         }
    817     }
    818 
    819     return mySharedConverterData;
    820 }
    821 
    822 U_CAPI UConverter *
    823 ucnv_createConverter(UConverter *myUConverter, const char *converterName, UErrorCode * err)
    824 {
    825     UConverterNamePieces stackPieces;
    826     UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER;
    827     UConverterSharedData *mySharedConverterData;
    828 
    829     UTRACE_ENTRY_OC(UTRACE_UCNV_OPEN);
    830 
    831     if(U_SUCCESS(*err)) {
    832         UTRACE_DATA1(UTRACE_OPEN_CLOSE, "open converter %s", converterName);
    833 
    834         mySharedConverterData = ucnv_loadSharedData(converterName, &stackPieces, &stackArgs, err);
    835 
    836         myUConverter = ucnv_createConverterFromSharedData(
    837             myUConverter, mySharedConverterData,
    838             &stackArgs,
    839             err);
    840 
    841         if(U_SUCCESS(*err)) {
    842             UTRACE_EXIT_PTR_STATUS(myUConverter, *err);
    843             return myUConverter;
    844         }
    845     }
    846 
    847     /* exit with error */
    848     UTRACE_EXIT_STATUS(*err);
    849     return NULL;
    850 }
    851 
    852 U_CFUNC UBool
    853 ucnv_canCreateConverter(const char *converterName, UErrorCode *err) {
    854     UConverter myUConverter;
    855     UConverterNamePieces stackPieces;
    856     UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER;
    857     UConverterSharedData *mySharedConverterData;
    858 
    859     UTRACE_ENTRY_OC(UTRACE_UCNV_OPEN);
    860 
    861     if(U_SUCCESS(*err)) {
    862         UTRACE_DATA1(UTRACE_OPEN_CLOSE, "test if can open converter %s", converterName);
    863 
    864         stackArgs.onlyTestIsLoadable=TRUE;
    865         mySharedConverterData = ucnv_loadSharedData(converterName, &stackPieces, &stackArgs, err);
    866         ucnv_createConverterFromSharedData(
    867             &myUConverter, mySharedConverterData,
    868             &stackArgs,
    869             err);
    870         ucnv_unloadSharedDataIfReady(mySharedConverterData);
    871     }
    872 
    873     UTRACE_EXIT_STATUS(*err);
    874     return U_SUCCESS(*err);
    875 }
    876 
    877 UConverter *
    878 ucnv_createAlgorithmicConverter(UConverter *myUConverter,
    879                                 UConverterType type,
    880                                 const char *locale, uint32_t options,
    881                                 UErrorCode *err) {
    882     UConverter *cnv;
    883     const UConverterSharedData *sharedData;
    884     UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER;
    885 
    886     UTRACE_ENTRY_OC(UTRACE_UCNV_OPEN_ALGORITHMIC);
    887     UTRACE_DATA1(UTRACE_OPEN_CLOSE, "open algorithmic converter type %d", (int32_t)type);
    888 
    889     if(type<0 || UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES<=type) {
    890         *err = U_ILLEGAL_ARGUMENT_ERROR;
    891         UTRACE_EXIT_STATUS(U_ILLEGAL_ARGUMENT_ERROR);
    892         return NULL;
    893     }
    894 
    895     sharedData = converterData[type];
    896     if(sharedData == NULL || sharedData->isReferenceCounted) {
    897         /* not a valid type, or not an algorithmic converter */
    898         *err = U_ILLEGAL_ARGUMENT_ERROR;
    899         UTRACE_EXIT_STATUS(U_ILLEGAL_ARGUMENT_ERROR);
    900         return NULL;
    901     }
    902 
    903     stackArgs.name = "";
    904     stackArgs.options = options;
    905     stackArgs.locale=locale;
    906     cnv = ucnv_createConverterFromSharedData(
    907             myUConverter, (UConverterSharedData *)sharedData,
    908             &stackArgs, err);
    909 
    910     UTRACE_EXIT_PTR_STATUS(cnv, *err);
    911     return cnv;
    912 }
    913 
    914 U_CFUNC UConverter*
    915 ucnv_createConverterFromPackage(const char *packageName, const char *converterName, UErrorCode * err)
    916 {
    917     UConverter *myUConverter;
    918     UConverterSharedData *mySharedConverterData;
    919     UConverterNamePieces stackPieces;
    920     UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER;
    921 
    922     UTRACE_ENTRY_OC(UTRACE_UCNV_OPEN_PACKAGE);
    923 
    924     if(U_FAILURE(*err)) {
    925         UTRACE_EXIT_STATUS(*err);
    926         return NULL;
    927     }
    928 
    929     UTRACE_DATA2(UTRACE_OPEN_CLOSE, "open converter %s from package %s", converterName, packageName);
    930 
    931     /* first, get the options out of the converterName string */
    932     stackPieces.cnvName[0] = 0;
    933     stackPieces.locale[0] = 0;
    934     stackPieces.options = 0;
    935     parseConverterOptions(converterName, &stackPieces, &stackArgs, err);
    936     if (U_FAILURE(*err)) {
    937         /* Very bad name used. */
    938         UTRACE_EXIT_STATUS(*err);
    939         return NULL;
    940     }
    941     stackArgs.nestedLoads=1;
    942     stackArgs.pkg=packageName;
    943 
    944     /* open the data, unflatten the shared structure */
    945     mySharedConverterData = createConverterFromFile(&stackArgs, err);
    946 
    947     if (U_FAILURE(*err)) {
    948         UTRACE_EXIT_STATUS(*err);
    949         return NULL;
    950     }
    951 
    952     /* create the actual converter */
    953     myUConverter = ucnv_createConverterFromSharedData(NULL, mySharedConverterData, &stackArgs, err);
    954 
    955     if (U_FAILURE(*err)) {
    956         ucnv_close(myUConverter);
    957         UTRACE_EXIT_STATUS(*err);
    958         return NULL;
    959     }
    960 
    961     UTRACE_EXIT_PTR_STATUS(myUConverter, *err);
    962     return myUConverter;
    963 }
    964 
    965 
    966 U_CFUNC UConverter*
    967 ucnv_createConverterFromSharedData(UConverter *myUConverter,
    968                                    UConverterSharedData *mySharedConverterData,
    969                                    UConverterLoadArgs *pArgs,
    970                                    UErrorCode *err)
    971 {
    972     UBool isCopyLocal;
    973 
    974     if(U_FAILURE(*err)) {
    975         ucnv_unloadSharedDataIfReady(mySharedConverterData);
    976         return myUConverter;
    977     }
    978     if(myUConverter == NULL)
    979     {
    980         myUConverter = (UConverter *) uprv_malloc (sizeof (UConverter));
    981         if(myUConverter == NULL)
    982         {
    983             *err = U_MEMORY_ALLOCATION_ERROR;
    984             ucnv_unloadSharedDataIfReady(mySharedConverterData);
    985             return NULL;
    986         }
    987         isCopyLocal = FALSE;
    988     } else {
    989         isCopyLocal = TRUE;
    990     }
    991 
    992     /* initialize the converter */
    993     uprv_memset(myUConverter, 0, sizeof(UConverter));
    994     myUConverter->isCopyLocal = isCopyLocal;
    995     /*myUConverter->isExtraLocal = FALSE;*/ /* Set by the memset call */
    996     myUConverter->sharedData = mySharedConverterData;
    997     myUConverter->options = pArgs->options;
    998     if(!pArgs->onlyTestIsLoadable) {
    999         myUConverter->preFromUFirstCP = U_SENTINEL;
   1000         myUConverter->fromCharErrorBehaviour = UCNV_TO_U_DEFAULT_CALLBACK;
   1001         myUConverter->fromUCharErrorBehaviour = UCNV_FROM_U_DEFAULT_CALLBACK;
   1002         myUConverter->toUnicodeStatus = mySharedConverterData->toUnicodeStatus;
   1003         myUConverter->maxBytesPerUChar = mySharedConverterData->staticData->maxBytesPerChar;
   1004         myUConverter->subChar1 = mySharedConverterData->staticData->subChar1;
   1005         myUConverter->subCharLen = mySharedConverterData->staticData->subCharLen;
   1006         myUConverter->subChars = (uint8_t *)myUConverter->subUChars;
   1007         uprv_memcpy(myUConverter->subChars, mySharedConverterData->staticData->subChar, myUConverter->subCharLen);
   1008         myUConverter->toUCallbackReason = UCNV_ILLEGAL; /* default reason to invoke (*fromCharErrorBehaviour) */
   1009     }
   1010 
   1011     if(mySharedConverterData->impl->open != NULL) {
   1012         mySharedConverterData->impl->open(myUConverter, pArgs, err);
   1013         if(U_FAILURE(*err) && !pArgs->onlyTestIsLoadable) {
   1014             /* don't ucnv_close() if onlyTestIsLoadable because not fully initialized */
   1015             ucnv_close(myUConverter);
   1016             return NULL;
   1017         }
   1018     }
   1019 
   1020     return myUConverter;
   1021 }
   1022 
   1023 /*Frees all shared immutable objects that aren't referred to (reference count = 0)
   1024  */
   1025 U_CAPI int32_t U_EXPORT2
   1026 ucnv_flushCache ()
   1027 {
   1028     UConverterSharedData *mySharedData = NULL;
   1029     int32_t pos;
   1030     int32_t tableDeletedNum = 0;
   1031     const UHashElement *e;
   1032     /*UErrorCode status = U_ILLEGAL_ARGUMENT_ERROR;*/
   1033     int32_t i, remaining;
   1034 
   1035     UTRACE_ENTRY_OC(UTRACE_UCNV_FLUSH_CACHE);
   1036 
   1037     /* Close the default converter without creating a new one so that everything will be flushed. */
   1038     u_flushDefaultConverter();
   1039 
   1040     /*if shared data hasn't even been lazy evaluated yet
   1041     * return 0
   1042     */
   1043     if (SHARED_DATA_HASHTABLE == NULL) {
   1044         UTRACE_EXIT_VALUE((int32_t)0);
   1045         return 0;
   1046     }
   1047 
   1048     /*creates an enumeration to iterate through every element in the
   1049     * table
   1050     *
   1051     * Synchronization:  holding cnvCacheMutex will prevent any other thread from
   1052     *                   accessing or modifying the hash table during the iteration.
   1053     *                   The reference count of an entry may be decremented by
   1054     *                   ucnv_close while the iteration is in process, but this is
   1055     *                   benign.  It can't be incremented (in ucnv_createConverter())
   1056     *                   because the sequence of looking up in the cache + incrementing
   1057     *                   is protected by cnvCacheMutex.
   1058     */
   1059     umtx_lock(&cnvCacheMutex);
   1060     /*
   1061      * double loop: A delta/extension-only converter has a pointer to its base table's
   1062      * shared data; the first iteration of the outer loop may see the delta converter
   1063      * before the base converter, and unloading the delta converter may get the base
   1064      * converter's reference counter down to 0.
   1065      */
   1066     i = 0;
   1067     do {
   1068         remaining = 0;
   1069         pos = UHASH_FIRST;
   1070         while ((e = uhash_nextElement (SHARED_DATA_HASHTABLE, &pos)) != NULL)
   1071         {
   1072             mySharedData = (UConverterSharedData *) e->value.pointer;
   1073             /*deletes only if reference counter == 0 */
   1074             if (mySharedData->referenceCounter == 0)
   1075             {
   1076                 tableDeletedNum++;
   1077 
   1078                 UCNV_DEBUG_LOG("del",mySharedData->staticData->name,mySharedData);
   1079 
   1080                 uhash_removeElement(SHARED_DATA_HASHTABLE, e);
   1081                 mySharedData->sharedDataCached = FALSE;
   1082                 ucnv_deleteSharedConverterData (mySharedData);
   1083             } else {
   1084                 ++remaining;
   1085             }
   1086         }
   1087     } while(++i == 1 && remaining > 0);
   1088     umtx_unlock(&cnvCacheMutex);
   1089 
   1090     UTRACE_DATA1(UTRACE_INFO, "ucnv_flushCache() exits with %d converters remaining", remaining);
   1091 
   1092     UTRACE_EXIT_VALUE(tableDeletedNum);
   1093     return tableDeletedNum;
   1094 }
   1095 
   1096 /* available converters list --------------------------------------------------- */
   1097 
   1098 static void U_CALLCONV initAvailableConvertersList(UErrorCode &errCode) {
   1099     U_ASSERT(gAvailableConverterCount == 0);
   1100     U_ASSERT(gAvailableConverters == NULL);
   1101 
   1102     ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
   1103     UEnumeration *allConvEnum = ucnv_openAllNames(&errCode);
   1104     int32_t allConverterCount = uenum_count(allConvEnum, &errCode);
   1105     if (U_FAILURE(errCode)) {
   1106         return;
   1107     }
   1108 
   1109     /* We can't have more than "*converterTable" converters to open */
   1110     gAvailableConverters = (const char **) uprv_malloc(allConverterCount * sizeof(char*));
   1111     if (!gAvailableConverters) {
   1112         errCode = U_MEMORY_ALLOCATION_ERROR;
   1113         return;
   1114     }
   1115 
   1116     /* Open the default converter to make sure that it has first dibs in the hash table. */
   1117     UErrorCode localStatus = U_ZERO_ERROR;
   1118     UConverter tempConverter;
   1119     ucnv_close(ucnv_createConverter(&tempConverter, NULL, &localStatus));
   1120 
   1121     gAvailableConverterCount = 0;
   1122 
   1123     for (int32_t idx = 0; idx < allConverterCount; idx++) {
   1124         localStatus = U_ZERO_ERROR;
   1125         const char *converterName = uenum_next(allConvEnum, NULL, &localStatus);
   1126         if (ucnv_canCreateConverter(converterName, &localStatus)) {
   1127             gAvailableConverters[gAvailableConverterCount++] = converterName;
   1128         }
   1129     }
   1130 
   1131     uenum_close(allConvEnum);
   1132 }
   1133 
   1134 
   1135 static UBool haveAvailableConverterList(UErrorCode *pErrorCode) {
   1136     umtx_initOnce(gAvailableConvertersInitOnce, &initAvailableConvertersList, *pErrorCode);
   1137     return U_SUCCESS(*pErrorCode);
   1138 }
   1139 
   1140 U_CFUNC uint16_t
   1141 ucnv_bld_countAvailableConverters(UErrorCode *pErrorCode) {
   1142     if (haveAvailableConverterList(pErrorCode)) {
   1143         return gAvailableConverterCount;
   1144     }
   1145     return 0;
   1146 }
   1147 
   1148 U_CFUNC const char *
   1149 ucnv_bld_getAvailableConverter(uint16_t n, UErrorCode *pErrorCode) {
   1150     if (haveAvailableConverterList(pErrorCode)) {
   1151         if (n < gAvailableConverterCount) {
   1152             return gAvailableConverters[n];
   1153         }
   1154         *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
   1155     }
   1156     return NULL;
   1157 }
   1158 
   1159 /* default converter name --------------------------------------------------- */
   1160 
   1161 #if !U_CHARSET_IS_UTF8
   1162 /*
   1163 Copy the canonical converter name.
   1164 ucnv_getDefaultName must be thread safe, which can call this function.
   1165 
   1166 ucnv_setDefaultName calls this function and it doesn't have to be
   1167 thread safe because there is no reliable/safe way to reset the
   1168 converter in use in all threads. If you did reset the converter, you
   1169 would not be sure that retrieving a default converter for one string
   1170 would be the same type of default converter for a successive string.
   1171 Since the name is a returned via ucnv_getDefaultName without copying,
   1172 you shouldn't be modifying or deleting the string from a separate thread.
   1173 */
   1174 static inline void
   1175 internalSetName(const char *name, UErrorCode *status) {
   1176     UConverterNamePieces stackPieces;
   1177     UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER;
   1178     int32_t length=(int32_t)(uprv_strlen(name));
   1179     UBool containsOption = (UBool)(uprv_strchr(name, UCNV_OPTION_SEP_CHAR) != NULL);
   1180     const UConverterSharedData *algorithmicSharedData;
   1181 
   1182     stackArgs.name = name;
   1183     if(containsOption) {
   1184         stackPieces.cnvName[0] = 0;
   1185         stackPieces.locale[0] = 0;
   1186         stackPieces.options = 0;
   1187         parseConverterOptions(name, &stackPieces, &stackArgs, status);
   1188         if(U_FAILURE(*status)) {
   1189             return;
   1190         }
   1191     }
   1192     algorithmicSharedData = getAlgorithmicTypeFromName(stackArgs.name);
   1193 
   1194     umtx_lock(&cnvCacheMutex);
   1195 
   1196     gDefaultAlgorithmicSharedData = algorithmicSharedData;
   1197     gDefaultConverterContainsOption = containsOption;
   1198     uprv_memcpy(gDefaultConverterNameBuffer, name, length);
   1199     gDefaultConverterNameBuffer[length]=0;
   1200 
   1201     /* gDefaultConverterName MUST be the last global var set by this function.  */
   1202     /*    It is the variable checked in ucnv_getDefaultName() to see if initialization is required. */
   1203     //    But there is nothing here preventing that from being reordered, either by the compiler
   1204     //             or hardware. I'm adding the mutex to ucnv_getDefaultName for now. UMTX_CHECK is not enough.
   1205     //             -- Andy
   1206     gDefaultConverterName = gDefaultConverterNameBuffer;
   1207 
   1208     ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
   1209 
   1210     umtx_unlock(&cnvCacheMutex);
   1211 }
   1212 #endif
   1213 
   1214 /*
   1215  * In order to be really thread-safe, the get function would have to take
   1216  * a buffer parameter and copy the current string inside a mutex block.
   1217  * This implementation only tries to be really thread-safe while
   1218  * setting the name.
   1219  * It assumes that setting a pointer is atomic.
   1220  */
   1221 
   1222 U_CAPI const char*  U_EXPORT2
   1223 ucnv_getDefaultName() {
   1224 #if U_CHARSET_IS_UTF8
   1225     return "UTF-8";
   1226 #else
   1227     /* local variable to be thread-safe */
   1228     const char *name;
   1229 
   1230     /*
   1231     Concurrent calls to ucnv_getDefaultName must be thread safe,
   1232     but ucnv_setDefaultName is not thread safe.
   1233     */
   1234     {
   1235         icu::Mutex lock(&cnvCacheMutex);
   1236         name = gDefaultConverterName;
   1237     }
   1238     if(name==NULL) {
   1239         UErrorCode errorCode = U_ZERO_ERROR;
   1240         UConverter *cnv = NULL;
   1241 
   1242         name = uprv_getDefaultCodepage();
   1243 
   1244         /* if the name is there, test it out and get the canonical name with options */
   1245         if(name != NULL) {
   1246             cnv = ucnv_open(name, &errorCode);
   1247             if(U_SUCCESS(errorCode) && cnv != NULL) {
   1248                 name = ucnv_getName(cnv, &errorCode);
   1249             }
   1250         }
   1251 
   1252         if(name == NULL || name[0] == 0
   1253             || U_FAILURE(errorCode) || cnv == NULL
   1254             || uprv_strlen(name)>=sizeof(gDefaultConverterNameBuffer))
   1255         {
   1256             /* Panic time, let's use a fallback. */
   1257 #if (U_CHARSET_FAMILY == U_ASCII_FAMILY)
   1258             name = "US-ASCII";
   1259             /* there is no 'algorithmic' converter for EBCDIC */
   1260 #elif U_PLATFORM == U_PF_OS390
   1261             name = "ibm-1047_P100-1995" UCNV_SWAP_LFNL_OPTION_STRING;
   1262 #else
   1263             name = "ibm-37_P100-1995";
   1264 #endif
   1265         }
   1266 
   1267         internalSetName(name, &errorCode);
   1268 
   1269         /* The close may make the current name go away. */
   1270         ucnv_close(cnv);
   1271     }
   1272 
   1273     return name;
   1274 #endif
   1275 }
   1276 
   1277 #if U_CHARSET_IS_UTF8
   1278 U_CAPI void U_EXPORT2 ucnv_setDefaultName(const char *) {}
   1279 #else
   1280 /*
   1281 This function is not thread safe, and it can't be thread safe.
   1282 See internalSetName or the API reference for details.
   1283 */
   1284 U_CAPI void U_EXPORT2
   1285 ucnv_setDefaultName(const char *converterName) {
   1286     if(converterName==NULL) {
   1287         /* reset to the default codepage */
   1288         gDefaultConverterName=NULL;
   1289     } else {
   1290         UErrorCode errorCode = U_ZERO_ERROR;
   1291         UConverter *cnv = NULL;
   1292         const char *name = NULL;
   1293 
   1294         /* if the name is there, test it out and get the canonical name with options */
   1295         cnv = ucnv_open(converterName, &errorCode);
   1296         if(U_SUCCESS(errorCode) && cnv != NULL) {
   1297             name = ucnv_getName(cnv, &errorCode);
   1298         }
   1299 
   1300         if(U_SUCCESS(errorCode) && name!=NULL) {
   1301             internalSetName(name, &errorCode);
   1302         }
   1303         /* else this converter is bad to use. Don't change it to a bad value. */
   1304 
   1305         /* The close may make the current name go away. */
   1306         ucnv_close(cnv);
   1307 
   1308         /* reset the converter cache */
   1309         u_flushDefaultConverter();
   1310     }
   1311 }
   1312 #endif
   1313 
   1314 /* data swapping ------------------------------------------------------------ */
   1315 
   1316 /* most of this might belong more properly into ucnvmbcs.c, but that is so large */
   1317 
   1318 #if !UCONFIG_NO_LEGACY_CONVERSION
   1319 
   1320 U_CAPI int32_t U_EXPORT2
   1321 ucnv_swap(const UDataSwapper *ds,
   1322           const void *inData, int32_t length, void *outData,
   1323           UErrorCode *pErrorCode) {
   1324     const UDataInfo *pInfo;
   1325     int32_t headerSize;
   1326 
   1327     const uint8_t *inBytes;
   1328     uint8_t *outBytes;
   1329 
   1330     uint32_t offset, count, staticDataSize;
   1331     int32_t size;
   1332 
   1333     const UConverterStaticData *inStaticData;
   1334     UConverterStaticData *outStaticData;
   1335 
   1336     const _MBCSHeader *inMBCSHeader;
   1337     _MBCSHeader *outMBCSHeader;
   1338     _MBCSHeader mbcsHeader;
   1339     uint32_t mbcsHeaderLength;
   1340     UBool noFromU=FALSE;
   1341 
   1342     uint8_t outputType;
   1343 
   1344     int32_t maxFastUChar, mbcsIndexLength;
   1345 
   1346     const int32_t *inExtIndexes;
   1347     int32_t extOffset;
   1348 
   1349     /* udata_swapDataHeader checks the arguments */
   1350     headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
   1351     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
   1352         return 0;
   1353     }
   1354 
   1355     /* check data format and format version */
   1356     pInfo=(const UDataInfo *)((const char *)inData+4);
   1357     if(!(
   1358         pInfo->dataFormat[0]==0x63 &&   /* dataFormat="cnvt" */
   1359         pInfo->dataFormat[1]==0x6e &&
   1360         pInfo->dataFormat[2]==0x76 &&
   1361         pInfo->dataFormat[3]==0x74 &&
   1362         pInfo->formatVersion[0]==6 &&
   1363         pInfo->formatVersion[1]>=2
   1364     )) {
   1365         udata_printError(ds, "ucnv_swap(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not recognized as an ICU .cnv conversion table\n",
   1366                          pInfo->dataFormat[0], pInfo->dataFormat[1],
   1367                          pInfo->dataFormat[2], pInfo->dataFormat[3],
   1368                          pInfo->formatVersion[0], pInfo->formatVersion[1]);
   1369         *pErrorCode=U_UNSUPPORTED_ERROR;
   1370         return 0;
   1371     }
   1372 
   1373     inBytes=(const uint8_t *)inData+headerSize;
   1374     outBytes=(uint8_t *)outData+headerSize;
   1375 
   1376     /* read the initial UConverterStaticData structure after the UDataInfo header */
   1377     inStaticData=(const UConverterStaticData *)inBytes;
   1378     outStaticData=(UConverterStaticData *)outBytes;
   1379 
   1380     if(length<0) {
   1381         staticDataSize=ds->readUInt32(inStaticData->structSize);
   1382     } else {
   1383         length-=headerSize;
   1384         if( length<(int32_t)sizeof(UConverterStaticData) ||
   1385             (uint32_t)length<(staticDataSize=ds->readUInt32(inStaticData->structSize))
   1386         ) {
   1387             udata_printError(ds, "ucnv_swap(): too few bytes (%d after header) for an ICU .cnv conversion table\n",
   1388                              length);
   1389             *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
   1390             return 0;
   1391         }
   1392     }
   1393 
   1394     if(length>=0) {
   1395         /* swap the static data */
   1396         if(inStaticData!=outStaticData) {
   1397             uprv_memcpy(outStaticData, inStaticData, staticDataSize);
   1398         }
   1399 
   1400         ds->swapArray32(ds, &inStaticData->structSize, 4,
   1401                            &outStaticData->structSize, pErrorCode);
   1402         ds->swapArray32(ds, &inStaticData->codepage, 4,
   1403                            &outStaticData->codepage, pErrorCode);
   1404 
   1405         ds->swapInvChars(ds, inStaticData->name, (int32_t)uprv_strlen(inStaticData->name),
   1406                             outStaticData->name, pErrorCode);
   1407         if(U_FAILURE(*pErrorCode)) {
   1408             udata_printError(ds, "ucnv_swap(): error swapping converter name\n");
   1409             return 0;
   1410         }
   1411     }
   1412 
   1413     inBytes+=staticDataSize;
   1414     outBytes+=staticDataSize;
   1415     if(length>=0) {
   1416         length-=(int32_t)staticDataSize;
   1417     }
   1418 
   1419     /* check for supported conversionType values */
   1420     if(inStaticData->conversionType==UCNV_MBCS) {
   1421         /* swap MBCS data */
   1422         inMBCSHeader=(const _MBCSHeader *)inBytes;
   1423         outMBCSHeader=(_MBCSHeader *)outBytes;
   1424 
   1425         if(0<=length && length<(int32_t)sizeof(_MBCSHeader)) {
   1426             udata_printError(ds, "ucnv_swap(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table\n",
   1427                                 length);
   1428             *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
   1429             return 0;
   1430         }
   1431         if(inMBCSHeader->version[0]==4 && inMBCSHeader->version[1]>=1) {
   1432             mbcsHeaderLength=MBCS_HEADER_V4_LENGTH;
   1433         } else if(inMBCSHeader->version[0]==5 && inMBCSHeader->version[1]>=3 &&
   1434                   ((mbcsHeader.options=ds->readUInt32(inMBCSHeader->options))&
   1435                    MBCS_OPT_UNKNOWN_INCOMPATIBLE_MASK)==0
   1436         ) {
   1437             mbcsHeaderLength=mbcsHeader.options&MBCS_OPT_LENGTH_MASK;
   1438             noFromU=(UBool)((mbcsHeader.options&MBCS_OPT_NO_FROM_U)!=0);
   1439         } else {
   1440             udata_printError(ds, "ucnv_swap(): unsupported _MBCSHeader.version %d.%d\n",
   1441                              inMBCSHeader->version[0], inMBCSHeader->version[1]);
   1442             *pErrorCode=U_UNSUPPORTED_ERROR;
   1443             return 0;
   1444         }
   1445 
   1446         uprv_memcpy(mbcsHeader.version, inMBCSHeader->version, 4);
   1447         mbcsHeader.countStates=         ds->readUInt32(inMBCSHeader->countStates);
   1448         mbcsHeader.countToUFallbacks=   ds->readUInt32(inMBCSHeader->countToUFallbacks);
   1449         mbcsHeader.offsetToUCodeUnits=  ds->readUInt32(inMBCSHeader->offsetToUCodeUnits);
   1450         mbcsHeader.offsetFromUTable=    ds->readUInt32(inMBCSHeader->offsetFromUTable);
   1451         mbcsHeader.offsetFromUBytes=    ds->readUInt32(inMBCSHeader->offsetFromUBytes);
   1452         mbcsHeader.flags=               ds->readUInt32(inMBCSHeader->flags);
   1453         mbcsHeader.fromUBytesLength=    ds->readUInt32(inMBCSHeader->fromUBytesLength);
   1454         /* mbcsHeader.options have been read above */
   1455 
   1456         extOffset=(int32_t)(mbcsHeader.flags>>8);
   1457         outputType=(uint8_t)mbcsHeader.flags;
   1458         if(noFromU && outputType==MBCS_OUTPUT_1) {
   1459             udata_printError(ds, "ucnv_swap(): unsupported combination of makeconv --small with SBCS\n");
   1460             *pErrorCode=U_UNSUPPORTED_ERROR;
   1461             return 0;
   1462         }
   1463 
   1464         /* make sure that the output type is known */
   1465         switch(outputType) {
   1466         case MBCS_OUTPUT_1:
   1467         case MBCS_OUTPUT_2:
   1468         case MBCS_OUTPUT_3:
   1469         case MBCS_OUTPUT_4:
   1470         case MBCS_OUTPUT_3_EUC:
   1471         case MBCS_OUTPUT_4_EUC:
   1472         case MBCS_OUTPUT_2_SISO:
   1473         case MBCS_OUTPUT_EXT_ONLY:
   1474             /* OK */
   1475             break;
   1476         default:
   1477             udata_printError(ds, "ucnv_swap(): unsupported MBCS output type 0x%x\n",
   1478                              outputType);
   1479             *pErrorCode=U_UNSUPPORTED_ERROR;
   1480             return 0;
   1481         }
   1482 
   1483         /* calculate the length of the MBCS data */
   1484 
   1485         /*
   1486          * utf8Friendly MBCS files (mbcsHeader.version 4.3)
   1487          * contain an additional mbcsIndex table:
   1488          *   uint16_t[(maxFastUChar+1)>>6];
   1489          * where maxFastUChar=((mbcsHeader.version[2]<<8)|0xff).
   1490          */
   1491         maxFastUChar=0;
   1492         mbcsIndexLength=0;
   1493         if( outputType!=MBCS_OUTPUT_EXT_ONLY && outputType!=MBCS_OUTPUT_1 &&
   1494             mbcsHeader.version[1]>=3 && (maxFastUChar=mbcsHeader.version[2])!=0
   1495         ) {
   1496             maxFastUChar=(maxFastUChar<<8)|0xff;
   1497             mbcsIndexLength=((maxFastUChar+1)>>6)*2;  /* number of bytes */
   1498         }
   1499 
   1500         if(extOffset==0) {
   1501             size=(int32_t)(mbcsHeader.offsetFromUBytes+mbcsIndexLength);
   1502             if(!noFromU) {
   1503                 size+=(int32_t)mbcsHeader.fromUBytesLength;
   1504             }
   1505 
   1506             /* avoid compiler warnings - not otherwise necessary, and the value does not matter */
   1507             inExtIndexes=NULL;
   1508         } else {
   1509             /* there is extension data after the base data, see ucnv_ext.h */
   1510             if(length>=0 && length<(extOffset+UCNV_EXT_INDEXES_MIN_LENGTH*4)) {
   1511                 udata_printError(ds, "ucnv_swap(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table with extension data\n",
   1512                                  length);
   1513                 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
   1514                 return 0;
   1515             }
   1516 
   1517             inExtIndexes=(const int32_t *)(inBytes+extOffset);
   1518             size=extOffset+udata_readInt32(ds, inExtIndexes[UCNV_EXT_SIZE]);
   1519         }
   1520 
   1521         if(length>=0) {
   1522             if(length<size) {
   1523                 udata_printError(ds, "ucnv_swap(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table\n",
   1524                                  length);
   1525                 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
   1526                 return 0;
   1527             }
   1528 
   1529             /* copy the data for inaccessible bytes */
   1530             if(inBytes!=outBytes) {
   1531                 uprv_memcpy(outBytes, inBytes, size);
   1532             }
   1533 
   1534             /* swap the MBCSHeader, except for the version field */
   1535             count=mbcsHeaderLength*4;
   1536             ds->swapArray32(ds, &inMBCSHeader->countStates, count-4,
   1537                                &outMBCSHeader->countStates, pErrorCode);
   1538 
   1539             if(outputType==MBCS_OUTPUT_EXT_ONLY) {
   1540                 /*
   1541                  * extension-only file,
   1542                  * contains a base name instead of normal base table data
   1543                  */
   1544 
   1545                 /* swap the base name, between the header and the extension data */
   1546                 const char *inBaseName=(const char *)inBytes+count;
   1547                 char *outBaseName=(char *)outBytes+count;
   1548                 ds->swapInvChars(ds, inBaseName, (int32_t)uprv_strlen(inBaseName),
   1549                                     outBaseName, pErrorCode);
   1550             } else {
   1551                 /* normal file with base table data */
   1552 
   1553                 /* swap the state table, 1kB per state */
   1554                 offset=count;
   1555                 count=mbcsHeader.countStates*1024;
   1556                 ds->swapArray32(ds, inBytes+offset, (int32_t)count,
   1557                                    outBytes+offset, pErrorCode);
   1558 
   1559                 /* swap the toUFallbacks[] */
   1560                 offset+=count;
   1561                 count=mbcsHeader.countToUFallbacks*8;
   1562                 ds->swapArray32(ds, inBytes+offset, (int32_t)count,
   1563                                    outBytes+offset, pErrorCode);
   1564 
   1565                 /* swap the unicodeCodeUnits[] */
   1566                 offset=mbcsHeader.offsetToUCodeUnits;
   1567                 count=mbcsHeader.offsetFromUTable-offset;
   1568                 ds->swapArray16(ds, inBytes+offset, (int32_t)count,
   1569                                    outBytes+offset, pErrorCode);
   1570 
   1571                 /* offset to the stage 1 table, independent of the outputType */
   1572                 offset=mbcsHeader.offsetFromUTable;
   1573 
   1574                 if(outputType==MBCS_OUTPUT_1) {
   1575                     /* SBCS: swap the fromU tables, all 16 bits wide */
   1576                     count=(mbcsHeader.offsetFromUBytes-offset)+mbcsHeader.fromUBytesLength;
   1577                     ds->swapArray16(ds, inBytes+offset, (int32_t)count,
   1578                                        outBytes+offset, pErrorCode);
   1579                 } else {
   1580                     /* otherwise: swap the stage tables separately */
   1581 
   1582                     /* stage 1 table: uint16_t[0x440 or 0x40] */
   1583                     if(inStaticData->unicodeMask&UCNV_HAS_SUPPLEMENTARY) {
   1584                         count=0x440*2; /* for all of Unicode */
   1585                     } else {
   1586                         count=0x40*2; /* only BMP */
   1587                     }
   1588                     ds->swapArray16(ds, inBytes+offset, (int32_t)count,
   1589                                        outBytes+offset, pErrorCode);
   1590 
   1591                     /* stage 2 table: uint32_t[] */
   1592                     offset+=count;
   1593                     count=mbcsHeader.offsetFromUBytes-offset;
   1594                     ds->swapArray32(ds, inBytes+offset, (int32_t)count,
   1595                                        outBytes+offset, pErrorCode);
   1596 
   1597                     /* stage 3/result bytes: sometimes uint16_t[] or uint32_t[] */
   1598                     offset=mbcsHeader.offsetFromUBytes;
   1599                     count= noFromU ? 0 : mbcsHeader.fromUBytesLength;
   1600                     switch(outputType) {
   1601                     case MBCS_OUTPUT_2:
   1602                     case MBCS_OUTPUT_3_EUC:
   1603                     case MBCS_OUTPUT_2_SISO:
   1604                         ds->swapArray16(ds, inBytes+offset, (int32_t)count,
   1605                                            outBytes+offset, pErrorCode);
   1606                         break;
   1607                     case MBCS_OUTPUT_4:
   1608                         ds->swapArray32(ds, inBytes+offset, (int32_t)count,
   1609                                            outBytes+offset, pErrorCode);
   1610                         break;
   1611                     default:
   1612                         /* just uint8_t[], nothing to swap */
   1613                         break;
   1614                     }
   1615 
   1616                     if(mbcsIndexLength!=0) {
   1617                         offset+=count;
   1618                         count=mbcsIndexLength;
   1619                         ds->swapArray16(ds, inBytes+offset, (int32_t)count,
   1620                                            outBytes+offset, pErrorCode);
   1621                     }
   1622                 }
   1623             }
   1624 
   1625             if(extOffset!=0) {
   1626                 /* swap the extension data */
   1627                 inBytes+=extOffset;
   1628                 outBytes+=extOffset;
   1629 
   1630                 /* swap toUTable[] */
   1631                 offset=udata_readInt32(ds, inExtIndexes[UCNV_EXT_TO_U_INDEX]);
   1632                 length=udata_readInt32(ds, inExtIndexes[UCNV_EXT_TO_U_LENGTH]);
   1633                 ds->swapArray32(ds, inBytes+offset, length*4, outBytes+offset, pErrorCode);
   1634 
   1635                 /* swap toUUChars[] */
   1636                 offset=udata_readInt32(ds, inExtIndexes[UCNV_EXT_TO_U_UCHARS_INDEX]);
   1637                 length=udata_readInt32(ds, inExtIndexes[UCNV_EXT_TO_U_UCHARS_LENGTH]);
   1638                 ds->swapArray16(ds, inBytes+offset, length*2, outBytes+offset, pErrorCode);
   1639 
   1640                 /* swap fromUTableUChars[] */
   1641                 offset=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_UCHARS_INDEX]);
   1642                 length=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_LENGTH]);
   1643                 ds->swapArray16(ds, inBytes+offset, length*2, outBytes+offset, pErrorCode);
   1644 
   1645                 /* swap fromUTableValues[] */
   1646                 offset=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_VALUES_INDEX]);
   1647                 /* same length as for fromUTableUChars[] */
   1648                 ds->swapArray32(ds, inBytes+offset, length*4, outBytes+offset, pErrorCode);
   1649 
   1650                 /* no need to swap fromUBytes[] */
   1651 
   1652                 /* swap fromUStage12[] */
   1653                 offset=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_STAGE_12_INDEX]);
   1654                 length=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_STAGE_12_LENGTH]);
   1655                 ds->swapArray16(ds, inBytes+offset, length*2, outBytes+offset, pErrorCode);
   1656 
   1657                 /* swap fromUStage3[] */
   1658                 offset=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_STAGE_3_INDEX]);
   1659                 length=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_STAGE_3_LENGTH]);
   1660                 ds->swapArray16(ds, inBytes+offset, length*2, outBytes+offset, pErrorCode);
   1661 
   1662                 /* swap fromUStage3b[] */
   1663                 offset=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_STAGE_3B_INDEX]);
   1664                 length=udata_readInt32(ds, inExtIndexes[UCNV_EXT_FROM_U_STAGE_3B_LENGTH]);
   1665                 ds->swapArray32(ds, inBytes+offset, length*4, outBytes+offset, pErrorCode);
   1666 
   1667                 /* swap indexes[] */
   1668                 length=udata_readInt32(ds, inExtIndexes[UCNV_EXT_INDEXES_LENGTH]);
   1669                 ds->swapArray32(ds, inBytes, length*4, outBytes, pErrorCode);
   1670             }
   1671         }
   1672     } else {
   1673         udata_printError(ds, "ucnv_swap(): unknown conversionType=%d!=UCNV_MBCS\n",
   1674                          inStaticData->conversionType);
   1675         *pErrorCode=U_UNSUPPORTED_ERROR;
   1676         return 0;
   1677     }
   1678 
   1679     return headerSize+(int32_t)staticDataSize+size;
   1680 }
   1681 
   1682 #endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */
   1683 
   1684 #endif
   1685