// // © 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:
//  *
//  */
