The Tor Browser / file comparison

comparison: intl/icu/source/tools/genrb/reslist.c

intl/icu/source/tools/genrb/reslist.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:eec404a642b0
1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 2000-2012, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 *
9 * File reslist.c
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 02/21/00 weiv Creation.
15 *******************************************************************************
16 */
17
18 #include <assert.h>
19 #include <stdio.h>
20 #include "reslist.h"
21 #include "unewdata.h"
22 #include "unicode/ures.h"
23 #include "unicode/putil.h"
24 #include "errmsg.h"
25
26 #include "uarrsort.h"
27 #include "uelement.h"
28 #include "uinvchar.h"
29 #include "ustr_imp.h"
30 #include "unicode/utf16.h"
31 /*
32 * Align binary data at a 16-byte offset from the start of the resource bundle,
33 * to be safe for any data type it may contain.
34 */
35 #define BIN_ALIGNMENT 16
36
37 static UBool gIncludeCopyright = FALSE;
38 static UBool gUsePoolBundle = FALSE;
39 static int32_t gFormatVersion = 2;
40
41 static UChar gEmptyString = 0;
42
43 /* How do we store string values? */
44 enum {
45 STRINGS_UTF16_V1, /* formatVersion 1: int length + UChars + NUL + padding to 4 bytes */
46 STRINGS_UTF16_V2 /* formatVersion 2: optional length in 1..3 UChars + UChars + NUL */
47 };
48
49 enum {
50 MAX_IMPLICIT_STRING_LENGTH = 40 /* do not store the length explicitly for such strings */
51 };
52
53 /*
54 * res_none() returns the address of kNoResource,
55 * for use in non-error cases when no resource is to be added to the bundle.
56 * (NULL is used in error cases.)
57 */
58 static const struct SResource kNoResource = { URES_NONE };
59
60 static UDataInfo dataInfo= {
61 sizeof(UDataInfo),
62 0,
63
64 U_IS_BIG_ENDIAN,
65 U_CHARSET_FAMILY,
66 sizeof(UChar),
67 0,
68
69 {0x52, 0x65, 0x73, 0x42}, /* dataFormat="ResB" */
70 {1, 3, 0, 0}, /* formatVersion */
71 {1, 4, 0, 0} /* dataVersion take a look at version inside parsed resb*/
72 };
73
74 static const UVersionInfo gFormatVersions[3] = { /* indexed by a major-formatVersion integer */
75 { 0, 0, 0, 0 },
76 { 1, 3, 0, 0 },
77 { 2, 0, 0, 0 }
78 };
79
80 static uint8_t calcPadding(uint32_t size) {
81 /* returns space we need to pad */
82 return (uint8_t) ((size % sizeof(uint32_t)) ? (sizeof(uint32_t) - (size % sizeof(uint32_t))) : 0);
83
84 }
85
86 void setIncludeCopyright(UBool val){
87 gIncludeCopyright=val;
88 }
89
90 UBool getIncludeCopyright(void){
91 return gIncludeCopyright;
92 }
93
94 void setFormatVersion(int32_t formatVersion) {
95 gFormatVersion = formatVersion;
96 }
97
98 void setUsePoolBundle(UBool use) {
99 gUsePoolBundle = use;
100 }
101
102 static void
103 bundle_compactStrings(struct SRBRoot *bundle, UErrorCode *status);
104
105 /* Writing Functions */
106
107 /*
108 * type_write16() functions write resource values into f16BitUnits
109 * and determine the resource item word, if possible.
110 */
111 static void
112 res_write16(struct SRBRoot *bundle, struct SResource *res,
113 UErrorCode *status);
114
115 /*
116 * type_preWrite() functions calculate ("preflight") and advance the *byteOffset
117 * by the size of their data in the binary file and
118 * determine the resource item word.
119 * Most type_preWrite() functions may add any number of bytes, but res_preWrite()
120 * will always pad it to a multiple of 4.
121 * The resource item type may be a related subtype of the fType.
122 *
123 * The type_preWrite() and type_write() functions start and end at the same
124 * byteOffset values.
125 * Prewriting allows bundle_write() to determine the root resource item word,
126 * before actually writing the bundle contents to the file,
127 * which is necessary because the root item is stored at the beginning.
128 */
129 static void
130 res_preWrite(uint32_t *byteOffset,
131 struct SRBRoot *bundle, struct SResource *res,
132 UErrorCode *status);
133
134 /*
135 * type_write() functions write their data to mem and update the byteOffset
136 * in parallel.
137 * (A kingdom for C++ and polymorphism...)
138 */
139 static void
140 res_write(UNewDataMemory *mem, uint32_t *byteOffset,
141 struct SRBRoot *bundle, struct SResource *res,
142 UErrorCode *status);
143
144 static uint16_t *
145 reserve16BitUnits(struct SRBRoot *bundle, int32_t length, UErrorCode *status) {
146 if (U_FAILURE(*status)) {
147 return NULL;
148 }
149 if ((bundle->f16BitUnitsLength + length) > bundle->f16BitUnitsCapacity) {
150 uint16_t *newUnits;
151 int32_t capacity = 2 * bundle->f16BitUnitsCapacity + length + 1024;
152 capacity &= ~1; /* ensures padding fits if f16BitUnitsLength needs it */
153 newUnits = (uint16_t *)uprv_malloc(capacity * 2);
154 if (newUnits == NULL) {
155 *status = U_MEMORY_ALLOCATION_ERROR;
156 return NULL;
157 }
158 if (bundle->f16BitUnitsLength > 0) {
159 uprv_memcpy(newUnits, bundle->f16BitUnits, bundle->f16BitUnitsLength * 2);
160 } else {
161 newUnits[0] = 0;
162 bundle->f16BitUnitsLength = 1;
163 }
164 uprv_free(bundle->f16BitUnits);
165 bundle->f16BitUnits = newUnits;
166 bundle->f16BitUnitsCapacity = capacity;
167 }
168 return bundle->f16BitUnits + bundle->f16BitUnitsLength;
169 }
170
171 static int32_t
172 makeRes16(uint32_t resWord) {
173 uint32_t type, offset;
174 if (resWord == 0) {
175 return 0; /* empty string */
176 }
177 type = RES_GET_TYPE(resWord);
178 offset = RES_GET_OFFSET(resWord);
179 if (type == URES_STRING_V2 && offset <= 0xffff) {
180 return (int32_t)offset;
181 }
182 return -1;
183 }
184
185 static int32_t
186 mapKey(struct SRBRoot *bundle, int32_t oldpos) {
187 const KeyMapEntry *map = bundle->fKeyMap;
188 int32_t i, start, limit;
189
190 /* do a binary search for the old, pre-bundle_compactKeys() key offset */
191 start = bundle->fPoolBundleKeysCount;
192 limit = start + bundle->fKeysCount;
193 while (start < limit - 1) {
194 i = (start + limit) / 2;
195 if (oldpos < map[i].oldpos) {
196 limit = i;
197 } else {
198 start = i;
199 }
200 }
201 assert(oldpos == map[start].oldpos);
202 return map[start].newpos;
203 }
204
205 static uint16_t
206 makeKey16(struct SRBRoot *bundle, int32_t key) {
207 if (key >= 0) {
208 return (uint16_t)key;
209 } else {
210 return (uint16_t)(key + bundle->fLocalKeyLimit); /* offset in the pool bundle */
211 }
212 }
213
214 /*
215 * Only called for UTF-16 v1 strings and duplicate UTF-16 v2 strings.
216 * For unique UTF-16 v2 strings, res_write16() sees fRes != RES_BOGUS
217 * and exits early.
218 */
219 static void
220 string_write16(struct SRBRoot *bundle, struct SResource *res, UErrorCode *status) {
221 struct SResource *same;
222 if ((same = res->u.fString.fSame) != NULL) {
223 /* This is a duplicate. */
224 if (same->fRes == RES_BOGUS) {
225 /* The original has not been visited yet. */
226 string_write16(bundle, same, status);
227 }
228 res->fRes = same->fRes;
229 res->fWritten = same->fWritten;
230 }
231 }
232
233 static void
234 array_write16(struct SRBRoot *bundle, struct SResource *res,
235 UErrorCode *status) {
236 struct SResource *current;
237 int32_t res16 = 0;
238
239 if (U_FAILURE(*status)) {
240 return;
241 }
242 if (res->u.fArray.fCount == 0 && gFormatVersion > 1) {
243 res->fRes = URES_MAKE_EMPTY_RESOURCE(URES_ARRAY);
244 res->fWritten = TRUE;
245 return;
246 }
247 for (current = res->u.fArray.fFirst; current != NULL; current = current->fNext) {
248 res_write16(bundle, current, status);
249 res16 |= makeRes16(current->fRes);
250 }
251 if (U_SUCCESS(*status) && res->u.fArray.fCount <= 0xffff && res16 >= 0 && gFormatVersion > 1) {
252 uint16_t *p16 = reserve16BitUnits(bundle, 1 + res->u.fArray.fCount, status);
253 if (U_SUCCESS(*status)) {
254 res->fRes = URES_MAKE_RESOURCE(URES_ARRAY16, bundle->f16BitUnitsLength);
255 *p16++ = (uint16_t)res->u.fArray.fCount;
256 for (current = res->u.fArray.fFirst; current != NULL; current = current->fNext) {
257 *p16++ = (uint16_t)makeRes16(current->fRes);
258 }
259 bundle->f16BitUnitsLength += 1 + res->u.fArray.fCount;
260 res->fWritten = TRUE;
261 }
262 }
263 }
264
265 static void
266 table_write16(struct SRBRoot *bundle, struct SResource *res,
267 UErrorCode *status) {
268 struct SResource *current;
269 int32_t maxKey = 0, maxPoolKey = 0x80000000;
270 int32_t res16 = 0;
271 UBool hasLocalKeys = FALSE, hasPoolKeys = FALSE;
272
273 if (U_FAILURE(*status)) {
274 return;
275 }
276 if (res->u.fTable.fCount == 0 && gFormatVersion > 1) {
277 res->fRes = URES_MAKE_EMPTY_RESOURCE(URES_TABLE);
278 res->fWritten = TRUE;
279 return;
280 }
281 /* Find the smallest table type that fits the data. */
282 for (current = res->u.fTable.fFirst; current != NULL; current = current->fNext) {
283 int32_t key;
284 res_write16(bundle, current, status);
285 if (bundle->fKeyMap == NULL) {
286 key = current->fKey;
287 } else {
288 key = current->fKey = mapKey(bundle, current->fKey);
289 }
290 if (key >= 0) {
291 hasLocalKeys = TRUE;
292 if (key > maxKey) {
293 maxKey = key;
294 }
295 } else {
296 hasPoolKeys = TRUE;
297 if (key > maxPoolKey) {
298 maxPoolKey = key;
299 }
300 }
301 res16 |= makeRes16(current->fRes);
302 }
303 if (U_FAILURE(*status)) {
304 return;
305 }
306 if(res->u.fTable.fCount > (uint32_t)bundle->fMaxTableLength) {
307 bundle->fMaxTableLength = res->u.fTable.fCount;
308 }
309 maxPoolKey &= 0x7fffffff;
310 if (res->u.fTable.fCount <= 0xffff &&
311 (!hasLocalKeys || maxKey < bundle->fLocalKeyLimit) &&
312 (!hasPoolKeys || maxPoolKey < (0x10000 - bundle->fLocalKeyLimit))
313 ) {
314 if (res16 >= 0 && gFormatVersion > 1) {
315 uint16_t *p16 = reserve16BitUnits(bundle, 1 + res->u.fTable.fCount * 2, status);
316 if (U_SUCCESS(*status)) {
317 /* 16-bit count, key offsets and values */
318 res->fRes = URES_MAKE_RESOURCE(URES_TABLE16, bundle->f16BitUnitsLength);
319 *p16++ = (uint16_t)res->u.fTable.fCount;
320 for (current = res->u.fTable.fFirst; current != NULL; current = current->fNext) {
321 *p16++ = makeKey16(bundle, current->fKey);
322 }
323 for (current = res->u.fTable.fFirst; current != NULL; current = current->fNext) {
324 *p16++ = (uint16_t)makeRes16(current->fRes);
325 }
326 bundle->f16BitUnitsLength += 1 + res->u.fTable.fCount * 2;
327 res->fWritten = TRUE;
328 }
329 } else {
330 /* 16-bit count, 16-bit key offsets, 32-bit values */
331 res->u.fTable.fType = URES_TABLE;
332 }
333 } else {
334 /* 32-bit count, key offsets and values */
335 res->u.fTable.fType = URES_TABLE32;
336 }
337 }
338
339 static void
340 res_write16(struct SRBRoot *bundle, struct SResource *res,
341 UErrorCode *status) {
342 if (U_FAILURE(*status) || res == NULL) {
343 return;
344 }
345 if (res->fRes != RES_BOGUS) {
346 /*
347 * The resource item word was already precomputed, which means
348 * no further data needs to be written.
349 * This might be an integer, or an empty or UTF-16 v2 string,
350 * an empty binary, etc.
351 */
352 return;
353 }
354 switch (res->fType) {
355 case URES_STRING:
356 string_write16(bundle, res, status);
357 break;
358 case URES_ARRAY:
359 array_write16(bundle, res, status);
360 break;
361 case URES_TABLE:
362 table_write16(bundle, res, status);
363 break;
364 default:
365 /* Only a few resource types write 16-bit units. */
366 break;
367 }
368 }
369
370 /*
371 * Only called for UTF-16 v1 strings.
372 * For UTF-16 v2 strings, res_preWrite() sees fRes != RES_BOGUS
373 * and exits early.
374 */
375 static void
376 string_preWrite(uint32_t *byteOffset,
377 struct SRBRoot *bundle, struct SResource *res,
378 UErrorCode *status) {
379 /* Write the UTF-16 v1 string. */
380 res->fRes = URES_MAKE_RESOURCE(URES_STRING, *byteOffset >> 2);
381 *byteOffset += 4 + (res->u.fString.fLength + 1) * U_SIZEOF_UCHAR;
382 }
383
384 static void
385 bin_preWrite(uint32_t *byteOffset,
386 struct SRBRoot *bundle, struct SResource *res,
387 UErrorCode *status) {
388 uint32_t pad = 0;
389 uint32_t dataStart = *byteOffset + sizeof(res->u.fBinaryValue.fLength);
390
391 if (dataStart % BIN_ALIGNMENT) {
392 pad = (BIN_ALIGNMENT - dataStart % BIN_ALIGNMENT);
393 *byteOffset += pad; /* pad == 4 or 8 or 12 */
394 }
395 res->fRes = URES_MAKE_RESOURCE(URES_BINARY, *byteOffset >> 2);
396 *byteOffset += 4 + res->u.fBinaryValue.fLength;
397 }
398
399 static void
400 array_preWrite(uint32_t *byteOffset,
401 struct SRBRoot *bundle, struct SResource *res,
402 UErrorCode *status) {
403 struct SResource *current;
404
405 if (U_FAILURE(*status)) {
406 return;
407 }
408 for (current = res->u.fArray.fFirst; current != NULL; current = current->fNext) {
409 res_preWrite(byteOffset, bundle, current, status);
410 }
411 res->fRes = URES_MAKE_RESOURCE(URES_ARRAY, *byteOffset >> 2);
412 *byteOffset += (1 + res->u.fArray.fCount) * 4;
413 }
414
415 static void
416 table_preWrite(uint32_t *byteOffset,
417 struct SRBRoot *bundle, struct SResource *res,
418 UErrorCode *status) {
419 struct SResource *current;
420
421 if (U_FAILURE(*status)) {
422 return;
423 }
424 for (current = res->u.fTable.fFirst; current != NULL; current = current->fNext) {
425 res_preWrite(byteOffset, bundle, current, status);
426 }
427 if (res->u.fTable.fType == URES_TABLE) {
428 /* 16-bit count, 16-bit key offsets, 32-bit values */
429 res->fRes = URES_MAKE_RESOURCE(URES_TABLE, *byteOffset >> 2);
430 *byteOffset += 2 + res->u.fTable.fCount * 6;
431 } else {
432 /* 32-bit count, key offsets and values */
433 res->fRes = URES_MAKE_RESOURCE(URES_TABLE32, *byteOffset >> 2);
434 *byteOffset += 4 + res->u.fTable.fCount * 8;
435 }
436 }
437
438 static void
439 res_preWrite(uint32_t *byteOffset,
440 struct SRBRoot *bundle, struct SResource *res,
441 UErrorCode *status) {
442 if (U_FAILURE(*status) || res == NULL) {
443 return;
444 }
445 if (res->fRes != RES_BOGUS) {
446 /*
447 * The resource item word was already precomputed, which means
448 * no further data needs to be written.
449 * This might be an integer, or an empty or UTF-16 v2 string,
450 * an empty binary, etc.
451 */
452 return;
453 }
454 switch (res->fType) {
455 case URES_STRING:
456 string_preWrite(byteOffset, bundle, res, status);
457 break;
458 case URES_ALIAS:
459 res->fRes = URES_MAKE_RESOURCE(URES_ALIAS, *byteOffset >> 2);
460 *byteOffset += 4 + (res->u.fString.fLength + 1) * U_SIZEOF_UCHAR;
461 break;
462 case URES_INT_VECTOR:
463 if (res->u.fIntVector.fCount == 0 && gFormatVersion > 1) {
464 res->fRes = URES_MAKE_EMPTY_RESOURCE(URES_INT_VECTOR);
465 res->fWritten = TRUE;
466 } else {
467 res->fRes = URES_MAKE_RESOURCE(URES_INT_VECTOR, *byteOffset >> 2);
468 *byteOffset += (1 + res->u.fIntVector.fCount) * 4;
469 }
470 break;
471 case URES_BINARY:
472 bin_preWrite(byteOffset, bundle, res, status);
473 break;
474 case URES_INT:
475 break;
476 case URES_ARRAY:
477 array_preWrite(byteOffset, bundle, res, status);
478 break;
479 case URES_TABLE:
480 table_preWrite(byteOffset, bundle, res, status);
481 break;
482 default:
483 *status = U_INTERNAL_PROGRAM_ERROR;
484 break;
485 }
486 *byteOffset += calcPadding(*byteOffset);
487 }
488
489 /*
490 * Only called for UTF-16 v1 strings. For UTF-16 v2 strings,
491 * res_write() sees fWritten and exits early.
492 */
493 static void string_write(UNewDataMemory *mem, uint32_t *byteOffset,
494 struct SRBRoot *bundle, struct SResource *res,
495 UErrorCode *status) {
496 /* Write the UTF-16 v1 string. */
497 int32_t length = res->u.fString.fLength;
498 udata_write32(mem, length);
499 udata_writeUString(mem, res->u.fString.fChars, length + 1);
500 *byteOffset += 4 + (length + 1) * U_SIZEOF_UCHAR;
501 res->fWritten = TRUE;
502 }
503
504 static void alias_write(UNewDataMemory *mem, uint32_t *byteOffset,
505 struct SRBRoot *bundle, struct SResource *res,
506 UErrorCode *status) {
507 int32_t length = res->u.fString.fLength;
508 udata_write32(mem, length);
509 udata_writeUString(mem, res->u.fString.fChars, length + 1);
510 *byteOffset += 4 + (length + 1) * U_SIZEOF_UCHAR;
511 }
512
513 static void array_write(UNewDataMemory *mem, uint32_t *byteOffset,
514 struct SRBRoot *bundle, struct SResource *res,
515 UErrorCode *status) {
516 uint32_t i;
517
518 struct SResource *current = NULL;
519
520 if (U_FAILURE(*status)) {
521 return;
522 }
523 for (i = 0, current = res->u.fArray.fFirst; current != NULL; ++i, current = current->fNext) {
524 res_write(mem, byteOffset, bundle, current, status);
525 }
526 assert(i == res->u.fArray.fCount);
527
528 udata_write32(mem, res->u.fArray.fCount);
529 for (current = res->u.fArray.fFirst; current != NULL; current = current->fNext) {
530 udata_write32(mem, current->fRes);
531 }
532 *byteOffset += (1 + res->u.fArray.fCount) * 4;
533 }
534
535 static void intvector_write(UNewDataMemory *mem, uint32_t *byteOffset,
536 struct SRBRoot *bundle, struct SResource *res,
537 UErrorCode *status) {
538 uint32_t i = 0;
539 udata_write32(mem, res->u.fIntVector.fCount);
540 for(i = 0; i<res->u.fIntVector.fCount; i++) {
541 udata_write32(mem, res->u.fIntVector.fArray[i]);
542 }
543 *byteOffset += (1 + res->u.fIntVector.fCount) * 4;
544 }
545
546 static void bin_write(UNewDataMemory *mem, uint32_t *byteOffset,
547 struct SRBRoot *bundle, struct SResource *res,
548 UErrorCode *status) {
549 uint32_t pad = 0;
550 uint32_t dataStart = *byteOffset + sizeof(res->u.fBinaryValue.fLength);
551
552 if (dataStart % BIN_ALIGNMENT) {
553 pad = (BIN_ALIGNMENT - dataStart % BIN_ALIGNMENT);
554 udata_writePadding(mem, pad); /* pad == 4 or 8 or 12 */
555 *byteOffset += pad;
556 }
557
558 udata_write32(mem, res->u.fBinaryValue.fLength);
559 if (res->u.fBinaryValue.fLength > 0) {
560 udata_writeBlock(mem, res->u.fBinaryValue.fData, res->u.fBinaryValue.fLength);
561 }
562 *byteOffset += 4 + res->u.fBinaryValue.fLength;
563 }
564
565 static void table_write(UNewDataMemory *mem, uint32_t *byteOffset,
566 struct SRBRoot *bundle, struct SResource *res,
567 UErrorCode *status) {
568 struct SResource *current;
569 uint32_t i;
570
571 if (U_FAILURE(*status)) {
572 return;
573 }
574 for (i = 0, current = res->u.fTable.fFirst; current != NULL; ++i, current = current->fNext) {
575 assert(i < res->u.fTable.fCount);
576 res_write(mem, byteOffset, bundle, current, status);
577 }
578 assert(i == res->u.fTable.fCount);
579
580 if(res->u.fTable.fType == URES_TABLE) {
581 udata_write16(mem, (uint16_t)res->u.fTable.fCount);
582 for (current = res->u.fTable.fFirst; current != NULL; current = current->fNext) {
583 udata_write16(mem, makeKey16(bundle, current->fKey));
584 }
585 *byteOffset += (1 + res->u.fTable.fCount)* 2;
586 if ((res->u.fTable.fCount & 1) == 0) {
587 /* 16-bit count and even number of 16-bit key offsets need padding before 32-bit resource items */
588 udata_writePadding(mem, 2);
589 *byteOffset += 2;
590 }
591 } else /* URES_TABLE32 */ {
592 udata_write32(mem, res->u.fTable.fCount);
593 for (current = res->u.fTable.fFirst; current != NULL; current = current->fNext) {
594 udata_write32(mem, (uint32_t)current->fKey);
595 }
596 *byteOffset += (1 + res->u.fTable.fCount)* 4;
597 }
598 for (current = res->u.fTable.fFirst; current != NULL; current = current->fNext) {
599 udata_write32(mem, current->fRes);
600 }
601 *byteOffset += res->u.fTable.fCount * 4;
602 }
603
604 void res_write(UNewDataMemory *mem, uint32_t *byteOffset,
605 struct SRBRoot *bundle, struct SResource *res,
606 UErrorCode *status) {
607 uint8_t paddingSize;
608
609 if (U_FAILURE(*status) || res == NULL) {
610 return;
611 }
612 if (res->fWritten) {
613 assert(res->fRes != RES_BOGUS);
614 return;
615 }
616 switch (res->fType) {
617 case URES_STRING:
618 string_write (mem, byteOffset, bundle, res, status);
619 break;
620 case URES_ALIAS:
621 alias_write (mem, byteOffset, bundle, res, status);
622 break;
623 case URES_INT_VECTOR:
624 intvector_write (mem, byteOffset, bundle, res, status);
625 break;
626 case URES_BINARY:
627 bin_write (mem, byteOffset, bundle, res, status);
628 break;
629 case URES_INT:
630 break; /* fRes was set by int_open() */
631 case URES_ARRAY:
632 array_write (mem, byteOffset, bundle, res, status);
633 break;
634 case URES_TABLE:
635 table_write (mem, byteOffset, bundle, res, status);
636 break;
637 default:
638 *status = U_INTERNAL_PROGRAM_ERROR;
639 break;
640 }
641 paddingSize = calcPadding(*byteOffset);
642 if (paddingSize > 0) {
643 udata_writePadding(mem, paddingSize);
644 *byteOffset += paddingSize;
645 }
646 res->fWritten = TRUE;
647 }
648
649 void bundle_write(struct SRBRoot *bundle,
650 const char *outputDir, const char *outputPkg,
651 char *writtenFilename, int writtenFilenameLen,
652 UErrorCode *status) {
653 UNewDataMemory *mem = NULL;
654 uint32_t byteOffset = 0;
655 uint32_t top, size;
656 char dataName[1024];
657 int32_t indexes[URES_INDEX_TOP];
658
659 bundle_compactKeys(bundle, status);
660 /*
661 * Add padding bytes to fKeys so that fKeysTop is 4-aligned.
662 * Safe because the capacity is a multiple of 4.
663 */
664 while (bundle->fKeysTop & 3) {
665 bundle->fKeys[bundle->fKeysTop++] = (char)0xaa;
666 }
667 /*
668 * In URES_TABLE, use all local key offsets that fit into 16 bits,
669 * and use the remaining 16-bit offsets for pool key offsets
670 * if there are any.
671 * If there are no local keys, then use the whole 16-bit space
672 * for pool key offsets.
673 * Note: This cannot be changed without changing the major formatVersion.
674 */
675 if (bundle->fKeysBottom < bundle->fKeysTop) {
676 if (bundle->fKeysTop <= 0x10000) {
677 bundle->fLocalKeyLimit = bundle->fKeysTop;
678 } else {
679 bundle->fLocalKeyLimit = 0x10000;
680 }
681 } else {
682 bundle->fLocalKeyLimit = 0;
683 }
684
685 bundle_compactStrings(bundle, status);
686 res_write16(bundle, bundle->fRoot, status);
687 if (bundle->f16BitUnitsLength & 1) {
688 bundle->f16BitUnits[bundle->f16BitUnitsLength++] = 0xaaaa; /* pad to multiple of 4 bytes */
689 }
690 /* all keys have been mapped */
691 uprv_free(bundle->fKeyMap);
692 bundle->fKeyMap = NULL;
693
694 byteOffset = bundle->fKeysTop + bundle->f16BitUnitsLength * 2;
695 res_preWrite(&byteOffset, bundle, bundle->fRoot, status);
696
697 /* total size including the root item */
698 top = byteOffset;
699
700 if (U_FAILURE(*status)) {
701 return;
702 }
703
704 if (writtenFilename && writtenFilenameLen) {
705 *writtenFilename = 0;
706 }
707
708 if (writtenFilename) {
709 int32_t off = 0, len = 0;
710 if (outputDir) {
711 len = (int32_t)uprv_strlen(outputDir);
712 if (len > writtenFilenameLen) {
713 len = writtenFilenameLen;
714 }
715 uprv_strncpy(writtenFilename, outputDir, len);
716 }
717 if (writtenFilenameLen -= len) {
718 off += len;
719 writtenFilename[off] = U_FILE_SEP_CHAR;
720 if (--writtenFilenameLen) {
721 ++off;
722 if(outputPkg != NULL)
723 {
724 uprv_strcpy(writtenFilename+off, outputPkg);
725 off += (int32_t)uprv_strlen(outputPkg);
726 writtenFilename[off] = '_';
727 ++off;
728 }
729
730 len = (int32_t)uprv_strlen(bundle->fLocale);
731 if (len > writtenFilenameLen) {
732 len = writtenFilenameLen;
733 }
734 uprv_strncpy(writtenFilename + off, bundle->fLocale, len);
735 if (writtenFilenameLen -= len) {
736 off += len;
737 len = 5;
738 if (len > writtenFilenameLen) {
739 len = writtenFilenameLen;
740 }
741 uprv_strncpy(writtenFilename + off, ".res", len);
742 }
743 }
744 }
745 }
746
747 if(outputPkg)
748 {
749 uprv_strcpy(dataName, outputPkg);
750 uprv_strcat(dataName, "_");
751 uprv_strcat(dataName, bundle->fLocale);
752 }
753 else
754 {
755 uprv_strcpy(dataName, bundle->fLocale);
756 }
757
758 uprv_memcpy(dataInfo.formatVersion, gFormatVersions + gFormatVersion, sizeof(UVersionInfo));
759
760 mem = udata_create(outputDir, "res", dataName, &dataInfo, (gIncludeCopyright==TRUE)? U_COPYRIGHT_STRING:NULL, status);
761 if(U_FAILURE(*status)){
762 return;
763 }
764
765 /* write the root item */
766 udata_write32(mem, bundle->fRoot->fRes);
767
768 /*
769 * formatVersion 1.1 (ICU 2.8):
770 * write int32_t indexes[] after root and before the strings
771 * to make it easier to parse resource bundles in icuswap or from Java etc.
772 */
773 uprv_memset(indexes, 0, sizeof(indexes));
774 indexes[URES_INDEX_LENGTH]= bundle->fIndexLength;
775 indexes[URES_INDEX_KEYS_TOP]= bundle->fKeysTop>>2;
776 indexes[URES_INDEX_RESOURCES_TOP]= (int32_t)(top>>2);
777 indexes[URES_INDEX_BUNDLE_TOP]= indexes[URES_INDEX_RESOURCES_TOP];
778 indexes[URES_INDEX_MAX_TABLE_LENGTH]= bundle->fMaxTableLength;
779
780 /*
781 * formatVersion 1.2 (ICU 3.6):
782 * write indexes[URES_INDEX_ATTRIBUTES] with URES_ATT_NO_FALLBACK set or not set
783 * the memset() above initialized all indexes[] to 0
784 */
785 if (bundle->noFallback) {
786 indexes[URES_INDEX_ATTRIBUTES]=URES_ATT_NO_FALLBACK;
787 }
788 /*
789 * formatVersion 2.0 (ICU 4.4):
790 * more compact string value storage, optional pool bundle
791 */
792 if (URES_INDEX_16BIT_TOP < bundle->fIndexLength) {
793 indexes[URES_INDEX_16BIT_TOP] = (bundle->fKeysTop>>2) + (bundle->f16BitUnitsLength>>1);
794 }
795 if (URES_INDEX_POOL_CHECKSUM < bundle->fIndexLength) {
796 if (bundle->fIsPoolBundle) {
797 indexes[URES_INDEX_ATTRIBUTES] |= URES_ATT_IS_POOL_BUNDLE | URES_ATT_NO_FALLBACK;
798 indexes[URES_INDEX_POOL_CHECKSUM] =
799 (int32_t)computeCRC((char *)(bundle->fKeys + bundle->fKeysBottom),
800 (uint32_t)(bundle->fKeysTop - bundle->fKeysBottom),
801 0);
802 } else if (gUsePoolBundle) {
803 indexes[URES_INDEX_ATTRIBUTES] |= URES_ATT_USES_POOL_BUNDLE;
804 indexes[URES_INDEX_POOL_CHECKSUM] = bundle->fPoolChecksum;
805 }
806 }
807
808 /* write the indexes[] */
809 udata_writeBlock(mem, indexes, bundle->fIndexLength*4);
810
811 /* write the table key strings */
812 udata_writeBlock(mem, bundle->fKeys+bundle->fKeysBottom,
813 bundle->fKeysTop-bundle->fKeysBottom);
814
815 /* write the v2 UTF-16 strings, URES_TABLE16 and URES_ARRAY16 */
816 udata_writeBlock(mem, bundle->f16BitUnits, bundle->f16BitUnitsLength*2);
817
818 /* write all of the bundle contents: the root item and its children */
819 byteOffset = bundle->fKeysTop + bundle->f16BitUnitsLength * 2;
820 res_write(mem, &byteOffset, bundle, bundle->fRoot, status);
821 assert(byteOffset == top);
822
823 size = udata_finish(mem, status);
824 if(top != size) {
825 fprintf(stderr, "genrb error: wrote %u bytes but counted %u\n",
826 (int)size, (int)top);
827 *status = U_INTERNAL_PROGRAM_ERROR;
828 }
829 }
830
831 /* Opening Functions */
832
833 /* gcc 4.2 complained "no previous prototype for res_open" without this prototype... */
834 struct SResource* res_open(struct SRBRoot *bundle, const char *tag,
835 const struct UString* comment, UErrorCode* status);
836
837 struct SResource* res_open(struct SRBRoot *bundle, const char *tag,
838 const struct UString* comment, UErrorCode* status){
839 struct SResource *res;
840 int32_t key = bundle_addtag(bundle, tag, status);
841 if (U_FAILURE(*status)) {
842 return NULL;
843 }
844
845 res = (struct SResource *) uprv_malloc(sizeof(struct SResource));
846 if (res == NULL) {
847 *status = U_MEMORY_ALLOCATION_ERROR;
848 return NULL;
849 }
850 uprv_memset(res, 0, sizeof(struct SResource));
851 res->fKey = key;
852 res->fRes = RES_BOGUS;
853
854 ustr_init(&res->fComment);
855 if(comment != NULL){
856 ustr_cpy(&res->fComment, comment, status);
857 if (U_FAILURE(*status)) {
858 res_close(res);
859 return NULL;
860 }
861 }
862 return res;
863 }
864
865 struct SResource* res_none() {
866 return (struct SResource*)&kNoResource;
867 }
868
869 struct SResource* table_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status) {
870 struct SResource *res = res_open(bundle, tag, comment, status);
871 if (U_FAILURE(*status)) {
872 return NULL;
873 }
874 res->fType = URES_TABLE;
875 res->u.fTable.fRoot = bundle;
876 return res;
877 }
878
879 struct SResource* array_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status) {
880 struct SResource *res = res_open(bundle, tag, comment, status);
881 if (U_FAILURE(*status)) {
882 return NULL;
883 }
884 res->fType = URES_ARRAY;
885 return res;
886 }
887
888 static int32_t U_CALLCONV
889 string_hash(const UElement key) {
890 const struct SResource *res = (struct SResource *)key.pointer;
891 return ustr_hashUCharsN(res->u.fString.fChars, res->u.fString.fLength);
892 }
893
894 static UBool U_CALLCONV
895 string_comp(const UElement key1, const UElement key2) {
896 const struct SResource *res1 = (struct SResource *)key1.pointer;
897 const struct SResource *res2 = (struct SResource *)key2.pointer;
898 return 0 == u_strCompare(res1->u.fString.fChars, res1->u.fString.fLength,
899 res2->u.fString.fChars, res2->u.fString.fLength,
900 FALSE);
901 }
902
903 struct SResource *string_open(struct SRBRoot *bundle, const char *tag, const UChar *value, int32_t len, const struct UString* comment, UErrorCode *status) {
904 struct SResource *res = res_open(bundle, tag, comment, status);
905 if (U_FAILURE(*status)) {
906 return NULL;
907 }
908 res->fType = URES_STRING;
909
910 if (len == 0 && gFormatVersion > 1) {
911 res->u.fString.fChars = &gEmptyString;
912 res->fRes = 0;
913 res->fWritten = TRUE;
914 return res;
915 }
916
917 res->u.fString.fLength = len;
918
919 if (gFormatVersion > 1) {
920 /* check for duplicates */
921 res->u.fString.fChars = (UChar *)value;
922 if (bundle->fStringSet == NULL) {
923 UErrorCode localStatus = U_ZERO_ERROR; /* if failure: just don't detect dups */
924 bundle->fStringSet = uhash_open(string_hash, string_comp, string_comp, &localStatus);
925 } else {
926 res->u.fString.fSame = uhash_get(bundle->fStringSet, res);
927 }
928 }
929 if (res->u.fString.fSame == NULL) {
930 /* this is a new string */
931 res->u.fString.fChars = (UChar *) uprv_malloc(sizeof(UChar) * (len + 1));
932
933 if (res->u.fString.fChars == NULL) {
934 *status = U_MEMORY_ALLOCATION_ERROR;
935 uprv_free(res);
936 return NULL;
937 }
938
939 uprv_memcpy(res->u.fString.fChars, value, sizeof(UChar) * len);
940 res->u.fString.fChars[len] = 0;
941 if (bundle->fStringSet != NULL) {
942 /* put it into the set for finding duplicates */
943 uhash_put(bundle->fStringSet, res, res, status);
944 }
945
946 if (bundle->fStringsForm != STRINGS_UTF16_V1) {
947 if (len <= MAX_IMPLICIT_STRING_LENGTH && !U16_IS_TRAIL(value[0]) && len == u_strlen(value)) {
948 /*
949 * This string will be stored without an explicit length.
950 * Runtime will detect !U16_IS_TRAIL(value[0]) and call u_strlen().
951 */
952 res->u.fString.fNumCharsForLength = 0;
953 } else if (len <= 0x3ee) {
954 res->u.fString.fNumCharsForLength = 1;
955 } else if (len <= 0xfffff) {
956 res->u.fString.fNumCharsForLength = 2;
957 } else {
958 res->u.fString.fNumCharsForLength = 3;
959 }
960 bundle->f16BitUnitsLength += res->u.fString.fNumCharsForLength + len + 1; /* +1 for the NUL */
961 }
962 } else {
963 /* this is a duplicate of fSame */
964 struct SResource *same = res->u.fString.fSame;
965 res->u.fString.fChars = same->u.fString.fChars;
966 }
967 return res;
968 }
969
970 /* TODO: make alias_open and string_open use the same code */
971 struct SResource *alias_open(struct SRBRoot *bundle, const char *tag, UChar *value, int32_t len, const struct UString* comment, UErrorCode *status) {
972 struct SResource *res = res_open(bundle, tag, comment, status);
973 if (U_FAILURE(*status)) {
974 return NULL;
975 }
976 res->fType = URES_ALIAS;
977 if (len == 0 && gFormatVersion > 1) {
978 res->u.fString.fChars = &gEmptyString;
979 res->fRes = URES_MAKE_EMPTY_RESOURCE(URES_ALIAS);
980 res->fWritten = TRUE;
981 return res;
982 }
983
984 res->u.fString.fLength = len;
985 res->u.fString.fChars = (UChar *) uprv_malloc(sizeof(UChar) * (len + 1));
986 if (res->u.fString.fChars == NULL) {
987 *status = U_MEMORY_ALLOCATION_ERROR;
988 uprv_free(res);
989 return NULL;
990 }
991 uprv_memcpy(res->u.fString.fChars, value, sizeof(UChar) * (len + 1));
992 return res;
993 }
994
995
996 struct SResource* intvector_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status) {
997 struct SResource *res = res_open(bundle, tag, comment, status);
998 if (U_FAILURE(*status)) {
999 return NULL;
1000 }
1001 res->fType = URES_INT_VECTOR;
1002
1003 res->u.fIntVector.fCount = 0;
1004 res->u.fIntVector.fArray = (uint32_t *) uprv_malloc(sizeof(uint32_t) * RESLIST_MAX_INT_VECTOR);
1005 if (res->u.fIntVector.fArray == NULL) {
1006 *status = U_MEMORY_ALLOCATION_ERROR;
1007 uprv_free(res);
1008 return NULL;
1009 }
1010 return res;
1011 }
1012
1013 struct SResource *int_open(struct SRBRoot *bundle, const char *tag, int32_t value, const struct UString* comment, UErrorCode *status) {
1014 struct SResource *res = res_open(bundle, tag, comment, status);
1015 if (U_FAILURE(*status)) {
1016 return NULL;
1017 }
1018 res->fType = URES_INT;
1019 res->u.fIntValue.fValue = value;
1020 res->fRes = URES_MAKE_RESOURCE(URES_INT, value & 0x0FFFFFFF);
1021 res->fWritten = TRUE;
1022 return res;
1023 }
1024
1025 struct SResource *bin_open(struct SRBRoot *bundle, const char *tag, uint32_t length, uint8_t *data, const char* fileName, const struct UString* comment, UErrorCode *status) {
1026 struct SResource *res = res_open(bundle, tag, comment, status);
1027 if (U_FAILURE(*status)) {
1028 return NULL;
1029 }
1030 res->fType = URES_BINARY;
1031
1032 res->u.fBinaryValue.fLength = length;
1033 res->u.fBinaryValue.fFileName = NULL;
1034 if(fileName!=NULL && uprv_strcmp(fileName, "") !=0){
1035 res->u.fBinaryValue.fFileName = (char*) uprv_malloc(sizeof(char) * (uprv_strlen(fileName)+1));
1036 uprv_strcpy(res->u.fBinaryValue.fFileName,fileName);
1037 }
1038 if (length > 0) {
1039 res->u.fBinaryValue.fData = (uint8_t *) uprv_malloc(sizeof(uint8_t) * length);
1040
1041 if (res->u.fBinaryValue.fData == NULL) {
1042 *status = U_MEMORY_ALLOCATION_ERROR;
1043 uprv_free(res);
1044 return NULL;
1045 }
1046
1047 uprv_memcpy(res->u.fBinaryValue.fData, data, length);
1048 }
1049 else {
1050 res->u.fBinaryValue.fData = NULL;
1051 if (gFormatVersion > 1) {
1052 res->fRes = URES_MAKE_EMPTY_RESOURCE(URES_BINARY);
1053 res->fWritten = TRUE;
1054 }
1055 }
1056
1057 return res;
1058 }
1059
1060 struct SRBRoot *bundle_open(const struct UString* comment, UBool isPoolBundle, UErrorCode *status) {
1061 struct SRBRoot *bundle;
1062
1063 if (U_FAILURE(*status)) {
1064 return NULL;
1065 }
1066
1067 bundle = (struct SRBRoot *) uprv_malloc(sizeof(struct SRBRoot));
1068 if (bundle == NULL) {
1069 *status = U_MEMORY_ALLOCATION_ERROR;
1070 return 0;
1071 }
1072 uprv_memset(bundle, 0, sizeof(struct SRBRoot));
1073
1074 bundle->fKeys = (char *) uprv_malloc(sizeof(char) * KEY_SPACE_SIZE);
1075 bundle->fRoot = table_open(bundle, NULL, comment, status);
1076 if (bundle->fKeys == NULL || bundle->fRoot == NULL || U_FAILURE(*status)) {
1077 if (U_SUCCESS(*status)) {
1078 *status = U_MEMORY_ALLOCATION_ERROR;
1079 }
1080 bundle_close(bundle, status);
1081 return NULL;
1082 }
1083
1084 bundle->fLocale = NULL;
1085 bundle->fKeysCapacity = KEY_SPACE_SIZE;
1086 /* formatVersion 1.1: start fKeysTop after the root item and indexes[] */
1087 bundle->fIsPoolBundle = isPoolBundle;
1088 if (gUsePoolBundle || isPoolBundle) {
1089 bundle->fIndexLength = URES_INDEX_POOL_CHECKSUM + 1;
1090 } else if (gFormatVersion >= 2) {
1091 bundle->fIndexLength = URES_INDEX_16BIT_TOP + 1;
1092 } else /* formatVersion 1 */ {
1093 bundle->fIndexLength = URES_INDEX_ATTRIBUTES + 1;
1094 }
1095 bundle->fKeysBottom = (1 /* root */ + bundle->fIndexLength) * 4;
1096 uprv_memset(bundle->fKeys, 0, bundle->fKeysBottom);
1097 bundle->fKeysTop = bundle->fKeysBottom;
1098
1099 if (gFormatVersion == 1) {
1100 bundle->fStringsForm = STRINGS_UTF16_V1;
1101 } else {
1102 bundle->fStringsForm = STRINGS_UTF16_V2;
1103 }
1104
1105 return bundle;
1106 }
1107
1108 /* Closing Functions */
1109 static void table_close(struct SResource *table) {
1110 struct SResource *current = NULL;
1111 struct SResource *prev = NULL;
1112
1113 current = table->u.fTable.fFirst;
1114
1115 while (current != NULL) {
1116 prev = current;
1117 current = current->fNext;
1118
1119 res_close(prev);
1120 }
1121
1122 table->u.fTable.fFirst = NULL;
1123 }
1124
1125 static void array_close(struct SResource *array) {
1126 struct SResource *current = NULL;
1127 struct SResource *prev = NULL;
1128
1129 if(array==NULL){
1130 return;
1131 }
1132 current = array->u.fArray.fFirst;
1133
1134 while (current != NULL) {
1135 prev = current;
1136 current = current->fNext;
1137
1138 res_close(prev);
1139 }
1140 array->u.fArray.fFirst = NULL;
1141 }
1142
1143 static void string_close(struct SResource *string) {
1144 if (string->u.fString.fChars != NULL &&
1145 string->u.fString.fChars != &gEmptyString &&
1146 string->u.fString.fSame == NULL
1147 ) {
1148 uprv_free(string->u.fString.fChars);
1149 string->u.fString.fChars =NULL;
1150 }
1151 }
1152
1153 static void alias_close(struct SResource *alias) {
1154 if (alias->u.fString.fChars != NULL) {
1155 uprv_free(alias->u.fString.fChars);
1156 alias->u.fString.fChars =NULL;
1157 }
1158 }
1159
1160 static void intvector_close(struct SResource *intvector) {
1161 if (intvector->u.fIntVector.fArray != NULL) {
1162 uprv_free(intvector->u.fIntVector.fArray);
1163 intvector->u.fIntVector.fArray =NULL;
1164 }
1165 }
1166
1167 static void int_close(struct SResource *intres) {
1168 /* Intentionally left blank */
1169 }
1170
1171 static void bin_close(struct SResource *binres) {
1172 if (binres->u.fBinaryValue.fData != NULL) {
1173 uprv_free(binres->u.fBinaryValue.fData);
1174 binres->u.fBinaryValue.fData = NULL;
1175 }
1176 if (binres->u.fBinaryValue.fFileName != NULL) {
1177 uprv_free(binres->u.fBinaryValue.fFileName);
1178 binres->u.fBinaryValue.fFileName = NULL;
1179 }
1180 }
1181
1182 void res_close(struct SResource *res) {
1183 if (res != NULL) {
1184 switch(res->fType) {
1185 case URES_STRING:
1186 string_close(res);
1187 break;
1188 case URES_ALIAS:
1189 alias_close(res);
1190 break;
1191 case URES_INT_VECTOR:
1192 intvector_close(res);
1193 break;
1194 case URES_BINARY:
1195 bin_close(res);
1196 break;
1197 case URES_INT:
1198 int_close(res);
1199 break;
1200 case URES_ARRAY:
1201 array_close(res);
1202 break;
1203 case URES_TABLE:
1204 table_close(res);
1205 break;
1206 default:
1207 /* Shouldn't happen */
1208 break;
1209 }
1210
1211 ustr_deinit(&res->fComment);
1212 uprv_free(res);
1213 }
1214 }
1215
1216 void bundle_close(struct SRBRoot *bundle, UErrorCode *status) {
1217 res_close(bundle->fRoot);
1218 uprv_free(bundle->fLocale);
1219 uprv_free(bundle->fKeys);
1220 uprv_free(bundle->fKeyMap);
1221 uhash_close(bundle->fStringSet);
1222 uprv_free(bundle->f16BitUnits);
1223 uprv_free(bundle);
1224 }
1225
1226 void bundle_closeString(struct SRBRoot *bundle, struct SResource *string) {
1227 if (bundle->fStringSet != NULL) {
1228 uhash_remove(bundle->fStringSet, string);
1229 }
1230 string_close(string);
1231 }
1232
1233 /* Adding Functions */
1234 void table_add(struct SResource *table, struct SResource *res, int linenumber, UErrorCode *status) {
1235 struct SResource *current = NULL;
1236 struct SResource *prev = NULL;
1237 struct SResTable *list;
1238 const char *resKeyString;
1239
1240 if (U_FAILURE(*status)) {
1241 return;
1242 }
1243 if (res == &kNoResource) {
1244 return;
1245 }
1246
1247 /* remember this linenumber to report to the user if there is a duplicate key */
1248 res->line = linenumber;
1249
1250 /* here we need to traverse the list */
1251 list = &(table->u.fTable);
1252 ++(list->fCount);
1253
1254 /* is list still empty? */
1255 if (list->fFirst == NULL) {
1256 list->fFirst = res;
1257 res->fNext = NULL;
1258 return;
1259 }
1260
1261 resKeyString = list->fRoot->fKeys + res->fKey;
1262
1263 current = list->fFirst;
1264
1265 while (current != NULL) {
1266 const char *currentKeyString = list->fRoot->fKeys + current->fKey;
1267 int diff;
1268 /*
1269 * formatVersion 1: compare key strings in native-charset order
1270 * formatVersion 2 and up: compare key strings in ASCII order
1271 */
1272 if (gFormatVersion == 1 || U_CHARSET_FAMILY == U_ASCII_FAMILY) {
1273 diff = uprv_strcmp(currentKeyString, resKeyString);
1274 } else {
1275 diff = uprv_compareInvCharsAsAscii(currentKeyString, resKeyString);
1276 }
1277 if (diff < 0) {
1278 prev = current;
1279 current = current->fNext;
1280 } else if (diff > 0) {
1281 /* we're either in front of list, or in middle */
1282 if (prev == NULL) {
1283 /* front of the list */
1284 list->fFirst = res;
1285 } else {
1286 /* middle of the list */
1287 prev->fNext = res;
1288 }
1289
1290 res->fNext = current;
1291 return;
1292 } else {
1293 /* Key already exists! ERROR! */
1294 error(linenumber, "duplicate key '%s' in table, first appeared at line %d", currentKeyString, current->line);
1295 *status = U_UNSUPPORTED_ERROR;
1296 return;
1297 }
1298 }
1299
1300 /* end of list */
1301 prev->fNext = res;
1302 res->fNext = NULL;
1303 }
1304
1305 void array_add(struct SResource *array, struct SResource *res, UErrorCode *status) {
1306 if (U_FAILURE(*status)) {
1307 return;
1308 }
1309
1310 if (array->u.fArray.fFirst == NULL) {
1311 array->u.fArray.fFirst = res;
1312 array->u.fArray.fLast = res;
1313 } else {
1314 array->u.fArray.fLast->fNext = res;
1315 array->u.fArray.fLast = res;
1316 }
1317
1318 (array->u.fArray.fCount)++;
1319 }
1320
1321 void intvector_add(struct SResource *intvector, int32_t value, UErrorCode *status) {
1322 if (U_FAILURE(*status)) {
1323 return;
1324 }
1325
1326 *(intvector->u.fIntVector.fArray + intvector->u.fIntVector.fCount) = value;
1327 intvector->u.fIntVector.fCount++;
1328 }
1329
1330 /* Misc Functions */
1331
1332 void bundle_setlocale(struct SRBRoot *bundle, UChar *locale, UErrorCode *status) {
1333
1334 if(U_FAILURE(*status)) {
1335 return;
1336 }
1337
1338 if (bundle->fLocale!=NULL) {
1339 uprv_free(bundle->fLocale);
1340 }
1341
1342 bundle->fLocale= (char*) uprv_malloc(sizeof(char) * (u_strlen(locale)+1));
1343
1344 if(bundle->fLocale == NULL) {
1345 *status = U_MEMORY_ALLOCATION_ERROR;
1346 return;
1347 }
1348
1349 /*u_strcpy(bundle->fLocale, locale);*/
1350 u_UCharsToChars(locale, bundle->fLocale, u_strlen(locale)+1);
1351
1352 }
1353
1354 static const char *
1355 getKeyString(const struct SRBRoot *bundle, int32_t key) {
1356 if (key < 0) {
1357 return bundle->fPoolBundleKeys + (key & 0x7fffffff);
1358 } else {
1359 return bundle->fKeys + key;
1360 }
1361 }
1362
1363 const char *
1364 res_getKeyString(const struct SRBRoot *bundle, const struct SResource *res, char temp[8]) {
1365 if (res->fKey == -1) {
1366 return NULL;
1367 }
1368 return getKeyString(bundle, res->fKey);
1369 }
1370
1371 const char *
1372 bundle_getKeyBytes(struct SRBRoot *bundle, int32_t *pLength) {
1373 *pLength = bundle->fKeysTop - bundle->fKeysBottom;
1374 return bundle->fKeys + bundle->fKeysBottom;
1375 }
1376
1377 int32_t
1378 bundle_addKeyBytes(struct SRBRoot *bundle, const char *keyBytes, int32_t length, UErrorCode *status) {
1379 int32_t keypos;
1380
1381 if (U_FAILURE(*status)) {
1382 return -1;
1383 }
1384 if (length < 0 || (keyBytes == NULL && length != 0)) {
1385 *status = U_ILLEGAL_ARGUMENT_ERROR;
1386 return -1;
1387 }
1388 if (length == 0) {
1389 return bundle->fKeysTop;
1390 }
1391
1392 keypos = bundle->fKeysTop;
1393 bundle->fKeysTop += length;
1394 if (bundle->fKeysTop >= bundle->fKeysCapacity) {
1395 /* overflow - resize the keys buffer */
1396 bundle->fKeysCapacity += KEY_SPACE_SIZE;
1397 bundle->fKeys = uprv_realloc(bundle->fKeys, bundle->fKeysCapacity);
1398 if(bundle->fKeys == NULL) {
1399 *status = U_MEMORY_ALLOCATION_ERROR;
1400 return -1;
1401 }
1402 }
1403
1404 uprv_memcpy(bundle->fKeys + keypos, keyBytes, length);
1405
1406 return keypos;
1407 }
1408
1409 int32_t
1410 bundle_addtag(struct SRBRoot *bundle, const char *tag, UErrorCode *status) {
1411 int32_t keypos;
1412
1413 if (U_FAILURE(*status)) {
1414 return -1;
1415 }
1416
1417 if (tag == NULL) {
1418 /* no error: the root table and array items have no keys */
1419 return -1;
1420 }
1421
1422 keypos = bundle_addKeyBytes(bundle, tag, (int32_t)(uprv_strlen(tag) + 1), status);
1423 if (U_SUCCESS(*status)) {
1424 ++bundle->fKeysCount;
1425 }
1426 return keypos;
1427 }
1428
1429 static int32_t
1430 compareInt32(int32_t lPos, int32_t rPos) {
1431 /*
1432 * Compare possibly-negative key offsets. Don't just return lPos - rPos
1433 * because that is prone to negative-integer underflows.
1434 */
1435 if (lPos < rPos) {
1436 return -1;
1437 } else if (lPos > rPos) {
1438 return 1;
1439 } else {
1440 return 0;
1441 }
1442 }
1443
1444 static int32_t U_CALLCONV
1445 compareKeySuffixes(const void *context, const void *l, const void *r) {
1446 const struct SRBRoot *bundle=(const struct SRBRoot *)context;
1447 int32_t lPos = ((const KeyMapEntry *)l)->oldpos;
1448 int32_t rPos = ((const KeyMapEntry *)r)->oldpos;
1449 const char *lStart = getKeyString(bundle, lPos);
1450 const char *lLimit = lStart;
1451 const char *rStart = getKeyString(bundle, rPos);
1452 const char *rLimit = rStart;
1453 int32_t diff;
1454 while (*lLimit != 0) { ++lLimit; }
1455 while (*rLimit != 0) { ++rLimit; }
1456 /* compare keys in reverse character order */
1457 while (lStart < lLimit && rStart < rLimit) {
1458 diff = (int32_t)(uint8_t)*--lLimit - (int32_t)(uint8_t)*--rLimit;
1459 if (diff != 0) {
1460 return diff;
1461 }
1462 }
1463 /* sort equal suffixes by descending key length */
1464 diff = (int32_t)(rLimit - rStart) - (int32_t)(lLimit - lStart);
1465 if (diff != 0) {
1466 return diff;
1467 }
1468 /* Sort pool bundle keys first (negative oldpos), and otherwise keys in parsing order. */
1469 return compareInt32(lPos, rPos);
1470 }
1471
1472 static int32_t U_CALLCONV
1473 compareKeyNewpos(const void *context, const void *l, const void *r) {
1474 return compareInt32(((const KeyMapEntry *)l)->newpos, ((const KeyMapEntry *)r)->newpos);
1475 }
1476
1477 static int32_t U_CALLCONV
1478 compareKeyOldpos(const void *context, const void *l, const void *r) {
1479 return compareInt32(((const KeyMapEntry *)l)->oldpos, ((const KeyMapEntry *)r)->oldpos);
1480 }
1481
1482 void
1483 bundle_compactKeys(struct SRBRoot *bundle, UErrorCode *status) {
1484 KeyMapEntry *map;
1485 char *keys;
1486 int32_t i;
1487 int32_t keysCount = bundle->fPoolBundleKeysCount + bundle->fKeysCount;
1488 if (U_FAILURE(*status) || bundle->fKeysCount == 0 || bundle->fKeyMap != NULL) {
1489 return;
1490 }
1491 map = (KeyMapEntry *)uprv_malloc(keysCount * sizeof(KeyMapEntry));
1492 if (map == NULL) {
1493 *status = U_MEMORY_ALLOCATION_ERROR;
1494 return;
1495 }
1496 keys = (char *)bundle->fPoolBundleKeys;
1497 for (i = 0; i < bundle->fPoolBundleKeysCount; ++i) {
1498 map[i].oldpos =
1499 (int32_t)(keys - bundle->fPoolBundleKeys) | 0x80000000; /* negative oldpos */
1500 map[i].newpos = 0;
1501 while (*keys != 0) { ++keys; } /* skip the key */
1502 ++keys; /* skip the NUL */
1503 }
1504 keys = bundle->fKeys + bundle->fKeysBottom;
1505 for (; i < keysCount; ++i) {
1506 map[i].oldpos = (int32_t)(keys - bundle->fKeys);
1507 map[i].newpos = 0;
1508 while (*keys != 0) { ++keys; } /* skip the key */
1509 ++keys; /* skip the NUL */
1510 }
1511 /* Sort the keys so that each one is immediately followed by all of its suffixes. */
1512 uprv_sortArray(map, keysCount, (int32_t)sizeof(KeyMapEntry),
1513 compareKeySuffixes, bundle, FALSE, status);
1514 /*
1515 * Make suffixes point into earlier, longer strings that contain them
1516 * and mark the old, now unused suffix bytes as deleted.
1517 */
1518 if (U_SUCCESS(*status)) {
1519 keys = bundle->fKeys;
1520 for (i = 0; i < keysCount;) {
1521 /*
1522 * This key is not a suffix of the previous one;
1523 * keep this one and delete the following ones that are
1524 * suffixes of this one.
1525 */
1526 const char *key;
1527 const char *keyLimit;
1528 int32_t j = i + 1;
1529 map[i].newpos = map[i].oldpos;
1530 if (j < keysCount && map[j].oldpos < 0) {
1531 /* Key string from the pool bundle, do not delete. */
1532 i = j;
1533 continue;
1534 }
1535 key = getKeyString(bundle, map[i].oldpos);
1536 for (keyLimit = key; *keyLimit != 0; ++keyLimit) {}
1537 for (; j < keysCount && map[j].oldpos >= 0; ++j) {
1538 const char *k;
1539 char *suffix;
1540 const char *suffixLimit;
1541 int32_t offset;
1542 suffix = keys + map[j].oldpos;
1543 for (suffixLimit = suffix; *suffixLimit != 0; ++suffixLimit) {}
1544 offset = (int32_t)(keyLimit - key) - (suffixLimit - suffix);
1545 if (offset < 0) {
1546 break; /* suffix cannot be longer than the original */
1547 }
1548 /* Is it a suffix of the earlier, longer key? */
1549 for (k = keyLimit; suffix < suffixLimit && *--k == *--suffixLimit;) {}
1550 if (suffix == suffixLimit && *k == *suffixLimit) {
1551 map[j].newpos = map[i].oldpos + offset; /* yes, point to the earlier key */
1552 /* mark the suffix as deleted */
1553 while (*suffix != 0) { *suffix++ = 1; }
1554 *suffix = 1;
1555 } else {
1556 break; /* not a suffix, restart from here */
1557 }
1558 }
1559 i = j;
1560 }
1561 /*
1562 * Re-sort by newpos, then modify the key characters array in-place
1563 * to squeeze out unused bytes, and readjust the newpos offsets.
1564 */
1565 uprv_sortArray(map, keysCount, (int32_t)sizeof(KeyMapEntry),
1566 compareKeyNewpos, NULL, FALSE, status);
1567 if (U_SUCCESS(*status)) {
1568 int32_t oldpos, newpos, limit;
1569 oldpos = newpos = bundle->fKeysBottom;
1570 limit = bundle->fKeysTop;
1571 /* skip key offsets that point into the pool bundle rather than this new bundle */
1572 for (i = 0; i < keysCount && map[i].newpos < 0; ++i) {}
1573 if (i < keysCount) {
1574 while (oldpos < limit) {
1575 if (keys[oldpos] == 1) {
1576 ++oldpos; /* skip unused bytes */
1577 } else {
1578 /* adjust the new offsets for keys starting here */
1579 while (i < keysCount && map[i].newpos == oldpos) {
1580 map[i++].newpos = newpos;
1581 }
1582 /* move the key characters to their new position */
1583 keys[newpos++] = keys[oldpos++];
1584 }
1585 }
1586 assert(i == keysCount);
1587 }
1588 bundle->fKeysTop = newpos;
1589 /* Re-sort once more, by old offsets for binary searching. */
1590 uprv_sortArray(map, keysCount, (int32_t)sizeof(KeyMapEntry),
1591 compareKeyOldpos, NULL, FALSE, status);
1592 if (U_SUCCESS(*status)) {
1593 /* key size reduction by limit - newpos */
1594 bundle->fKeyMap = map;
1595 map = NULL;
1596 }
1597 }
1598 }
1599 uprv_free(map);
1600 }
1601
1602 static int32_t U_CALLCONV
1603 compareStringSuffixes(const void *context, const void *l, const void *r) {
1604 struct SResource *left = *((struct SResource **)l);
1605 struct SResource *right = *((struct SResource **)r);
1606 const UChar *lStart = left->u.fString.fChars;
1607 const UChar *lLimit = lStart + left->u.fString.fLength;
1608 const UChar *rStart = right->u.fString.fChars;
1609 const UChar *rLimit = rStart + right->u.fString.fLength;
1610 int32_t diff;
1611 /* compare keys in reverse character order */
1612 while (lStart < lLimit && rStart < rLimit) {
1613 diff = (int32_t)*--lLimit - (int32_t)*--rLimit;
1614 if (diff != 0) {
1615 return diff;
1616 }
1617 }
1618 /* sort equal suffixes by descending string length */
1619 return right->u.fString.fLength - left->u.fString.fLength;
1620 }
1621
1622 static int32_t U_CALLCONV
1623 compareStringLengths(const void *context, const void *l, const void *r) {
1624 struct SResource *left = *((struct SResource **)l);
1625 struct SResource *right = *((struct SResource **)r);
1626 int32_t diff;
1627 /* Make "is suffix of another string" compare greater than a non-suffix. */
1628 diff = (int)(left->u.fString.fSame != NULL) - (int)(right->u.fString.fSame != NULL);
1629 if (diff != 0) {
1630 return diff;
1631 }
1632 /* sort by ascending string length */
1633 return left->u.fString.fLength - right->u.fString.fLength;
1634 }
1635
1636 static int32_t
1637 string_writeUTF16v2(struct SRBRoot *bundle, struct SResource *res, int32_t utf16Length) {
1638 int32_t length = res->u.fString.fLength;
1639 res->fRes = URES_MAKE_RESOURCE(URES_STRING_V2, utf16Length);
1640 res->fWritten = TRUE;
1641 switch(res->u.fString.fNumCharsForLength) {
1642 case 0:
1643 break;
1644 case 1:
1645 bundle->f16BitUnits[utf16Length++] = (uint16_t)(0xdc00 + length);
1646 break;
1647 case 2:
1648 bundle->f16BitUnits[utf16Length] = (uint16_t)(0xdfef + (length >> 16));
1649 bundle->f16BitUnits[utf16Length + 1] = (uint16_t)length;
1650 utf16Length += 2;
1651 break;
1652 case 3:
1653 bundle->f16BitUnits[utf16Length] = 0xdfff;
1654 bundle->f16BitUnits[utf16Length + 1] = (uint16_t)(length >> 16);
1655 bundle->f16BitUnits[utf16Length + 2] = (uint16_t)length;
1656 utf16Length += 3;
1657 break;
1658 default:
1659 break; /* will not occur */
1660 }
1661 u_memcpy(bundle->f16BitUnits + utf16Length, res->u.fString.fChars, length + 1);
1662 return utf16Length + length + 1;
1663 }
1664
1665 static void
1666 bundle_compactStrings(struct SRBRoot *bundle, UErrorCode *status) {
1667 if (U_FAILURE(*status)) {
1668 return;
1669 }
1670 switch(bundle->fStringsForm) {
1671 case STRINGS_UTF16_V2:
1672 if (bundle->f16BitUnitsLength > 0) {
1673 struct SResource **array;
1674 int32_t count = uhash_count(bundle->fStringSet);
1675 int32_t i, pos;
1676 /*
1677 * Allocate enough space for the initial NUL and the UTF-16 v2 strings,
1678 * and some extra for URES_TABLE16 and URES_ARRAY16 values.
1679 * Round down to an even number.
1680 */
1681 int32_t utf16Length = (bundle->f16BitUnitsLength + 20000) & ~1;
1682 bundle->f16BitUnits = (UChar *)uprv_malloc(utf16Length * U_SIZEOF_UCHAR);
1683 array = (struct SResource **)uprv_malloc(count * sizeof(struct SResource **));
1684 if (bundle->f16BitUnits == NULL || array == NULL) {
1685 uprv_free(bundle->f16BitUnits);
1686 bundle->f16BitUnits = NULL;
1687 uprv_free(array);
1688 *status = U_MEMORY_ALLOCATION_ERROR;
1689 return;
1690 }
1691 bundle->f16BitUnitsCapacity = utf16Length;
1692 /* insert the initial NUL */
1693 bundle->f16BitUnits[0] = 0;
1694 utf16Length = 1;
1695 ++bundle->f16BitUnitsLength;
1696 for (pos = -1, i = 0; i < count; ++i) {
1697 array[i] = (struct SResource *)uhash_nextElement(bundle->fStringSet, &pos)->key.pointer;
1698 }
1699 /* Sort the strings so that each one is immediately followed by all of its suffixes. */
1700 uprv_sortArray(array, count, (int32_t)sizeof(struct SResource **),
1701 compareStringSuffixes, NULL, FALSE, status);
1702 /*
1703 * Make suffixes point into earlier, longer strings that contain them.
1704 * Temporarily use fSame and fSuffixOffset for suffix strings to
1705 * refer to the remaining ones.
1706 */
1707 if (U_SUCCESS(*status)) {
1708 for (i = 0; i < count;) {
1709 /*
1710 * This string is not a suffix of the previous one;
1711 * write this one and subsume the following ones that are
1712 * suffixes of this one.
1713 */
1714 struct SResource *res = array[i];
1715 const UChar *strLimit = res->u.fString.fChars + res->u.fString.fLength;
1716 int32_t j;
1717 for (j = i + 1; j < count; ++j) {
1718 struct SResource *suffixRes = array[j];
1719 const UChar *s;
1720 const UChar *suffix = suffixRes->u.fString.fChars;
1721 const UChar *suffixLimit = suffix + suffixRes->u.fString.fLength;
1722 int32_t offset = res->u.fString.fLength - suffixRes->u.fString.fLength;
1723 if (offset < 0) {
1724 break; /* suffix cannot be longer than the original */
1725 }
1726 /* Is it a suffix of the earlier, longer key? */
1727 for (s = strLimit; suffix < suffixLimit && *--s == *--suffixLimit;) {}
1728 if (suffix == suffixLimit && *s == *suffixLimit) {
1729 if (suffixRes->u.fString.fNumCharsForLength == 0) {
1730 /* yes, point to the earlier string */
1731 suffixRes->u.fString.fSame = res;
1732 suffixRes->u.fString.fSuffixOffset = offset;
1733 } else {
1734 /* write the suffix by itself if we need explicit length */
1735 }
1736 } else {
1737 break; /* not a suffix, restart from here */
1738 }
1739 }
1740 i = j;
1741 }
1742 }
1743 /*
1744 * Re-sort the strings by ascending length (except suffixes last)
1745 * to optimize for URES_TABLE16 and URES_ARRAY16:
1746 * Keep as many as possible within reach of 16-bit offsets.
1747 */
1748 uprv_sortArray(array, count, (int32_t)sizeof(struct SResource **),
1749 compareStringLengths, NULL, FALSE, status);
1750 if (U_SUCCESS(*status)) {
1751 /* Write the non-suffix strings. */
1752 for (i = 0; i < count && array[i]->u.fString.fSame == NULL; ++i) {
1753 utf16Length = string_writeUTF16v2(bundle, array[i], utf16Length);
1754 }
1755 /* Write the suffix strings. Make each point to the real string. */
1756 for (; i < count; ++i) {
1757 struct SResource *res = array[i];
1758 struct SResource *same = res->u.fString.fSame;
1759 res->fRes = same->fRes + same->u.fString.fNumCharsForLength + res->u.fString.fSuffixOffset;
1760 res->u.fString.fSame = NULL;
1761 res->fWritten = TRUE;
1762 }
1763 }
1764 assert(utf16Length <= bundle->f16BitUnitsLength);
1765 bundle->f16BitUnitsLength = utf16Length;
1766 uprv_free(array);
1767 }
1768 break;
1769 default:
1770 break;
1771 }
1772 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial