• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ******************************************************************************
5 *
6 *   Copyright (C) 1999-2015, International Business Machines
7 *   Corporation and others.  All Rights Reserved.
8 *
9 ******************************************************************************
10 *
11 *
12 *  ucnv_io.cpp:
13 *  initializes global variables and defines functions pertaining to converter
14 *  name resolution aspect of the conversion code.
15 *
16 *   new implementation:
17 *
18 *   created on: 1999nov22
19 *   created by: Markus W. Scherer
20 *
21 *   Use the binary cnvalias.icu (created from convrtrs.txt) to work
22 *   with aliases for converter names.
23 *
24 *   Date        Name        Description
25 *   11/22/1999  markus      Created
26 *   06/28/2002  grhoten     Major overhaul of the converter alias design.
27 *                           Now an alias can map to different converters
28 *                           depending on the specified standard.
29 *******************************************************************************
30 */
31 
32 #include "unicode/utypes.h"
33 
34 #if !UCONFIG_NO_CONVERSION
35 
36 #include "unicode/ucnv.h"
37 #include "unicode/udata.h"
38 
39 #include "umutex.h"
40 #include "uarrsort.h"
41 #include "uassert.h"
42 #include "udataswp.h"
43 #include "cstring.h"
44 #include "cmemory.h"
45 #include "ucnv_io.h"
46 #include "uenumimp.h"
47 #include "ucln_cmn.h"
48 
49 /* Format of cnvalias.icu -----------------------------------------------------
50  *
51  * cnvalias.icu is a binary, memory-mappable form of convrtrs.txt.
52  * This binary form contains several tables. All indexes are to uint16_t
53  * units, and not to the bytes (uint8_t units). Addressing everything on
54  * 16-bit boundaries allows us to store more information with small index
55  * numbers, which are also 16-bit in size. The majority of the table (except
56  * the string table) are 16-bit numbers.
57  *
58  * First there is the size of the Table of Contents (TOC). The TOC
59  * entries contain the size of each section. In order to find the offset
60  * you just need to sum up the previous offsets.
61  * The TOC length and entries are an array of uint32_t values.
62  * The first section after the TOC starts immediately after the TOC.
63  *
64  * 1) This section contains a list of converters. This list contains indexes
65  * into the string table for the converter name. The index of this list is
66  * also used by other sections, which are mentioned later on.
67  * This list is not sorted.
68  *
69  * 2) This section contains a list of tags. This list contains indexes
70  * into the string table for the tag name. The index of this list is
71  * also used by other sections, which are mentioned later on.
72  * This list is in priority order of standards.
73  *
74  * 3) This section contains a list of sorted unique aliases. This
75  * list contains indexes into the string table for the alias name. The
76  * index of this list is also used by other sections, like the 4th section.
77  * The index for the 3rd and 4th section is used to get the
78  * alias -> converter name mapping. Section 3 and 4 form a two column table.
79  * Some of the most significant bits of each index may contain other
80  * information (see findConverter for details).
81  *
82  * 4) This section contains a list of mapped converter names. Consider this
83  * as a table that maps the 3rd section to the 1st section. This list contains
84  * indexes into the 1st section. The index of this list is the same index in
85  * the 3rd section. There is also some extra information in the high bits of
86  * each converter index in this table. Currently it's only used to say that
87  * an alias mapped to this converter is ambiguous. See UCNV_CONVERTER_INDEX_MASK
88  * and UCNV_AMBIGUOUS_ALIAS_MAP_BIT for more information. This section is
89  * the predigested form of the 5th section so that an alias lookup can be fast.
90  *
91  * 5) This section contains a 2D array with indexes to the 6th section. This
92  * section is the full form of all alias mappings. The column index is the
93  * index into the converter list (column header). The row index is the index
94  * to tag list (row header). This 2D array is the top part a 3D array. The
95  * third dimension is in the 6th section.
96  *
97  * 6) This is blob of variable length arrays. Each array starts with a size,
98  * and is followed by indexes to alias names in the string table. This is
99  * the third dimension to the section 5. No other section should be referencing
100  * this section.
101  *
102  * 7) Starting in ICU 3.6, this can be a UConverterAliasOptions struct. Its
103  * presence indicates that a section 9 exists. UConverterAliasOptions specifies
104  * what type of string normalization is used among other potential things in the
105  * future.
106  *
107  * 8) This is the string table. All strings are indexed on an even address.
108  * There are two reasons for this. First many chip architectures locate strings
109  * faster on even address boundaries. Second, since all indexes are 16-bit
110  * numbers, this string table can be 128KB in size instead of 64KB when we
111  * only have strings starting on an even address.
112  *
113  * 9) When present this is a set of prenormalized strings from section 8. This
114  * table contains normalized strings with the dashes and spaces stripped out,
115  * and all strings lowercased. In the future, the options in section 7 may state
116  * other types of normalization.
117  *
118  * Here is the concept of section 5 and 6. It's a 3D cube. Each tag
119  * has a unique alias among all converters. That same alias can
120  * be mentioned in other standards on different converters,
121  * but only one alias per tag can be unique.
122  *
123  *
124  *              Converter Names (Usually in TR22 form)
125  *           -------------------------------------------.
126  *     T    /                                          /|
127  *     a   /                                          / |
128  *     g  /                                          /  |
129  *     s /                                          /   |
130  *      /                                          /    |
131  *      ------------------------------------------/     |
132  *    A |                                         |     |
133  *    l |                                         |     |
134  *    i |                                         |    /
135  *    a |                                         |   /
136  *    s |                                         |  /
137  *    e |                                         | /
138  *    s |                                         |/
139  *      -------------------------------------------
140  *
141  *
142  *
143  * Here is what it really looks like. It's like swiss cheese.
144  * There are holes. Some converters aren't recognized by
145  * a standard, or they are really old converters that the
146  * standard doesn't recognize anymore.
147  *
148  *              Converter Names (Usually in TR22 form)
149  *           -------------------------------------------.
150  *     T    /##########################################/|
151  *     a   /     #            #                       /#
152  *     g  /  #      ##     ##     ### # ### ### ### #/
153  *     s / #             #####  ####        ##  ## #/#
154  *      / ### # # ##  #  #   #          ### # #   #/##
155  *      ------------------------------------------/# #
156  *    A |### # # ##  #  #   #          ### # #   #|# #
157  *    l |# # #    #     #               ## #     #|# #
158  *    i |# # #    #     #                #       #|#
159  *    a |#                                       #|#
160  *    s |                                        #|#
161  *    e
162  *    s
163  *
164  */
165 
166 /**
167  * Used by the UEnumeration API
168  */
169 typedef struct UAliasContext {
170     uint32_t listOffset;
171     uint32_t listIdx;
172 } UAliasContext;
173 
174 static const char DATA_NAME[] = "cnvalias";
175 static const char DATA_TYPE[] = "icu";
176 
177 static UDataMemory *gAliasData=NULL;
178 static icu::UInitOnce gAliasDataInitOnce = U_INITONCE_INITIALIZER;
179 
180 enum {
181     tocLengthIndex=0,
182     converterListIndex=1,
183     tagListIndex=2,
184     aliasListIndex=3,
185     untaggedConvArrayIndex=4,
186     taggedAliasArrayIndex=5,
187     taggedAliasListsIndex=6,
188     tableOptionsIndex=7,
189     stringTableIndex=8,
190     normalizedStringTableIndex=9,
191     offsetsCount,    /* length of the swapper's temporary offsets[] */
192     minTocLength=8 /* min. tocLength in the file, does not count the tocLengthIndex! */
193 };
194 
195 static const UConverterAliasOptions defaultTableOptions = {
196     UCNV_IO_UNNORMALIZED,
197     0 /* containsCnvOptionInfo */
198 };
199 static UConverterAlias gMainTable;
200 
201 #define GET_STRING(idx) (const char *)(gMainTable.stringTable + (idx))
202 #define GET_NORMALIZED_STRING(idx) (const char *)(gMainTable.normalizedStringTable + (idx))
203 
204 static UBool U_CALLCONV
isAcceptable(void *,const char *,const char *,const UDataInfo * pInfo)205 isAcceptable(void * /*context*/,
206              const char * /*type*/, const char * /*name*/,
207              const UDataInfo *pInfo) {
208     return (UBool)(
209         pInfo->size>=20 &&
210         pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
211         pInfo->charsetFamily==U_CHARSET_FAMILY &&
212         pInfo->dataFormat[0]==0x43 &&   /* dataFormat="CvAl" */
213         pInfo->dataFormat[1]==0x76 &&
214         pInfo->dataFormat[2]==0x41 &&
215         pInfo->dataFormat[3]==0x6c &&
216         pInfo->formatVersion[0]==3);
217 }
218 
ucnv_io_cleanup(void)219 static UBool U_CALLCONV ucnv_io_cleanup(void)
220 {
221     if (gAliasData) {
222         udata_close(gAliasData);
223         gAliasData = NULL;
224     }
225     gAliasDataInitOnce.reset();
226 
227     uprv_memset(&gMainTable, 0, sizeof(gMainTable));
228 
229     return TRUE;                   /* Everything was cleaned up */
230 }
231 
initAliasData(UErrorCode & errCode)232 static void U_CALLCONV initAliasData(UErrorCode &errCode) {
233     UDataMemory *data;
234     const uint16_t *table;
235     const uint32_t *sectionSizes;
236     uint32_t tableStart;
237     uint32_t currOffset;
238 
239     ucln_common_registerCleanup(UCLN_COMMON_UCNV_IO, ucnv_io_cleanup);
240 
241     U_ASSERT(gAliasData == NULL);
242     data = udata_openChoice(NULL, DATA_TYPE, DATA_NAME, isAcceptable, NULL, &errCode);
243     if(U_FAILURE(errCode)) {
244         return;
245     }
246 
247     sectionSizes = (const uint32_t *)udata_getMemory(data);
248     table = (const uint16_t *)sectionSizes;
249 
250     tableStart      = sectionSizes[0];
251     if (tableStart < minTocLength) {
252         errCode = U_INVALID_FORMAT_ERROR;
253         udata_close(data);
254         return;
255     }
256     gAliasData = data;
257 
258     gMainTable.converterListSize      = sectionSizes[1];
259     gMainTable.tagListSize            = sectionSizes[2];
260     gMainTable.aliasListSize          = sectionSizes[3];
261     gMainTable.untaggedConvArraySize  = sectionSizes[4];
262     gMainTable.taggedAliasArraySize   = sectionSizes[5];
263     gMainTable.taggedAliasListsSize   = sectionSizes[6];
264     gMainTable.optionTableSize        = sectionSizes[7];
265     gMainTable.stringTableSize        = sectionSizes[8];
266 
267     if (tableStart > 8) {
268         gMainTable.normalizedStringTableSize = sectionSizes[9];
269     }
270 
271     currOffset = tableStart * (sizeof(uint32_t)/sizeof(uint16_t)) + (sizeof(uint32_t)/sizeof(uint16_t));
272     gMainTable.converterList = table + currOffset;
273 
274     currOffset += gMainTable.converterListSize;
275     gMainTable.tagList = table + currOffset;
276 
277     currOffset += gMainTable.tagListSize;
278     gMainTable.aliasList = table + currOffset;
279 
280     currOffset += gMainTable.aliasListSize;
281     gMainTable.untaggedConvArray = table + currOffset;
282 
283     currOffset += gMainTable.untaggedConvArraySize;
284     gMainTable.taggedAliasArray = table + currOffset;
285 
286     /* aliasLists is a 1's based array, but it has a padding character */
287     currOffset += gMainTable.taggedAliasArraySize;
288     gMainTable.taggedAliasLists = table + currOffset;
289 
290     currOffset += gMainTable.taggedAliasListsSize;
291     if (gMainTable.optionTableSize > 0
292         && ((const UConverterAliasOptions *)(table + currOffset))->stringNormalizationType < UCNV_IO_NORM_TYPE_COUNT)
293     {
294         /* Faster table */
295         gMainTable.optionTable = (const UConverterAliasOptions *)(table + currOffset);
296     }
297     else {
298         /* Smaller table, or I can't handle this normalization mode!
299         Use the original slower table lookup. */
300         gMainTable.optionTable = &defaultTableOptions;
301     }
302 
303     currOffset += gMainTable.optionTableSize;
304     gMainTable.stringTable = table + currOffset;
305 
306     currOffset += gMainTable.stringTableSize;
307     gMainTable.normalizedStringTable = ((gMainTable.optionTable->stringNormalizationType == UCNV_IO_UNNORMALIZED)
308         ? gMainTable.stringTable : (table + currOffset));
309 }
310 
311 
312 static UBool
haveAliasData(UErrorCode * pErrorCode)313 haveAliasData(UErrorCode *pErrorCode) {
314     umtx_initOnce(gAliasDataInitOnce, &initAliasData, *pErrorCode);
315     return U_SUCCESS(*pErrorCode);
316 }
317 
318 static inline UBool
isAlias(const char * alias,UErrorCode * pErrorCode)319 isAlias(const char *alias, UErrorCode *pErrorCode) {
320     if(alias==NULL) {
321         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
322         return FALSE;
323     }
324     return (UBool)(*alias!=0);
325 }
326 
getTagNumber(const char * tagname)327 static uint32_t getTagNumber(const char *tagname) {
328     if (gMainTable.tagList) {
329         uint32_t tagNum;
330         for (tagNum = 0; tagNum < gMainTable.tagListSize; tagNum++) {
331             if (!uprv_stricmp(GET_STRING(gMainTable.tagList[tagNum]), tagname)) {
332                 return tagNum;
333             }
334         }
335     }
336 
337     return UINT32_MAX;
338 }
339 
340 /* character types relevant for ucnv_compareNames() */
341 enum {
342     UIGNORE,
343     ZERO,
344     NONZERO,
345     MINLETTER /* any values from here on are lowercase letter mappings */
346 };
347 
348 /* character types for ASCII 00..7F */
349 static const uint8_t asciiTypes[128] = {
350     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
351     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
352     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
353     ZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, 0, 0, 0, 0, 0, 0,
354     0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
355     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0, 0, 0, 0, 0,
356     0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
357     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0, 0, 0, 0, 0
358 };
359 
360 #define GET_ASCII_TYPE(c) ((int8_t)(c) >= 0 ? asciiTypes[(uint8_t)c] : (uint8_t)UIGNORE)
361 
362 /* character types for EBCDIC 80..FF */
363 static const uint8_t ebcdicTypes[128] = {
364     0,    0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0, 0, 0, 0, 0, 0,
365     0,    0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0, 0, 0, 0, 0, 0,
366     0,    0,    0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0, 0, 0, 0, 0, 0,
367     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
368     0,    0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0, 0, 0, 0, 0, 0,
369     0,    0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0, 0, 0, 0, 0, 0,
370     0,    0,    0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0, 0, 0, 0, 0, 0,
371     ZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, NONZERO, 0, 0, 0, 0, 0, 0
372 };
373 
374 #define GET_EBCDIC_TYPE(c) ((int8_t)(c) < 0 ? ebcdicTypes[(c)&0x7f] : (uint8_t)UIGNORE)
375 
376 #if U_CHARSET_FAMILY==U_ASCII_FAMILY
377 #   define GET_CHAR_TYPE(c) GET_ASCII_TYPE(c)
378 #elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
379 #   define GET_CHAR_TYPE(c) GET_EBCDIC_TYPE(c)
380 #else
381 #   error U_CHARSET_FAMILY is not valid
382 #endif
383 
384 
385 /* @see ucnv_compareNames */
386 U_CAPI char * U_CALLCONV
ucnv_io_stripASCIIForCompare(char * dst,const char * name)387 ucnv_io_stripASCIIForCompare(char *dst, const char *name) {
388     char *dstItr = dst;
389     uint8_t type, nextType;
390     char c1;
391     UBool afterDigit = FALSE;
392 
393     while ((c1 = *name++) != 0) {
394         type = GET_ASCII_TYPE(c1);
395         switch (type) {
396         case UIGNORE:
397             afterDigit = FALSE;
398             continue; /* ignore all but letters and digits */
399         case ZERO:
400             if (!afterDigit) {
401                 nextType = GET_ASCII_TYPE(*name);
402                 if (nextType == ZERO || nextType == NONZERO) {
403                     continue; /* ignore leading zero before another digit */
404                 }
405             }
406             break;
407         case NONZERO:
408             afterDigit = TRUE;
409             break;
410         default:
411             c1 = (char)type; /* lowercased letter */
412             afterDigit = FALSE;
413             break;
414         }
415         *dstItr++ = c1;
416     }
417     *dstItr = 0;
418     return dst;
419 }
420 
421 U_CAPI char * U_CALLCONV
ucnv_io_stripEBCDICForCompare(char * dst,const char * name)422 ucnv_io_stripEBCDICForCompare(char *dst, const char *name) {
423     char *dstItr = dst;
424     uint8_t type, nextType;
425     char c1;
426     UBool afterDigit = FALSE;
427 
428     while ((c1 = *name++) != 0) {
429         type = GET_EBCDIC_TYPE(c1);
430         switch (type) {
431         case UIGNORE:
432             afterDigit = FALSE;
433             continue; /* ignore all but letters and digits */
434         case ZERO:
435             if (!afterDigit) {
436                 nextType = GET_EBCDIC_TYPE(*name);
437                 if (nextType == ZERO || nextType == NONZERO) {
438                     continue; /* ignore leading zero before another digit */
439                 }
440             }
441             break;
442         case NONZERO:
443             afterDigit = TRUE;
444             break;
445         default:
446             c1 = (char)type; /* lowercased letter */
447             afterDigit = FALSE;
448             break;
449         }
450         *dstItr++ = c1;
451     }
452     *dstItr = 0;
453     return dst;
454 }
455 
456 /**
457  * Do a fuzzy compare of two converter/alias names.
458  * The comparison is case-insensitive, ignores leading zeroes if they are not
459  * followed by further digits, and ignores all but letters and digits.
460  * Thus the strings "UTF-8", "utf_8", "u*T@f08" and "Utf 8" are exactly equivalent.
461  * See section 1.4, Charset Alias Matching in Unicode Technical Standard #22
462  * at http://www.unicode.org/reports/tr22/
463  *
464  * This is a symmetrical (commutative) operation; order of arguments
465  * is insignificant.  This is an important property for sorting the
466  * list (when the list is preprocessed into binary form) and for
467  * performing binary searches on it at run time.
468  *
469  * @param name1 a converter name or alias, zero-terminated
470  * @param name2 a converter name or alias, zero-terminated
471  * @return 0 if the names match, or a negative value if the name1
472  * lexically precedes name2, or a positive value if the name1
473  * lexically follows name2.
474  *
475  * @see ucnv_io_stripForCompare
476  */
477 U_CAPI int U_EXPORT2
ucnv_compareNames(const char * name1,const char * name2)478 ucnv_compareNames(const char *name1, const char *name2) {
479     int rc;
480     uint8_t type, nextType;
481     char c1, c2;
482     UBool afterDigit1 = FALSE, afterDigit2 = FALSE;
483 
484     for (;;) {
485         while ((c1 = *name1++) != 0) {
486             type = GET_CHAR_TYPE(c1);
487             switch (type) {
488             case UIGNORE:
489                 afterDigit1 = FALSE;
490                 continue; /* ignore all but letters and digits */
491             case ZERO:
492                 if (!afterDigit1) {
493                     nextType = GET_CHAR_TYPE(*name1);
494                     if (nextType == ZERO || nextType == NONZERO) {
495                         continue; /* ignore leading zero before another digit */
496                     }
497                 }
498                 break;
499             case NONZERO:
500                 afterDigit1 = TRUE;
501                 break;
502             default:
503                 c1 = (char)type; /* lowercased letter */
504                 afterDigit1 = FALSE;
505                 break;
506             }
507             break; /* deliver c1 */
508         }
509         while ((c2 = *name2++) != 0) {
510             type = GET_CHAR_TYPE(c2);
511             switch (type) {
512             case UIGNORE:
513                 afterDigit2 = FALSE;
514                 continue; /* ignore all but letters and digits */
515             case ZERO:
516                 if (!afterDigit2) {
517                     nextType = GET_CHAR_TYPE(*name2);
518                     if (nextType == ZERO || nextType == NONZERO) {
519                         continue; /* ignore leading zero before another digit */
520                     }
521                 }
522                 break;
523             case NONZERO:
524                 afterDigit2 = TRUE;
525                 break;
526             default:
527                 c2 = (char)type; /* lowercased letter */
528                 afterDigit2 = FALSE;
529                 break;
530             }
531             break; /* deliver c2 */
532         }
533 
534         /* If we reach the ends of both strings then they match */
535         if ((c1|c2)==0) {
536             return 0;
537         }
538 
539         /* Case-insensitive comparison */
540         rc = (int)(unsigned char)c1 - (int)(unsigned char)c2;
541         if (rc != 0) {
542             return rc;
543         }
544     }
545 }
546 
547 /*
548  * search for an alias
549  * return the converter number index for gConverterList
550  */
551 static inline uint32_t
findConverter(const char * alias,UBool * containsOption,UErrorCode * pErrorCode)552 findConverter(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) {
553     uint32_t mid, start, limit;
554     uint32_t lastMid;
555     int result;
556     int isUnnormalized = (gMainTable.optionTable->stringNormalizationType == UCNV_IO_UNNORMALIZED);
557     char strippedName[UCNV_MAX_CONVERTER_NAME_LENGTH];
558 
559     if (!isUnnormalized) {
560         if (uprv_strlen(alias) >= UCNV_MAX_CONVERTER_NAME_LENGTH) {
561             *pErrorCode = U_BUFFER_OVERFLOW_ERROR;
562             return UINT32_MAX;
563         }
564 
565         /* Lower case and remove ignoreable characters. */
566         ucnv_io_stripForCompare(strippedName, alias);
567         alias = strippedName;
568     }
569 
570     /* do a binary search for the alias */
571     start = 0;
572     limit = gMainTable.untaggedConvArraySize;
573     mid = limit;
574     lastMid = UINT32_MAX;
575 
576     for (;;) {
577         mid = (uint32_t)((start + limit) / 2);
578         if (lastMid == mid) {   /* Have we moved? */
579             break;  /* We haven't moved, and it wasn't found. */
580         }
581         lastMid = mid;
582         if (isUnnormalized) {
583             result = ucnv_compareNames(alias, GET_STRING(gMainTable.aliasList[mid]));
584         }
585         else {
586             result = uprv_strcmp(alias, GET_NORMALIZED_STRING(gMainTable.aliasList[mid]));
587         }
588 
589         if (result < 0) {
590             limit = mid;
591         } else if (result > 0) {
592             start = mid;
593         } else {
594             /* Since the gencnval tool folds duplicates into one entry,
595              * this alias in gAliasList is unique, but different standards
596              * may map an alias to different converters.
597              */
598             if (gMainTable.untaggedConvArray[mid] & UCNV_AMBIGUOUS_ALIAS_MAP_BIT) {
599                 *pErrorCode = U_AMBIGUOUS_ALIAS_WARNING;
600             }
601             /* State whether the canonical converter name contains an option.
602             This information is contained in this list in order to maintain backward & forward compatibility. */
603             if (containsOption) {
604                 UBool containsCnvOptionInfo = (UBool)gMainTable.optionTable->containsCnvOptionInfo;
605                 *containsOption = (UBool)((containsCnvOptionInfo
606                     && ((gMainTable.untaggedConvArray[mid] & UCNV_CONTAINS_OPTION_BIT) != 0))
607                     || !containsCnvOptionInfo);
608             }
609             return gMainTable.untaggedConvArray[mid] & UCNV_CONVERTER_INDEX_MASK;
610         }
611     }
612 
613     return UINT32_MAX;
614 }
615 
616 /*
617  * Is this alias in this list?
618  * alias and listOffset should be non-NULL.
619  */
620 static inline UBool
isAliasInList(const char * alias,uint32_t listOffset)621 isAliasInList(const char *alias, uint32_t listOffset) {
622     if (listOffset) {
623         uint32_t currAlias;
624         uint32_t listCount = gMainTable.taggedAliasLists[listOffset];
625         /* +1 to skip listCount */
626         const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1;
627         for (currAlias = 0; currAlias < listCount; currAlias++) {
628             if (currList[currAlias]
629                 && ucnv_compareNames(alias, GET_STRING(currList[currAlias]))==0)
630             {
631                 return TRUE;
632             }
633         }
634     }
635     return FALSE;
636 }
637 
638 /*
639  * Search for an standard name of an alias (what is the default name
640  * that this standard uses?)
641  * return the listOffset for gTaggedAliasLists. If it's 0,
642  * the it couldn't be found, but the parameters are valid.
643  */
644 static uint32_t
findTaggedAliasListsOffset(const char * alias,const char * standard,UErrorCode * pErrorCode)645 findTaggedAliasListsOffset(const char *alias, const char *standard, UErrorCode *pErrorCode) {
646     uint32_t idx;
647     uint32_t listOffset;
648     uint32_t convNum;
649     UErrorCode myErr = U_ZERO_ERROR;
650     uint32_t tagNum = getTagNumber(standard);
651 
652     /* Make a quick guess. Hopefully they used a TR22 canonical alias. */
653     convNum = findConverter(alias, NULL, &myErr);
654     if (myErr != U_ZERO_ERROR) {
655         *pErrorCode = myErr;
656     }
657 
658     if (tagNum < (gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS) && convNum < gMainTable.converterListSize) {
659         listOffset = gMainTable.taggedAliasArray[tagNum*gMainTable.converterListSize + convNum];
660         if (listOffset && gMainTable.taggedAliasLists[listOffset + 1]) {
661             return listOffset;
662         }
663         if (myErr == U_AMBIGUOUS_ALIAS_WARNING) {
664             /* Uh Oh! They used an ambiguous alias.
665                We have to search the whole swiss cheese starting
666                at the highest standard affinity.
667                This may take a while.
668             */
669             for (idx = 0; idx < gMainTable.taggedAliasArraySize; idx++) {
670                 listOffset = gMainTable.taggedAliasArray[idx];
671                 if (listOffset && isAliasInList(alias, listOffset)) {
672                     uint32_t currTagNum = idx/gMainTable.converterListSize;
673                     uint32_t currConvNum = (idx - currTagNum*gMainTable.converterListSize);
674                     uint32_t tempListOffset = gMainTable.taggedAliasArray[tagNum*gMainTable.converterListSize + currConvNum];
675                     if (tempListOffset && gMainTable.taggedAliasLists[tempListOffset + 1]) {
676                         return tempListOffset;
677                     }
678                     /* else keep on looking */
679                     /* We could speed this up by starting on the next row
680                        because an alias is unique per row, right now.
681                        This would change if alias versioning appears. */
682                 }
683             }
684             /* The standard doesn't know about the alias */
685         }
686         /* else no default name */
687         return 0;
688     }
689     /* else converter or tag not found */
690 
691     return UINT32_MAX;
692 }
693 
694 /* Return the canonical name */
695 static uint32_t
findTaggedConverterNum(const char * alias,const char * standard,UErrorCode * pErrorCode)696 findTaggedConverterNum(const char *alias, const char *standard, UErrorCode *pErrorCode) {
697     uint32_t idx;
698     uint32_t listOffset;
699     uint32_t convNum;
700     UErrorCode myErr = U_ZERO_ERROR;
701     uint32_t tagNum = getTagNumber(standard);
702 
703     /* Make a quick guess. Hopefully they used a TR22 canonical alias. */
704     convNum = findConverter(alias, NULL, &myErr);
705     if (myErr != U_ZERO_ERROR) {
706         *pErrorCode = myErr;
707     }
708 
709     if (tagNum < (gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS) && convNum < gMainTable.converterListSize) {
710         listOffset = gMainTable.taggedAliasArray[tagNum*gMainTable.converterListSize + convNum];
711         if (listOffset && isAliasInList(alias, listOffset)) {
712             return convNum;
713         }
714         if (myErr == U_AMBIGUOUS_ALIAS_WARNING) {
715             /* Uh Oh! They used an ambiguous alias.
716                We have to search one slice of the swiss cheese.
717                We search only in the requested tag, not the whole thing.
718                This may take a while.
719             */
720             uint32_t convStart = (tagNum)*gMainTable.converterListSize;
721             uint32_t convLimit = (tagNum+1)*gMainTable.converterListSize;
722             for (idx = convStart; idx < convLimit; idx++) {
723                 listOffset = gMainTable.taggedAliasArray[idx];
724                 if (listOffset && isAliasInList(alias, listOffset)) {
725                     return idx-convStart;
726                 }
727             }
728             /* The standard doesn't know about the alias */
729         }
730         /* else no canonical name */
731     }
732     /* else converter or tag not found */
733 
734     return UINT32_MAX;
735 }
736 
737 U_CAPI const char *
ucnv_io_getConverterName(const char * alias,UBool * containsOption,UErrorCode * pErrorCode)738 ucnv_io_getConverterName(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) {
739     const char *aliasTmp = alias;
740     int32_t i = 0;
741     for (i = 0; i < 2; i++) {
742         if (i == 1) {
743             /*
744              * After the first unsuccess converter lookup, check to see if
745              * the name begins with 'x-'. If it does, strip it off and try
746              * again.  This behaviour is similar to how ICU4J does it.
747              */
748             if (aliasTmp[0] == 'x' && aliasTmp[1] == '-') {
749                 aliasTmp = aliasTmp+2;
750             } else {
751                 break;
752             }
753         }
754         if(haveAliasData(pErrorCode) && isAlias(aliasTmp, pErrorCode)) {
755             uint32_t convNum = findConverter(aliasTmp, containsOption, pErrorCode);
756             if (convNum < gMainTable.converterListSize) {
757                 return GET_STRING(gMainTable.converterList[convNum]);
758             }
759             /* else converter not found */
760         } else {
761             break;
762         }
763     }
764 
765     return NULL;
766 }
767 
768 U_CDECL_BEGIN
769 
770 
771 static int32_t U_CALLCONV
ucnv_io_countStandardAliases(UEnumeration * enumerator,UErrorCode *)772 ucnv_io_countStandardAliases(UEnumeration *enumerator, UErrorCode * /*pErrorCode*/) {
773     int32_t value = 0;
774     UAliasContext *myContext = (UAliasContext *)(enumerator->context);
775     uint32_t listOffset = myContext->listOffset;
776 
777     if (listOffset) {
778         value = gMainTable.taggedAliasLists[listOffset];
779     }
780     return value;
781 }
782 
783 static const char * U_CALLCONV
ucnv_io_nextStandardAliases(UEnumeration * enumerator,int32_t * resultLength,UErrorCode *)784 ucnv_io_nextStandardAliases(UEnumeration *enumerator,
785                             int32_t* resultLength,
786                             UErrorCode * /*pErrorCode*/)
787 {
788     UAliasContext *myContext = (UAliasContext *)(enumerator->context);
789     uint32_t listOffset = myContext->listOffset;
790 
791     if (listOffset) {
792         uint32_t listCount = gMainTable.taggedAliasLists[listOffset];
793         const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1;
794 
795         if (myContext->listIdx < listCount) {
796             const char *myStr = GET_STRING(currList[myContext->listIdx++]);
797             if (resultLength) {
798                 *resultLength = (int32_t)uprv_strlen(myStr);
799             }
800             return myStr;
801         }
802     }
803     /* Either we accessed a zero length list, or we enumerated too far. */
804     if (resultLength) {
805         *resultLength = 0;
806     }
807     return NULL;
808 }
809 
810 static void U_CALLCONV
ucnv_io_resetStandardAliases(UEnumeration * enumerator,UErrorCode *)811 ucnv_io_resetStandardAliases(UEnumeration *enumerator, UErrorCode * /*pErrorCode*/) {
812     ((UAliasContext *)(enumerator->context))->listIdx = 0;
813 }
814 
815 static void U_CALLCONV
ucnv_io_closeUEnumeration(UEnumeration * enumerator)816 ucnv_io_closeUEnumeration(UEnumeration *enumerator) {
817     uprv_free(enumerator->context);
818     uprv_free(enumerator);
819 }
820 
821 U_CDECL_END
822 
823 /* Enumerate the aliases for the specified converter and standard tag */
824 static const UEnumeration gEnumAliases = {
825     NULL,
826     NULL,
827     ucnv_io_closeUEnumeration,
828     ucnv_io_countStandardAliases,
829     uenum_unextDefault,
830     ucnv_io_nextStandardAliases,
831     ucnv_io_resetStandardAliases
832 };
833 
834 U_CAPI UEnumeration * U_EXPORT2
ucnv_openStandardNames(const char * convName,const char * standard,UErrorCode * pErrorCode)835 ucnv_openStandardNames(const char *convName,
836                        const char *standard,
837                        UErrorCode *pErrorCode)
838 {
839     UEnumeration *myEnum = NULL;
840     if (haveAliasData(pErrorCode) && isAlias(convName, pErrorCode)) {
841         uint32_t listOffset = findTaggedAliasListsOffset(convName, standard, pErrorCode);
842 
843         /* When listOffset == 0, we want to acknowledge that the
844            converter name and standard are okay, but there
845            is nothing to enumerate. */
846         if (listOffset < gMainTable.taggedAliasListsSize) {
847             UAliasContext *myContext;
848 
849             myEnum = static_cast<UEnumeration *>(uprv_malloc(sizeof(UEnumeration)));
850             if (myEnum == NULL) {
851                 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
852                 return NULL;
853             }
854             uprv_memcpy(myEnum, &gEnumAliases, sizeof(UEnumeration));
855             myContext = static_cast<UAliasContext *>(uprv_malloc(sizeof(UAliasContext)));
856             if (myContext == NULL) {
857                 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
858                 uprv_free(myEnum);
859                 return NULL;
860             }
861             myContext->listOffset = listOffset;
862             myContext->listIdx = 0;
863             myEnum->context = myContext;
864         }
865         /* else converter or tag not found */
866     }
867     return myEnum;
868 }
869 
870 static uint16_t
ucnv_io_countAliases(const char * alias,UErrorCode * pErrorCode)871 ucnv_io_countAliases(const char *alias, UErrorCode *pErrorCode) {
872     if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
873         uint32_t convNum = findConverter(alias, NULL, pErrorCode);
874         if (convNum < gMainTable.converterListSize) {
875             /* tagListNum - 1 is the ALL tag */
876             int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum];
877 
878             if (listOffset) {
879                 return gMainTable.taggedAliasLists[listOffset];
880             }
881             /* else this shouldn't happen. internal program error */
882         }
883         /* else converter not found */
884     }
885     return 0;
886 }
887 
888 static uint16_t
ucnv_io_getAliases(const char * alias,uint16_t start,const char ** aliases,UErrorCode * pErrorCode)889 ucnv_io_getAliases(const char *alias, uint16_t start, const char **aliases, UErrorCode *pErrorCode) {
890     if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
891         uint32_t currAlias;
892         uint32_t convNum = findConverter(alias, NULL, pErrorCode);
893         if (convNum < gMainTable.converterListSize) {
894             /* tagListNum - 1 is the ALL tag */
895             int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum];
896 
897             if (listOffset) {
898                 uint32_t listCount = gMainTable.taggedAliasLists[listOffset];
899                 /* +1 to skip listCount */
900                 const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1;
901 
902                 for (currAlias = start; currAlias < listCount; currAlias++) {
903                     aliases[currAlias] = GET_STRING(currList[currAlias]);
904                 }
905             }
906             /* else this shouldn't happen. internal program error */
907         }
908         /* else converter not found */
909     }
910     return 0;
911 }
912 
913 static const char *
ucnv_io_getAlias(const char * alias,uint16_t n,UErrorCode * pErrorCode)914 ucnv_io_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode) {
915     if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
916         uint32_t convNum = findConverter(alias, NULL, pErrorCode);
917         if (convNum < gMainTable.converterListSize) {
918             /* tagListNum - 1 is the ALL tag */
919             int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum];
920 
921             if (listOffset) {
922                 uint32_t listCount = gMainTable.taggedAliasLists[listOffset];
923                 /* +1 to skip listCount */
924                 const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1;
925 
926                 if (n < listCount)  {
927                     return GET_STRING(currList[n]);
928                 }
929                 *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
930             }
931             /* else this shouldn't happen. internal program error */
932         }
933         /* else converter not found */
934     }
935     return NULL;
936 }
937 
938 static uint16_t
ucnv_io_countStandards(UErrorCode * pErrorCode)939 ucnv_io_countStandards(UErrorCode *pErrorCode) {
940     if (haveAliasData(pErrorCode)) {
941         /* Don't include the empty list */
942         return (uint16_t)(gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS);
943     }
944 
945     return 0;
946 }
947 
948 U_CAPI const char * U_EXPORT2
ucnv_getStandard(uint16_t n,UErrorCode * pErrorCode)949 ucnv_getStandard(uint16_t n, UErrorCode *pErrorCode) {
950     if (haveAliasData(pErrorCode)) {
951         if (n < gMainTable.tagListSize - UCNV_NUM_HIDDEN_TAGS) {
952             return GET_STRING(gMainTable.tagList[n]);
953         }
954         *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
955     }
956 
957     return NULL;
958 }
959 
960 U_CAPI const char * U_EXPORT2
ucnv_getStandardName(const char * alias,const char * standard,UErrorCode * pErrorCode)961 ucnv_getStandardName(const char *alias, const char *standard, UErrorCode *pErrorCode) {
962     if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
963         uint32_t listOffset = findTaggedAliasListsOffset(alias, standard, pErrorCode);
964 
965         if (0 < listOffset && listOffset < gMainTable.taggedAliasListsSize) {
966             const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1;
967 
968             /* Get the preferred name from this list */
969             if (currList[0]) {
970                 return GET_STRING(currList[0]);
971             }
972             /* else someone screwed up the alias table. */
973             /* *pErrorCode = U_INVALID_FORMAT_ERROR */
974         }
975     }
976 
977     return NULL;
978 }
979 
980 U_CAPI uint16_t U_EXPORT2
ucnv_countAliases(const char * alias,UErrorCode * pErrorCode)981 ucnv_countAliases(const char *alias, UErrorCode *pErrorCode)
982 {
983     return ucnv_io_countAliases(alias, pErrorCode);
984 }
985 
986 
987 U_CAPI const char* U_EXPORT2
ucnv_getAlias(const char * alias,uint16_t n,UErrorCode * pErrorCode)988 ucnv_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode)
989 {
990     return ucnv_io_getAlias(alias, n, pErrorCode);
991 }
992 
993 U_CAPI void U_EXPORT2
ucnv_getAliases(const char * alias,const char ** aliases,UErrorCode * pErrorCode)994 ucnv_getAliases(const char *alias, const char **aliases, UErrorCode *pErrorCode)
995 {
996     ucnv_io_getAliases(alias, 0, aliases, pErrorCode);
997 }
998 
999 U_CAPI uint16_t U_EXPORT2
ucnv_countStandards(void)1000 ucnv_countStandards(void)
1001 {
1002     UErrorCode err = U_ZERO_ERROR;
1003     return ucnv_io_countStandards(&err);
1004 }
1005 
1006 U_CAPI const char * U_EXPORT2
ucnv_getCanonicalName(const char * alias,const char * standard,UErrorCode * pErrorCode)1007 ucnv_getCanonicalName(const char *alias, const char *standard, UErrorCode *pErrorCode) {
1008     if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
1009         uint32_t convNum = findTaggedConverterNum(alias, standard, pErrorCode);
1010 
1011         if (convNum < gMainTable.converterListSize) {
1012             return GET_STRING(gMainTable.converterList[convNum]);
1013         }
1014     }
1015 
1016     return NULL;
1017 }
1018 
1019 U_CDECL_BEGIN
1020 
1021 
1022 static int32_t U_CALLCONV
ucnv_io_countAllConverters(UEnumeration *,UErrorCode *)1023 ucnv_io_countAllConverters(UEnumeration * /*enumerator*/, UErrorCode * /*pErrorCode*/) {
1024     return gMainTable.converterListSize;
1025 }
1026 
1027 static const char * U_CALLCONV
ucnv_io_nextAllConverters(UEnumeration * enumerator,int32_t * resultLength,UErrorCode *)1028 ucnv_io_nextAllConverters(UEnumeration *enumerator,
1029                             int32_t* resultLength,
1030                             UErrorCode * /*pErrorCode*/)
1031 {
1032     uint16_t *myContext = (uint16_t *)(enumerator->context);
1033 
1034     if (*myContext < gMainTable.converterListSize) {
1035         const char *myStr = GET_STRING(gMainTable.converterList[(*myContext)++]);
1036         if (resultLength) {
1037             *resultLength = (int32_t)uprv_strlen(myStr);
1038         }
1039         return myStr;
1040     }
1041     /* Either we accessed a zero length list, or we enumerated too far. */
1042     if (resultLength) {
1043         *resultLength = 0;
1044     }
1045     return NULL;
1046 }
1047 
1048 static void U_CALLCONV
ucnv_io_resetAllConverters(UEnumeration * enumerator,UErrorCode *)1049 ucnv_io_resetAllConverters(UEnumeration *enumerator, UErrorCode * /*pErrorCode*/) {
1050     *((uint16_t *)(enumerator->context)) = 0;
1051 }
1052 U_CDECL_END
1053 static const UEnumeration gEnumAllConverters = {
1054     NULL,
1055     NULL,
1056     ucnv_io_closeUEnumeration,
1057     ucnv_io_countAllConverters,
1058     uenum_unextDefault,
1059     ucnv_io_nextAllConverters,
1060     ucnv_io_resetAllConverters
1061 };
1062 
1063 U_CAPI UEnumeration * U_EXPORT2
ucnv_openAllNames(UErrorCode * pErrorCode)1064 ucnv_openAllNames(UErrorCode *pErrorCode) {
1065     UEnumeration *myEnum = NULL;
1066     if (haveAliasData(pErrorCode)) {
1067         uint16_t *myContext;
1068 
1069         myEnum = static_cast<UEnumeration *>(uprv_malloc(sizeof(UEnumeration)));
1070         if (myEnum == NULL) {
1071             *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
1072             return NULL;
1073         }
1074         uprv_memcpy(myEnum, &gEnumAllConverters, sizeof(UEnumeration));
1075         myContext = static_cast<uint16_t *>(uprv_malloc(sizeof(uint16_t)));
1076         if (myContext == NULL) {
1077             *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
1078             uprv_free(myEnum);
1079             return NULL;
1080         }
1081         *myContext = 0;
1082         myEnum->context = myContext;
1083     }
1084     return myEnum;
1085 }
1086 
1087 U_CAPI uint16_t
ucnv_io_countKnownConverters(UErrorCode * pErrorCode)1088 ucnv_io_countKnownConverters(UErrorCode *pErrorCode) {
1089     if (haveAliasData(pErrorCode)) {
1090         return (uint16_t)gMainTable.converterListSize;
1091     }
1092     return 0;
1093 }
1094 
1095 /* alias table swapping ----------------------------------------------------- */
1096 
1097 U_CDECL_BEGIN
1098 
1099 typedef char * U_CALLCONV StripForCompareFn(char *dst, const char *name);
1100 U_CDECL_END
1101 
1102 
1103 /*
1104  * row of a temporary array
1105  *
1106  * gets platform-endian charset string indexes and sorting indexes;
1107  * after sorting this array by strings, the actual arrays are permutated
1108  * according to the sorting indexes
1109  */
1110 typedef struct TempRow {
1111     uint16_t strIndex, sortIndex;
1112 } TempRow;
1113 
1114 typedef struct TempAliasTable {
1115     const char *chars;
1116     TempRow *rows;
1117     uint16_t *resort;
1118     StripForCompareFn *stripForCompare;
1119 } TempAliasTable;
1120 
1121 enum {
1122     STACK_ROW_CAPACITY=500
1123 };
1124 
1125 static int32_t U_CALLCONV
io_compareRows(const void * context,const void * left,const void * right)1126 io_compareRows(const void *context, const void *left, const void *right) {
1127     char strippedLeft[UCNV_MAX_CONVERTER_NAME_LENGTH],
1128          strippedRight[UCNV_MAX_CONVERTER_NAME_LENGTH];
1129 
1130     TempAliasTable *tempTable=(TempAliasTable *)context;
1131     const char *chars=tempTable->chars;
1132 
1133     return (int32_t)uprv_strcmp(tempTable->stripForCompare(strippedLeft, chars+2*((const TempRow *)left)->strIndex),
1134                                 tempTable->stripForCompare(strippedRight, chars+2*((const TempRow *)right)->strIndex));
1135 }
1136 
1137 U_CAPI int32_t U_EXPORT2
ucnv_swapAliases(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)1138 ucnv_swapAliases(const UDataSwapper *ds,
1139                  const void *inData, int32_t length, void *outData,
1140                  UErrorCode *pErrorCode) {
1141     const UDataInfo *pInfo;
1142     int32_t headerSize;
1143 
1144     const uint16_t *inTable;
1145     const uint32_t *inSectionSizes;
1146     uint32_t toc[offsetsCount];
1147     uint32_t offsets[offsetsCount]; /* 16-bit-addressed offsets from inTable/outTable */
1148     uint32_t i, count, tocLength, topOffset;
1149 
1150     TempRow rows[STACK_ROW_CAPACITY];
1151     uint16_t resort[STACK_ROW_CAPACITY];
1152     TempAliasTable tempTable;
1153 
1154     /* udata_swapDataHeader checks the arguments */
1155     headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
1156     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
1157         return 0;
1158     }
1159 
1160     /* check data format and format version */
1161     pInfo=(const UDataInfo *)((const char *)inData+4);
1162     if(!(
1163         pInfo->dataFormat[0]==0x43 &&   /* dataFormat="CvAl" */
1164         pInfo->dataFormat[1]==0x76 &&
1165         pInfo->dataFormat[2]==0x41 &&
1166         pInfo->dataFormat[3]==0x6c &&
1167         pInfo->formatVersion[0]==3
1168     )) {
1169         udata_printError(ds, "ucnv_swapAliases(): data format %02x.%02x.%02x.%02x (format version %02x) is not an alias table\n",
1170                          pInfo->dataFormat[0], pInfo->dataFormat[1],
1171                          pInfo->dataFormat[2], pInfo->dataFormat[3],
1172                          pInfo->formatVersion[0]);
1173         *pErrorCode=U_UNSUPPORTED_ERROR;
1174         return 0;
1175     }
1176 
1177     /* an alias table must contain at least the table of contents array */
1178     if(length>=0 && (length-headerSize)<4*(1+minTocLength)) {
1179         udata_printError(ds, "ucnv_swapAliases(): too few bytes (%d after header) for an alias table\n",
1180                          length-headerSize);
1181         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1182         return 0;
1183     }
1184 
1185     inSectionSizes=(const uint32_t *)((const char *)inData+headerSize);
1186     inTable=(const uint16_t *)inSectionSizes;
1187     uprv_memset(toc, 0, sizeof(toc));
1188     toc[tocLengthIndex]=tocLength=ds->readUInt32(inSectionSizes[tocLengthIndex]);
1189     if(tocLength<minTocLength || offsetsCount<=tocLength) {
1190         udata_printError(ds, "ucnv_swapAliases(): table of contents contains unsupported number of sections (%u sections)\n", tocLength);
1191         *pErrorCode=U_INVALID_FORMAT_ERROR;
1192         return 0;
1193     }
1194 
1195     /* read the known part of the table of contents */
1196     for(i=converterListIndex; i<=tocLength; ++i) {
1197         toc[i]=ds->readUInt32(inSectionSizes[i]);
1198     }
1199 
1200     /* compute offsets */
1201     uprv_memset(offsets, 0, sizeof(offsets));
1202     offsets[converterListIndex]=2*(1+tocLength); /* count two 16-bit units per toc entry */
1203     for(i=tagListIndex; i<=tocLength; ++i) {
1204         offsets[i]=offsets[i-1]+toc[i-1];
1205     }
1206 
1207     /* compute the overall size of the after-header data, in numbers of 16-bit units */
1208     topOffset=offsets[i-1]+toc[i-1];
1209 
1210     if(length>=0) {
1211         uint16_t *outTable;
1212         const uint16_t *p, *p2;
1213         uint16_t *q, *q2;
1214         uint16_t oldIndex;
1215 
1216         if((length-headerSize)<(2*(int32_t)topOffset)) {
1217             udata_printError(ds, "ucnv_swapAliases(): too few bytes (%d after header) for an alias table\n",
1218                              length-headerSize);
1219             *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1220             return 0;
1221         }
1222 
1223         outTable=(uint16_t *)((char *)outData+headerSize);
1224 
1225         /* swap the entire table of contents */
1226         ds->swapArray32(ds, inTable, 4*(1+tocLength), outTable, pErrorCode);
1227 
1228         /* swap unormalized strings & normalized strings */
1229         ds->swapInvChars(ds, inTable+offsets[stringTableIndex], 2*(int32_t)(toc[stringTableIndex]+toc[normalizedStringTableIndex]),
1230                              outTable+offsets[stringTableIndex], pErrorCode);
1231         if(U_FAILURE(*pErrorCode)) {
1232             udata_printError(ds, "ucnv_swapAliases().swapInvChars(charset names) failed\n");
1233             return 0;
1234         }
1235 
1236         if(ds->inCharset==ds->outCharset) {
1237             /* no need to sort, just swap all 16-bit values together */
1238             ds->swapArray16(ds,
1239                             inTable+offsets[converterListIndex],
1240                             2*(int32_t)(offsets[stringTableIndex]-offsets[converterListIndex]),
1241                             outTable+offsets[converterListIndex],
1242                             pErrorCode);
1243         } else {
1244             /* allocate the temporary table for sorting */
1245             count=toc[aliasListIndex];
1246 
1247             tempTable.chars=(const char *)(outTable+offsets[stringTableIndex]); /* sort by outCharset */
1248 
1249             if(count<=STACK_ROW_CAPACITY) {
1250                 tempTable.rows=rows;
1251                 tempTable.resort=resort;
1252             } else {
1253                 tempTable.rows=(TempRow *)uprv_malloc(count*sizeof(TempRow)+count*2);
1254                 if(tempTable.rows==NULL) {
1255                     udata_printError(ds, "ucnv_swapAliases(): unable to allocate memory for sorting tables (max length: %u)\n",
1256                                      count);
1257                     *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
1258                     return 0;
1259                 }
1260                 tempTable.resort=(uint16_t *)(tempTable.rows+count);
1261             }
1262 
1263             if(ds->outCharset==U_ASCII_FAMILY) {
1264                 tempTable.stripForCompare=ucnv_io_stripASCIIForCompare;
1265             } else /* U_EBCDIC_FAMILY */ {
1266                 tempTable.stripForCompare=ucnv_io_stripEBCDICForCompare;
1267             }
1268 
1269             /*
1270              * Sort unique aliases+mapped names.
1271              *
1272              * We need to sort the list again by outCharset strings because they
1273              * sort differently for different charset families.
1274              * First we set up a temporary table with the string indexes and
1275              * sorting indexes and sort that.
1276              * Then we permutate and copy/swap the actual values.
1277              */
1278             p=inTable+offsets[aliasListIndex];
1279             q=outTable+offsets[aliasListIndex];
1280 
1281             p2=inTable+offsets[untaggedConvArrayIndex];
1282             q2=outTable+offsets[untaggedConvArrayIndex];
1283 
1284             for(i=0; i<count; ++i) {
1285                 tempTable.rows[i].strIndex=ds->readUInt16(p[i]);
1286                 tempTable.rows[i].sortIndex=(uint16_t)i;
1287             }
1288 
1289             uprv_sortArray(tempTable.rows, (int32_t)count, sizeof(TempRow),
1290                            io_compareRows, &tempTable,
1291                            FALSE, pErrorCode);
1292 
1293             if(U_SUCCESS(*pErrorCode)) {
1294                 /* copy/swap/permutate items */
1295                 if(p!=q) {
1296                     for(i=0; i<count; ++i) {
1297                         oldIndex=tempTable.rows[i].sortIndex;
1298                         ds->swapArray16(ds, p+oldIndex, 2, q+i, pErrorCode);
1299                         ds->swapArray16(ds, p2+oldIndex, 2, q2+i, pErrorCode);
1300                     }
1301                 } else {
1302                     /*
1303                      * If we swap in-place, then the permutation must use another
1304                      * temporary array (tempTable.resort)
1305                      * before the results are copied to the outBundle.
1306                      */
1307                     uint16_t *r=tempTable.resort;
1308 
1309                     for(i=0; i<count; ++i) {
1310                         oldIndex=tempTable.rows[i].sortIndex;
1311                         ds->swapArray16(ds, p+oldIndex, 2, r+i, pErrorCode);
1312                     }
1313                     uprv_memcpy(q, r, 2*(size_t)count);
1314 
1315                     for(i=0; i<count; ++i) {
1316                         oldIndex=tempTable.rows[i].sortIndex;
1317                         ds->swapArray16(ds, p2+oldIndex, 2, r+i, pErrorCode);
1318                     }
1319                     uprv_memcpy(q2, r, 2*(size_t)count);
1320                 }
1321             }
1322 
1323             if(tempTable.rows!=rows) {
1324                 uprv_free(tempTable.rows);
1325             }
1326 
1327             if(U_FAILURE(*pErrorCode)) {
1328                 udata_printError(ds, "ucnv_swapAliases().uprv_sortArray(%u items) failed\n",
1329                                  count);
1330                 return 0;
1331             }
1332 
1333             /* swap remaining 16-bit values */
1334             ds->swapArray16(ds,
1335                             inTable+offsets[converterListIndex],
1336                             2*(int32_t)(offsets[aliasListIndex]-offsets[converterListIndex]),
1337                             outTable+offsets[converterListIndex],
1338                             pErrorCode);
1339             ds->swapArray16(ds,
1340                             inTable+offsets[taggedAliasArrayIndex],
1341                             2*(int32_t)(offsets[stringTableIndex]-offsets[taggedAliasArrayIndex]),
1342                             outTable+offsets[taggedAliasArrayIndex],
1343                             pErrorCode);
1344         }
1345     }
1346 
1347     return headerSize+2*(int32_t)topOffset;
1348 }
1349 
1350 #endif
1351 
1352 
1353 /*
1354  * Hey, Emacs, please set the following:
1355  *
1356  * Local Variables:
1357  * indent-tabs-mode: nil
1358  * End:
1359  *
1360  */
1361