| /* |
| ******************************************************************** |
| * COPYRIGHT: |
| * Copyright (c) 1996-1999, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ******************************************************************** |
| * |
| * 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 |
| */ |
| |
| |
| #include "ucnv_io.h" |
| #include "uhash.h" |
| #include "ucmp16.h" |
| #include "ucmp8.h" |
| #include "unicode/ucnv_bld.h" |
| #include "unicode/ucnv_err.h" |
| #include "ucnv_imp.h" |
| #include "unicode/udata.h" |
| #include "unicode/ucnv.h" |
| #include "umutex.h" |
| #include "cstring.h" |
| #include "cmemory.h" |
| #include "filestrm.h" |
| |
| #include <stdio.h> |
| |
| /*Array used to generate ALGORITHMIC_CONVERTERS_HASHTABLE |
| *should ALWAYS BE EMPTY STRING TERMINATED. |
| */ |
| static const char *algorithmicConverterNames[] = { |
| "LATIN_1", |
| "UTF8", |
| "UTF16_BigEndian", |
| "UTF16_LittleEndian", |
| "UTF16_PlatformEndian", |
| "UTF16_OppositeEndian", |
| "ISO_2022", |
| "JIS", |
| "EUC", |
| "GB", |
| "" |
| }; |
| |
| /*Takes an alias name gets an actual converter file name |
| *goes to disk and opens it. |
| *allocates the memory and returns a new UConverter object |
| */ |
| static UConverter *createConverterFromFile (const char *converterName, UErrorCode * err); |
| static UConverter *createConverterFromAlgorithmicType (const char *realName, UErrorCode * err); |
| |
| /*Given a file returns a newly allocated CompactByteArray based on the a serialized one */ |
| static CompactByteArray *createCompactByteArrayFromFile (FileStream * infile, UErrorCode * err); |
| |
| /*Given a file returns a newly allocated CompactShortArray based on the a serialized one */ |
| static CompactShortArray *createCompactShortArrayFromFile (FileStream * infile, UErrorCode * err); |
| |
| /*Currently we have function to take us from a codepage name to |
| *a platform type and a codepage number |
| *assuming the following |
| *codepage name = $PLATFORM-#CODEPAGE |
| *e.g. ibm-949 = platform type = UCNV_IBM and codepage # = 949 |
| *the functions below implement that |
| */ |
| static UConverterPlatform getPlatformFromName (char *name); |
| static int32_t getCodepageNumberFromName (char *name); |
| |
| static UConverterType getAlgorithmicTypeFromName (const char *realName); |
| |
| |
| /*these functions initialize the lightweight mutable part of the |
| *object to correct values based on the sharedData defaults. |
| */ |
| static void initializeDataConverter (UConverter * myConverter); |
| static void initializeAlgorithmicConverter (UConverter * myConverter); |
| /** |
| *hash function for UConverterSharedData |
| */ |
| |
| static int32_t uhash_hashSharedData (void *sharedData); |
| |
| /** |
| * Un flatten shared data from a UDATA.. |
| */ |
| U_CAPI UConverterSharedData* U_EXPORT2 ucnv_data_unFlattenClone(const UConverterSharedData *data, UErrorCode *status); |
| |
| |
| /*initializes some global variables */ |
| UHashtable *SHARED_DATA_HASHTABLE = NULL; |
| UHashtable *ALGORITHMIC_CONVERTERS_HASHTABLE = NULL; |
| |
| /*Returns uppercased string */ |
| char * |
| strtoupper (char *name) |
| { |
| int32_t i = 0; |
| |
| while (name[i] = uprv_toupper (name[i])) |
| i++; |
| |
| return name; |
| } |
| |
| /* Returns true in c is a in set 'setOfChars', false otherwise |
| */ |
| bool_t |
| isInSet (char c, const char *setOfChars) |
| { |
| uint8_t i = 0; |
| |
| while (setOfChars[i] != '\0') |
| { |
| if (c == setOfChars[i++]) |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| /* Returns pointer to the next non-whitespace (or non-separator) |
| */ |
| int32_t |
| nextTokenOffset (const char *line, const char *separators) |
| { |
| int32_t i = 0; |
| |
| while (line[i] && isInSet (line[i], separators)) |
| i++; |
| |
| return i; |
| } |
| |
| /* Returns pointer to the next token based on the set of separators |
| */ |
| char * |
| getToken (char *token, char *line, const char *separators) |
| { |
| int32_t i = nextTokenOffset (line, separators); |
| int8_t j = 0; |
| |
| while (line[i] && (!isInSet (line[i], separators))) |
| token[j++] = line[i++]; |
| token[j] = '\0'; |
| |
| return line + i; |
| } |
| |
| int32_t uhash_hashIString(const void* name) |
| { |
| char myName[UCNV_MAX_CONVERTER_NAME_LENGTH]; |
| uprv_strcpy(myName, (char*)name); |
| strtoupper(myName); |
| |
| return uhash_hashString(myName); |
| } |
| |
| CompactShortArray* createCompactShortArrayFromFile (FileStream * infile, UErrorCode * err) |
| { |
| int32_t i = 0; |
| int16_t *myShortArray = NULL; |
| uint16_t *myIndexArray = NULL; |
| int32_t myValuesCount = 0; |
| int32_t myIndexCount = 0; |
| int32_t myBlockShift = 0; |
| |
| if (U_FAILURE (*err)) |
| return NULL; |
| |
| /*reads in the lengths of the 2 serialized array */ |
| T_FileStream_read (infile, &myValuesCount, sizeof (int32_t)); |
| T_FileStream_read (infile, &myIndexCount, sizeof (int32_t)); |
| T_FileStream_read (infile, &myBlockShift, sizeof (int32_t)); |
| |
| if (myValuesCount < 0) |
| { |
| *err = U_INVALID_TABLE_FILE; |
| return NULL; |
| } |
| myShortArray = (int16_t *) uprv_malloc (myValuesCount * sizeof (int16_t)); |
| if (myShortArray == NULL) |
| { |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| /*reads in the first array */ |
| T_FileStream_read (infile, myShortArray, myValuesCount * sizeof (int16_t)); |
| |
| if (myIndexCount < 0) |
| { |
| uprv_free (myShortArray); |
| *err = U_INVALID_TABLE_FILE; |
| return NULL; |
| } |
| |
| myIndexArray = (uint16_t *) uprv_malloc (myIndexCount * sizeof (uint16_t)); |
| if (myIndexArray == NULL) |
| { |
| uprv_free (myShortArray); |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| /*reads in the second array */ |
| T_FileStream_read (infile, myIndexArray, myIndexCount * sizeof (uint16_t)); |
| |
| /*create a compact array from the data just read |
| *that adopts our newly created arrays |
| */ |
| return ucmp16_openAdoptWithBlockShift (myIndexArray, myShortArray, myValuesCount, 0, myBlockShift); |
| } |
| |
| CompactByteArray* createCompactByteArrayFromFile (FileStream * infile, |
| UErrorCode * err) |
| { |
| int32_t i = 0; |
| int8_t *myByteArray = NULL; |
| uint16_t *myIndexArray = NULL; |
| int32_t myValuesCount = 0; |
| int32_t myIndexCount = 0; |
| |
| if (U_FAILURE (*err)) |
| return NULL; |
| |
| /*reads in the lengths of the 2 serialized array */ |
| T_FileStream_read (infile, &myValuesCount, sizeof (int32_t)); |
| T_FileStream_read (infile, &myIndexCount, sizeof (int32_t)); |
| |
| if (myValuesCount < 0) |
| { |
| *err = U_INVALID_TABLE_FILE; |
| return NULL; |
| } |
| myByteArray = (int8_t *) uprv_malloc (myValuesCount * sizeof (int8_t)); |
| if (myByteArray == NULL) |
| { |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| /*reads in the first array */ |
| T_FileStream_read (infile, myByteArray, myValuesCount * sizeof (int8_t)); |
| |
| if (myIndexCount < 0) |
| { |
| uprv_free (myByteArray); |
| *err = U_INVALID_TABLE_FILE; |
| return NULL; |
| } |
| myIndexArray = (uint16_t *) uprv_malloc (myIndexCount * sizeof (uint16_t)); |
| if (myIndexArray == NULL) |
| { |
| uprv_free (myByteArray); |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| /*reads in the second array */ |
| T_FileStream_read (infile, myIndexArray, myIndexCount * sizeof (uint16_t)); |
| |
| /*create a compact array from the data just read |
| *that adopts our newly created arrays |
| */ |
| return ucmp8_openAdopt (myIndexArray, myByteArray, myValuesCount); |
| } |
| |
| |
| static bool_t |
| isCnvAcceptable(void *context, |
| const char *type, const char *name, |
| UDataInfo *pInfo) { |
| return |
| 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 && |
| pInfo->formatVersion[0]==2; |
| } |
| |
| #define DATA_TYPE "cnv" |
| |
| UConverter* createConverterFromFile (const char *fileName, UErrorCode * err) |
| { |
| int32_t i = 0; |
| const int8_t *myByteArray = NULL; |
| const uint16_t *myIndexArray = NULL; |
| int32_t myValuesCount = 0; |
| int32_t myIndexCount = 0; |
| UConverter *myConverter = NULL; |
| int8_t errorLevel = 0; |
| |
| UDataMemory *data; |
| |
| if (err == NULL || U_FAILURE (*err)) { |
| return NULL; |
| } |
| |
| |
| data = udata_openChoice(NULL, DATA_TYPE, fileName, isCnvAcceptable, NULL, err); |
| if(U_FAILURE(*err)) |
| { |
| return NULL; |
| } |
| |
| myConverter = (UConverter *) uprv_malloc (sizeof (UConverter)); |
| if (myConverter == NULL) |
| { |
| udata_close(data); |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| myConverter->sharedData = |
| (UConverterSharedData *) udata_getMemory(data); |
| |
| if (myConverter->sharedData == NULL) |
| { |
| udata_close(data); |
| uprv_free (myConverter); |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| /* clone it. OK to drop the original sharedData */ |
| myConverter->sharedData = ucnv_data_unFlattenClone(myConverter->sharedData, err); |
| |
| myConverter->sharedData->dataMemory = (void*)data; /* for future use */ |
| |
| |
| if(U_FAILURE(*err)) |
| { |
| udata_close(data); |
| uprv_free (myConverter); |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| if (U_SUCCESS (*err)) |
| { |
| initializeDataConverter (myConverter); |
| } |
| |
| return myConverter; |
| } |
| |
| |
| void |
| copyPlatformString (char *platformString, UConverterPlatform pltfrm) |
| { |
| switch (pltfrm) |
| { |
| case UCNV_IBM: |
| { |
| uprv_strcpy (platformString, "ibm"); |
| break; |
| } |
| default: |
| { |
| uprv_strcpy (platformString, ""); |
| break; |
| } |
| }; |
| |
| return; |
| } |
| |
| /*returns a converter type from a string |
| */ |
| UConverterType |
| getAlgorithmicTypeFromName (const char *realName) |
| { |
| if (uprv_strcmp (realName, "UTF8") == 0) |
| return UCNV_UTF8; |
| else if (uprv_strcmp (realName, "UTF16_BigEndian") == 0) |
| return UCNV_UTF16_BigEndian; |
| else if (uprv_strcmp (realName, "UTF16_LittleEndian") == 0) |
| return UCNV_UTF16_LittleEndian; |
| else if (uprv_strcmp (realName, "LATIN_1") == 0) |
| return UCNV_LATIN_1; |
| else if (uprv_strcmp (realName, "JIS") == 0) |
| return UCNV_JIS; |
| else if (uprv_strcmp (realName, "EUC") == 0) |
| return UCNV_EUC; |
| else if (uprv_strcmp (realName, "GB") == 0) |
| return UCNV_GB; |
| else if (uprv_strcmp (realName, "ISO_2022") == 0) |
| return UCNV_ISO_2022; |
| else if (uprv_strcmp (realName, "UTF16_PlatformEndian") == 0) |
| # if U_IS_BIG_ENDIAN |
| return UCNV_UTF16_BigEndian; |
| # else |
| return UCNV_UTF16_LittleEndian; |
| # endif |
| else if (uprv_strcmp (realName, "UTF16_OppositeEndian") == 0) |
| # if U_IS_BIG_ENDIAN |
| return UCNV_UTF16_LittleEndian; |
| # else |
| return UCNV_UTF16_BigEndian; |
| # endif |
| else |
| return UCNV_UNSUPPORTED_CONVERTER; |
| } |
| |
| |
| UConverterPlatform |
| getPlatformFromName (char *name) |
| { |
| char myPlatform[10]; |
| char mySeparators[2] = {'-', '\0'}; |
| |
| getToken (myPlatform, name, mySeparators); |
| strtoupper (myPlatform); |
| |
| if (uprv_strcmp (myPlatform, "IBM") == 0) |
| return UCNV_IBM; |
| else |
| return UCNV_UNKNOWN; |
| } |
| |
| int32_t |
| getCodepageNumberFromName (char *name) |
| { |
| char myNumber[10]; |
| char mySeparators[2] = {'-', '\0'}; |
| char *line = NULL; |
| |
| line = getToken (myNumber, name, mySeparators); |
| getToken (myNumber, line, mySeparators); |
| |
| return T_CString_stringToInteger (myNumber, 10); |
| } |
| |
| int32_t uhash_hashSharedData (void *sharedData) |
| { |
| return uhash_hashIString(((UConverterSharedData *) sharedData)->name); |
| } |
| |
| /*Puts the shared data in the static hashtable SHARED_DATA_HASHTABLE */ |
| void shareConverterData (UConverterSharedData * data) |
| { |
| UErrorCode err = U_ZERO_ERROR; |
| /*Lazy evaluates the Hashtable itself */ |
| |
| if (SHARED_DATA_HASHTABLE == NULL) |
| { |
| UHashtable* myHT = uhash_openSize ((UHashFunction) uhash_hashSharedData, |
| ucnv_io_countAvailableAliases(&err), |
| &err); |
| if (U_FAILURE (err)) return; |
| umtx_lock (NULL); |
| if (SHARED_DATA_HASHTABLE == NULL) SHARED_DATA_HASHTABLE = myHT; |
| else uhash_close(myHT); |
| umtx_unlock (NULL); |
| |
| } |
| umtx_lock (NULL); |
| uhash_put(SHARED_DATA_HASHTABLE, |
| data, |
| &err); |
| umtx_unlock (NULL); |
| |
| return; |
| } |
| |
| UConverterSharedData *getSharedConverterData (const char *name) |
| { |
| /*special case when no Table has yet been created we return NULL */ |
| if (SHARED_DATA_HASHTABLE == NULL) return NULL; |
| else |
| /* return (UConverterSharedData *) uhash_get (SHARED_DATA_HASHTABLE, uhash_hashString (name));*/ |
| { |
| UConverterSharedData *i = (UConverterSharedData*)uhash_get (SHARED_DATA_HASHTABLE, uhash_hashIString (name)); |
| return i; |
| } |
| } |
| |
| /*frees the string of memory blocks associates with a sharedConverter |
| *if and only if the referenceCounter == 0 |
| */ |
| bool_t deleteSharedConverterData (UConverterSharedData * deadSharedData) |
| { |
| if (deadSharedData->referenceCounter > 0) |
| return FALSE; |
| |
| /* Note: if we have a dataMemory, then that means that all ucmp's came |
| from udata, and their tables will go away at the end |
| of this function. So, we need to simply dealloc the UCMP8's themselves. |
| We're guaranteed that they do not allocate any further memory. |
| |
| When we have an API to simply 'init' a ucmp8, then no action at all will |
| need to happen. --srl |
| */ |
| |
| switch (deadSharedData->conversionType) |
| { |
| case UCNV_SBCS: |
| { |
| ucmp8_close (deadSharedData->table->sbcs.fromUnicode); |
| uprv_free (deadSharedData->table); |
| }; |
| break; |
| |
| case UCNV_MBCS: |
| { |
| ucmp16_close (deadSharedData->table->mbcs.fromUnicode); |
| ucmp16_close (deadSharedData->table->mbcs.toUnicode); |
| uprv_free (deadSharedData->table); |
| }; |
| break; |
| |
| case UCNV_DBCS: |
| case UCNV_EBCDIC_STATEFUL: |
| { |
| ucmp16_close (deadSharedData->table->dbcs.fromUnicode); |
| ucmp16_close (deadSharedData->table->dbcs.toUnicode); |
| uprv_free (deadSharedData->table); |
| }; |
| break; |
| |
| default: ; /* semicolon makes MSVC happy */ |
| }; |
| |
| if(deadSharedData->dataMemory != NULL) |
| { |
| UDataMemory *data = (UDataMemory*)deadSharedData->dataMemory; |
| udata_close(data); |
| } |
| |
| uprv_free (deadSharedData); |
| |
| return TRUE; |
| } |
| |
| bool_t isDataBasedConverter (const char *name) |
| { |
| int32_t i = 0; |
| bool_t result = FALSE; |
| UErrorCode err = U_ZERO_ERROR; |
| |
| /*Lazy evaluates the hashtable */ |
| if (ALGORITHMIC_CONVERTERS_HASHTABLE == NULL) |
| { |
| UHashtable* myHT; |
| |
| { |
| myHT = uhash_open ((UHashFunction)uhash_hashIString, &err); |
| |
| if (U_FAILURE (err)) return FALSE; |
| while (algorithmicConverterNames[i][0] != '\0') |
| { |
| /*Stores in the hashtable a pointer to the statically init'ed array containing |
| *the names |
| */ |
| |
| uhash_put (myHT, |
| (void *) algorithmicConverterNames[i], |
| &err); |
| i++; /*Some Compilers (Solaris WSpro and MSVC-Release Mode |
| *don't differentiate between i++ and ++i |
| *so we have to increment in a line by itself |
| */ |
| } |
| } |
| |
| umtx_lock (NULL); |
| if (ALGORITHMIC_CONVERTERS_HASHTABLE == NULL) ALGORITHMIC_CONVERTERS_HASHTABLE = myHT; |
| else uhash_close(myHT); |
| umtx_unlock (NULL); |
| |
| |
| } |
| |
| |
| if (uhash_get (ALGORITHMIC_CONVERTERS_HASHTABLE, |
| uhash_hashIString (name)) == NULL) |
| { |
| result = TRUE; |
| } |
| |
| |
| return result; |
| } |
| /*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 * |
| createConverter (const char *converterName, UErrorCode * err) |
| { |
| const char *realName; |
| UConverter *myUConverter = NULL; |
| UConverterSharedData *mySharedConverterData = NULL; |
| UErrorCode internalErrorCode = U_ZERO_ERROR; |
| bool_t isDefaultConverter; |
| |
| if (U_FAILURE (*err)) |
| return NULL; |
| |
| /* In case "name" is NULL we want to open the default converter. */ |
| if (converterName == NULL) { |
| converterName = ucnv_io_getDefaultConverterName(); |
| if (converterName == NULL) { |
| *err = U_MISSING_RESOURCE_ERROR; |
| return NULL; |
| } else { |
| isDefaultConverter = TRUE; |
| } |
| } else { |
| isDefaultConverter = FALSE; |
| } |
| |
| if (*converterName == 0) { |
| /* Use the PlatformInvariant algorithmic converter. */ |
| realName = "PlatformInvariant"; |
| } else if(isDefaultConverter) { |
| /* the default converter name is already canonical */ |
| realName = converterName; |
| } else { |
| /* get the canonical converter name */ |
| realName = ucnv_io_getConverterName(converterName, &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 = converterName; |
| } |
| } |
| |
| if (isDataBasedConverter (realName)) |
| { |
| mySharedConverterData = getSharedConverterData (realName); |
| |
| if (mySharedConverterData == NULL) |
| { |
| /*Not cached, we need to stream it in from file */ |
| myUConverter = createConverterFromFile (realName, err); |
| |
| if (U_FAILURE (*err) || (myUConverter == NULL)) |
| { |
| return myUConverter; |
| } |
| else |
| { |
| /*shared it with other library clients */ |
| |
| |
| shareConverterData (myUConverter->sharedData); |
| return myUConverter; |
| } |
| } |
| else |
| { |
| /*Is already cached, point to an existing one */ |
| myUConverter = (UConverter *) uprv_malloc (sizeof (UConverter)); |
| if (myUConverter == NULL) |
| { |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| /*update the reference counter: one more client */ |
| umtx_lock (NULL); |
| mySharedConverterData->referenceCounter++; |
| umtx_unlock (NULL); |
| |
| myUConverter->sharedData = mySharedConverterData; |
| initializeDataConverter (myUConverter); |
| |
| return myUConverter; |
| } |
| } |
| else |
| { |
| /*with have an algorithmic converter */ |
| mySharedConverterData = getSharedConverterData (realName); |
| |
| /*Non cached */ |
| if (mySharedConverterData == NULL) |
| { |
| myUConverter = createConverterFromAlgorithmicType (realName, err); |
| if (U_FAILURE (*err) || (myUConverter == NULL)) |
| { |
| uprv_free (myUConverter); |
| return NULL; |
| } |
| else |
| { |
| /* put the shared object in shared table */ |
| shareConverterData (myUConverter->sharedData); |
| return myUConverter; |
| } |
| } |
| else |
| { |
| myUConverter = (UConverter *) uprv_malloc (sizeof (UConverter)); |
| if (myUConverter == NULL) |
| { |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| /*Increase the reference counter */ |
| umtx_lock (NULL); |
| mySharedConverterData->referenceCounter++; |
| umtx_unlock (NULL); |
| |
| /*initializes the converter */ |
| myUConverter->sharedData = mySharedConverterData; |
| initializeAlgorithmicConverter (myUConverter); |
| return myUConverter; |
| } |
| |
| return myUConverter; |
| } |
| |
| return NULL; |
| } |
| |
| /*Initializes the mutable lightweight portion of the object |
| *By copying data from UConverter->sharedData->defaultConverter |
| */ |
| void initializeDataConverter (UConverter * myUConverter) |
| { |
| |
| myUConverter->mode = UCNV_SI; |
| myUConverter->UCharErrorBufferLength = 0; |
| myUConverter->charErrorBufferLength = 0; |
| myUConverter->subCharLen = myUConverter->sharedData->defaultConverterValues.subCharLen; |
| uprv_memcpy (myUConverter->subChar, |
| myUConverter->sharedData->defaultConverterValues.subChar, |
| myUConverter->subCharLen); |
| myUConverter->toUnicodeStatus = 0x00; |
| myUConverter->fromUnicodeStatus = 0x00; |
| myUConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0x00; |
| |
| myUConverter->fromCharErrorBehaviour = (UConverterToUCallback) UCNV_TO_U_CALLBACK_SUBSTITUTE; |
| myUConverter->fromUCharErrorBehaviour = (UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE; |
| myUConverter->extraInfo = NULL; |
| |
| return; |
| } |
| |
| /* This function initializes algorithmic converters |
| * based on there type |
| */ |
| void |
| initializeAlgorithmicConverter (UConverter * myConverter) |
| { |
| char UTF8_subChar[] = {(char) 0xFF, (char) 0xFF, (char) 0xFF}; |
| char UTF16BE_subChar[] = {(char) 0xFF, (char) 0xFD}; |
| char UTF16LE_subChar[] = {(char) 0xFD, (char) 0xFF}; |
| char EUC_subChar[] = {(char) 0xAF, (char) 0xFE}; |
| char GB_subChar[] = {(char) 0xFF, (char) 0xFF}; |
| char JIS_subChar[] = {(char) 0xFF, (char) 0xFF}; |
| char LATIN1_subChar = 0x1A; |
| |
| |
| |
| myConverter->mode = UCNV_SI; |
| myConverter->fromCharErrorBehaviour = (UConverterToUCallback) UCNV_TO_U_CALLBACK_SUBSTITUTE; |
| myConverter->fromUCharErrorBehaviour = (UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE; |
| myConverter->charErrorBufferLength = 0; |
| myConverter->UCharErrorBufferLength = 0; |
| |
| myConverter->extraInfo = NULL; |
| |
| |
| switch (myConverter->sharedData->conversionType) |
| { |
| case UCNV_UTF8: |
| { |
| myConverter->sharedData->minBytesPerChar = 1; |
| myConverter->sharedData->maxBytesPerChar = 4; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 3; |
| myConverter->subCharLen = 3; |
| myConverter->toUnicodeStatus = 0; |
| myConverter->fromUnicodeStatus = 0; /* srl */ |
| myConverter->sharedData->platform = UCNV_IBM; |
| myConverter->sharedData->codepage = 1208; |
| uprv_strcpy(myConverter->sharedData->name, "UTF8"); |
| uprv_memcpy (myConverter->subChar, UTF8_subChar, 3); |
| uprv_memcpy (myConverter->sharedData->defaultConverterValues.subChar, UTF8_subChar, 3); |
| |
| break; |
| } |
| case UCNV_LATIN_1: |
| { |
| myConverter->sharedData->minBytesPerChar = 1; |
| myConverter->sharedData->maxBytesPerChar = 1; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 1; |
| myConverter->subCharLen = 1; |
| myConverter->toUnicodeStatus = 0; |
| myConverter->sharedData->platform = UCNV_IBM; |
| myConverter->sharedData->codepage = 819; |
| uprv_strcpy(myConverter->sharedData->name, "LATIN_1"); |
| *(myConverter->subChar) = LATIN1_subChar; |
| *(myConverter->sharedData->defaultConverterValues.subChar) = LATIN1_subChar; |
| break; |
| } |
| |
| case UCNV_UTF16_BigEndian: |
| { |
| myConverter->sharedData->minBytesPerChar = 2; |
| myConverter->sharedData->maxBytesPerChar = 2; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 2; |
| myConverter->subCharLen = 2; |
| myConverter->toUnicodeStatus = 0; |
| myConverter->fromUnicodeStatus = 0; |
| uprv_strcpy(myConverter->sharedData->name, "UTF_16BE"); |
| myConverter->sharedData->platform = UCNV_IBM; |
| myConverter->sharedData->codepage = 1200; |
| uprv_memcpy (myConverter->subChar, UTF16BE_subChar, 2); |
| uprv_memcpy (myConverter->sharedData->defaultConverterValues.subChar, UTF16BE_subChar, 2); |
| |
| break; |
| } |
| |
| case UCNV_UTF16_LittleEndian: |
| { |
| myConverter->sharedData->minBytesPerChar = 2; |
| myConverter->sharedData->maxBytesPerChar = 2; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 2; |
| myConverter->subCharLen = 2; |
| myConverter->toUnicodeStatus = 0; |
| myConverter->fromUnicodeStatus = 0; |
| myConverter->sharedData->platform = UCNV_IBM; |
| myConverter->sharedData->codepage = 1200; |
| uprv_strcpy(myConverter->sharedData->name, "UTF_16LE"); |
| uprv_memcpy (myConverter->subChar, UTF16LE_subChar, 2); |
| uprv_memcpy (myConverter->sharedData->defaultConverterValues.subChar, UTF16LE_subChar, 2); |
| break; |
| } |
| case UCNV_EUC: |
| { |
| myConverter->sharedData->minBytesPerChar = 1; |
| myConverter->sharedData->maxBytesPerChar = 2; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 2; |
| myConverter->subCharLen = 2; |
| myConverter->toUnicodeStatus = 0; |
| uprv_memcpy (myConverter->subChar, EUC_subChar, 2); |
| uprv_memcpy (myConverter->sharedData->defaultConverterValues.subChar, EUC_subChar, 2); |
| break; |
| } |
| case UCNV_ISO_2022: |
| { |
| myConverter->charErrorBuffer[0] = 0x1b; |
| myConverter->charErrorBuffer[1] = 0x25; |
| myConverter->charErrorBuffer[2] = 0x42; |
| myConverter->charErrorBufferLength = 3; |
| myConverter->sharedData->minBytesPerChar = 1; |
| myConverter->sharedData->maxBytesPerChar = 3; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 1; |
| myConverter->subCharLen = 1; |
| myConverter->toUnicodeStatus = 0; |
| myConverter->fromUnicodeStatus = 0; /* srl */ |
| myConverter->sharedData->codepage = 2022; |
| uprv_strcpy(myConverter->sharedData->name, "ISO_2022"); |
| *(myConverter->subChar) = LATIN1_subChar; |
| *(myConverter->sharedData->defaultConverterValues.subChar) = LATIN1_subChar; |
| myConverter->extraInfo = uprv_malloc (sizeof (UConverterDataISO2022)); |
| ((UConverterDataISO2022 *) myConverter->extraInfo)->currentConverter = NULL; |
| ((UConverterDataISO2022 *) myConverter->extraInfo)->escSeq2022Length = 0; |
| break; |
| } |
| case UCNV_GB: |
| { |
| myConverter->sharedData->minBytesPerChar = 2; |
| myConverter->sharedData->maxBytesPerChar = 2; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 2; |
| myConverter->subCharLen = 2; |
| myConverter->toUnicodeStatus = 0; |
| uprv_memcpy (myConverter->subChar, GB_subChar, 2); |
| uprv_memcpy (myConverter->sharedData->defaultConverterValues.subChar, GB_subChar, 2); |
| break; |
| } |
| case UCNV_JIS: |
| { |
| myConverter->sharedData->minBytesPerChar = 2; |
| myConverter->sharedData->maxBytesPerChar = 2; |
| myConverter->sharedData->defaultConverterValues.toUnicodeStatus = 0; |
| myConverter->sharedData->defaultConverterValues.subCharLen = 2; |
| myConverter->subCharLen = 2; |
| myConverter->toUnicodeStatus = 0; |
| uprv_memcpy (myConverter->subChar, JIS_subChar, 2); |
| uprv_memcpy (myConverter->sharedData->defaultConverterValues.subChar, JIS_subChar, 2); |
| break; |
| } |
| default: |
| break; |
| }; |
| |
| myConverter->toUnicodeStatus = myConverter->sharedData->defaultConverterValues.toUnicodeStatus; |
| } |
| |
| |
| /*This function creates an algorithmic converter |
| *Note That even algorithmic converters are shared |
| * (The UConverterSharedData->table == NULL since |
| * there are no tables) |
| *for uniformity of design and control flow |
| */ |
| UConverter * |
| createConverterFromAlgorithmicType (const char *actualName, UErrorCode * err) |
| { |
| int32_t i = 0; |
| UConverter *myConverter = NULL; |
| UConverterSharedData *mySharedData = NULL; |
| UConverterType myType = getAlgorithmicTypeFromName (actualName); |
| |
| if (U_FAILURE (*err)) |
| return NULL; |
| |
| myConverter = (UConverter *) uprv_malloc (sizeof (UConverter)); |
| if (myConverter == NULL) |
| { |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| myConverter->sharedData = NULL; |
| mySharedData = (UConverterSharedData *) uprv_malloc (sizeof (UConverterSharedData)); |
| if (mySharedData == NULL) |
| { |
| *err = U_MEMORY_ALLOCATION_ERROR; |
| uprv_free (myConverter); |
| return NULL; |
| } |
| mySharedData->structSize = sizeof(UConverterSharedData); |
| mySharedData->table = NULL; |
| mySharedData->dataMemory = NULL; |
| uprv_strcpy (mySharedData->name, actualName); |
| /*Initializes the referenceCounter to 1 */ |
| mySharedData->referenceCounter = 1; |
| mySharedData->platform = UCNV_UNKNOWN; |
| mySharedData->codepage = 0; |
| mySharedData->conversionType = myType; |
| myConverter->sharedData = mySharedData; |
| |
| initializeAlgorithmicConverter (myConverter); |
| return myConverter; |
| } |
| |
| |
| UConverterSharedData* ucnv_data_unFlattenClone(const UConverterSharedData *source, UErrorCode *status) |
| { |
| const uint8_t *raw, *oldraw; |
| UConverterSharedData *data = NULL; |
| |
| if(U_FAILURE(*status)) |
| return NULL; |
| |
| if(source->structSize != sizeof(UConverterSharedData)) |
| { |
| *status = U_INVALID_TABLE_FORMAT; |
| return NULL; |
| } |
| |
| data = (UConverterSharedData*) malloc(sizeof(UConverterSharedData)); |
| raw = (uint8_t*)source; |
| uprv_memcpy(data,source,sizeof(UConverterSharedData)); |
| |
| raw += data->structSize; |
| |
| /* data->table = (UConverterTable*)raw; */ |
| |
| switch (data->conversionType) |
| { |
| case UCNV_SBCS: |
| data->table = malloc(sizeof(UConverterSBCSTable)); |
| data->table->sbcs.toUnicode = (UChar*)raw; |
| raw += sizeof(UChar)*256; |
| |
| data->table->sbcs.fromUnicode = ucmp8_cloneFromData(&raw, status); |
| |
| break; |
| |
| case UCNV_EBCDIC_STATEFUL: |
| case UCNV_DBCS: |
| data->table = uprv_malloc(sizeof(UConverterDBCSTable)); |
| |
| oldraw = raw; |
| |
| data->table->dbcs.toUnicode=ucmp16_cloneFromData(&raw, status); |
| |
| while((raw-oldraw)%4) /* pad to 4 */ |
| raw++; |
| |
| data->table->dbcs.fromUnicode =ucmp16_cloneFromData(&raw, status); |
| |
| break; |
| |
| case UCNV_MBCS: |
| data->table = uprv_malloc(sizeof(UConverterMBCSTable)); |
| |
| data->table->mbcs.starters = (bool_t*)raw; |
| raw += sizeof(bool_t)*256; |
| |
| oldraw = raw; |
| |
| data->table->mbcs.toUnicode = ucmp16_cloneFromData(&raw, status); |
| |
| while((raw-oldraw)%4) /* pad to 4 */ |
| raw++; |
| |
| data->table->mbcs.fromUnicode = ucmp16_cloneFromData(&raw, status); |
| |
| break; |
| |
| default: |
| *status = U_INVALID_TABLE_FORMAT; |
| return NULL; |
| } |
| |
| return data; |
| } |
| |
| |
| |
| |
| |
| |
| |
