The Tor Browser / file comparison

comparison: intl/icu/source/common/uresdata.c

intl/icu/source/common/uresdata.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:26f639f16011
1 /*
2 *******************************************************************************
3 * *
4 * Copyright (C) 1999-2012, International Business Machines Corporation *
5 * and others. All Rights Reserved. *
6 * *
7 *******************************************************************************
8 * file name: uresdata.c
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 1999dec08
14 * created by: Markus W. Scherer
15 * Modification History:
16 *
17 * Date Name Description
18 * 06/20/2000 helena OS/400 port changes; mostly typecast.
19 * 06/24/02 weiv Added support for resource sharing
20 */
21
22 #include "unicode/utypes.h"
23 #include "unicode/udata.h"
24 #include "unicode/ustring.h"
25 #include "unicode/utf16.h"
26 #include "cmemory.h"
27 #include "cstring.h"
28 #include "uarrsort.h"
29 #include "udataswp.h"
30 #include "ucol_swp.h"
31 #include "uinvchar.h"
32 #include "uresdata.h"
33 #include "uresimp.h"
34 #include "uassert.h"
35
36 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
37
38 /*
39 * Resource access helpers
40 */
41
42 /* get a const char* pointer to the key with the keyOffset byte offset from pRoot */
43 #define RES_GET_KEY16(pResData, keyOffset) \
44 ((keyOffset)<(pResData)->localKeyLimit ? \
45 (const char *)(pResData)->pRoot+(keyOffset) : \
46 (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit)
47
48 #define RES_GET_KEY32(pResData, keyOffset) \
49 ((keyOffset)>=0 ? \
50 (const char *)(pResData)->pRoot+(keyOffset) : \
51 (pResData)->poolBundleKeys+((keyOffset)&0x7fffffff))
52
53 #define URESDATA_ITEM_NOT_FOUND -1
54
55 /* empty resources, returned when the resource offset is 0 */
56 static const uint16_t gEmpty16=0;
57
58 static const struct {
59 int32_t length;
60 int32_t res;
61 } gEmpty32={ 0, 0 };
62
63 static const struct {
64 int32_t length;
65 UChar nul;
66 UChar pad;
67 } gEmptyString={ 0, 0, 0 };
68
69 /*
70 * All the type-access functions assume that
71 * the resource is of the expected type.
72 */
73
74 static int32_t
75 _res_findTableItem(const ResourceData *pResData, const uint16_t *keyOffsets, int32_t length,
76 const char *key, const char **realKey) {
77 const char *tableKey;
78 int32_t mid, start, limit;
79 int result;
80
81 /* do a binary search for the key */
82 start=0;
83 limit=length;
84 while(start<limit) {
85 mid = (start + limit) / 2;
86 tableKey = RES_GET_KEY16(pResData, keyOffsets[mid]);
87 if (pResData->useNativeStrcmp) {
88 result = uprv_strcmp(key, tableKey);
89 } else {
90 result = uprv_compareInvCharsAsAscii(key, tableKey);
91 }
92 if (result < 0) {
93 limit = mid;
94 } else if (result > 0) {
95 start = mid + 1;
96 } else {
97 /* We found it! */
98 *realKey=tableKey;
99 return mid;
100 }
101 }
102 return URESDATA_ITEM_NOT_FOUND; /* not found or table is empty. */
103 }
104
105 static int32_t
106 _res_findTable32Item(const ResourceData *pResData, const int32_t *keyOffsets, int32_t length,
107 const char *key, const char **realKey) {
108 const char *tableKey;
109 int32_t mid, start, limit;
110 int result;
111
112 /* do a binary search for the key */
113 start=0;
114 limit=length;
115 while(start<limit) {
116 mid = (start + limit) / 2;
117 tableKey = RES_GET_KEY32(pResData, keyOffsets[mid]);
118 if (pResData->useNativeStrcmp) {
119 result = uprv_strcmp(key, tableKey);
120 } else {
121 result = uprv_compareInvCharsAsAscii(key, tableKey);
122 }
123 if (result < 0) {
124 limit = mid;
125 } else if (result > 0) {
126 start = mid + 1;
127 } else {
128 /* We found it! */
129 *realKey=tableKey;
130 return mid;
131 }
132 }
133 return URESDATA_ITEM_NOT_FOUND; /* not found or table is empty. */
134 }
135
136 /* helper for res_load() ---------------------------------------------------- */
137
138 static UBool U_CALLCONV
139 isAcceptable(void *context,
140 const char *type, const char *name,
141 const UDataInfo *pInfo) {
142 uprv_memcpy(context, pInfo->formatVersion, 4);
143 return (UBool)(
144 pInfo->size>=20 &&
145 pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
146 pInfo->charsetFamily==U_CHARSET_FAMILY &&
147 pInfo->sizeofUChar==U_SIZEOF_UCHAR &&
148 pInfo->dataFormat[0]==0x52 && /* dataFormat="ResB" */
149 pInfo->dataFormat[1]==0x65 &&
150 pInfo->dataFormat[2]==0x73 &&
151 pInfo->dataFormat[3]==0x42 &&
152 (pInfo->formatVersion[0]==1 || pInfo->formatVersion[0]==2));
153 }
154
155 /* semi-public functions ---------------------------------------------------- */
156
157 static void
158 res_init(ResourceData *pResData,
159 UVersionInfo formatVersion, const void *inBytes, int32_t length,
160 UErrorCode *errorCode) {
161 UResType rootType;
162
163 /* get the root resource */
164 pResData->pRoot=(const int32_t *)inBytes;
165 pResData->rootRes=(Resource)*pResData->pRoot;
166 pResData->p16BitUnits=&gEmpty16;
167
168 /* formatVersion 1.1 must have a root item and at least 5 indexes */
169 if(length>=0 && (length/4)<((formatVersion[0]==1 && formatVersion[1]==0) ? 1 : 1+5)) {
170 *errorCode=U_INVALID_FORMAT_ERROR;
171 res_unload(pResData);
172 return;
173 }
174
175 /* currently, we accept only resources that have a Table as their roots */
176 rootType=(UResType)RES_GET_TYPE(pResData->rootRes);
177 if(!URES_IS_TABLE(rootType)) {
178 *errorCode=U_INVALID_FORMAT_ERROR;
179 res_unload(pResData);
180 return;
181 }
182
183 if(formatVersion[0]==1 && formatVersion[1]==0) {
184 pResData->localKeyLimit=0x10000; /* greater than any 16-bit key string offset */
185 } else {
186 /* bundles with formatVersion 1.1 and later contain an indexes[] array */
187 const int32_t *indexes=pResData->pRoot+1;
188 int32_t indexLength=indexes[URES_INDEX_LENGTH]&0xff;
189 if(indexLength<=URES_INDEX_MAX_TABLE_LENGTH) {
190 *errorCode=U_INVALID_FORMAT_ERROR;
191 res_unload(pResData);
192 return;
193 }
194 if( length>=0 &&
195 (length<((1+indexLength)<<2) ||
196 length<(indexes[URES_INDEX_BUNDLE_TOP]<<2))
197 ) {
198 *errorCode=U_INVALID_FORMAT_ERROR;
199 res_unload(pResData);
200 return;
201 }
202 if(indexes[URES_INDEX_KEYS_TOP]>(1+indexLength)) {
203 pResData->localKeyLimit=indexes[URES_INDEX_KEYS_TOP]<<2;
204 }
205 if(indexLength>URES_INDEX_ATTRIBUTES) {
206 int32_t att=indexes[URES_INDEX_ATTRIBUTES];
207 pResData->noFallback=(UBool)(att&URES_ATT_NO_FALLBACK);
208 pResData->isPoolBundle=(UBool)((att&URES_ATT_IS_POOL_BUNDLE)!=0);
209 pResData->usesPoolBundle=(UBool)((att&URES_ATT_USES_POOL_BUNDLE)!=0);
210 }
211 if((pResData->isPoolBundle || pResData->usesPoolBundle) && indexLength<=URES_INDEX_POOL_CHECKSUM) {
212 *errorCode=U_INVALID_FORMAT_ERROR;
213 res_unload(pResData);
214 return;
215 }
216 if( indexLength>URES_INDEX_16BIT_TOP &&
217 indexes[URES_INDEX_16BIT_TOP]>indexes[URES_INDEX_KEYS_TOP]
218 ) {
219 pResData->p16BitUnits=(const uint16_t *)(pResData->pRoot+indexes[URES_INDEX_KEYS_TOP]);
220 }
221 }
222
223 if(formatVersion[0]==1 || U_CHARSET_FAMILY==U_ASCII_FAMILY) {
224 /*
225 * formatVersion 1: compare key strings in native-charset order
226 * formatVersion 2 and up: compare key strings in ASCII order
227 */
228 pResData->useNativeStrcmp=TRUE;
229 }
230 }
231
232 U_CAPI void U_EXPORT2
233 res_read(ResourceData *pResData,
234 const UDataInfo *pInfo, const void *inBytes, int32_t length,
235 UErrorCode *errorCode) {
236 UVersionInfo formatVersion;
237
238 uprv_memset(pResData, 0, sizeof(ResourceData));
239 if(U_FAILURE(*errorCode)) {
240 return;
241 }
242 if(!isAcceptable(formatVersion, NULL, NULL, pInfo)) {
243 *errorCode=U_INVALID_FORMAT_ERROR;
244 return;
245 }
246 res_init(pResData, formatVersion, inBytes, length, errorCode);
247 }
248
249 U_CFUNC void
250 res_load(ResourceData *pResData,
251 const char *path, const char *name, UErrorCode *errorCode) {
252 UVersionInfo formatVersion;
253
254 uprv_memset(pResData, 0, sizeof(ResourceData));
255
256 /* load the ResourceBundle file */
257 pResData->data=udata_openChoice(path, "res", name, isAcceptable, formatVersion, errorCode);
258 if(U_FAILURE(*errorCode)) {
259 return;
260 }
261
262 /* get its memory and initialize *pResData */
263 res_init(pResData, formatVersion, udata_getMemory(pResData->data), -1, errorCode);
264 }
265
266 U_CFUNC void
267 res_unload(ResourceData *pResData) {
268 if(pResData->data!=NULL) {
269 udata_close(pResData->data);
270 pResData->data=NULL;
271 }
272 }
273
274 static const int8_t gPublicTypes[URES_LIMIT] = {
275 URES_STRING,
276 URES_BINARY,
277 URES_TABLE,
278 URES_ALIAS,
279
280 URES_TABLE, /* URES_TABLE32 */
281 URES_TABLE, /* URES_TABLE16 */
282 URES_STRING, /* URES_STRING_V2 */
283 URES_INT,
284
285 URES_ARRAY,
286 URES_ARRAY, /* URES_ARRAY16 */
287 URES_NONE,
288 URES_NONE,
289
290 URES_NONE,
291 URES_NONE,
292 URES_INT_VECTOR,
293 URES_NONE
294 };
295
296 U_CAPI UResType U_EXPORT2
297 res_getPublicType(Resource res) {
298 return (UResType)gPublicTypes[RES_GET_TYPE(res)];
299 }
300
301 U_CAPI const UChar * U_EXPORT2
302 res_getString(const ResourceData *pResData, Resource res, int32_t *pLength) {
303 const UChar *p;
304 uint32_t offset=RES_GET_OFFSET(res);
305 int32_t length;
306 if(RES_GET_TYPE(res)==URES_STRING_V2) {
307 int32_t first;
308 p=(const UChar *)(pResData->p16BitUnits+offset);
309 first=*p;
310 if(!U16_IS_TRAIL(first)) {
311 length=u_strlen(p);
312 } else if(first<0xdfef) {
313 length=first&0x3ff;
314 ++p;
315 } else if(first<0xdfff) {
316 length=((first-0xdfef)<<16)|p[1];
317 p+=2;
318 } else {
319 length=((int32_t)p[1]<<16)|p[2];
320 p+=3;
321 }
322 } else if(res==offset) /* RES_GET_TYPE(res)==URES_STRING */ {
323 const int32_t *p32= res==0 ? &gEmptyString.length : pResData->pRoot+res;
324 length=*p32++;
325 p=(const UChar *)p32;
326 } else {
327 p=NULL;
328 length=0;
329 }
330 if(pLength) {
331 *pLength=length;
332 }
333 return p;
334 }
335
336 U_CAPI const UChar * U_EXPORT2
337 res_getAlias(const ResourceData *pResData, Resource res, int32_t *pLength) {
338 const UChar *p;
339 uint32_t offset=RES_GET_OFFSET(res);
340 int32_t length;
341 if(RES_GET_TYPE(res)==URES_ALIAS) {
342 const int32_t *p32= offset==0 ? &gEmptyString.length : pResData->pRoot+offset;
343 length=*p32++;
344 p=(const UChar *)p32;
345 } else {
346 p=NULL;
347 length=0;
348 }
349 if(pLength) {
350 *pLength=length;
351 }
352 return p;
353 }
354
355 U_CAPI const uint8_t * U_EXPORT2
356 res_getBinary(const ResourceData *pResData, Resource res, int32_t *pLength) {
357 const uint8_t *p;
358 uint32_t offset=RES_GET_OFFSET(res);
359 int32_t length;
360 if(RES_GET_TYPE(res)==URES_BINARY) {
361 const int32_t *p32= offset==0 ? (const int32_t*)&gEmpty32 : pResData->pRoot+offset;
362 length=*p32++;
363 p=(const uint8_t *)p32;
364 } else {
365 p=NULL;
366 length=0;
367 }
368 if(pLength) {
369 *pLength=length;
370 }
371 return p;
372 }
373
374
375 U_CAPI const int32_t * U_EXPORT2
376 res_getIntVector(const ResourceData *pResData, Resource res, int32_t *pLength) {
377 const int32_t *p;
378 uint32_t offset=RES_GET_OFFSET(res);
379 int32_t length;
380 if(RES_GET_TYPE(res)==URES_INT_VECTOR) {
381 p= offset==0 ? (const int32_t *)&gEmpty32 : pResData->pRoot+offset;
382 length=*p++;
383 } else {
384 p=NULL;
385 length=0;
386 }
387 if(pLength) {
388 *pLength=length;
389 }
390 return p;
391 }
392
393 U_CAPI int32_t U_EXPORT2
394 res_countArrayItems(const ResourceData *pResData, Resource res) {
395 uint32_t offset=RES_GET_OFFSET(res);
396 switch(RES_GET_TYPE(res)) {
397 case URES_STRING:
398 case URES_STRING_V2:
399 case URES_BINARY:
400 case URES_ALIAS:
401 case URES_INT:
402 case URES_INT_VECTOR:
403 return 1;
404 case URES_ARRAY:
405 case URES_TABLE32:
406 return offset==0 ? 0 : *(pResData->pRoot+offset);
407 case URES_TABLE:
408 return offset==0 ? 0 : *((const uint16_t *)(pResData->pRoot+offset));
409 case URES_ARRAY16:
410 case URES_TABLE16:
411 return pResData->p16BitUnits[offset];
412 default:
413 return 0;
414 }
415 }
416
417 U_CAPI Resource U_EXPORT2
418 res_getTableItemByKey(const ResourceData *pResData, Resource table,
419 int32_t *indexR, const char **key) {
420 uint32_t offset=RES_GET_OFFSET(table);
421 int32_t length;
422 int32_t idx;
423 if(key == NULL || *key == NULL) {
424 return RES_BOGUS;
425 }
426 switch(RES_GET_TYPE(table)) {
427 case URES_TABLE: {
428 if (offset!=0) { /* empty if offset==0 */
429 const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset);
430 length=*p++;
431 *indexR=idx=_res_findTableItem(pResData, p, length, *key, key);
432 if(idx>=0) {
433 const Resource *p32=(const Resource *)(p+length+(~length&1));
434 return p32[idx];
435 }
436 }
437 break;
438 }
439 case URES_TABLE16: {
440 const uint16_t *p=pResData->p16BitUnits+offset;
441 length=*p++;
442 *indexR=idx=_res_findTableItem(pResData, p, length, *key, key);
443 if(idx>=0) {
444 return URES_MAKE_RESOURCE(URES_STRING_V2, p[length+idx]);
445 }
446 break;
447 }
448 case URES_TABLE32: {
449 if (offset!=0) { /* empty if offset==0 */
450 const int32_t *p= pResData->pRoot+offset;
451 length=*p++;
452 *indexR=idx=_res_findTable32Item(pResData, p, length, *key, key);
453 if(idx>=0) {
454 return (Resource)p[length+idx];
455 }
456 }
457 break;
458 }
459 default:
460 break;
461 }
462 return RES_BOGUS;
463 }
464
465 U_CAPI Resource U_EXPORT2
466 res_getTableItemByIndex(const ResourceData *pResData, Resource table,
467 int32_t indexR, const char **key) {
468 uint32_t offset=RES_GET_OFFSET(table);
469 int32_t length;
470 U_ASSERT(indexR>=0); /* to ensure the index is not negative */
471 switch(RES_GET_TYPE(table)) {
472 case URES_TABLE: {
473 if (offset != 0) { /* empty if offset==0 */
474 const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset);
475 length=*p++;
476 if(indexR<length) {
477 const Resource *p32=(const Resource *)(p+length+(~length&1));
478 if(key!=NULL) {
479 *key=RES_GET_KEY16(pResData, p[indexR]);
480 }
481 return p32[indexR];
482 }
483 }
484 break;
485 }
486 case URES_TABLE16: {
487 const uint16_t *p=pResData->p16BitUnits+offset;
488 length=*p++;
489 if(indexR<length) {
490 if(key!=NULL) {
491 *key=RES_GET_KEY16(pResData, p[indexR]);
492 }
493 return URES_MAKE_RESOURCE(URES_STRING_V2, p[length+indexR]);
494 }
495 break;
496 }
497 case URES_TABLE32: {
498 if (offset != 0) { /* empty if offset==0 */
499 const int32_t *p= pResData->pRoot+offset;
500 length=*p++;
501 if(indexR<length) {
502 if(key!=NULL) {
503 *key=RES_GET_KEY32(pResData, p[indexR]);
504 }
505 return (Resource)p[length+indexR];
506 }
507 }
508 break;
509 }
510 default:
511 break;
512 }
513 return RES_BOGUS;
514 }
515
516 U_CAPI Resource U_EXPORT2
517 res_getResource(const ResourceData *pResData, const char *key) {
518 const char *realKey=key;
519 int32_t idx;
520 return res_getTableItemByKey(pResData, pResData->rootRes, &idx, &realKey);
521 }
522
523 U_CAPI Resource U_EXPORT2
524 res_getArrayItem(const ResourceData *pResData, Resource array, int32_t indexR) {
525 uint32_t offset=RES_GET_OFFSET(array);
526 U_ASSERT(indexR>=0); /* to ensure the index is not negative */
527 switch(RES_GET_TYPE(array)) {
528 case URES_ARRAY: {
529 if (offset!=0) { /* empty if offset==0 */
530 const int32_t *p= pResData->pRoot+offset;
531 if(indexR<*p) {
532 return (Resource)p[1+indexR];
533 }
534 }
535 break;
536 }
537 case URES_ARRAY16: {
538 const uint16_t *p=pResData->p16BitUnits+offset;
539 if(indexR<*p) {
540 return URES_MAKE_RESOURCE(URES_STRING_V2, p[1+indexR]);
541 }
542 break;
543 }
544 default:
545 break;
546 }
547 return RES_BOGUS;
548 }
549
550 U_CFUNC Resource
551 res_findResource(const ResourceData *pResData, Resource r, char** path, const char** key) {
552 /* we pass in a path. CollationElements/Sequence or zoneStrings/3/2 etc.
553 * iterates over a path and stops when a scalar resource is found. This
554 * CAN be an alias. Path gets set to the part that has not yet been processed.
555 */
556
557 char *pathP = *path, *nextSepP = *path;
558 char *closeIndex = NULL;
559 Resource t1 = r;
560 Resource t2;
561 int32_t indexR = 0;
562 UResType type = (UResType)RES_GET_TYPE(t1);
563
564 /* if you come in with an empty path, you'll be getting back the same resource */
565 if(!uprv_strlen(pathP)) {
566 return r;
567 }
568
569 /* one needs to have an aggregate resource in order to search in it */
570 if(!URES_IS_CONTAINER(type)) {
571 return RES_BOGUS;
572 }
573
574 while(nextSepP && *pathP && t1 != RES_BOGUS && URES_IS_CONTAINER(type)) {
575 /* Iteration stops if: the path has been consumed, we found a non-existing
576 * resource (t1 == RES_BOGUS) or we found a scalar resource (including alias)
577 */
578 nextSepP = uprv_strchr(pathP, RES_PATH_SEPARATOR);
579 /* if there are more separators, terminate string
580 * and set path to the remaining part of the string
581 */
582 if(nextSepP != NULL) {
583 *nextSepP = 0; /* overwrite the separator with a NUL to terminate the key */
584 *path = nextSepP+1;
585 } else {
586 *path = uprv_strchr(pathP, 0);
587 }
588
589 /* if the resource is a table */
590 /* try the key based access */
591 if(URES_IS_TABLE(type)) {
592 *key = pathP;
593 t2 = res_getTableItemByKey(pResData, t1, &indexR, key);
594 if(t2 == RES_BOGUS) {
595 /* if we fail to get the resource by key, maybe we got an index */
596 indexR = uprv_strtol(pathP, &closeIndex, 10);
597 if(closeIndex != pathP) {
598 /* if we indeed have an index, try to get the item by index */
599 t2 = res_getTableItemByIndex(pResData, t1, indexR, key);
600 }
601 }
602 } else if(URES_IS_ARRAY(type)) {
603 indexR = uprv_strtol(pathP, &closeIndex, 10);
604 if(closeIndex != pathP) {
605 t2 = res_getArrayItem(pResData, t1, indexR);
606 } else {
607 t2 = RES_BOGUS; /* have an array, but don't have a valid index */
608 }
609 *key = NULL;
610 } else { /* can't do much here, except setting t2 to bogus */
611 t2 = RES_BOGUS;
612 }
613 t1 = t2;
614 type = (UResType)RES_GET_TYPE(t1);
615 /* position pathP to next resource key/index */
616 pathP = *path;
617 }
618
619 return t1;
620 }
621
622 /* resource bundle swapping ------------------------------------------------- */
623
624 /*
625 * Need to always enumerate the entire item tree,
626 * track the lowest address of any item to use as the limit for char keys[],
627 * track the highest address of any item to return the size of the data.
628 *
629 * We should have thought of storing those in the data...
630 * It is possible to extend the data structure by putting additional values
631 * in places that are inaccessible by ordinary enumeration of the item tree.
632 * For example, additional integers could be stored at the beginning or
633 * end of the key strings; this could be indicated by a minor version number,
634 * and the data swapping would have to know about these values.
635 *
636 * The data structure does not forbid keys to be shared, so we must swap
637 * all keys once instead of each key when it is referenced.
638 *
639 * These swapping functions assume that a resource bundle always has a length
640 * that is a multiple of 4 bytes.
641 * Currently, this is trivially true because genrb writes bundle tree leaves
642 * physically first, before their branches, so that the root table with its
643 * array of resource items (uint32_t values) is always last.
644 */
645
646 /* definitions for table sorting ------------------------ */
647
648 /*
649 * row of a temporary array
650 *
651 * gets platform-endian key string indexes and sorting indexes;
652 * after sorting this array by keys, the actual key/value arrays are permutated
653 * according to the sorting indexes
654 */
655 typedef struct Row {
656 int32_t keyIndex, sortIndex;
657 } Row;
658
659 static int32_t
660 ures_compareRows(const void *context, const void *left, const void *right) {
661 const char *keyChars=(const char *)context;
662 return (int32_t)uprv_strcmp(keyChars+((const Row *)left)->keyIndex,
663 keyChars+((const Row *)right)->keyIndex);
664 }
665
666 typedef struct TempTable {
667 const char *keyChars;
668 Row *rows;
669 int32_t *resort;
670 uint32_t *resFlags;
671 int32_t localKeyLimit;
672 uint8_t majorFormatVersion;
673 } TempTable;
674
675 enum {
676 STACK_ROW_CAPACITY=200
677 };
678
679 /* The table item key string is not locally available. */
680 static const char *const gUnknownKey="";
681
682 /* resource table key for collation binaries: "%%CollationBin" */
683 static const UChar gCollationBinKey[]={
684 0x25, 0x25,
685 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
686 0x42, 0x69, 0x6e,
687 0
688 };
689
690 /*
691 * swap one resource item
692 */
693 static void
694 ures_swapResource(const UDataSwapper *ds,
695 const Resource *inBundle, Resource *outBundle,
696 Resource res, /* caller swaps res itself */
697 const char *key,
698 TempTable *pTempTable,
699 UErrorCode *pErrorCode) {
700 const Resource *p;
701 Resource *q;
702 int32_t offset, count;
703
704 switch(RES_GET_TYPE(res)) {
705 case URES_TABLE16:
706 case URES_STRING_V2:
707 case URES_INT:
708 case URES_ARRAY16:
709 /* integer, or points to 16-bit units, nothing to do here */
710 return;
711 default:
712 break;
713 }
714
715 /* all other types use an offset to point to their data */
716 offset=(int32_t)RES_GET_OFFSET(res);
717 if(offset==0) {
718 /* special offset indicating an empty item */
719 return;
720 }
721 if(pTempTable->resFlags[offset>>5]&((uint32_t)1<<(offset&0x1f))) {
722 /* we already swapped this resource item */
723 return;
724 } else {
725 /* mark it as swapped now */
726 pTempTable->resFlags[offset>>5]|=((uint32_t)1<<(offset&0x1f));
727 }
728
729 p=inBundle+offset;
730 q=outBundle+offset;
731
732 switch(RES_GET_TYPE(res)) {
733 case URES_ALIAS:
734 /* physically same value layout as string, fall through */
735 case URES_STRING:
736 count=udata_readInt32(ds, (int32_t)*p);
737 /* swap length */
738 ds->swapArray32(ds, p, 4, q, pErrorCode);
739 /* swap each UChar (the terminating NUL would not change) */
740 ds->swapArray16(ds, p+1, 2*count, q+1, pErrorCode);
741 break;
742 case URES_BINARY:
743 count=udata_readInt32(ds, (int32_t)*p);
744 /* swap length */
745 ds->swapArray32(ds, p, 4, q, pErrorCode);
746 /* no need to swap or copy bytes - ures_swap() copied them all */
747
748 /* swap known formats */
749 #if !UCONFIG_NO_COLLATION
750 if( key!=NULL && /* the binary is in a table */
751 (key!=gUnknownKey ?
752 /* its table key string is "%%CollationBin" */
753 0==ds->compareInvChars(ds, key, -1,
754 gCollationBinKey, LENGTHOF(gCollationBinKey)-1) :
755 /* its table key string is unknown but it looks like a collation binary */
756 ucol_looksLikeCollationBinary(ds, p+1, count))
757 ) {
758 ucol_swapBinary(ds, p+1, count, q+1, pErrorCode);
759 }
760 #endif
761 break;
762 case URES_TABLE:
763 case URES_TABLE32:
764 {
765 const uint16_t *pKey16;
766 uint16_t *qKey16;
767
768 const int32_t *pKey32;
769 int32_t *qKey32;
770
771 Resource item;
772 int32_t i, oldIndex;
773
774 if(RES_GET_TYPE(res)==URES_TABLE) {
775 /* get table item count */
776 pKey16=(const uint16_t *)p;
777 qKey16=(uint16_t *)q;
778 count=ds->readUInt16(*pKey16);
779
780 pKey32=qKey32=NULL;
781
782 /* swap count */
783 ds->swapArray16(ds, pKey16++, 2, qKey16++, pErrorCode);
784
785 offset+=((1+count)+1)/2;
786 } else {
787 /* get table item count */
788 pKey32=(const int32_t *)p;
789 qKey32=(int32_t *)q;
790 count=udata_readInt32(ds, *pKey32);
791
792 pKey16=qKey16=NULL;
793
794 /* swap count */
795 ds->swapArray32(ds, pKey32++, 4, qKey32++, pErrorCode);
796
797 offset+=1+count;
798 }
799
800 if(count==0) {
801 break;
802 }
803
804 p=inBundle+offset; /* pointer to table resources */
805 q=outBundle+offset;
806
807 /* recurse */
808 for(i=0; i<count; ++i) {
809 const char *itemKey=gUnknownKey;
810 if(pKey16!=NULL) {
811 int32_t keyOffset=ds->readUInt16(pKey16[i]);
812 if(keyOffset<pTempTable->localKeyLimit) {
813 itemKey=(const char *)outBundle+keyOffset;
814 }
815 } else {
816 int32_t keyOffset=udata_readInt32(ds, pKey32[i]);
817 if(keyOffset>=0) {
818 itemKey=(const char *)outBundle+keyOffset;
819 }
820 }
821 item=ds->readUInt32(p[i]);
822 ures_swapResource(ds, inBundle, outBundle, item, itemKey, pTempTable, pErrorCode);
823 if(U_FAILURE(*pErrorCode)) {
824 udata_printError(ds, "ures_swapResource(table res=%08x)[%d].recurse(%08x) failed\n",
825 res, i, item);
826 return;
827 }
828 }
829
830 if(pTempTable->majorFormatVersion>1 || ds->inCharset==ds->outCharset) {
831 /* no need to sort, just swap the offset/value arrays */
832 if(pKey16!=NULL) {
833 ds->swapArray16(ds, pKey16, count*2, qKey16, pErrorCode);
834 ds->swapArray32(ds, p, count*4, q, pErrorCode);
835 } else {
836 /* swap key offsets and items as one array */
837 ds->swapArray32(ds, pKey32, count*2*4, qKey32, pErrorCode);
838 }
839 break;
840 }
841
842 /*
843 * We need to sort tables by outCharset key strings because they
844 * sort differently for different charset families.
845 * ures_swap() already set pTempTable->keyChars appropriately.
846 * First we set up a temporary table with the key indexes and
847 * sorting indexes and sort that.
848 * Then we permutate and copy/swap the actual values.
849 */
850 if(pKey16!=NULL) {
851 for(i=0; i<count; ++i) {
852 pTempTable->rows[i].keyIndex=ds->readUInt16(pKey16[i]);
853 pTempTable->rows[i].sortIndex=i;
854 }
855 } else {
856 for(i=0; i<count; ++i) {
857 pTempTable->rows[i].keyIndex=udata_readInt32(ds, pKey32[i]);
858 pTempTable->rows[i].sortIndex=i;
859 }
860 }
861 uprv_sortArray(pTempTable->rows, count, sizeof(Row),
862 ures_compareRows, pTempTable->keyChars,
863 FALSE, pErrorCode);
864 if(U_FAILURE(*pErrorCode)) {
865 udata_printError(ds, "ures_swapResource(table res=%08x).uprv_sortArray(%d items) failed\n",
866 res, count);
867 return;
868 }
869
870 /*
871 * copy/swap/permutate items
872 *
873 * If we swap in-place, then the permutation must use another
874 * temporary array (pTempTable->resort)
875 * before the results are copied to the outBundle.
876 */
877 /* keys */
878 if(pKey16!=NULL) {
879 uint16_t *rKey16;
880
881 if(pKey16!=qKey16) {
882 rKey16=qKey16;
883 } else {
884 rKey16=(uint16_t *)pTempTable->resort;
885 }
886 for(i=0; i<count; ++i) {
887 oldIndex=pTempTable->rows[i].sortIndex;
888 ds->swapArray16(ds, pKey16+oldIndex, 2, rKey16+i, pErrorCode);
889 }
890 if(qKey16!=rKey16) {
891 uprv_memcpy(qKey16, rKey16, 2*count);
892 }
893 } else {
894 int32_t *rKey32;
895
896 if(pKey32!=qKey32) {
897 rKey32=qKey32;
898 } else {
899 rKey32=pTempTable->resort;
900 }
901 for(i=0; i<count; ++i) {
902 oldIndex=pTempTable->rows[i].sortIndex;
903 ds->swapArray32(ds, pKey32+oldIndex, 4, rKey32+i, pErrorCode);
904 }
905 if(qKey32!=rKey32) {
906 uprv_memcpy(qKey32, rKey32, 4*count);
907 }
908 }
909
910 /* resources */
911 {
912 Resource *r;
913
914
915 if(p!=q) {
916 r=q;
917 } else {
918 r=(Resource *)pTempTable->resort;
919 }
920 for(i=0; i<count; ++i) {
921 oldIndex=pTempTable->rows[i].sortIndex;
922 ds->swapArray32(ds, p+oldIndex, 4, r+i, pErrorCode);
923 }
924 if(q!=r) {
925 uprv_memcpy(q, r, 4*count);
926 }
927 }
928 }
929 break;
930 case URES_ARRAY:
931 {
932 Resource item;
933 int32_t i;
934
935 count=udata_readInt32(ds, (int32_t)*p);
936 /* swap length */
937 ds->swapArray32(ds, p++, 4, q++, pErrorCode);
938
939 /* recurse */
940 for(i=0; i<count; ++i) {
941 item=ds->readUInt32(p[i]);
942 ures_swapResource(ds, inBundle, outBundle, item, NULL, pTempTable, pErrorCode);
943 if(U_FAILURE(*pErrorCode)) {
944 udata_printError(ds, "ures_swapResource(array res=%08x)[%d].recurse(%08x) failed\n",
945 res, i, item);
946 return;
947 }
948 }
949
950 /* swap items */
951 ds->swapArray32(ds, p, 4*count, q, pErrorCode);
952 }
953 break;
954 case URES_INT_VECTOR:
955 count=udata_readInt32(ds, (int32_t)*p);
956 /* swap length and each integer */
957 ds->swapArray32(ds, p, 4*(1+count), q, pErrorCode);
958 break;
959 default:
960 /* also catches RES_BOGUS */
961 *pErrorCode=U_UNSUPPORTED_ERROR;
962 break;
963 }
964 }
965
966 U_CAPI int32_t U_EXPORT2
967 ures_swap(const UDataSwapper *ds,
968 const void *inData, int32_t length, void *outData,
969 UErrorCode *pErrorCode) {
970 const UDataInfo *pInfo;
971 const Resource *inBundle;
972 Resource rootRes;
973 int32_t headerSize, maxTableLength;
974
975 Row rows[STACK_ROW_CAPACITY];
976 int32_t resort[STACK_ROW_CAPACITY];
977 TempTable tempTable;
978
979 const int32_t *inIndexes;
980
981 /* the following integers count Resource item offsets (4 bytes each), not bytes */
982 int32_t bundleLength, indexLength, keysBottom, keysTop, resBottom, top;
983
984 /* udata_swapDataHeader checks the arguments */
985 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
986 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
987 return 0;
988 }
989
990 /* check data format and format version */
991 pInfo=(const UDataInfo *)((const char *)inData+4);
992 if(!(
993 pInfo->dataFormat[0]==0x52 && /* dataFormat="ResB" */
994 pInfo->dataFormat[1]==0x65 &&
995 pInfo->dataFormat[2]==0x73 &&
996 pInfo->dataFormat[3]==0x42 &&
997 ((pInfo->formatVersion[0]==1 && pInfo->formatVersion[1]>=1) || /* formatVersion 1.1+ or 2.x */
998 pInfo->formatVersion[0]==2)
999 )) {
1000 udata_printError(ds, "ures_swap(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not a resource bundle\n",
1001 pInfo->dataFormat[0], pInfo->dataFormat[1],
1002 pInfo->dataFormat[2], pInfo->dataFormat[3],
1003 pInfo->formatVersion[0], pInfo->formatVersion[1]);
1004 *pErrorCode=U_UNSUPPORTED_ERROR;
1005 return 0;
1006 }
1007 tempTable.majorFormatVersion=pInfo->formatVersion[0];
1008
1009 /* a resource bundle must contain at least one resource item */
1010 if(length<0) {
1011 bundleLength=-1;
1012 } else {
1013 bundleLength=(length-headerSize)/4;
1014
1015 /* formatVersion 1.1 must have a root item and at least 5 indexes */
1016 if(bundleLength<(1+5)) {
1017 udata_printError(ds, "ures_swap(): too few bytes (%d after header) for a resource bundle\n",
1018 length-headerSize);
1019 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1020 return 0;
1021 }
1022 }
1023
1024 inBundle=(const Resource *)((const char *)inData+headerSize);
1025 rootRes=ds->readUInt32(*inBundle);
1026
1027 /* formatVersion 1.1 adds the indexes[] array */
1028 inIndexes=(const int32_t *)(inBundle+1);
1029
1030 indexLength=udata_readInt32(ds, inIndexes[URES_INDEX_LENGTH])&0xff;
1031 if(indexLength<=URES_INDEX_MAX_TABLE_LENGTH) {
1032 udata_printError(ds, "ures_swap(): too few indexes for a 1.1+ resource bundle\n");
1033 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1034 return 0;
1035 }
1036 keysBottom=1+indexLength;
1037 keysTop=udata_readInt32(ds, inIndexes[URES_INDEX_KEYS_TOP]);
1038 if(indexLength>URES_INDEX_16BIT_TOP) {
1039 resBottom=udata_readInt32(ds, inIndexes[URES_INDEX_16BIT_TOP]);
1040 } else {
1041 resBottom=keysTop;
1042 }
1043 top=udata_readInt32(ds, inIndexes[URES_INDEX_BUNDLE_TOP]);
1044 maxTableLength=udata_readInt32(ds, inIndexes[URES_INDEX_MAX_TABLE_LENGTH]);
1045
1046 if(0<=bundleLength && bundleLength<top) {
1047 udata_printError(ds, "ures_swap(): resource top %d exceeds bundle length %d\n",
1048 top, bundleLength);
1049 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1050 return 0;
1051 }
1052 if(keysTop>(1+indexLength)) {
1053 tempTable.localKeyLimit=keysTop<<2;
1054 } else {
1055 tempTable.localKeyLimit=0;
1056 }
1057
1058 if(length>=0) {
1059 Resource *outBundle=(Resource *)((char *)outData+headerSize);
1060
1061 /* track which resources we have already swapped */
1062 uint32_t stackResFlags[STACK_ROW_CAPACITY];
1063 int32_t resFlagsLength;
1064
1065 /*
1066 * We need one bit per 4 resource bundle bytes so that we can track
1067 * every possible Resource for whether we have swapped it already.
1068 * Multiple Resource words can refer to the same bundle offsets
1069 * for sharing identical values.
1070 * We could optimize this by allocating only for locations above
1071 * where Resource values are stored (above keys & strings).
1072 */
1073 resFlagsLength=(length+31)>>5; /* number of bytes needed */
1074 resFlagsLength=(resFlagsLength+3)&~3; /* multiple of 4 bytes for uint32_t */
1075 if(resFlagsLength<=sizeof(stackResFlags)) {
1076 tempTable.resFlags=stackResFlags;
1077 } else {
1078 tempTable.resFlags=(uint32_t *)uprv_malloc(resFlagsLength);
1079 if(tempTable.resFlags==NULL) {
1080 udata_printError(ds, "ures_swap(): unable to allocate memory for tracking resources\n");
1081 *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
1082 return 0;
1083 }
1084 }
1085 uprv_memset(tempTable.resFlags, 0, resFlagsLength);
1086
1087 /* copy the bundle for binary and inaccessible data */
1088 if(inData!=outData) {
1089 uprv_memcpy(outBundle, inBundle, 4*top);
1090 }
1091
1092 /* swap the key strings, but not the padding bytes (0xaa) after the last string and its NUL */
1093 udata_swapInvStringBlock(ds, inBundle+keysBottom, 4*(keysTop-keysBottom),
1094 outBundle+keysBottom, pErrorCode);
1095 if(U_FAILURE(*pErrorCode)) {
1096 udata_printError(ds, "ures_swap().udata_swapInvStringBlock(keys[%d]) failed\n", 4*(keysTop-keysBottom));
1097 return 0;
1098 }
1099
1100 /* swap the 16-bit units (strings, table16, array16) */
1101 if(keysTop<resBottom) {
1102 ds->swapArray16(ds, inBundle+keysTop, (resBottom-keysTop)*4, outBundle+keysTop, pErrorCode);
1103 if(U_FAILURE(*pErrorCode)) {
1104 udata_printError(ds, "ures_swap().swapArray16(16-bit units[%d]) failed\n", 2*(resBottom-keysTop));
1105 return 0;
1106 }
1107 }
1108
1109 /* allocate the temporary table for sorting resource tables */
1110 tempTable.keyChars=(const char *)outBundle; /* sort by outCharset */
1111 if(tempTable.majorFormatVersion>1 || maxTableLength<=STACK_ROW_CAPACITY) {
1112 tempTable.rows=rows;
1113 tempTable.resort=resort;
1114 } else {
1115 tempTable.rows=(Row *)uprv_malloc(maxTableLength*sizeof(Row)+maxTableLength*4);
1116 if(tempTable.rows==NULL) {
1117 udata_printError(ds, "ures_swap(): unable to allocate memory for sorting tables (max length: %d)\n",
1118 maxTableLength);
1119 *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
1120 if(tempTable.resFlags!=stackResFlags) {
1121 uprv_free(tempTable.resFlags);
1122 }
1123 return 0;
1124 }
1125 tempTable.resort=(int32_t *)(tempTable.rows+maxTableLength);
1126 }
1127
1128 /* swap the resources */
1129 ures_swapResource(ds, inBundle, outBundle, rootRes, NULL, &tempTable, pErrorCode);
1130 if(U_FAILURE(*pErrorCode)) {
1131 udata_printError(ds, "ures_swapResource(root res=%08x) failed\n",
1132 rootRes);
1133 }
1134
1135 if(tempTable.rows!=rows) {
1136 uprv_free(tempTable.rows);
1137 }
1138 if(tempTable.resFlags!=stackResFlags) {
1139 uprv_free(tempTable.resFlags);
1140 }
1141
1142 /* swap the root resource and indexes */
1143 ds->swapArray32(ds, inBundle, keysBottom*4, outBundle, pErrorCode);
1144 }
1145
1146 return headerSize+4*top;
1147 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial