The Tor Browser / file comparison

comparison: intl/icu/source/common/ucnv_io.cpp

intl/icu/source/common/ucnv_io.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial