summaryrefslogtreecommitdiff
path: root/deps/node/deps/icu-small/source/common/ucnv_io.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'deps/node/deps/icu-small/source/common/ucnv_io.cpp')
-rw-r--r--deps/node/deps/icu-small/source/common/ucnv_io.cpp1360
1 files changed, 0 insertions, 1360 deletions
diff --git a/deps/node/deps/icu-small/source/common/ucnv_io.cpp b/deps/node/deps/icu-small/source/common/ucnv_io.cpp
deleted file mode 100644
index d9e91314..00000000
--- a/deps/node/deps/icu-small/source/common/ucnv_io.cpp
+++ /dev/null
@@ -1,1360 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-* Copyright (C) 1999-2015, International Business Machines
-* Corporation and others. All Rights Reserved.
-*
-******************************************************************************
-*
-*
-* ucnv_io.cpp:
-* 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 "uassert.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;
-static icu::UInitOnce gAliasDataInitOnce = U_INITONCE_INITIALIZER;
-
-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;
- }
- gAliasDataInitOnce.reset();
-
- uprv_memset(&gMainTable, 0, sizeof(gMainTable));
-
- return TRUE; /* Everything was cleaned up */
-}
-
-static void U_CALLCONV initAliasData(UErrorCode &errCode) {
- UDataMemory *data;
- const uint16_t *table;
- const uint32_t *sectionSizes;
- uint32_t tableStart;
- uint32_t currOffset;
-
- ucln_common_registerCleanup(UCLN_COMMON_UCNV_IO, ucnv_io_cleanup);
-
- U_ASSERT(gAliasData == NULL);
- data = udata_openChoice(NULL, DATA_TYPE, DATA_NAME, isAcceptable, NULL, &errCode);
- if(U_FAILURE(errCode)) {
- return;
- }
-
- sectionSizes = (const uint32_t *)udata_getMemory(data);
- table = (const uint16_t *)sectionSizes;
-
- tableStart = sectionSizes[0];
- if (tableStart < minTocLength) {
- errCode = U_INVALID_FORMAT_ERROR;
- udata_close(data);
- return;
- }
- gAliasData = data;
-
- 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));
-}
-
-
-static UBool
-haveAliasData(UErrorCode *pErrorCode) {
- umtx_initOnce(gAliasDataInitOnce, &initAliasData, *pErrorCode);
- return U_SUCCESS(*pErrorCode);
-}
-
-static 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 {
- UIGNORE,
- 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)UIGNORE)
-
-/* 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)UIGNORE)
-
-#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_CAPI char * U_CALLCONV
-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 UIGNORE:
- 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_CAPI char * U_CALLCONV
-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 UIGNORE:
- 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 UIGNORE:
- 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 UIGNORE:
- 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 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 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_CAPI const char *
-ucnv_io_getConverterName(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) {
- const char *aliasTmp = alias;
- int32_t i = 0;
- for (i = 0; i < 2; i++) {
- if (i == 1) {
- /*
- * After the first unsuccess converter lookup, check to see if
- * the name begins with 'x-'. If it does, strip it off and try
- * again. This behaviour is similar to how ICU4J does it.
- */
- if (aliasTmp[0] == 'x' && aliasTmp[1] == '-') {
- aliasTmp = aliasTmp+2;
- } else {
- break;
- }
- }
- if(haveAliasData(pErrorCode) && isAlias(aliasTmp, pErrorCode)) {
- uint32_t convNum = findConverter(aliasTmp, containsOption, pErrorCode);
- if (convNum < gMainTable.converterListSize) {
- return GET_STRING(gMainTable.converterList[convNum]);
- }
- /* else converter not found */
- } else {
- break;
- }
- }
-
- return NULL;
-}
-
-U_CDECL_BEGIN
-
-
-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);
-}
-
-U_CDECL_END
-
-/* 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 = static_cast<UEnumeration *>(uprv_malloc(sizeof(UEnumeration)));
- if (myEnum == NULL) {
- *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
- return NULL;
- }
- uprv_memcpy(myEnum, &gEnumAliases, sizeof(UEnumeration));
- myContext = static_cast<UAliasContext *>(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;
-}
-
-U_CDECL_BEGIN
-
-
-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;
-}
-U_CDECL_END
-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 = static_cast<UEnumeration *>(uprv_malloc(sizeof(UEnumeration)));
- if (myEnum == NULL) {
- *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
- return NULL;
- }
- uprv_memcpy(myEnum, &gEnumAllConverters, sizeof(UEnumeration));
- myContext = static_cast<uint16_t *>(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_CAPI uint16_t
-ucnv_io_countKnownConverters(UErrorCode *pErrorCode) {
- if (haveAliasData(pErrorCode)) {
- return (uint16_t)gMainTable.converterListSize;
- }
- return 0;
-}
-
-/* alias table swapping ----------------------------------------------------- */
-
-U_CDECL_BEGIN
-
-typedef char * U_CALLCONV StripForCompareFn(char *dst, const char *name);
-U_CDECL_END
-
-
-/*
- * 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 U_CALLCONV
-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*(size_t)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*(size_t)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:
- *
- */