Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 2 of 2.

1 files changed, 1359 insertions, 1359 deletions

diff --git a/contrib/libs/icu/common/ucnv_io.cpp b/contrib/libs/icu/common/ucnv_io.cpp
index 1bc5de7475..7a95a3f1e6 100644
--- a/contrib/libs/icu/common/ucnv_io.cpp
+++ b/contrib/libs/icu/common/ucnv_io.cpp
@@ -1,1360 +1,1360 @@
 // © 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: 
- * 
- */ 
+// 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:
+ *
+ */