1999-08-16 21:50:52 +00:00
|
|
|
/*
|
1999-12-04 02:31:40 +00:00
|
|
|
********************************************************************
|
|
|
|
* COPYRIGHT:
|
2002-07-02 22:50:35 +00:00
|
|
|
* Copyright (c) 1996-2002, International Business Machines Corporation and
|
1999-12-04 02:31:40 +00:00
|
|
|
* others. All Rights Reserved.
|
|
|
|
********************************************************************
|
1999-08-16 21:50:52 +00:00
|
|
|
*
|
|
|
|
* uconv_bld.c:
|
|
|
|
*
|
|
|
|
* Defines functions that are used in the creation/initialization/deletion
|
|
|
|
* of converters and related structures.
|
|
|
|
* uses uconv_io.h routines to access disk information
|
|
|
|
* is used by ucnv.h to implement public API create/delete/flushCache routines
|
2000-06-20 23:42:20 +00:00
|
|
|
* Modification History:
|
|
|
|
*
|
|
|
|
* Date Name Description
|
|
|
|
*
|
|
|
|
* 06/20/2000 helena OS/400 port changes; mostly typecast.
|
2000-06-27 20:47:56 +00:00
|
|
|
* 06/29/2000 helena Major rewrite of the callback interface.
|
2000-06-20 23:42:20 +00:00
|
|
|
*/
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
|
2002-07-02 19:21:35 +00:00
|
|
|
#include "unicode/udata.h"
|
|
|
|
#include "unicode/ucnv.h"
|
|
|
|
#include "unicode/ucnv_err.h"
|
|
|
|
#include "unicode/uloc.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
#include "ucnv_io.h"
|
2000-06-27 20:47:56 +00:00
|
|
|
#include "ucnv_bld.h"
|
2000-02-05 00:19:15 +00:00
|
|
|
#include "ucnv_cnv.h"
|
1999-10-18 22:48:32 +00:00
|
|
|
#include "ucnv_imp.h"
|
2002-07-02 19:21:35 +00:00
|
|
|
#include "uhash.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
#include "umutex.h"
|
|
|
|
#include "cstring.h"
|
|
|
|
#include "cmemory.h"
|
2001-08-11 00:29:58 +00:00
|
|
|
#include "ucln_cmn.h"
|
2003-04-18 20:31:45 +00:00
|
|
|
#include "ustr_imp.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
|
1999-12-04 02:31:40 +00:00
|
|
|
|
2000-08-14 23:11:00 +00:00
|
|
|
#if 0
|
2001-02-06 22:26:52 +00:00
|
|
|
#include <stdio.h>
|
2000-08-14 23:11:00 +00:00
|
|
|
extern void UCNV_DEBUG_LOG(char *what, char *who, void *p, int l);
|
|
|
|
#define UCNV_DEBUG_LOG(x,y,z) UCNV_DEBUG_LOG(x,y,z,__LINE__)
|
|
|
|
#else
|
|
|
|
# define UCNV_DEBUG_LOG(x,y,z)
|
|
|
|
#endif
|
|
|
|
|
2001-08-24 00:22:07 +00:00
|
|
|
static const UConverterSharedData * const
|
2000-02-05 00:19:15 +00:00
|
|
|
converterData[UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES]={
|
2002-09-20 01:54:48 +00:00
|
|
|
NULL, NULL,
|
|
|
|
|
|
|
|
#if UCONFIG_NO_LEGACY_CONVERSION
|
|
|
|
NULL,
|
|
|
|
#else
|
|
|
|
&_MBCSData,
|
|
|
|
#endif
|
|
|
|
|
|
|
|
&_Latin1Data,
|
2000-11-16 17:20:03 +00:00
|
|
|
&_UTF8Data, &_UTF16BEData, &_UTF16LEData, &_UTF32BEData, &_UTF32LEData,
|
2002-09-20 01:54:48 +00:00
|
|
|
NULL,
|
|
|
|
|
|
|
|
#if UCONFIG_NO_LEGACY_CONVERSION
|
|
|
|
NULL,
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL,
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL,
|
|
|
|
NULL,
|
|
|
|
#else
|
|
|
|
&_ISO2022Data,
|
2000-03-31 16:53:09 +00:00
|
|
|
&_LMBCSData1,&_LMBCSData2, &_LMBCSData3, &_LMBCSData4, &_LMBCSData5, &_LMBCSData6,
|
2000-10-17 08:03:36 +00:00
|
|
|
&_LMBCSData8,&_LMBCSData11,&_LMBCSData16,&_LMBCSData17,&_LMBCSData18,&_LMBCSData19,
|
2002-09-20 01:54:48 +00:00
|
|
|
&_HZData,
|
|
|
|
#endif
|
|
|
|
|
|
|
|
&_SCSUData,
|
|
|
|
|
|
|
|
#if UCONFIG_NO_LEGACY_CONVERSION
|
|
|
|
NULL,
|
|
|
|
#else
|
|
|
|
&_ISCIIData,
|
|
|
|
#endif
|
|
|
|
|
|
|
|
&_ASCIIData,
|
2002-11-07 21:02:24 +00:00
|
|
|
&_UTF7Data, &_Bocu1Data, &_UTF16Data, &_UTF32Data, &_CESU8Data, &_IMAPData
|
2000-02-05 00:19:15 +00:00
|
|
|
};
|
|
|
|
|
2002-09-06 00:48:35 +00:00
|
|
|
/* Please keep this in binary sorted order for getAlgorithmicTypeFromName.
|
|
|
|
Also the name should be in lower case and all spaces, dashes and underscores
|
|
|
|
removed
|
|
|
|
*/
|
2000-02-05 00:19:15 +00:00
|
|
|
static struct {
|
|
|
|
const char *name;
|
2001-08-24 00:22:07 +00:00
|
|
|
const UConverterType type;
|
|
|
|
} const cnvNameType[] = {
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "bocu1", UCNV_BOCU1 },
|
|
|
|
{ "cesu8", UCNV_CESU8 },
|
2002-09-20 01:54:48 +00:00
|
|
|
#if !UCONFIG_NO_LEGACY_CONVERSION
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "hz",UCNV_HZ },
|
2002-11-07 21:02:24 +00:00
|
|
|
{ "imapmailboxname", UCNV_IMAP_MAILBOX },
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "iscii", UCNV_ISCII },
|
|
|
|
{ "iso2022", UCNV_ISO_2022 },
|
2002-09-20 01:54:48 +00:00
|
|
|
#endif
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "iso88591", UCNV_LATIN_1 },
|
2002-09-20 01:54:48 +00:00
|
|
|
#if !UCONFIG_NO_LEGACY_CONVERSION
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "lmbcs1", UCNV_LMBCS_1 },
|
|
|
|
{ "lmbcs11",UCNV_LMBCS_11 },
|
|
|
|
{ "lmbcs16",UCNV_LMBCS_16 },
|
|
|
|
{ "lmbcs17",UCNV_LMBCS_17 },
|
|
|
|
{ "lmbcs18",UCNV_LMBCS_18 },
|
|
|
|
{ "lmbcs19",UCNV_LMBCS_19 },
|
|
|
|
{ "lmbcs2", UCNV_LMBCS_2 },
|
|
|
|
{ "lmbcs3", UCNV_LMBCS_3 },
|
|
|
|
{ "lmbcs4", UCNV_LMBCS_4 },
|
|
|
|
{ "lmbcs5", UCNV_LMBCS_5 },
|
|
|
|
{ "lmbcs6", UCNV_LMBCS_6 },
|
|
|
|
{ "lmbcs8", UCNV_LMBCS_8 },
|
2002-09-20 01:54:48 +00:00
|
|
|
#endif
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "scsu", UCNV_SCSU },
|
|
|
|
{ "usascii", UCNV_US_ASCII },
|
|
|
|
{ "utf16", UCNV_UTF16 },
|
|
|
|
{ "utf16be", UCNV_UTF16_BigEndian },
|
|
|
|
{ "utf16le", UCNV_UTF16_LittleEndian },
|
2000-02-05 00:19:15 +00:00
|
|
|
#if U_IS_BIG_ENDIAN
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "utf16oppositeendian", UCNV_UTF16_LittleEndian },
|
|
|
|
{ "utf16platformendian", UCNV_UTF16_BigEndian },
|
2000-02-05 00:19:15 +00:00
|
|
|
#else
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "utf16oppositeendian", UCNV_UTF16_BigEndian},
|
|
|
|
{ "utf16platformendian", UCNV_UTF16_LittleEndian },
|
2000-11-16 17:20:03 +00:00
|
|
|
#endif
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "utf32", UCNV_UTF32 },
|
|
|
|
{ "utf32be", UCNV_UTF32_BigEndian },
|
|
|
|
{ "utf32le", UCNV_UTF32_LittleEndian },
|
2000-11-16 17:20:03 +00:00
|
|
|
#if U_IS_BIG_ENDIAN
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "utf32oppositeendian", UCNV_UTF32_LittleEndian },
|
|
|
|
{ "utf32platformendian", UCNV_UTF32_BigEndian },
|
2000-11-16 17:20:03 +00:00
|
|
|
#else
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "utf32oppositeendian", UCNV_UTF32_BigEndian },
|
|
|
|
{ "utf32platformendian", UCNV_UTF32_LittleEndian },
|
2000-02-05 00:19:15 +00:00
|
|
|
#endif
|
2002-09-06 00:48:35 +00:00
|
|
|
{ "utf7", UCNV_UTF7 },
|
|
|
|
{ "utf8", UCNV_UTF8 }
|
1999-10-18 22:48:32 +00:00
|
|
|
};
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2000-03-31 16:53:09 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
/*Takes an alias name gets an actual converter file name
|
1999-08-16 21:50:52 +00:00
|
|
|
*goes to disk and opens it.
|
|
|
|
*allocates the memory and returns a new UConverter object
|
|
|
|
*/
|
2002-09-04 00:36:40 +00:00
|
|
|
static UConverterSharedData *createConverterFromFile(const char *pkg, const char *converterName, UErrorCode * err);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2002-09-04 00:36:40 +00:00
|
|
|
static const UConverterSharedData *getAlgorithmicTypeFromName(const char *realName);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
1999-12-04 02:31:40 +00:00
|
|
|
/**
|
|
|
|
* Un flatten shared data from a UDATA..
|
|
|
|
*/
|
2002-03-21 19:31:32 +00:00
|
|
|
static UConverterSharedData* ucnv_data_unFlattenClone(UDataMemory *pData, UErrorCode *status);
|
1999-12-04 02:31:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
/*initializes some global variables */
|
2001-10-04 01:04:28 +00:00
|
|
|
static UHashtable *SHARED_DATA_HASHTABLE = NULL;
|
2002-03-27 17:36:15 +00:00
|
|
|
static UMTX cnvCacheMutex = NULL; /* Mutex for synchronizing cnv cache access. */
|
2002-03-12 21:54:23 +00:00
|
|
|
/* Note: the global mutex is used for */
|
|
|
|
/* reference count updates. */
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2002-03-12 21:54:23 +00:00
|
|
|
|
|
|
|
/* ucnv_cleanup - delete all storage held by the converter cache, except any in use */
|
|
|
|
/* by open converters. */
|
|
|
|
/* Not thread safe. */
|
2002-03-13 18:34:45 +00:00
|
|
|
/* Not supported API. Marked U_CAPI only for use by test programs. */
|
|
|
|
U_CAPI UBool U_EXPORT2 ucnv_cleanup(void) {
|
2001-08-11 00:29:58 +00:00
|
|
|
if (SHARED_DATA_HASHTABLE != NULL) {
|
|
|
|
ucnv_flushCache();
|
|
|
|
if (SHARED_DATA_HASHTABLE != NULL && uhash_count(SHARED_DATA_HASHTABLE) == 0) {
|
|
|
|
uhash_close(SHARED_DATA_HASHTABLE);
|
|
|
|
SHARED_DATA_HASHTABLE = NULL;
|
|
|
|
}
|
|
|
|
}
|
2002-03-12 21:54:23 +00:00
|
|
|
|
|
|
|
umtx_destroy(&cnvCacheMutex); /* Don't worry about destroying the mutex even */
|
|
|
|
/* if the hash table still exists. The mutex */
|
|
|
|
/* will lazily re-init itself if needed. */
|
2001-08-11 00:29:58 +00:00
|
|
|
return (SHARED_DATA_HASHTABLE == NULL);
|
2000-08-14 23:11:00 +00:00
|
|
|
}
|
|
|
|
|
2002-07-23 23:01:08 +00:00
|
|
|
static UBool U_CALLCONV
|
1999-12-04 02:31:40 +00:00
|
|
|
isCnvAcceptable(void *context,
|
|
|
|
const char *type, const char *name,
|
2000-05-03 23:15:02 +00:00
|
|
|
const UDataInfo *pInfo) {
|
2000-08-10 01:59:18 +00:00
|
|
|
return (UBool)(
|
1999-12-04 02:31:40 +00:00
|
|
|
pInfo->size>=20 &&
|
|
|
|
pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
|
|
|
|
pInfo->charsetFamily==U_CHARSET_FAMILY &&
|
|
|
|
pInfo->sizeofUChar==U_SIZEOF_UCHAR &&
|
|
|
|
pInfo->dataFormat[0]==0x63 && /* dataFormat="cnvt" */
|
|
|
|
pInfo->dataFormat[1]==0x6e &&
|
|
|
|
pInfo->dataFormat[2]==0x76 &&
|
|
|
|
pInfo->dataFormat[3]==0x74 &&
|
2002-07-17 02:34:50 +00:00
|
|
|
pInfo->formatVersion[0]==6); /* Everything will be version 6 */
|
1999-12-04 02:31:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define DATA_TYPE "cnv"
|
|
|
|
|
2002-07-17 02:34:50 +00:00
|
|
|
static UConverterSharedData *createConverterFromFile (const char* pkg, const char *fileName, UErrorCode * err)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
UDataMemory *data;
|
|
|
|
UConverterSharedData *sharedData;
|
1999-11-23 23:02:55 +00:00
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
if (err == NULL || U_FAILURE (*err)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
1999-11-23 23:02:55 +00:00
|
|
|
|
2002-07-17 02:34:50 +00:00
|
|
|
data = udata_openChoice(pkg, DATA_TYPE, fileName, isCnvAcceptable, NULL, err);
|
2001-08-11 00:29:58 +00:00
|
|
|
if(U_FAILURE(*err))
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
return NULL;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
sharedData = ucnv_data_unFlattenClone(data, err);
|
|
|
|
if(U_FAILURE(*err))
|
1999-12-04 02:31:40 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
udata_close(data);
|
|
|
|
return NULL;
|
1999-12-04 02:31:40 +00:00
|
|
|
}
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
return sharedData;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2002-07-03 16:54:59 +00:00
|
|
|
int32_t
|
2001-10-04 01:04:28 +00:00
|
|
|
ucnv_copyPlatformString(char *platformString, UConverterPlatform pltfrm)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
switch (pltfrm)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
1999-10-18 22:48:32 +00:00
|
|
|
case UCNV_IBM:
|
2002-07-03 16:54:59 +00:00
|
|
|
uprv_strcpy(platformString, "ibm-");
|
|
|
|
return 4;
|
2002-07-16 22:32:54 +00:00
|
|
|
case UCNV_UNKNOWN:
|
|
|
|
break;
|
2002-11-30 04:41:53 +00:00
|
|
|
}
|
2002-07-03 16:54:59 +00:00
|
|
|
|
|
|
|
/* default to empty string */
|
|
|
|
*platformString = 0;
|
|
|
|
return 0;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*returns a converter type from a string
|
|
|
|
*/
|
2000-08-11 01:27:17 +00:00
|
|
|
static const UConverterSharedData *
|
2001-08-11 00:29:58 +00:00
|
|
|
getAlgorithmicTypeFromName(const char *realName)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2002-09-04 00:36:40 +00:00
|
|
|
uint32_t mid, start, limit;
|
|
|
|
uint32_t lastMid;
|
|
|
|
int result;
|
2002-09-06 00:48:35 +00:00
|
|
|
char strippedName[UCNV_MAX_CONVERTER_NAME_LENGTH];
|
|
|
|
|
|
|
|
/* Lower case and remove ignoreable characters. */
|
|
|
|
ucnv_io_stripForCompare(strippedName, realName);
|
2002-09-04 00:36:40 +00:00
|
|
|
|
|
|
|
/* do a binary search for the alias */
|
|
|
|
start = 0;
|
|
|
|
limit = sizeof(cnvNameType)/sizeof(cnvNameType[0]);
|
|
|
|
mid = limit;
|
|
|
|
lastMid = UINT32_MAX;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
mid = (uint32_t)((start + limit) / 2);
|
|
|
|
if (lastMid == mid) { /* Have we moved? */
|
|
|
|
break; /* We haven't moved, and it wasn't found. */
|
|
|
|
}
|
|
|
|
lastMid = mid;
|
2002-09-06 00:48:35 +00:00
|
|
|
result = uprv_strcmp(strippedName, cnvNameType[mid].name);
|
2002-09-04 00:36:40 +00:00
|
|
|
|
|
|
|
if (result < 0) {
|
|
|
|
limit = mid;
|
|
|
|
} else if (result > 0) {
|
|
|
|
start = mid;
|
|
|
|
} else {
|
|
|
|
return converterData[cnvNameType[mid].type];
|
2001-08-11 00:29:58 +00:00
|
|
|
}
|
2000-02-05 00:19:15 +00:00
|
|
|
}
|
2002-09-04 00:36:40 +00:00
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
return NULL;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2002-03-12 21:54:23 +00:00
|
|
|
/* Puts the shared data in the static hashtable SHARED_DATA_HASHTABLE */
|
|
|
|
/* Will always be called with the cnvCacheMutex alrady being held */
|
|
|
|
/* by the calling function. */
|
2001-10-04 01:14:52 +00:00
|
|
|
void
|
|
|
|
ucnv_shareConverterData(UConverterSharedData * data)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
UErrorCode err = U_ZERO_ERROR;
|
|
|
|
/*Lazy evaluates the Hashtable itself */
|
|
|
|
/*void *sanity = NULL;*/
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2002-08-06 15:59:27 +00:00
|
|
|
if (SHARED_DATA_HASHTABLE == NULL)
|
|
|
|
{
|
2002-09-06 00:48:35 +00:00
|
|
|
SHARED_DATA_HASHTABLE = uhash_openSize(uhash_hashChars, uhash_compareChars,
|
2001-08-11 00:29:58 +00:00
|
|
|
ucnv_io_countAvailableAliases(&err),
|
|
|
|
&err);
|
2002-03-12 21:54:23 +00:00
|
|
|
if (U_FAILURE(err))
|
2001-08-11 00:29:58 +00:00
|
|
|
return;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-03-12 21:54:23 +00:00
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
/* ### check to see if the element is not already there! */
|
2000-08-14 23:11:00 +00:00
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
/*
|
2001-10-04 01:14:52 +00:00
|
|
|
sanity = ucnv_getSharedConverterData (data->staticData->name);
|
2000-08-14 23:11:00 +00:00
|
|
|
if(sanity != NULL)
|
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
UCNV_DEBUG_LOG("put:overwrite!",data->staticData->name,sanity);
|
2000-08-14 23:11:00 +00:00
|
|
|
}
|
|
|
|
UCNV_DEBUG_LOG("put:chk",data->staticData->name,sanity);
|
2001-08-11 00:29:58 +00:00
|
|
|
*/
|
2002-07-17 02:34:50 +00:00
|
|
|
|
|
|
|
/* Mark it shared */
|
|
|
|
data->sharedDataCached = TRUE;
|
2000-08-14 23:11:00 +00:00
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
uhash_put(SHARED_DATA_HASHTABLE,
|
|
|
|
(void*) data->staticData->name, /* Okay to cast away const as long as
|
|
|
|
keyDeleter == NULL */
|
1999-12-04 00:55:54 +00:00
|
|
|
data,
|
|
|
|
&err);
|
2001-08-11 00:29:58 +00:00
|
|
|
UCNV_DEBUG_LOG("put", data->staticData->name,data);
|
2002-03-12 21:54:23 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2002-03-12 21:54:23 +00:00
|
|
|
/* Look up a converter name in the shared data cache. */
|
|
|
|
/* cnvCacheMutex must be held by the caller to protect the hash table. */
|
2001-10-04 01:04:28 +00:00
|
|
|
UConverterSharedData *
|
2001-10-04 01:14:52 +00:00
|
|
|
ucnv_getSharedConverterData(const char *name)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
/*special case when no Table has yet been created we return NULL */
|
|
|
|
if (SHARED_DATA_HASHTABLE == NULL)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
else
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
UConverterSharedData *rc;
|
2000-08-14 23:11:00 +00:00
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
rc = (UConverterSharedData*)uhash_get(SHARED_DATA_HASHTABLE, name);
|
|
|
|
UCNV_DEBUG_LOG("get",name,rc);
|
|
|
|
return rc;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*frees the string of memory blocks associates with a sharedConverter
|
|
|
|
*if and only if the referenceCounter == 0
|
|
|
|
*/
|
2001-10-04 01:04:28 +00:00
|
|
|
UBool
|
2001-10-04 01:14:52 +00:00
|
|
|
ucnv_deleteSharedConverterData(UConverterSharedData * deadSharedData)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
1999-12-04 02:31:40 +00:00
|
|
|
if (deadSharedData->referenceCounter > 0)
|
|
|
|
return FALSE;
|
2002-07-17 02:34:50 +00:00
|
|
|
|
2000-02-08 23:41:16 +00:00
|
|
|
if (deadSharedData->impl->unload != NULL) {
|
|
|
|
deadSharedData->impl->unload(deadSharedData);
|
|
|
|
}
|
2002-07-17 02:34:50 +00:00
|
|
|
|
1999-12-04 02:31:40 +00:00
|
|
|
if(deadSharedData->dataMemory != NULL)
|
|
|
|
{
|
|
|
|
UDataMemory *data = (UDataMemory*)deadSharedData->dataMemory;
|
|
|
|
udata_close(data);
|
|
|
|
}
|
|
|
|
|
2000-08-14 23:11:00 +00:00
|
|
|
if(deadSharedData->table != NULL)
|
|
|
|
{
|
|
|
|
uprv_free(deadSharedData->table);
|
|
|
|
}
|
|
|
|
|
2002-07-17 02:34:50 +00:00
|
|
|
#if 0
|
|
|
|
/* if the static data is actually owned by the shared data */
|
|
|
|
/* enable if we ever have this situation. */
|
|
|
|
if(deadSharedData->staticDataOwned == TRUE) /* see ucnv_bld.h */
|
|
|
|
{
|
|
|
|
uprv_free((void*)deadSharedData->staticData);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* Zap it ! */
|
|
|
|
uprv_memset(deadSharedData->0, sizeof(*deadSharedData));
|
|
|
|
#endif
|
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
uprv_free(deadSharedData);
|
1999-12-04 02:31:40 +00:00
|
|
|
|
|
|
|
return TRUE;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2000-05-22 20:15:09 +00:00
|
|
|
static void
|
|
|
|
parseConverterOptions(const char *inName,
|
2002-07-02 19:21:35 +00:00
|
|
|
char *cnvName,
|
|
|
|
char *locale,
|
|
|
|
uint32_t *pFlags,
|
|
|
|
UErrorCode *err)
|
|
|
|
{
|
2000-05-22 20:15:09 +00:00
|
|
|
char c;
|
2002-07-02 19:21:35 +00:00
|
|
|
int32_t len = 0;
|
2000-05-22 20:15:09 +00:00
|
|
|
|
|
|
|
/* copy the converter name itself to cnvName */
|
|
|
|
while((c=*inName)!=0 && c!=UCNV_OPTION_SEP_CHAR) {
|
2002-07-02 19:21:35 +00:00
|
|
|
if (++len>=UCNV_MAX_CONVERTER_NAME_LENGTH) {
|
2002-07-03 20:18:36 +00:00
|
|
|
*err = U_ILLEGAL_ARGUMENT_ERROR; /* bad name */
|
2002-07-02 21:42:29 +00:00
|
|
|
*cnvName=0;
|
2002-07-02 19:21:35 +00:00
|
|
|
return;
|
|
|
|
}
|
2000-05-22 20:15:09 +00:00
|
|
|
*cnvName++=c;
|
2002-07-02 19:21:35 +00:00
|
|
|
inName++;
|
2000-05-22 20:15:09 +00:00
|
|
|
}
|
|
|
|
*cnvName=0;
|
|
|
|
|
2002-07-02 19:21:35 +00:00
|
|
|
/* parse options. No more name copying should occur. */
|
2002-09-18 01:42:32 +00:00
|
|
|
while((c=*inName)!=0) {
|
|
|
|
if(c==UCNV_OPTION_SEP_CHAR) {
|
|
|
|
++inName;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* inName is behind an option separator */
|
|
|
|
if(uprv_strncmp(inName, "locale=", 7)==0) {
|
|
|
|
/* do not modify locale itself in case we have multiple locale options */
|
|
|
|
char *dest=locale;
|
|
|
|
|
|
|
|
/* copy the locale option value */
|
|
|
|
inName+=7;
|
|
|
|
len=0;
|
|
|
|
while((c=*inName)!=0 && c!=UCNV_OPTION_SEP_CHAR) {
|
|
|
|
++inName;
|
|
|
|
|
|
|
|
if(++len>=ULOC_FULLNAME_CAPACITY) {
|
|
|
|
*err=U_ILLEGAL_ARGUMENT_ERROR; /* bad name */
|
|
|
|
*locale=0;
|
|
|
|
return;
|
2000-05-22 20:15:09 +00:00
|
|
|
}
|
2002-09-18 01:42:32 +00:00
|
|
|
|
|
|
|
*dest++=c;
|
|
|
|
}
|
|
|
|
*dest=0;
|
|
|
|
} else if(uprv_strncmp(inName, "version=", 8)==0) {
|
|
|
|
/* copy the version option value into bits 3..0 of *pFlags */
|
|
|
|
inName+=8;
|
|
|
|
c=*inName;
|
|
|
|
if(c==0) {
|
|
|
|
*pFlags&=~UCNV_OPTION_VERSION;
|
|
|
|
return;
|
|
|
|
} else if((uint8_t)(c-'0')<10) {
|
|
|
|
*pFlags=(*pFlags&~UCNV_OPTION_VERSION)|(uint32_t)(c-'0');
|
|
|
|
++inName;
|
|
|
|
}
|
|
|
|
} else if(uprv_strncmp(inName, "swaplfnl", 8)==0) {
|
|
|
|
inName+=8;
|
|
|
|
*pFlags|=UCNV_OPTION_SWAP_LFNL;
|
|
|
|
/* add processing for new options here with another } else if(uprv_strncmp(inName, "option-name=", XX)==0) { */
|
|
|
|
} else {
|
|
|
|
/* ignore any other options until we define some */
|
|
|
|
do {
|
|
|
|
c=*inName++;
|
2001-01-09 03:33:07 +00:00
|
|
|
if(c==0) {
|
|
|
|
return;
|
|
|
|
}
|
2002-09-18 01:42:32 +00:00
|
|
|
} while(c!=UCNV_OPTION_SEP_CHAR);
|
2000-05-22 20:15:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
/*Logic determines if the converter is Algorithmic AND/OR cached
|
|
|
|
*depending on that:
|
|
|
|
* -we either go to get data from disk and cache it (Data=TRUE, Cached=False)
|
|
|
|
* -Get it from a Hashtable (Data=X, Cached=TRUE)
|
|
|
|
* -Call dataConverter initializer (Data=TRUE, Cached=TRUE)
|
|
|
|
* -Call AlgorithmicConverter initializer (Data=FALSE, Cached=TRUE)
|
|
|
|
*/
|
|
|
|
UConverter *
|
2002-09-06 00:48:35 +00:00
|
|
|
ucnv_createConverter(const char *converterName, UErrorCode * err)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2002-07-02 19:21:35 +00:00
|
|
|
char cnvName[UCNV_MAX_CONVERTER_NAME_LENGTH], locale[ULOC_FULLNAME_CAPACITY];
|
2001-08-11 00:29:58 +00:00
|
|
|
const char *realName;
|
|
|
|
UConverter *myUConverter = NULL;
|
|
|
|
UConverterSharedData *mySharedConverterData = NULL;
|
|
|
|
UErrorCode internalErrorCode = U_ZERO_ERROR;
|
|
|
|
uint32_t options=0;
|
|
|
|
if (U_FAILURE (*err))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
locale[0] = 0;
|
|
|
|
|
|
|
|
/* In case "name" is NULL we want to open the default converter. */
|
|
|
|
if (converterName == NULL) {
|
|
|
|
realName = ucnv_io_getDefaultConverterName();
|
|
|
|
if (realName == NULL) {
|
|
|
|
*err = U_MISSING_RESOURCE_ERROR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* the default converter name is already canonical */
|
|
|
|
} else {
|
|
|
|
/* separate the converter name from the options */
|
2002-07-02 21:42:29 +00:00
|
|
|
parseConverterOptions(converterName, cnvName, locale, &options, err);
|
|
|
|
if (U_FAILURE(*err)) {
|
|
|
|
/* Very bad name used. */
|
|
|
|
return NULL;
|
|
|
|
}
|
2001-08-11 00:29:58 +00:00
|
|
|
|
|
|
|
/* get the canonical converter name */
|
|
|
|
realName = ucnv_io_getConverterName(cnvName, &internalErrorCode);
|
|
|
|
if (U_FAILURE(internalErrorCode) || realName == NULL) {
|
|
|
|
/*
|
|
|
|
* set the input name in case the converter was added
|
|
|
|
* without updating the alias table, or when there is no alias table
|
|
|
|
*/
|
|
|
|
realName = cnvName;
|
|
|
|
}
|
1999-12-04 00:55:54 +00:00
|
|
|
}
|
2001-08-11 00:29:58 +00:00
|
|
|
|
2000-05-22 20:15:09 +00:00
|
|
|
/* separate the converter name from the options */
|
2001-08-11 00:29:58 +00:00
|
|
|
if(realName != cnvName) {
|
2002-07-02 19:21:35 +00:00
|
|
|
parseConverterOptions(realName, cnvName, locale, &options, err);
|
2001-08-11 00:29:58 +00:00
|
|
|
realName = cnvName;
|
1999-12-04 00:55:54 +00:00
|
|
|
}
|
2001-08-11 00:29:58 +00:00
|
|
|
|
|
|
|
/* get the shared data for an algorithmic converter, if it is one */
|
2002-07-02 19:21:35 +00:00
|
|
|
mySharedConverterData = (UConverterSharedData *)getAlgorithmicTypeFromName(realName);
|
2001-08-11 00:29:58 +00:00
|
|
|
if (mySharedConverterData == NULL)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2002-03-12 21:54:23 +00:00
|
|
|
/* it is a data-based converter, get its shared data. */
|
|
|
|
/* Hold the cnvCacheMutex through the whole process of checking the */
|
|
|
|
/* converter data cache, and adding new entries to the cache */
|
|
|
|
/* to prevent other threads from modifying the cache during the */
|
|
|
|
/* process. */
|
|
|
|
umtx_lock(&cnvCacheMutex);
|
2002-09-06 00:48:35 +00:00
|
|
|
mySharedConverterData = ucnv_getSharedConverterData(realName);
|
2001-08-11 00:29:58 +00:00
|
|
|
if (mySharedConverterData == NULL)
|
1999-12-04 00:55:54 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
/*Not cached, we need to stream it in from file */
|
2002-09-06 00:48:35 +00:00
|
|
|
mySharedConverterData = createConverterFromFile(NULL, realName, err);
|
2001-08-11 00:29:58 +00:00
|
|
|
if (U_FAILURE (*err) || (mySharedConverterData == NULL))
|
1999-12-04 00:55:54 +00:00
|
|
|
{
|
2002-03-12 21:54:23 +00:00
|
|
|
umtx_unlock(&cnvCacheMutex);
|
2001-08-11 00:29:58 +00:00
|
|
|
return NULL;
|
1999-12-04 00:55:54 +00:00
|
|
|
}
|
2001-08-11 00:29:58 +00:00
|
|
|
else
|
1999-12-04 00:55:54 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
/* share it with other library clients */
|
2001-10-04 01:14:52 +00:00
|
|
|
ucnv_shareConverterData(mySharedConverterData);
|
1999-12-04 00:55:54 +00:00
|
|
|
}
|
|
|
|
}
|
2001-08-11 00:29:58 +00:00
|
|
|
else
|
1999-12-04 00:55:54 +00:00
|
|
|
{
|
2002-03-12 21:54:23 +00:00
|
|
|
/* The data for this converter was already in the cache. */
|
|
|
|
/* Update the reference counter on the shared data: one more client */
|
2002-09-06 00:48:35 +00:00
|
|
|
umtx_lock(NULL);
|
2001-08-11 00:29:58 +00:00
|
|
|
mySharedConverterData->referenceCounter++;
|
2002-09-06 00:48:35 +00:00
|
|
|
umtx_unlock(NULL);
|
1999-12-04 00:55:54 +00:00
|
|
|
}
|
2002-03-12 21:54:23 +00:00
|
|
|
umtx_unlock(&cnvCacheMutex);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2002-07-17 02:34:50 +00:00
|
|
|
myUConverter = ucnv_createConverterFromSharedData(mySharedConverterData, realName, locale, options, err);
|
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
/* allocate the converter */
|
|
|
|
if (myUConverter == NULL)
|
2000-02-09 19:15:17 +00:00
|
|
|
{
|
2001-08-11 00:29:58 +00:00
|
|
|
if (mySharedConverterData->referenceCounter != ~0) {
|
|
|
|
umtx_lock (NULL);
|
|
|
|
--mySharedConverterData->referenceCounter;
|
|
|
|
umtx_unlock (NULL);
|
|
|
|
}
|
|
|
|
*err = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2002-07-17 02:34:50 +00:00
|
|
|
return myUConverter;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
UConverter*
|
|
|
|
ucnv_createConverterFromPackage(const char *packageName, const char *converterName, UErrorCode * err)
|
|
|
|
{
|
|
|
|
char cnvName[UCNV_MAX_CONVERTER_NAME_LENGTH], locale[ULOC_FULLNAME_CAPACITY];
|
|
|
|
uint32_t options=0;
|
|
|
|
UConverter *myUConverter;
|
|
|
|
UConverterSharedData *mySharedConverterData = NULL;
|
|
|
|
|
|
|
|
if(U_FAILURE(*err)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* first, get the options out of the convertername string */
|
|
|
|
parseConverterOptions(converterName, cnvName, locale, &options, err);
|
|
|
|
if (U_FAILURE(*err)) {
|
|
|
|
/* Very bad name used. */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* open the data, unflatten the shared structure */
|
|
|
|
mySharedConverterData = createConverterFromFile(packageName, cnvName, err);
|
|
|
|
|
|
|
|
if (U_FAILURE(*err)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create the actual converter */
|
|
|
|
myUConverter = ucnv_createConverterFromSharedData( mySharedConverterData, cnvName, locale, options, err);
|
|
|
|
|
|
|
|
if (U_FAILURE(*err)) {
|
|
|
|
ucnv_close(myUConverter);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return myUConverter;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
UConverter*
|
|
|
|
ucnv_createConverterFromSharedData(UConverterSharedData *mySharedConverterData, const char *realName, const char *locale, uint32_t options, UErrorCode *err)
|
|
|
|
{
|
|
|
|
UConverter *myUConverter;
|
|
|
|
|
|
|
|
myUConverter = (UConverter *) uprv_malloc (sizeof (UConverter));
|
|
|
|
if(myUConverter == NULL)
|
|
|
|
{
|
|
|
|
*err = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
/* initialize the converter */
|
|
|
|
uprv_memset(myUConverter, 0, sizeof(UConverter));
|
|
|
|
myUConverter->sharedData = mySharedConverterData;
|
2002-09-18 01:42:32 +00:00
|
|
|
myUConverter->options = options;
|
2001-08-11 00:29:58 +00:00
|
|
|
myUConverter->mode = UCNV_SI;
|
|
|
|
myUConverter->fromCharErrorBehaviour = (UConverterToUCallback) UCNV_TO_U_CALLBACK_SUBSTITUTE;
|
|
|
|
myUConverter->fromUCharErrorBehaviour = (UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE;
|
|
|
|
myUConverter->toUnicodeStatus = myUConverter->sharedData->toUnicodeStatus;
|
|
|
|
myUConverter->subChar1 = myUConverter->sharedData->staticData->subChar1;
|
|
|
|
myUConverter->subCharLen = myUConverter->sharedData->staticData->subCharLen;
|
|
|
|
uprv_memcpy (myUConverter->subChar, myUConverter->sharedData->staticData->subChar, myUConverter->subCharLen);
|
|
|
|
|
|
|
|
if(myUConverter != NULL && myUConverter->sharedData->impl->open != NULL) {
|
|
|
|
myUConverter->sharedData->impl->open(myUConverter, realName, locale,options, err);
|
|
|
|
if(U_FAILURE(*err)) {
|
|
|
|
ucnv_close(myUConverter);
|
|
|
|
return NULL;
|
|
|
|
}
|
2000-02-09 19:15:17 +00:00
|
|
|
}
|
|
|
|
|
2001-08-11 00:29:58 +00:00
|
|
|
return myUConverter;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2002-03-21 19:31:32 +00:00
|
|
|
static UConverterSharedData*
|
2001-10-04 01:04:28 +00:00
|
|
|
ucnv_data_unFlattenClone(UDataMemory *pData, UErrorCode *status)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2000-07-13 23:55:33 +00:00
|
|
|
/* UDataInfo info; -- necessary only if some converters have different formatVersion */
|
2000-02-08 23:41:16 +00:00
|
|
|
const uint8_t *raw = (const uint8_t *)udata_getMemory(pData);
|
2000-04-19 23:05:27 +00:00
|
|
|
const UConverterStaticData *source = (const UConverterStaticData *) raw;
|
2000-02-08 23:41:16 +00:00
|
|
|
UConverterSharedData *data;
|
2000-06-20 23:42:20 +00:00
|
|
|
UConverterType type = (UConverterType)source->conversionType;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2000-02-05 00:19:15 +00:00
|
|
|
if(U_FAILURE(*status))
|
|
|
|
return NULL;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2000-02-05 00:19:15 +00:00
|
|
|
if( (uint16_t)type >= UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES ||
|
2001-01-02 23:09:45 +00:00
|
|
|
converterData[type] == NULL ||
|
2000-02-05 00:19:15 +00:00
|
|
|
converterData[type]->referenceCounter != 1 ||
|
2000-04-19 23:05:27 +00:00
|
|
|
source->structSize != sizeof(UConverterStaticData))
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2000-02-05 00:19:15 +00:00
|
|
|
*status = U_INVALID_TABLE_FORMAT;
|
2000-07-13 00:11:11 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2000-02-05 00:19:15 +00:00
|
|
|
data = (UConverterSharedData *)uprv_malloc(sizeof(UConverterSharedData));
|
|
|
|
if(data == NULL) {
|
|
|
|
*status = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
1999-12-04 02:31:40 +00:00
|
|
|
|
2000-02-05 00:19:15 +00:00
|
|
|
/* copy initial values from the static structure for this type */
|
|
|
|
uprv_memcpy(data, converterData[type], sizeof(UConverterSharedData));
|
1999-12-04 02:31:40 +00:00
|
|
|
|
2002-09-18 01:42:32 +00:00
|
|
|
/*
|
|
|
|
* It would be much more efficient if the table were a direct member, not a pointer.
|
|
|
|
* However, that would add to the size of all UConverterSharedData objects
|
|
|
|
* even if they do not use this table (especially algorithmic ones).
|
|
|
|
* If this changes, then the static templates from converterData[type]
|
|
|
|
* need more entries.
|
|
|
|
*/
|
2000-02-05 00:19:15 +00:00
|
|
|
data->table = (UConverterTable *)uprv_malloc(sizeof(UConverterTable));
|
|
|
|
if(data->table == NULL) {
|
|
|
|
uprv_free(data);
|
|
|
|
*status = U_MEMORY_ALLOCATION_ERROR;
|
1999-12-04 02:31:40 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2002-09-18 01:42:32 +00:00
|
|
|
uprv_memset(data->table, 0, sizeof(UConverterTable));
|
2000-04-19 23:05:27 +00:00
|
|
|
|
|
|
|
data->staticData = source;
|
2002-07-17 02:34:50 +00:00
|
|
|
|
|
|
|
data->sharedDataCached = FALSE;
|
1999-12-04 02:31:40 +00:00
|
|
|
|
2000-02-05 00:19:15 +00:00
|
|
|
/* fill in fields from the loaded data */
|
2000-02-08 23:41:16 +00:00
|
|
|
data->dataMemory = (void*)pData; /* for future use */
|
1999-12-04 02:31:40 +00:00
|
|
|
|
2000-02-08 23:41:16 +00:00
|
|
|
if(data->impl->load != NULL) {
|
|
|
|
data->impl->load(data, raw + source->structSize, status);
|
|
|
|
if(U_FAILURE(*status)) {
|
2000-12-14 00:29:46 +00:00
|
|
|
uprv_free(data->table);
|
2000-02-08 23:41:16 +00:00
|
|
|
uprv_free(data);
|
|
|
|
return NULL;
|
|
|
|
}
|
1999-12-04 02:31:40 +00:00
|
|
|
}
|
2000-02-08 23:41:16 +00:00
|
|
|
return data;
|
1999-12-04 02:31:40 +00:00
|
|
|
}
|
2001-10-04 01:04:28 +00:00
|
|
|
|
|
|
|
/*Frees all shared immutable objects that aren't referred to (reference count = 0)
|
|
|
|
*/
|
2001-11-21 01:02:11 +00:00
|
|
|
U_CAPI int32_t U_EXPORT2
|
2001-10-04 01:04:28 +00:00
|
|
|
ucnv_flushCache ()
|
|
|
|
{
|
|
|
|
UConverterSharedData *mySharedData = NULL;
|
|
|
|
int32_t pos = -1;
|
|
|
|
int32_t tableDeletedNum = 0;
|
|
|
|
const UHashElement *e;
|
2003-04-18 20:31:45 +00:00
|
|
|
UErrorCode status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
|
|
|
|
|
|
/* Close the default converter without creating a new one so that everything will be flushed. */
|
|
|
|
ucnv_close(u_getDefaultConverter(&status));
|
2001-10-04 01:04:28 +00:00
|
|
|
|
|
|
|
/*if shared data hasn't even been lazy evaluated yet
|
|
|
|
* return 0
|
|
|
|
*/
|
|
|
|
if (SHARED_DATA_HASHTABLE == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*creates an enumeration to iterate through every element in the
|
2002-03-12 21:54:23 +00:00
|
|
|
* table
|
|
|
|
*
|
|
|
|
* Synchronization: holding cnvCacheMutex will prevent any other thread from
|
|
|
|
* accessing or modifying the hash table during the iteration.
|
|
|
|
* The reference count of an entry may be decremented by
|
|
|
|
* ucnv_close while the iteration is in process, but this is
|
|
|
|
* benign. It can't be incremented (in ucnv_createConverter())
|
|
|
|
* because the sequence of looking up in the cache + incrementing
|
|
|
|
* is protected by cnvCacheMutex.
|
2001-10-04 01:04:28 +00:00
|
|
|
*/
|
2002-03-12 21:54:23 +00:00
|
|
|
umtx_lock (&cnvCacheMutex);
|
2001-10-04 01:04:28 +00:00
|
|
|
while ((e = uhash_nextElement (SHARED_DATA_HASHTABLE, &pos)) != NULL)
|
|
|
|
{
|
2001-10-16 18:31:13 +00:00
|
|
|
mySharedData = (UConverterSharedData *) e->value.pointer;
|
2001-10-04 01:04:28 +00:00
|
|
|
/*deletes only if reference counter == 0 */
|
|
|
|
if (mySharedData->referenceCounter == 0)
|
|
|
|
{
|
|
|
|
tableDeletedNum++;
|
|
|
|
|
|
|
|
UCNV_DEBUG_LOG("del",mySharedData->staticData->name,mySharedData);
|
|
|
|
|
|
|
|
uhash_removeElement(SHARED_DATA_HASHTABLE, e);
|
2002-07-17 02:34:50 +00:00
|
|
|
mySharedData->sharedDataCached = FALSE;
|
2001-10-04 01:14:52 +00:00
|
|
|
ucnv_deleteSharedConverterData (mySharedData);
|
2001-10-04 01:04:28 +00:00
|
|
|
}
|
|
|
|
}
|
2002-03-12 21:54:23 +00:00
|
|
|
umtx_unlock (&cnvCacheMutex);
|
2001-10-04 01:04:28 +00:00
|
|
|
|
2002-06-13 16:43:41 +00:00
|
|
|
ucnv_io_flushAvailableConverterCache();
|
|
|
|
|
2001-10-04 01:04:28 +00:00
|
|
|
return tableDeletedNum;
|
|
|
|
}
|
|
|
|
|