Index: icu46/source/common/ucnv_io.c |
=================================================================== |
--- icu46/source/common/ucnv_io.c (revision 0) |
+++ icu46/source/common/ucnv_io.c (revision 0) |
@@ -0,0 +1,1341 @@ |
+/* |
+****************************************************************************** |
+* |
+* Copyright (C) 1999-2008, International Business Machines |
+* Corporation and others. All Rights Reserved. |
+* |
+****************************************************************************** |
+* |
+* |
+* ucnv_io.c: |
+* initializes global variables and defines functions pertaining to converter |
+* name resolution aspect of the conversion code. |
+* |
+* new implementation: |
+* |
+* created on: 1999nov22 |
+* created by: Markus W. Scherer |
+* |
+* Use the binary cnvalias.icu (created from convrtrs.txt) to work |
+* with aliases for converter names. |
+* |
+* Date Name Description |
+* 11/22/1999 markus Created |
+* 06/28/2002 grhoten Major overhaul of the converter alias design. |
+* Now an alias can map to different converters |
+* depending on the specified standard. |
+******************************************************************************* |
+*/ |
+ |
+#include "unicode/utypes.h" |
+ |
+#if !UCONFIG_NO_CONVERSION |
+ |
+#include "unicode/ucnv.h" |
+#include "unicode/udata.h" |
+ |
+#include "umutex.h" |
+#include "uarrsort.h" |
+#include "udataswp.h" |
+#include "cstring.h" |
+#include "cmemory.h" |
+#include "ucnv_io.h" |
+#include "uenumimp.h" |
+#include "ucln_cmn.h" |
+ |
+/* Format of cnvalias.icu ----------------------------------------------------- |
+ * |
+ * cnvalias.icu is a binary, memory-mappable form of convrtrs.txt. |
+ * This binary form contains several tables. All indexes are to uint16_t |
+ * units, and not to the bytes (uint8_t units). Addressing everything on |
+ * 16-bit boundaries allows us to store more information with small index |
+ * numbers, which are also 16-bit in size. The majority of the table (except |
+ * the string table) are 16-bit numbers. |
+ * |
+ * First there is the size of the Table of Contents (TOC). The TOC |
+ * entries contain the size of each section. In order to find the offset |
+ * you just need to sum up the previous offsets. |
+ * The TOC length and entries are an array of uint32_t values. |
+ * The first section after the TOC starts immediately after the TOC. |
+ * |
+ * 1) This section contains a list of converters. This list contains indexes |
+ * into the string table for the converter name. The index of this list is |
+ * also used by other sections, which are mentioned later on. |
+ * This list is not sorted. |
+ * |
+ * 2) This section contains a list of tags. This list contains indexes |
+ * into the string table for the tag name. The index of this list is |
+ * also used by other sections, which are mentioned later on. |
+ * This list is in priority order of standards. |
+ * |
+ * 3) This section contains a list of sorted unique aliases. This |
+ * list contains indexes into the string table for the alias name. The |
+ * index of this list is also used by other sections, like the 4th section. |
+ * The index for the 3rd and 4th section is used to get the |
+ * alias -> converter name mapping. Section 3 and 4 form a two column table. |
+ * Some of the most significant bits of each index may contain other |
+ * information (see findConverter for details). |
+ * |
+ * 4) This section contains a list of mapped converter names. Consider this |
+ * as a table that maps the 3rd section to the 1st section. This list contains |
+ * indexes into the 1st section. The index of this list is the same index in |
+ * the 3rd section. There is also some extra information in the high bits of |
+ * each converter index in this table. Currently it's only used to say that |
+ * an alias mapped to this converter is ambiguous. See UCNV_CONVERTER_INDEX_MASK |
+ * and UCNV_AMBIGUOUS_ALIAS_MAP_BIT for more information. This section is |
+ * the predigested form of the 5th section so that an alias lookup can be fast. |
+ * |
+ * 5) This section contains a 2D array with indexes to the 6th section. This |
+ * section is the full form of all alias mappings. The column index is the |
+ * index into the converter list (column header). The row index is the index |
+ * to tag list (row header). This 2D array is the top part a 3D array. The |
+ * third dimension is in the 6th section. |
+ * |
+ * 6) This is blob of variable length arrays. Each array starts with a size, |
+ * and is followed by indexes to alias names in the string table. This is |
+ * the third dimension to the section 5. No other section should be referencing |
+ * this section. |
+ * |
+ * 7) Starting in ICU 3.6, this can be a UConverterAliasOptions struct. Its |
+ * presence indicates that a section 9 exists. UConverterAliasOptions specifies |
+ * what type of string normalization is used among other potential things in the |
+ * future. |
+ * |
+ * 8) This is the string table. All strings are indexed on an even address. |
+ * There are two reasons for this. First many chip architectures locate strings |
+ * faster on even address boundaries. Second, since all indexes are 16-bit |
+ * numbers, this string table can be 128KB in size instead of 64KB when we |
+ * only have strings starting on an even address. |
+ * |
+ * 9) When present this is a set of prenormalized strings from section 8. This |
+ * table contains normalized strings with the dashes and spaces stripped out, |
+ * and all strings lowercased. In the future, the options in section 7 may state |
+ * other types of normalization. |
+ * |
+ * Here is the concept of section 5 and 6. It's a 3D cube. Each tag |
+ * has a unique alias among all converters. That same alias can |
+ * be mentioned in other standards on different converters, |
+ * but only one alias per tag can be unique. |
+ * |
+ * |
+ * Converter Names (Usually in TR22 form) |
+ * -------------------------------------------. |
+ * T / /| |
+ * a / / | |
+ * g / / | |
+ * s / / | |
+ * / / | |
+ * ------------------------------------------/ | |
+ * A | | | |
+ * l | | | |
+ * i | | / |
+ * a | | / |
+ * s | | / |
+ * e | | / |
+ * s | |/ |
+ * ------------------------------------------- |
+ * |
+ * |
+ * |
+ * Here is what it really looks like. It's like swiss cheese. |
+ * There are holes. Some converters aren't recognized by |
+ * a standard, or they are really old converters that the |
+ * standard doesn't recognize anymore. |
+ * |
+ * Converter Names (Usually in TR22 form) |
+ * -------------------------------------------. |
+ * T /##########################################/| |
+ * a / # # /# |
+ * g / # ## ## ### # ### ### ### #/ |
+ * s / # ##### #### ## ## #/# |
+ * / ### # # ## # # # ### # # #/## |
+ * ------------------------------------------/# # |
+ * A |### # # ## # # # ### # # #|# # |
+ * l |# # # # # ## # #|# # |
+ * i |# # # # # # #|# |
+ * a |# #|# |
+ * s | #|# |
+ * e |
+ * s |
+ * |
+ */ |
+ |
+/** |
+ * Used by the UEnumeration API |
+ */ |
+typedef struct UAliasContext { |
+ uint32_t listOffset; |
+ uint32_t listIdx; |
+} UAliasContext; |
+ |
+static const char DATA_NAME[] = "cnvalias"; |
+static const char DATA_TYPE[] = "icu"; |
+ |
+static UDataMemory *gAliasData=NULL; |
+ |
+enum { |
+ tocLengthIndex=0, |
+ converterListIndex=1, |
+ tagListIndex=2, |
+ aliasListIndex=3, |
+ untaggedConvArrayIndex=4, |
+ taggedAliasArrayIndex=5, |
+ taggedAliasListsIndex=6, |
+ tableOptionsIndex=7, |
+ stringTableIndex=8, |
+ normalizedStringTableIndex=9, |
+ offsetsCount, /* length of the swapper's temporary offsets[] */ |
+ minTocLength=8 /* min. tocLength in the file, does not count the tocLengthIndex! */ |
+}; |
+ |
+static const UConverterAliasOptions defaultTableOptions = { |
+ UCNV_IO_UNNORMALIZED, |
+ 0 /* containsCnvOptionInfo */ |
+}; |
+static UConverterAlias gMainTable; |
+ |
+#define GET_STRING(idx) (const char *)(gMainTable.stringTable + (idx)) |
+#define GET_NORMALIZED_STRING(idx) (const char *)(gMainTable.normalizedStringTable + (idx)) |
+ |
+static UBool U_CALLCONV |
+isAcceptable(void *context, |
+ const char *type, const char *name, |
+ const UDataInfo *pInfo) { |
+ return (UBool)( |
+ pInfo->size>=20 && |
+ pInfo->isBigEndian==U_IS_BIG_ENDIAN && |
+ pInfo->charsetFamily==U_CHARSET_FAMILY && |
+ pInfo->dataFormat[0]==0x43 && /* dataFormat="CvAl" */ |
+ pInfo->dataFormat[1]==0x76 && |
+ pInfo->dataFormat[2]==0x41 && |
+ pInfo->dataFormat[3]==0x6c && |
+ pInfo->formatVersion[0]==3); |
+} |
+ |
+static UBool U_CALLCONV ucnv_io_cleanup(void) |
+{ |
+ if (gAliasData) { |
+ udata_close(gAliasData); |
+ gAliasData = NULL; |
+ } |
+ |
+ uprv_memset(&gMainTable, 0, sizeof(gMainTable)); |
+ |
+ return TRUE; /* Everything was cleaned up */ |
+} |
+ |
+static UBool |
+haveAliasData(UErrorCode *pErrorCode) { |
+ int needInit; |
+ |
+ if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
+ return FALSE; |
+ } |
+ |
+ UMTX_CHECK(NULL, (gAliasData==NULL), needInit); |
+ |
+ /* load converter alias data from file if necessary */ |
+ if (needInit) { |
+ UDataMemory *data; |
+ const uint16_t *table; |
+ const uint32_t *sectionSizes; |
+ uint32_t tableStart; |
+ uint32_t currOffset; |
+ |
+ data = udata_openChoice(NULL, DATA_TYPE, DATA_NAME, isAcceptable, NULL, pErrorCode); |
+ if(U_FAILURE(*pErrorCode)) { |
+ return FALSE; |
+ } |
+ |
+ sectionSizes = (const uint32_t *)udata_getMemory(data); |
+ table = (const uint16_t *)sectionSizes; |
+ |
+ tableStart = sectionSizes[0]; |
+ if (tableStart < minTocLength) { |
+ *pErrorCode = U_INVALID_FORMAT_ERROR; |
+ udata_close(data); |
+ return FALSE; |
+ } |
+ |
+ umtx_lock(NULL); |
+ if(gAliasData==NULL) { |
+ gMainTable.converterListSize = sectionSizes[1]; |
+ gMainTable.tagListSize = sectionSizes[2]; |
+ gMainTable.aliasListSize = sectionSizes[3]; |
+ gMainTable.untaggedConvArraySize = sectionSizes[4]; |
+ gMainTable.taggedAliasArraySize = sectionSizes[5]; |
+ gMainTable.taggedAliasListsSize = sectionSizes[6]; |
+ gMainTable.optionTableSize = sectionSizes[7]; |
+ gMainTable.stringTableSize = sectionSizes[8]; |
+ |
+ if (tableStart > 8) { |
+ gMainTable.normalizedStringTableSize = sectionSizes[9]; |
+ } |
+ |
+ currOffset = tableStart * (sizeof(uint32_t)/sizeof(uint16_t)) + (sizeof(uint32_t)/sizeof(uint16_t)); |
+ gMainTable.converterList = table + currOffset; |
+ |
+ currOffset += gMainTable.converterListSize; |
+ gMainTable.tagList = table + currOffset; |
+ |
+ currOffset += gMainTable.tagListSize; |
+ gMainTable.aliasList = table + currOffset; |
+ |
+ currOffset += gMainTable.aliasListSize; |
+ gMainTable.untaggedConvArray = table + currOffset; |
+ |
+ currOffset += gMainTable.untaggedConvArraySize; |
+ gMainTable.taggedAliasArray = table + currOffset; |
+ |
+ /* aliasLists is a 1's based array, but it has a padding character */ |
+ currOffset += gMainTable.taggedAliasArraySize; |
+ gMainTable.taggedAliasLists = table + currOffset; |
+ |
+ currOffset += gMainTable.taggedAliasListsSize; |
+ if (gMainTable.optionTableSize > 0 |
+ && ((const UConverterAliasOptions *)(table + currOffset))->stringNormalizationType < UCNV_IO_NORM_TYPE_COUNT) |
+ { |
+ /* Faster table */ |
+ gMainTable.optionTable = (const UConverterAliasOptions *)(table + currOffset); |
+ } |
+ else { |
+ /* Smaller table, or I can't handle this normalization mode! |
+ Use the original slower table lookup. */ |
+ gMainTable.optionTable = &defaultTableOptions; |
+ } |
+ |
+ currOffset += gMainTable.optionTableSize; |
+ gMainTable.stringTable = table + currOffset; |
+ |
+ currOffset += gMainTable.stringTableSize; |
+ gMainTable.normalizedStringTable = ((gMainTable.optionTable->stringNormalizationType == UCNV_IO_UNNORMALIZED) |
+ ? gMainTable.stringTable : (table + currOffset)); |
+ |
+ ucln_common_registerCleanup(UCLN_COMMON_UCNV_IO, ucnv_io_cleanup); |
+ |
+ gAliasData = data; |
+ data=NULL; |
+ } |
+ umtx_unlock(NULL); |
+ |
+ /* if a different thread set it first, then close the extra data */ |
+ if(data!=NULL) { |
+ udata_close(data); /* NULL if it was set correctly */ |
+ } |
+ } |
+ |
+ return TRUE; |
+} |
+ |
+static U_INLINE UBool |
+isAlias(const char *alias, UErrorCode *pErrorCode) { |
+ if(alias==NULL) { |
+ *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
+ return FALSE; |
+ } |
+ return (UBool)(*alias!=0); |
+} |
+ |
+static uint32_t getTagNumber(const char *tagname) { |
+ if (gMainTable.tagList) { |
+ uint32_t tagNum; |
+ for (tagNum = 0; tagNum < gMainTable.tagListSize; tagNum++) { |
+ if (!uprv_stricmp(GET_STRING(gMainTable.tagList[tagNum]), tagname)) { |
+ return tagNum; |
+ } |
+ } |
+ } |
+ |
+ return UINT32_MAX; |
+} |
+ |
+/* character types relevant for ucnv_compareNames() */ |
+enum { |
+ IGNORE, |
+ ZERO, |
+ NONZERO, |
+ MINLETTER /* any values from here on are lowercase letter mappings */ |
+}; |
+ |
+/* character types for ASCII 00..7F */ |
+static const uint8_t asciiTypes[128] = { |
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
+ ZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, 0, 0, 0, 0, 0, 0, |
+ 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, |
+ 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0, 0, 0, 0, 0, |
+ 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, |
+ 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0, 0, 0, 0, 0 |
+}; |
+ |
+#define GET_ASCII_TYPE(c) ((int8_t)(c) >= 0 ? asciiTypes[(uint8_t)c] : (uint8_t)IGNORE) |
+ |
+/* character types for EBCDIC 80..FF */ |
+static const uint8_t ebcdicTypes[128] = { |
+ 0, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0, 0, 0, 0, 0, 0, |
+ 0, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0, 0, 0, 0, 0, 0, |
+ 0, 0, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0, 0, 0, 0, 0, 0, |
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
+ 0, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0, 0, 0, 0, 0, 0, |
+ 0, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0, 0, 0, 0, 0, 0, |
+ 0, 0, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0, 0, 0, 0, 0, 0, |
+ ZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, 0, 0, 0, 0, 0, 0 |
+}; |
+ |
+#define GET_EBCDIC_TYPE(c) ((int8_t)(c) < 0 ? ebcdicTypes[(c)&0x7f] : (uint8_t)IGNORE) |
+ |
+#if U_CHARSET_FAMILY==U_ASCII_FAMILY |
+# define GET_CHAR_TYPE(c) GET_ASCII_TYPE(c) |
+#elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY |
+# define GET_CHAR_TYPE(c) GET_EBCDIC_TYPE(c) |
+#else |
+# error U_CHARSET_FAMILY is not valid |
+#endif |
+ |
+/* @see ucnv_compareNames */ |
+U_CFUNC char * U_EXPORT2 |
+ucnv_io_stripASCIIForCompare(char *dst, const char *name) { |
+ char *dstItr = dst; |
+ uint8_t type, nextType; |
+ char c1; |
+ UBool afterDigit = FALSE; |
+ |
+ while ((c1 = *name++) != 0) { |
+ type = GET_ASCII_TYPE(c1); |
+ switch (type) { |
+ case IGNORE: |
+ afterDigit = FALSE; |
+ continue; /* ignore all but letters and digits */ |
+ case ZERO: |
+ if (!afterDigit) { |
+ nextType = GET_ASCII_TYPE(*name); |
+ if (nextType == ZERO || nextType == NONZERO) { |
+ continue; /* ignore leading zero before another digit */ |
+ } |
+ } |
+ break; |
+ case NONZERO: |
+ afterDigit = TRUE; |
+ break; |
+ default: |
+ c1 = (char)type; /* lowercased letter */ |
+ afterDigit = FALSE; |
+ break; |
+ } |
+ *dstItr++ = c1; |
+ } |
+ *dstItr = 0; |
+ return dst; |
+} |
+ |
+U_CFUNC char * U_EXPORT2 |
+ucnv_io_stripEBCDICForCompare(char *dst, const char *name) { |
+ char *dstItr = dst; |
+ uint8_t type, nextType; |
+ char c1; |
+ UBool afterDigit = FALSE; |
+ |
+ while ((c1 = *name++) != 0) { |
+ type = GET_EBCDIC_TYPE(c1); |
+ switch (type) { |
+ case IGNORE: |
+ afterDigit = FALSE; |
+ continue; /* ignore all but letters and digits */ |
+ case ZERO: |
+ if (!afterDigit) { |
+ nextType = GET_EBCDIC_TYPE(*name); |
+ if (nextType == ZERO || nextType == NONZERO) { |
+ continue; /* ignore leading zero before another digit */ |
+ } |
+ } |
+ break; |
+ case NONZERO: |
+ afterDigit = TRUE; |
+ break; |
+ default: |
+ c1 = (char)type; /* lowercased letter */ |
+ afterDigit = FALSE; |
+ break; |
+ } |
+ *dstItr++ = c1; |
+ } |
+ *dstItr = 0; |
+ return dst; |
+} |
+ |
+/** |
+ * Do a fuzzy compare of two converter/alias names. |
+ * The comparison is case-insensitive, ignores leading zeroes if they are not |
+ * followed by further digits, and ignores all but letters and digits. |
+ * Thus the strings "UTF-8", "utf_8", "u*T@f08" and "Utf 8" are exactly equivalent. |
+ * See section 1.4, Charset Alias Matching in Unicode Technical Standard #22 |
+ * at http://www.unicode.org/reports/tr22/ |
+ * |
+ * This is a symmetrical (commutative) operation; order of arguments |
+ * is insignificant. This is an important property for sorting the |
+ * list (when the list is preprocessed into binary form) and for |
+ * performing binary searches on it at run time. |
+ * |
+ * @param name1 a converter name or alias, zero-terminated |
+ * @param name2 a converter name or alias, zero-terminated |
+ * @return 0 if the names match, or a negative value if the name1 |
+ * lexically precedes name2, or a positive value if the name1 |
+ * lexically follows name2. |
+ * |
+ * @see ucnv_io_stripForCompare |
+ */ |
+U_CAPI int U_EXPORT2 |
+ucnv_compareNames(const char *name1, const char *name2) { |
+ int rc; |
+ uint8_t type, nextType; |
+ char c1, c2; |
+ UBool afterDigit1 = FALSE, afterDigit2 = FALSE; |
+ |
+ for (;;) { |
+ while ((c1 = *name1++) != 0) { |
+ type = GET_CHAR_TYPE(c1); |
+ switch (type) { |
+ case IGNORE: |
+ afterDigit1 = FALSE; |
+ continue; /* ignore all but letters and digits */ |
+ case ZERO: |
+ if (!afterDigit1) { |
+ nextType = GET_CHAR_TYPE(*name1); |
+ if (nextType == ZERO || nextType == NONZERO) { |
+ continue; /* ignore leading zero before another digit */ |
+ } |
+ } |
+ break; |
+ case NONZERO: |
+ afterDigit1 = TRUE; |
+ break; |
+ default: |
+ c1 = (char)type; /* lowercased letter */ |
+ afterDigit1 = FALSE; |
+ break; |
+ } |
+ break; /* deliver c1 */ |
+ } |
+ while ((c2 = *name2++) != 0) { |
+ type = GET_CHAR_TYPE(c2); |
+ switch (type) { |
+ case IGNORE: |
+ afterDigit2 = FALSE; |
+ continue; /* ignore all but letters and digits */ |
+ case ZERO: |
+ if (!afterDigit2) { |
+ nextType = GET_CHAR_TYPE(*name2); |
+ if (nextType == ZERO || nextType == NONZERO) { |
+ continue; /* ignore leading zero before another digit */ |
+ } |
+ } |
+ break; |
+ case NONZERO: |
+ afterDigit2 = TRUE; |
+ break; |
+ default: |
+ c2 = (char)type; /* lowercased letter */ |
+ afterDigit2 = FALSE; |
+ break; |
+ } |
+ break; /* deliver c2 */ |
+ } |
+ |
+ /* If we reach the ends of both strings then they match */ |
+ if ((c1|c2)==0) { |
+ return 0; |
+ } |
+ |
+ /* Case-insensitive comparison */ |
+ rc = (int)(unsigned char)c1 - (int)(unsigned char)c2; |
+ if (rc != 0) { |
+ return rc; |
+ } |
+ } |
+} |
+ |
+/* |
+ * search for an alias |
+ * return the converter number index for gConverterList |
+ */ |
+static U_INLINE uint32_t |
+findConverter(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) { |
+ uint32_t mid, start, limit; |
+ uint32_t lastMid; |
+ int result; |
+ int isUnnormalized = (gMainTable.optionTable->stringNormalizationType == UCNV_IO_UNNORMALIZED); |
+ char strippedName[UCNV_MAX_CONVERTER_NAME_LENGTH]; |
+ |
+ if (!isUnnormalized) { |
+ if (uprv_strlen(alias) >= UCNV_MAX_CONVERTER_NAME_LENGTH) { |
+ *pErrorCode = U_BUFFER_OVERFLOW_ERROR; |
+ return UINT32_MAX; |
+ } |
+ |
+ /* Lower case and remove ignoreable characters. */ |
+ ucnv_io_stripForCompare(strippedName, alias); |
+ alias = strippedName; |
+ } |
+ |
+ /* do a binary search for the alias */ |
+ start = 0; |
+ limit = gMainTable.untaggedConvArraySize; |
+ 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; |
+ if (isUnnormalized) { |
+ result = ucnv_compareNames(alias, GET_STRING(gMainTable.aliasList[mid])); |
+ } |
+ else { |
+ result = uprv_strcmp(alias, GET_NORMALIZED_STRING(gMainTable.aliasList[mid])); |
+ } |
+ |
+ if (result < 0) { |
+ limit = mid; |
+ } else if (result > 0) { |
+ start = mid; |
+ } else { |
+ /* Since the gencnval tool folds duplicates into one entry, |
+ * this alias in gAliasList is unique, but different standards |
+ * may map an alias to different converters. |
+ */ |
+ if (gMainTable.untaggedConvArray[mid] & UCNV_AMBIGUOUS_ALIAS_MAP_BIT) { |
+ *pErrorCode = U_AMBIGUOUS_ALIAS_WARNING; |
+ } |
+ /* State whether the canonical converter name contains an option. |
+ This information is contained in this list in order to maintain backward & forward compatibility. */ |
+ if (containsOption) { |
+ UBool containsCnvOptionInfo = (UBool)gMainTable.optionTable->containsCnvOptionInfo; |
+ *containsOption = (UBool)((containsCnvOptionInfo |
+ && ((gMainTable.untaggedConvArray[mid] & UCNV_CONTAINS_OPTION_BIT) != 0)) |
+ || !containsCnvOptionInfo); |
+ } |
+ return gMainTable.untaggedConvArray[mid] & UCNV_CONVERTER_INDEX_MASK; |
+ } |
+ } |
+ |
+ return UINT32_MAX; |
+} |
+ |
+/* |
+ * Is this alias in this list? |
+ * alias and listOffset should be non-NULL. |
+ */ |
+static U_INLINE UBool |
+isAliasInList(const char *alias, uint32_t listOffset) { |
+ if (listOffset) { |
+ uint32_t currAlias; |
+ uint32_t listCount = gMainTable.taggedAliasLists[listOffset]; |
+ /* +1 to skip listCount */ |
+ const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1; |
+ for (currAlias = 0; currAlias < listCount; currAlias++) { |
+ if (currList[currAlias] |
+ && ucnv_compareNames(alias, GET_STRING(currList[currAlias]))==0) |
+ { |
+ return TRUE; |
+ } |
+ } |
+ } |
+ return FALSE; |
+} |
+ |
+/* |
+ * Search for an standard name of an alias (what is the default name |
+ * that this standard uses?) |
+ * return the listOffset for gTaggedAliasLists. If it's 0, |
+ * the it couldn't be found, but the parameters are valid. |
+ */ |
+static uint32_t |
+findTaggedAliasListsOffset(const char *alias, const char *standard, UErrorCode *pErrorCode) { |
+ uint32_t idx; |
+ uint32_t listOffset; |
+ uint32_t convNum; |
+ UErrorCode myErr = U_ZERO_ERROR; |
+ uint32_t tagNum = getTagNumber(standard); |
+ |
+ /* Make a quick guess. Hopefully they used a TR22 canonical alias. */ |
+ convNum = findConverter(alias, NULL, &myErr); |
+ if (myErr != U_ZERO_ERROR) { |
+ *pErrorCode = myErr; |
+ } |
+ |
+ if (tagNum < (gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS) && convNum < gMainTable.converterListSize) { |
+ listOffset = gMainTable.taggedAliasArray[tagNum*gMainTable.converterListSize + convNum]; |
+ if (listOffset && gMainTable.taggedAliasLists[listOffset + 1]) { |
+ return listOffset; |
+ } |
+ if (myErr == U_AMBIGUOUS_ALIAS_WARNING) { |
+ /* Uh Oh! They used an ambiguous alias. |
+ We have to search the whole swiss cheese starting |
+ at the highest standard affinity. |
+ This may take a while. |
+ */ |
+ for (idx = 0; idx < gMainTable.taggedAliasArraySize; idx++) { |
+ listOffset = gMainTable.taggedAliasArray[idx]; |
+ if (listOffset && isAliasInList(alias, listOffset)) { |
+ uint32_t currTagNum = idx/gMainTable.converterListSize; |
+ uint32_t currConvNum = (idx - currTagNum*gMainTable.converterListSize); |
+ uint32_t tempListOffset = gMainTable.taggedAliasArray[tagNum*gMainTable.converterListSize + currConvNum]; |
+ if (tempListOffset && gMainTable.taggedAliasLists[tempListOffset + 1]) { |
+ return tempListOffset; |
+ } |
+ /* else keep on looking */ |
+ /* We could speed this up by starting on the next row |
+ because an alias is unique per row, right now. |
+ This would change if alias versioning appears. */ |
+ } |
+ } |
+ /* The standard doesn't know about the alias */ |
+ } |
+ /* else no default name */ |
+ return 0; |
+ } |
+ /* else converter or tag not found */ |
+ |
+ return UINT32_MAX; |
+} |
+ |
+/* Return the canonical name */ |
+static uint32_t |
+findTaggedConverterNum(const char *alias, const char *standard, UErrorCode *pErrorCode) { |
+ uint32_t idx; |
+ uint32_t listOffset; |
+ uint32_t convNum; |
+ UErrorCode myErr = U_ZERO_ERROR; |
+ uint32_t tagNum = getTagNumber(standard); |
+ |
+ /* Make a quick guess. Hopefully they used a TR22 canonical alias. */ |
+ convNum = findConverter(alias, NULL, &myErr); |
+ if (myErr != U_ZERO_ERROR) { |
+ *pErrorCode = myErr; |
+ } |
+ |
+ if (tagNum < (gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS) && convNum < gMainTable.converterListSize) { |
+ listOffset = gMainTable.taggedAliasArray[tagNum*gMainTable.converterListSize + convNum]; |
+ if (listOffset && isAliasInList(alias, listOffset)) { |
+ return convNum; |
+ } |
+ if (myErr == U_AMBIGUOUS_ALIAS_WARNING) { |
+ /* Uh Oh! They used an ambiguous alias. |
+ We have to search one slice of the swiss cheese. |
+ We search only in the requested tag, not the whole thing. |
+ This may take a while. |
+ */ |
+ uint32_t convStart = (tagNum)*gMainTable.converterListSize; |
+ uint32_t convLimit = (tagNum+1)*gMainTable.converterListSize; |
+ for (idx = convStart; idx < convLimit; idx++) { |
+ listOffset = gMainTable.taggedAliasArray[idx]; |
+ if (listOffset && isAliasInList(alias, listOffset)) { |
+ return idx-convStart; |
+ } |
+ } |
+ /* The standard doesn't know about the alias */ |
+ } |
+ /* else no canonical name */ |
+ } |
+ /* else converter or tag not found */ |
+ |
+ return UINT32_MAX; |
+} |
+ |
+ |
+ |
+U_CFUNC const char * |
+ucnv_io_getConverterName(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) { |
+ if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { |
+ uint32_t convNum = findConverter(alias, containsOption, pErrorCode); |
+ if (convNum < gMainTable.converterListSize) { |
+ return GET_STRING(gMainTable.converterList[convNum]); |
+ } |
+ /* else converter not found */ |
+ } |
+ return NULL; |
+} |
+ |
+static int32_t U_CALLCONV |
+ucnv_io_countStandardAliases(UEnumeration *enumerator, UErrorCode *pErrorCode) { |
+ int32_t value = 0; |
+ UAliasContext *myContext = (UAliasContext *)(enumerator->context); |
+ uint32_t listOffset = myContext->listOffset; |
+ |
+ if (listOffset) { |
+ value = gMainTable.taggedAliasLists[listOffset]; |
+ } |
+ return value; |
+} |
+ |
+static const char* U_CALLCONV |
+ucnv_io_nextStandardAliases(UEnumeration *enumerator, |
+ int32_t* resultLength, |
+ UErrorCode *pErrorCode) |
+{ |
+ UAliasContext *myContext = (UAliasContext *)(enumerator->context); |
+ uint32_t listOffset = myContext->listOffset; |
+ |
+ if (listOffset) { |
+ uint32_t listCount = gMainTable.taggedAliasLists[listOffset]; |
+ const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1; |
+ |
+ if (myContext->listIdx < listCount) { |
+ const char *myStr = GET_STRING(currList[myContext->listIdx++]); |
+ if (resultLength) { |
+ *resultLength = (int32_t)uprv_strlen(myStr); |
+ } |
+ return myStr; |
+ } |
+ } |
+ /* Either we accessed a zero length list, or we enumerated too far. */ |
+ if (resultLength) { |
+ *resultLength = 0; |
+ } |
+ return NULL; |
+} |
+ |
+static void U_CALLCONV |
+ucnv_io_resetStandardAliases(UEnumeration *enumerator, UErrorCode *pErrorCode) { |
+ ((UAliasContext *)(enumerator->context))->listIdx = 0; |
+} |
+ |
+static void U_CALLCONV |
+ucnv_io_closeUEnumeration(UEnumeration *enumerator) { |
+ uprv_free(enumerator->context); |
+ uprv_free(enumerator); |
+} |
+ |
+/* Enumerate the aliases for the specified converter and standard tag */ |
+static const UEnumeration gEnumAliases = { |
+ NULL, |
+ NULL, |
+ ucnv_io_closeUEnumeration, |
+ ucnv_io_countStandardAliases, |
+ uenum_unextDefault, |
+ ucnv_io_nextStandardAliases, |
+ ucnv_io_resetStandardAliases |
+}; |
+ |
+U_CAPI UEnumeration * U_EXPORT2 |
+ucnv_openStandardNames(const char *convName, |
+ const char *standard, |
+ UErrorCode *pErrorCode) |
+{ |
+ UEnumeration *myEnum = NULL; |
+ if (haveAliasData(pErrorCode) && isAlias(convName, pErrorCode)) { |
+ uint32_t listOffset = findTaggedAliasListsOffset(convName, standard, pErrorCode); |
+ |
+ /* When listOffset == 0, we want to acknowledge that the |
+ converter name and standard are okay, but there |
+ is nothing to enumerate. */ |
+ if (listOffset < gMainTable.taggedAliasListsSize) { |
+ UAliasContext *myContext; |
+ |
+ myEnum = uprv_malloc(sizeof(UEnumeration)); |
+ if (myEnum == NULL) { |
+ *pErrorCode = U_MEMORY_ALLOCATION_ERROR; |
+ return NULL; |
+ } |
+ uprv_memcpy(myEnum, &gEnumAliases, sizeof(UEnumeration)); |
+ myContext = uprv_malloc(sizeof(UAliasContext)); |
+ if (myContext == NULL) { |
+ *pErrorCode = U_MEMORY_ALLOCATION_ERROR; |
+ uprv_free(myEnum); |
+ return NULL; |
+ } |
+ myContext->listOffset = listOffset; |
+ myContext->listIdx = 0; |
+ myEnum->context = myContext; |
+ } |
+ /* else converter or tag not found */ |
+ } |
+ return myEnum; |
+} |
+ |
+static uint16_t |
+ucnv_io_countAliases(const char *alias, UErrorCode *pErrorCode) { |
+ if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { |
+ uint32_t convNum = findConverter(alias, NULL, pErrorCode); |
+ if (convNum < gMainTable.converterListSize) { |
+ /* tagListNum - 1 is the ALL tag */ |
+ int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum]; |
+ |
+ if (listOffset) { |
+ return gMainTable.taggedAliasLists[listOffset]; |
+ } |
+ /* else this shouldn't happen. internal program error */ |
+ } |
+ /* else converter not found */ |
+ } |
+ return 0; |
+} |
+ |
+static uint16_t |
+ucnv_io_getAliases(const char *alias, uint16_t start, const char **aliases, UErrorCode *pErrorCode) { |
+ if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { |
+ uint32_t currAlias; |
+ uint32_t convNum = findConverter(alias, NULL, pErrorCode); |
+ if (convNum < gMainTable.converterListSize) { |
+ /* tagListNum - 1 is the ALL tag */ |
+ int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum]; |
+ |
+ if (listOffset) { |
+ uint32_t listCount = gMainTable.taggedAliasLists[listOffset]; |
+ /* +1 to skip listCount */ |
+ const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1; |
+ |
+ for (currAlias = start; currAlias < listCount; currAlias++) { |
+ aliases[currAlias] = GET_STRING(currList[currAlias]); |
+ } |
+ } |
+ /* else this shouldn't happen. internal program error */ |
+ } |
+ /* else converter not found */ |
+ } |
+ return 0; |
+} |
+ |
+static const char * |
+ucnv_io_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode) { |
+ if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { |
+ uint32_t convNum = findConverter(alias, NULL, pErrorCode); |
+ if (convNum < gMainTable.converterListSize) { |
+ /* tagListNum - 1 is the ALL tag */ |
+ int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum]; |
+ |
+ if (listOffset) { |
+ uint32_t listCount = gMainTable.taggedAliasLists[listOffset]; |
+ /* +1 to skip listCount */ |
+ const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1; |
+ |
+ if (n < listCount) { |
+ return GET_STRING(currList[n]); |
+ } |
+ *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR; |
+ } |
+ /* else this shouldn't happen. internal program error */ |
+ } |
+ /* else converter not found */ |
+ } |
+ return NULL; |
+} |
+ |
+static uint16_t |
+ucnv_io_countStandards(UErrorCode *pErrorCode) { |
+ if (haveAliasData(pErrorCode)) { |
+ /* Don't include the empty list */ |
+ return (uint16_t)(gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS); |
+ } |
+ |
+ return 0; |
+} |
+ |
+U_CAPI const char * U_EXPORT2 |
+ucnv_getStandard(uint16_t n, UErrorCode *pErrorCode) { |
+ if (haveAliasData(pErrorCode)) { |
+ if (n < gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS) { |
+ return GET_STRING(gMainTable.tagList[n]); |
+ } |
+ *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR; |
+ } |
+ |
+ return NULL; |
+} |
+ |
+U_CAPI const char * U_EXPORT2 |
+ucnv_getStandardName(const char *alias, const char *standard, UErrorCode *pErrorCode) { |
+ if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { |
+ uint32_t listOffset = findTaggedAliasListsOffset(alias, standard, pErrorCode); |
+ |
+ if (0 < listOffset && listOffset < gMainTable.taggedAliasListsSize) { |
+ const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1; |
+ |
+ /* Get the preferred name from this list */ |
+ if (currList[0]) { |
+ return GET_STRING(currList[0]); |
+ } |
+ /* else someone screwed up the alias table. */ |
+ /* *pErrorCode = U_INVALID_FORMAT_ERROR */ |
+ } |
+ } |
+ |
+ return NULL; |
+} |
+ |
+U_CAPI uint16_t U_EXPORT2 |
+ucnv_countAliases(const char *alias, UErrorCode *pErrorCode) |
+{ |
+ return ucnv_io_countAliases(alias, pErrorCode); |
+} |
+ |
+ |
+U_CAPI const char* U_EXPORT2 |
+ucnv_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode) |
+{ |
+ return ucnv_io_getAlias(alias, n, pErrorCode); |
+} |
+ |
+U_CAPI void U_EXPORT2 |
+ucnv_getAliases(const char *alias, const char **aliases, UErrorCode *pErrorCode) |
+{ |
+ ucnv_io_getAliases(alias, 0, aliases, pErrorCode); |
+} |
+ |
+U_CAPI uint16_t U_EXPORT2 |
+ucnv_countStandards(void) |
+{ |
+ UErrorCode err = U_ZERO_ERROR; |
+ return ucnv_io_countStandards(&err); |
+} |
+ |
+U_CAPI const char * U_EXPORT2 |
+ucnv_getCanonicalName(const char *alias, const char *standard, UErrorCode *pErrorCode) { |
+ if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { |
+ uint32_t convNum = findTaggedConverterNum(alias, standard, pErrorCode); |
+ |
+ if (convNum < gMainTable.converterListSize) { |
+ return GET_STRING(gMainTable.converterList[convNum]); |
+ } |
+ } |
+ |
+ return NULL; |
+} |
+ |
+static int32_t U_CALLCONV |
+ucnv_io_countAllConverters(UEnumeration *enumerator, UErrorCode *pErrorCode) { |
+ return gMainTable.converterListSize; |
+} |
+ |
+static const char* U_CALLCONV |
+ucnv_io_nextAllConverters(UEnumeration *enumerator, |
+ int32_t* resultLength, |
+ UErrorCode *pErrorCode) |
+{ |
+ uint16_t *myContext = (uint16_t *)(enumerator->context); |
+ |
+ if (*myContext < gMainTable.converterListSize) { |
+ const char *myStr = GET_STRING(gMainTable.converterList[(*myContext)++]); |
+ if (resultLength) { |
+ *resultLength = (int32_t)uprv_strlen(myStr); |
+ } |
+ return myStr; |
+ } |
+ /* Either we accessed a zero length list, or we enumerated too far. */ |
+ if (resultLength) { |
+ *resultLength = 0; |
+ } |
+ return NULL; |
+} |
+ |
+static void U_CALLCONV |
+ucnv_io_resetAllConverters(UEnumeration *enumerator, UErrorCode *pErrorCode) { |
+ *((uint16_t *)(enumerator->context)) = 0; |
+} |
+ |
+static const UEnumeration gEnumAllConverters = { |
+ NULL, |
+ NULL, |
+ ucnv_io_closeUEnumeration, |
+ ucnv_io_countAllConverters, |
+ uenum_unextDefault, |
+ ucnv_io_nextAllConverters, |
+ ucnv_io_resetAllConverters |
+}; |
+ |
+U_CAPI UEnumeration * U_EXPORT2 |
+ucnv_openAllNames(UErrorCode *pErrorCode) { |
+ UEnumeration *myEnum = NULL; |
+ if (haveAliasData(pErrorCode)) { |
+ uint16_t *myContext; |
+ |
+ myEnum = uprv_malloc(sizeof(UEnumeration)); |
+ if (myEnum == NULL) { |
+ *pErrorCode = U_MEMORY_ALLOCATION_ERROR; |
+ return NULL; |
+ } |
+ uprv_memcpy(myEnum, &gEnumAllConverters, sizeof(UEnumeration)); |
+ myContext = uprv_malloc(sizeof(uint16_t)); |
+ if (myContext == NULL) { |
+ *pErrorCode = U_MEMORY_ALLOCATION_ERROR; |
+ uprv_free(myEnum); |
+ return NULL; |
+ } |
+ *myContext = 0; |
+ myEnum->context = myContext; |
+ } |
+ return myEnum; |
+} |
+ |
+U_CFUNC uint16_t |
+ucnv_io_countKnownConverters(UErrorCode *pErrorCode) { |
+ if (haveAliasData(pErrorCode)) { |
+ return (uint16_t)gMainTable.converterListSize; |
+ } |
+ return 0; |
+} |
+ |
+/* alias table swapping ----------------------------------------------------- */ |
+ |
+typedef char * U_CALLCONV StripForCompareFn(char *dst, const char *name); |
+ |
+/* |
+ * row of a temporary array |
+ * |
+ * gets platform-endian charset string indexes and sorting indexes; |
+ * after sorting this array by strings, the actual arrays are permutated |
+ * according to the sorting indexes |
+ */ |
+typedef struct TempRow { |
+ uint16_t strIndex, sortIndex; |
+} TempRow; |
+ |
+typedef struct TempAliasTable { |
+ const char *chars; |
+ TempRow *rows; |
+ uint16_t *resort; |
+ StripForCompareFn *stripForCompare; |
+} TempAliasTable; |
+ |
+enum { |
+ STACK_ROW_CAPACITY=500 |
+}; |
+ |
+static int32_t |
+io_compareRows(const void *context, const void *left, const void *right) { |
+ char strippedLeft[UCNV_MAX_CONVERTER_NAME_LENGTH], |
+ strippedRight[UCNV_MAX_CONVERTER_NAME_LENGTH]; |
+ |
+ TempAliasTable *tempTable=(TempAliasTable *)context; |
+ const char *chars=tempTable->chars; |
+ |
+ return (int32_t)uprv_strcmp(tempTable->stripForCompare(strippedLeft, chars+2*((const TempRow *)left)->strIndex), |
+ tempTable->stripForCompare(strippedRight, chars+2*((const TempRow *)right)->strIndex)); |
+} |
+ |
+U_CAPI int32_t U_EXPORT2 |
+ucnv_swapAliases(const UDataSwapper *ds, |
+ const void *inData, int32_t length, void *outData, |
+ UErrorCode *pErrorCode) { |
+ const UDataInfo *pInfo; |
+ int32_t headerSize; |
+ |
+ const uint16_t *inTable; |
+ const uint32_t *inSectionSizes; |
+ uint32_t toc[offsetsCount]; |
+ uint32_t offsets[offsetsCount]; /* 16-bit-addressed offsets from inTable/outTable */ |
+ uint32_t i, count, tocLength, topOffset; |
+ |
+ TempRow rows[STACK_ROW_CAPACITY]; |
+ uint16_t resort[STACK_ROW_CAPACITY]; |
+ TempAliasTable tempTable; |
+ |
+ /* udata_swapDataHeader checks the arguments */ |
+ headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode); |
+ if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
+ return 0; |
+ } |
+ |
+ /* check data format and format version */ |
+ pInfo=(const UDataInfo *)((const char *)inData+4); |
+ if(!( |
+ pInfo->dataFormat[0]==0x43 && /* dataFormat="CvAl" */ |
+ pInfo->dataFormat[1]==0x76 && |
+ pInfo->dataFormat[2]==0x41 && |
+ pInfo->dataFormat[3]==0x6c && |
+ pInfo->formatVersion[0]==3 |
+ )) { |
+ udata_printError(ds, "ucnv_swapAliases(): data format %02x.%02x.%02x.%02x (format version %02x) is not an alias table\n", |
+ pInfo->dataFormat[0], pInfo->dataFormat[1], |
+ pInfo->dataFormat[2], pInfo->dataFormat[3], |
+ pInfo->formatVersion[0]); |
+ *pErrorCode=U_UNSUPPORTED_ERROR; |
+ return 0; |
+ } |
+ |
+ /* an alias table must contain at least the table of contents array */ |
+ if(length>=0 && (length-headerSize)<4*(1+minTocLength)) { |
+ udata_printError(ds, "ucnv_swapAliases(): too few bytes (%d after header) for an alias table\n", |
+ length-headerSize); |
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; |
+ return 0; |
+ } |
+ |
+ inSectionSizes=(const uint32_t *)((const char *)inData+headerSize); |
+ inTable=(const uint16_t *)inSectionSizes; |
+ uprv_memset(toc, 0, sizeof(toc)); |
+ toc[tocLengthIndex]=tocLength=ds->readUInt32(inSectionSizes[tocLengthIndex]); |
+ if(tocLength<minTocLength || offsetsCount<=tocLength) { |
+ udata_printError(ds, "ucnv_swapAliases(): table of contents contains unsupported number of sections (%u sections)\n", tocLength); |
+ *pErrorCode=U_INVALID_FORMAT_ERROR; |
+ return 0; |
+ } |
+ |
+ /* read the known part of the table of contents */ |
+ for(i=converterListIndex; i<=tocLength; ++i) { |
+ toc[i]=ds->readUInt32(inSectionSizes[i]); |
+ } |
+ |
+ /* compute offsets */ |
+ uprv_memset(offsets, 0, sizeof(offsets)); |
+ offsets[converterListIndex]=2*(1+tocLength); /* count two 16-bit units per toc entry */ |
+ for(i=tagListIndex; i<=tocLength; ++i) { |
+ offsets[i]=offsets[i-1]+toc[i-1]; |
+ } |
+ |
+ /* compute the overall size of the after-header data, in numbers of 16-bit units */ |
+ topOffset=offsets[i-1]+toc[i-1]; |
+ |
+ if(length>=0) { |
+ uint16_t *outTable; |
+ const uint16_t *p, *p2; |
+ uint16_t *q, *q2; |
+ uint16_t oldIndex; |
+ |
+ if((length-headerSize)<(2*(int32_t)topOffset)) { |
+ udata_printError(ds, "ucnv_swapAliases(): too few bytes (%d after header) for an alias table\n", |
+ length-headerSize); |
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; |
+ return 0; |
+ } |
+ |
+ outTable=(uint16_t *)((char *)outData+headerSize); |
+ |
+ /* swap the entire table of contents */ |
+ ds->swapArray32(ds, inTable, 4*(1+tocLength), outTable, pErrorCode); |
+ |
+ /* swap unormalized strings & normalized strings */ |
+ ds->swapInvChars(ds, inTable+offsets[stringTableIndex], 2*(int32_t)(toc[stringTableIndex]+toc[normalizedStringTableIndex]), |
+ outTable+offsets[stringTableIndex], pErrorCode); |
+ if(U_FAILURE(*pErrorCode)) { |
+ udata_printError(ds, "ucnv_swapAliases().swapInvChars(charset names) failed\n"); |
+ return 0; |
+ } |
+ |
+ if(ds->inCharset==ds->outCharset) { |
+ /* no need to sort, just swap all 16-bit values together */ |
+ ds->swapArray16(ds, |
+ inTable+offsets[converterListIndex], |
+ 2*(int32_t)(offsets[stringTableIndex]-offsets[converterListIndex]), |
+ outTable+offsets[converterListIndex], |
+ pErrorCode); |
+ } else { |
+ /* allocate the temporary table for sorting */ |
+ count=toc[aliasListIndex]; |
+ |
+ tempTable.chars=(const char *)(outTable+offsets[stringTableIndex]); /* sort by outCharset */ |
+ |
+ if(count<=STACK_ROW_CAPACITY) { |
+ tempTable.rows=rows; |
+ tempTable.resort=resort; |
+ } else { |
+ tempTable.rows=(TempRow *)uprv_malloc(count*sizeof(TempRow)+count*2); |
+ if(tempTable.rows==NULL) { |
+ udata_printError(ds, "ucnv_swapAliases(): unable to allocate memory for sorting tables (max length: %u)\n", |
+ count); |
+ *pErrorCode=U_MEMORY_ALLOCATION_ERROR; |
+ return 0; |
+ } |
+ tempTable.resort=(uint16_t *)(tempTable.rows+count); |
+ } |
+ |
+ if(ds->outCharset==U_ASCII_FAMILY) { |
+ tempTable.stripForCompare=ucnv_io_stripASCIIForCompare; |
+ } else /* U_EBCDIC_FAMILY */ { |
+ tempTable.stripForCompare=ucnv_io_stripEBCDICForCompare; |
+ } |
+ |
+ /* |
+ * Sort unique aliases+mapped names. |
+ * |
+ * We need to sort the list again by outCharset strings because they |
+ * sort differently for different charset families. |
+ * First we set up a temporary table with the string indexes and |
+ * sorting indexes and sort that. |
+ * Then we permutate and copy/swap the actual values. |
+ */ |
+ p=inTable+offsets[aliasListIndex]; |
+ q=outTable+offsets[aliasListIndex]; |
+ |
+ p2=inTable+offsets[untaggedConvArrayIndex]; |
+ q2=outTable+offsets[untaggedConvArrayIndex]; |
+ |
+ for(i=0; i<count; ++i) { |
+ tempTable.rows[i].strIndex=ds->readUInt16(p[i]); |
+ tempTable.rows[i].sortIndex=(uint16_t)i; |
+ } |
+ |
+ uprv_sortArray(tempTable.rows, (int32_t)count, sizeof(TempRow), |
+ io_compareRows, &tempTable, |
+ FALSE, pErrorCode); |
+ |
+ if(U_SUCCESS(*pErrorCode)) { |
+ /* copy/swap/permutate items */ |
+ if(p!=q) { |
+ for(i=0; i<count; ++i) { |
+ oldIndex=tempTable.rows[i].sortIndex; |
+ ds->swapArray16(ds, p+oldIndex, 2, q+i, pErrorCode); |
+ ds->swapArray16(ds, p2+oldIndex, 2, q2+i, pErrorCode); |
+ } |
+ } else { |
+ /* |
+ * If we swap in-place, then the permutation must use another |
+ * temporary array (tempTable.resort) |
+ * before the results are copied to the outBundle. |
+ */ |
+ uint16_t *r=tempTable.resort; |
+ |
+ for(i=0; i<count; ++i) { |
+ oldIndex=tempTable.rows[i].sortIndex; |
+ ds->swapArray16(ds, p+oldIndex, 2, r+i, pErrorCode); |
+ } |
+ uprv_memcpy(q, r, 2*count); |
+ |
+ for(i=0; i<count; ++i) { |
+ oldIndex=tempTable.rows[i].sortIndex; |
+ ds->swapArray16(ds, p2+oldIndex, 2, r+i, pErrorCode); |
+ } |
+ uprv_memcpy(q2, r, 2*count); |
+ } |
+ } |
+ |
+ if(tempTable.rows!=rows) { |
+ uprv_free(tempTable.rows); |
+ } |
+ |
+ if(U_FAILURE(*pErrorCode)) { |
+ udata_printError(ds, "ucnv_swapAliases().uprv_sortArray(%u items) failed\n", |
+ count); |
+ return 0; |
+ } |
+ |
+ /* swap remaining 16-bit values */ |
+ ds->swapArray16(ds, |
+ inTable+offsets[converterListIndex], |
+ 2*(int32_t)(offsets[aliasListIndex]-offsets[converterListIndex]), |
+ outTable+offsets[converterListIndex], |
+ pErrorCode); |
+ ds->swapArray16(ds, |
+ inTable+offsets[taggedAliasArrayIndex], |
+ 2*(int32_t)(offsets[stringTableIndex]-offsets[taggedAliasArrayIndex]), |
+ outTable+offsets[taggedAliasArrayIndex], |
+ pErrorCode); |
+ } |
+ } |
+ |
+ return headerSize+2*(int32_t)topOffset; |
+} |
+ |
+#endif |
+ |
+/* |
+ * Hey, Emacs, please set the following: |
+ * |
+ * Local Variables: |
+ * indent-tabs-mode: nil |
+ * End: |
+ * |
+ */ |
Property changes on: icu46/source/common/ucnv_io.c |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |