1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 *
6 * Copyright (C) 2005-2014, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 *******************************************************************************
10 * file name: swapimpl.cpp
11 * encoding: US-ASCII
12 * tab size: 8 (not used)
13 * indentation:4
14 *
15 * created on: 2005may05
16 * created by: Markus W. Scherer
17 *
18 * Data file swapping functions moved here from the common library
19 * because some data is hardcoded in ICU4C and needs not be swapped any more.
20 * Moving the functions here simplifies testing (for code coverage) because
21 * we need not jump through hoops (like adding snapshots of these files
22 * to testdata).
23 *
24 * The declarations for these functions remain in the internal header files
25 * in icu/source/common/
26 */
27
28 #include "unicode/utypes.h"
29 #include "unicode/putil.h"
30 #include "unicode/udata.h"
31
32 /* Explicit include statement for std_string.h is needed
33 * for compilation on certain platforms. (e.g. AIX/VACPP)
34 */
35 #include "unicode/std_string.h"
36
37 #include "cmemory.h"
38 #include "cstring.h"
39 #include "uinvchar.h"
40 #include "uassert.h"
41 #include "uarrsort.h"
42 #include "ucmndata.h"
43 #include "udataswp.h"
44
45 /* swapping implementations in common */
46
47 #include "uresdata.h"
48 #include "ucnv_io.h"
49 #include "uprops.h"
50 #include "ucase.h"
51 #include "ubidi_props.h"
52 #include "ucol_swp.h"
53 #include "ucnv_bld.h"
54 #include "unormimp.h"
55 #include "normalizer2impl.h"
56 #include "sprpimpl.h"
57 #include "propname.h"
58 #include "rbbidata.h"
59 #include "utrie2.h"
60 #include "dictionarydata.h"
61
62 /* swapping implementations in i18n */
63
64 #if !UCONFIG_NO_NORMALIZATION
65 #include "uspoof_impl.h"
66 #endif
67
68 U_NAMESPACE_USE
69
70 /* definitions */
71
72 /* Unicode property (value) aliases data swapping --------------------------- */
73
74 static int32_t U_CALLCONV
upname_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)75 upname_swap(const UDataSwapper *ds,
76 const void *inData, int32_t length, void *outData,
77 UErrorCode *pErrorCode) {
78 /* udata_swapDataHeader checks the arguments */
79 int32_t headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
80 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
81 return 0;
82 }
83
84 /* check data format and format version */
85 const UDataInfo *pInfo=
86 reinterpret_cast<const UDataInfo *>(
87 static_cast<const char *>(inData)+4);
88 if(!(
89 pInfo->dataFormat[0]==0x70 && /* dataFormat="pnam" */
90 pInfo->dataFormat[1]==0x6e &&
91 pInfo->dataFormat[2]==0x61 &&
92 pInfo->dataFormat[3]==0x6d &&
93 pInfo->formatVersion[0]==2
94 )) {
95 udata_printError(ds, "upname_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as pnames.icu\n",
96 pInfo->dataFormat[0], pInfo->dataFormat[1],
97 pInfo->dataFormat[2], pInfo->dataFormat[3],
98 pInfo->formatVersion[0]);
99 *pErrorCode=U_UNSUPPORTED_ERROR;
100 return 0;
101 }
102
103 const uint8_t *inBytes=static_cast<const uint8_t *>(inData)+headerSize;
104 uint8_t *outBytes=static_cast<uint8_t *>(outData)+headerSize;
105
106 if(length>=0) {
107 length-=headerSize;
108 // formatVersion 2 initially has indexes[8], 32 bytes.
109 if(length<32) {
110 udata_printError(ds, "upname_swap(): too few bytes (%d after header) for pnames.icu\n",
111 (int)length);
112 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
113 return 0;
114 }
115 }
116
117 const int32_t *inIndexes=reinterpret_cast<const int32_t *>(inBytes);
118 int32_t totalSize=udata_readInt32(ds, inIndexes[PropNameData::IX_TOTAL_SIZE]);
119 if(length>=0) {
120 if(length<totalSize) {
121 udata_printError(ds, "upname_swap(): too few bytes (%d after header, should be %d) "
122 "for pnames.icu\n",
123 (int)length, (int)totalSize);
124 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
125 return 0;
126 }
127
128 int32_t numBytesIndexesAndValueMaps=
129 udata_readInt32(ds, inIndexes[PropNameData::IX_BYTE_TRIES_OFFSET]);
130
131 // Swap the indexes[] and the valueMaps[].
132 ds->swapArray32(ds, inBytes, numBytesIndexesAndValueMaps, outBytes, pErrorCode);
133
134 // Copy the rest of the data.
135 if(inBytes!=outBytes) {
136 uprv_memcpy(outBytes+numBytesIndexesAndValueMaps,
137 inBytes+numBytesIndexesAndValueMaps,
138 totalSize-numBytesIndexesAndValueMaps);
139 }
140
141 // We need not swap anything else:
142 //
143 // The ByteTries are already byte-serialized, and are fixed on ASCII.
144 // (On an EBCDIC machine, the input string is converted to lowercase ASCII
145 // while matching.)
146 //
147 // The name groups are mostly invariant characters, but since we only
148 // generate, and keep in subversion, ASCII versions of pnames.icu,
149 // and since only ICU4J uses the pnames.icu data file
150 // (the data is hardcoded in ICU4C) and ICU4J uses ASCII data files,
151 // we just copy those bytes too.
152 }
153
154 return headerSize+totalSize;
155 }
156
157 /* Unicode properties data swapping ----------------------------------------- */
158
159 static int32_t U_CALLCONV
uprops_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)160 uprops_swap(const UDataSwapper *ds,
161 const void *inData, int32_t length, void *outData,
162 UErrorCode *pErrorCode) {
163 const UDataInfo *pInfo;
164 int32_t headerSize, i;
165
166 int32_t dataIndexes[UPROPS_INDEX_COUNT];
167 const int32_t *inData32;
168
169 /* udata_swapDataHeader checks the arguments */
170 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
171 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
172 return 0;
173 }
174
175 /* check data format and format version */
176 pInfo=(const UDataInfo *)((const char *)inData+4);
177 if(!(
178 pInfo->dataFormat[0]==0x55 && /* dataFormat="UPro" */
179 pInfo->dataFormat[1]==0x50 &&
180 pInfo->dataFormat[2]==0x72 &&
181 pInfo->dataFormat[3]==0x6f &&
182 (3<=pInfo->formatVersion[0] && pInfo->formatVersion[0]<=7) &&
183 (pInfo->formatVersion[0]>=7 ||
184 (pInfo->formatVersion[2]==UTRIE_SHIFT &&
185 pInfo->formatVersion[3]==UTRIE_INDEX_SHIFT))
186 )) {
187 udata_printError(ds, "uprops_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not a Unicode properties file\n",
188 pInfo->dataFormat[0], pInfo->dataFormat[1],
189 pInfo->dataFormat[2], pInfo->dataFormat[3],
190 pInfo->formatVersion[0]);
191 *pErrorCode=U_UNSUPPORTED_ERROR;
192 return 0;
193 }
194
195 /* the properties file must contain at least the indexes array */
196 if(length>=0 && (length-headerSize)<(int32_t)sizeof(dataIndexes)) {
197 udata_printError(ds, "uprops_swap(): too few bytes (%d after header) for a Unicode properties file\n",
198 length-headerSize);
199 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
200 return 0;
201 }
202
203 /* read the indexes */
204 inData32=(const int32_t *)((const char *)inData+headerSize);
205 for(i=0; i<UPROPS_INDEX_COUNT; ++i) {
206 dataIndexes[i]=udata_readInt32(ds, inData32[i]);
207 }
208
209 /*
210 * comments are copied from the data format description in genprops/store.c
211 * indexes[] constants are in uprops.h
212 */
213 int32_t dataTop;
214 if(length>=0) {
215 int32_t *outData32;
216
217 /*
218 * In formatVersion 7, UPROPS_DATA_TOP_INDEX has the post-header data size.
219 * In earlier formatVersions, it is 0 and a lower dataIndexes entry
220 * has the top of the last item.
221 */
222 for(i=UPROPS_DATA_TOP_INDEX; i>0 && (dataTop=dataIndexes[i])==0; --i) {}
223
224 if((length-headerSize)<(4*dataTop)) {
225 udata_printError(ds, "uprops_swap(): too few bytes (%d after header) for a Unicode properties file\n",
226 length-headerSize);
227 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
228 return 0;
229 }
230
231 outData32=(int32_t *)((char *)outData+headerSize);
232
233 /* copy everything for inaccessible data (padding) */
234 if(inData32!=outData32) {
235 uprv_memcpy(outData32, inData32, 4*(size_t)dataTop);
236 }
237
238 /* swap the indexes[16] */
239 ds->swapArray32(ds, inData32, 4*UPROPS_INDEX_COUNT, outData32, pErrorCode);
240
241 /*
242 * swap the main properties UTrie
243 * PT serialized properties trie, see utrie.h (byte size: 4*(i0-16))
244 */
245 utrie2_swapAnyVersion(ds,
246 inData32+UPROPS_INDEX_COUNT,
247 4*(dataIndexes[UPROPS_PROPS32_INDEX]-UPROPS_INDEX_COUNT),
248 outData32+UPROPS_INDEX_COUNT,
249 pErrorCode);
250
251 /*
252 * swap the properties and exceptions words
253 * P const uint32_t props32[i1-i0];
254 * E const uint32_t exceptions[i2-i1];
255 */
256 ds->swapArray32(ds,
257 inData32+dataIndexes[UPROPS_PROPS32_INDEX],
258 4*(dataIndexes[UPROPS_EXCEPTIONS_TOP_INDEX]-dataIndexes[UPROPS_PROPS32_INDEX]),
259 outData32+dataIndexes[UPROPS_PROPS32_INDEX],
260 pErrorCode);
261
262 /*
263 * swap the UChars
264 * U const UChar uchars[2*(i3-i2)];
265 */
266 ds->swapArray16(ds,
267 inData32+dataIndexes[UPROPS_EXCEPTIONS_TOP_INDEX],
268 4*(dataIndexes[UPROPS_ADDITIONAL_TRIE_INDEX]-dataIndexes[UPROPS_EXCEPTIONS_TOP_INDEX]),
269 outData32+dataIndexes[UPROPS_EXCEPTIONS_TOP_INDEX],
270 pErrorCode);
271
272 /*
273 * swap the additional UTrie
274 * i3 additionalTrieIndex; -- 32-bit unit index to the additional trie for more properties
275 */
276 utrie2_swapAnyVersion(ds,
277 inData32+dataIndexes[UPROPS_ADDITIONAL_TRIE_INDEX],
278 4*(dataIndexes[UPROPS_ADDITIONAL_VECTORS_INDEX]-dataIndexes[UPROPS_ADDITIONAL_TRIE_INDEX]),
279 outData32+dataIndexes[UPROPS_ADDITIONAL_TRIE_INDEX],
280 pErrorCode);
281
282 /*
283 * swap the properties vectors
284 * PV const uint32_t propsVectors[(i6-i4)/i5][i5]==uint32_t propsVectors[i6-i4];
285 */
286 ds->swapArray32(ds,
287 inData32+dataIndexes[UPROPS_ADDITIONAL_VECTORS_INDEX],
288 4*(dataIndexes[UPROPS_SCRIPT_EXTENSIONS_INDEX]-dataIndexes[UPROPS_ADDITIONAL_VECTORS_INDEX]),
289 outData32+dataIndexes[UPROPS_ADDITIONAL_VECTORS_INDEX],
290 pErrorCode);
291
292 // swap the Script_Extensions data
293 // SCX const uint16_t scriptExtensions[2*(i7-i6)];
294 ds->swapArray16(ds,
295 inData32+dataIndexes[UPROPS_SCRIPT_EXTENSIONS_INDEX],
296 4*(dataIndexes[UPROPS_RESERVED_INDEX_7]-dataIndexes[UPROPS_SCRIPT_EXTENSIONS_INDEX]),
297 outData32+dataIndexes[UPROPS_SCRIPT_EXTENSIONS_INDEX],
298 pErrorCode);
299 }
300
301 /* i7 reservedIndex7; -- 32-bit unit index to the top of the Script_Extensions data */
302 return headerSize+4*dataIndexes[UPROPS_RESERVED_INDEX_7];
303 }
304
305 /* Unicode case mapping data swapping --------------------------------------- */
306
307 static int32_t U_CALLCONV
ucase_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)308 ucase_swap(const UDataSwapper *ds,
309 const void *inData, int32_t length, void *outData,
310 UErrorCode *pErrorCode) {
311 const UDataInfo *pInfo;
312 int32_t headerSize;
313
314 const uint8_t *inBytes;
315 uint8_t *outBytes;
316
317 const int32_t *inIndexes;
318 int32_t indexes[16];
319
320 int32_t i, offset, count, size;
321
322 /* udata_swapDataHeader checks the arguments */
323 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
324 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
325 return 0;
326 }
327
328 /* check data format and format version */
329 pInfo=(const UDataInfo *)((const char *)inData+4);
330 if(!(
331 pInfo->dataFormat[0]==UCASE_FMT_0 && /* dataFormat="cAsE" */
332 pInfo->dataFormat[1]==UCASE_FMT_1 &&
333 pInfo->dataFormat[2]==UCASE_FMT_2 &&
334 pInfo->dataFormat[3]==UCASE_FMT_3 &&
335 ((pInfo->formatVersion[0]==1 &&
336 pInfo->formatVersion[2]==UTRIE_SHIFT &&
337 pInfo->formatVersion[3]==UTRIE_INDEX_SHIFT) ||
338 pInfo->formatVersion[0]==2 || pInfo->formatVersion[0]==3)
339 )) {
340 udata_printError(ds, "ucase_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as case mapping data\n",
341 pInfo->dataFormat[0], pInfo->dataFormat[1],
342 pInfo->dataFormat[2], pInfo->dataFormat[3],
343 pInfo->formatVersion[0]);
344 *pErrorCode=U_UNSUPPORTED_ERROR;
345 return 0;
346 }
347
348 inBytes=(const uint8_t *)inData+headerSize;
349 outBytes=(uint8_t *)outData+headerSize;
350
351 inIndexes=(const int32_t *)inBytes;
352
353 if(length>=0) {
354 length-=headerSize;
355 if(length<16*4) {
356 udata_printError(ds, "ucase_swap(): too few bytes (%d after header) for case mapping data\n",
357 length);
358 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
359 return 0;
360 }
361 }
362
363 /* read the first 16 indexes (ICU 3.2/format version 1: UCASE_IX_TOP==16, might grow) */
364 for(i=0; i<16; ++i) {
365 indexes[i]=udata_readInt32(ds, inIndexes[i]);
366 }
367
368 /* get the total length of the data */
369 size=indexes[UCASE_IX_LENGTH];
370
371 if(length>=0) {
372 if(length<size) {
373 udata_printError(ds, "ucase_swap(): too few bytes (%d after header) for all of case mapping data\n",
374 length);
375 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
376 return 0;
377 }
378
379 /* copy the data for inaccessible bytes */
380 if(inBytes!=outBytes) {
381 uprv_memcpy(outBytes, inBytes, size);
382 }
383
384 offset=0;
385
386 /* swap the int32_t indexes[] */
387 count=indexes[UCASE_IX_INDEX_TOP]*4;
388 ds->swapArray32(ds, inBytes, count, outBytes, pErrorCode);
389 offset+=count;
390
391 /* swap the UTrie */
392 count=indexes[UCASE_IX_TRIE_SIZE];
393 utrie2_swapAnyVersion(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
394 offset+=count;
395
396 /* swap the uint16_t exceptions[] and unfold[] */
397 count=(indexes[UCASE_IX_EXC_LENGTH]+indexes[UCASE_IX_UNFOLD_LENGTH])*2;
398 ds->swapArray16(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
399 offset+=count;
400
401 U_ASSERT(offset==size);
402 }
403
404 return headerSize+size;
405 }
406
407 /* Unicode bidi/shaping data swapping --------------------------------------- */
408
409 static int32_t U_CALLCONV
ubidi_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)410 ubidi_swap(const UDataSwapper *ds,
411 const void *inData, int32_t length, void *outData,
412 UErrorCode *pErrorCode) {
413 const UDataInfo *pInfo;
414 int32_t headerSize;
415
416 const uint8_t *inBytes;
417 uint8_t *outBytes;
418
419 const int32_t *inIndexes;
420 int32_t indexes[16];
421
422 int32_t i, offset, count, size;
423
424 /* udata_swapDataHeader checks the arguments */
425 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
426 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
427 return 0;
428 }
429
430 /* check data format and format version */
431 pInfo=(const UDataInfo *)((const char *)inData+4);
432 if(!(
433 pInfo->dataFormat[0]==UBIDI_FMT_0 && /* dataFormat="BiDi" */
434 pInfo->dataFormat[1]==UBIDI_FMT_1 &&
435 pInfo->dataFormat[2]==UBIDI_FMT_2 &&
436 pInfo->dataFormat[3]==UBIDI_FMT_3 &&
437 ((pInfo->formatVersion[0]==1 &&
438 pInfo->formatVersion[2]==UTRIE_SHIFT &&
439 pInfo->formatVersion[3]==UTRIE_INDEX_SHIFT) ||
440 pInfo->formatVersion[0]==2)
441 )) {
442 udata_printError(ds, "ubidi_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as bidi/shaping data\n",
443 pInfo->dataFormat[0], pInfo->dataFormat[1],
444 pInfo->dataFormat[2], pInfo->dataFormat[3],
445 pInfo->formatVersion[0]);
446 *pErrorCode=U_UNSUPPORTED_ERROR;
447 return 0;
448 }
449
450 inBytes=(const uint8_t *)inData+headerSize;
451 outBytes=(uint8_t *)outData+headerSize;
452
453 inIndexes=(const int32_t *)inBytes;
454
455 if(length>=0) {
456 length-=headerSize;
457 if(length<16*4) {
458 udata_printError(ds, "ubidi_swap(): too few bytes (%d after header) for bidi/shaping data\n",
459 length);
460 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
461 return 0;
462 }
463 }
464
465 /* read the first 16 indexes (ICU 3.4/format version 1: UBIDI_IX_TOP==16, might grow) */
466 for(i=0; i<16; ++i) {
467 indexes[i]=udata_readInt32(ds, inIndexes[i]);
468 }
469
470 /* get the total length of the data */
471 size=indexes[UBIDI_IX_LENGTH];
472
473 if(length>=0) {
474 if(length<size) {
475 udata_printError(ds, "ubidi_swap(): too few bytes (%d after header) for all of bidi/shaping data\n",
476 length);
477 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
478 return 0;
479 }
480
481 /* copy the data for inaccessible bytes */
482 if(inBytes!=outBytes) {
483 uprv_memcpy(outBytes, inBytes, size);
484 }
485
486 offset=0;
487
488 /* swap the int32_t indexes[] */
489 count=indexes[UBIDI_IX_INDEX_TOP]*4;
490 ds->swapArray32(ds, inBytes, count, outBytes, pErrorCode);
491 offset+=count;
492
493 /* swap the UTrie */
494 count=indexes[UBIDI_IX_TRIE_SIZE];
495 utrie2_swapAnyVersion(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
496 offset+=count;
497
498 /* swap the uint32_t mirrors[] */
499 count=indexes[UBIDI_IX_MIRROR_LENGTH]*4;
500 ds->swapArray32(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
501 offset+=count;
502
503 /* just skip the uint8_t jgArray[] and jgArray2[] */
504 count=indexes[UBIDI_IX_JG_LIMIT]-indexes[UBIDI_IX_JG_START];
505 offset+=count;
506 count=indexes[UBIDI_IX_JG_LIMIT2]-indexes[UBIDI_IX_JG_START2];
507 offset+=count;
508
509 U_ASSERT(offset==size);
510 }
511
512 return headerSize+size;
513 }
514
515 /* Unicode normalization data swapping -------------------------------------- */
516
517 #if !UCONFIG_NO_NORMALIZATION
518
519 static int32_t U_CALLCONV
unorm_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)520 unorm_swap(const UDataSwapper *ds,
521 const void *inData, int32_t length, void *outData,
522 UErrorCode *pErrorCode) {
523 const UDataInfo *pInfo;
524 int32_t headerSize;
525
526 const uint8_t *inBytes;
527 uint8_t *outBytes;
528
529 const int32_t *inIndexes;
530 int32_t indexes[32];
531
532 int32_t i, offset, count, size;
533
534 /* udata_swapDataHeader checks the arguments */
535 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
536 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
537 return 0;
538 }
539
540 /* check data format and format version */
541 pInfo=(const UDataInfo *)((const char *)inData+4);
542 if(!(
543 pInfo->dataFormat[0]==0x4e && /* dataFormat="Norm" */
544 pInfo->dataFormat[1]==0x6f &&
545 pInfo->dataFormat[2]==0x72 &&
546 pInfo->dataFormat[3]==0x6d &&
547 pInfo->formatVersion[0]==2
548 )) {
549 udata_printError(ds, "unorm_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as unorm.icu\n",
550 pInfo->dataFormat[0], pInfo->dataFormat[1],
551 pInfo->dataFormat[2], pInfo->dataFormat[3],
552 pInfo->formatVersion[0]);
553 *pErrorCode=U_UNSUPPORTED_ERROR;
554 return 0;
555 }
556
557 inBytes=(const uint8_t *)inData+headerSize;
558 outBytes=(uint8_t *)outData+headerSize;
559
560 inIndexes=(const int32_t *)inBytes;
561
562 if(length>=0) {
563 length-=headerSize;
564 if(length<32*4) {
565 udata_printError(ds, "unorm_swap(): too few bytes (%d after header) for unorm.icu\n",
566 length);
567 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
568 return 0;
569 }
570 }
571
572 /* read the first 32 indexes (ICU 2.8/format version 2.2: _NORM_INDEX_TOP==32, might grow) */
573 for(i=0; i<32; ++i) {
574 indexes[i]=udata_readInt32(ds, inIndexes[i]);
575 }
576
577 /* calculate the total length of the data */
578 size=
579 32*4+ /* size of indexes[] */
580 indexes[_NORM_INDEX_TRIE_SIZE]+
581 indexes[_NORM_INDEX_UCHAR_COUNT]*2+
582 indexes[_NORM_INDEX_COMBINE_DATA_COUNT]*2+
583 indexes[_NORM_INDEX_FCD_TRIE_SIZE]+
584 indexes[_NORM_INDEX_AUX_TRIE_SIZE]+
585 indexes[_NORM_INDEX_CANON_SET_COUNT]*2;
586
587 if(length>=0) {
588 if(length<size) {
589 udata_printError(ds, "unorm_swap(): too few bytes (%d after header) for all of unorm.icu\n",
590 length);
591 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
592 return 0;
593 }
594
595 /* copy the data for inaccessible bytes */
596 if(inBytes!=outBytes) {
597 uprv_memcpy(outBytes, inBytes, size);
598 }
599
600 offset=0;
601
602 /* swap the indexes[] */
603 count=32*4;
604 ds->swapArray32(ds, inBytes, count, outBytes, pErrorCode);
605 offset+=count;
606
607 /* swap the main UTrie */
608 count=indexes[_NORM_INDEX_TRIE_SIZE];
609 utrie_swap(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
610 offset+=count;
611
612 /* swap the uint16_t extraData[] and the uint16_t combiningTable[] */
613 count=(indexes[_NORM_INDEX_UCHAR_COUNT]+indexes[_NORM_INDEX_COMBINE_DATA_COUNT])*2;
614 ds->swapArray16(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
615 offset+=count;
616
617 /* swap the FCD UTrie */
618 count=indexes[_NORM_INDEX_FCD_TRIE_SIZE];
619 if(count!=0) {
620 utrie_swap(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
621 offset+=count;
622 }
623
624 /* swap the aux UTrie */
625 count=indexes[_NORM_INDEX_AUX_TRIE_SIZE];
626 if(count!=0) {
627 utrie_swap(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
628 offset+=count;
629 }
630
631 /* swap the uint16_t combiningTable[] */
632 count=indexes[_NORM_INDEX_CANON_SET_COUNT]*2;
633 ds->swapArray16(ds, inBytes+offset, count, outBytes+offset, pErrorCode);
634 offset+=count;
635 }
636
637 return headerSize+size;
638 }
639
640 #endif
641
642 /* Swap 'Test' data from gentest */
643 static int32_t U_CALLCONV
test_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)644 test_swap(const UDataSwapper *ds,
645 const void *inData, int32_t length, void *outData,
646 UErrorCode *pErrorCode) {
647 const UDataInfo *pInfo;
648 int32_t headerSize;
649
650 const uint8_t *inBytes;
651 uint8_t *outBytes;
652
653 int32_t offset;
654
655 /* udata_swapDataHeader checks the arguments */
656 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
657 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
658 udata_printError(ds, "test_swap(): data header swap failed %s\n", pErrorCode != NULL ? u_errorName(*pErrorCode) : "pErrorCode is NULL");
659 return 0;
660 }
661
662 /* check data format and format version */
663 pInfo=(const UDataInfo *)((const char *)inData+4);
664 if(!(
665 pInfo->dataFormat[0]==0x54 && /* dataFormat="Norm" */
666 pInfo->dataFormat[1]==0x65 &&
667 pInfo->dataFormat[2]==0x73 &&
668 pInfo->dataFormat[3]==0x74 &&
669 pInfo->formatVersion[0]==1
670 )) {
671 udata_printError(ds, "test_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as testdata\n",
672 pInfo->dataFormat[0], pInfo->dataFormat[1],
673 pInfo->dataFormat[2], pInfo->dataFormat[3],
674 pInfo->formatVersion[0]);
675 *pErrorCode=U_UNSUPPORTED_ERROR;
676 return 0;
677 }
678
679 inBytes=(const uint8_t *)inData+headerSize;
680 outBytes=(uint8_t *)outData+headerSize;
681
682 int32_t size16 = 2; // 16bit plus padding
683 int32_t sizeStr = 5; // 4 char inv-str plus null
684 int32_t size = size16 + sizeStr;
685
686 if(length>=0) {
687 if(length<size) {
688 udata_printError(ds, "test_swap(): too few bytes (%d after header, wanted %d) for all of testdata\n",
689 length, size);
690 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
691 return 0;
692 }
693
694 offset =0;
695 /* swap a 1 entry array */
696 ds->swapArray16(ds, inBytes+offset, size16, outBytes+offset, pErrorCode);
697 offset+=size16;
698 ds->swapInvChars(ds, inBytes+offset, sizeStr, outBytes+offset, pErrorCode);
699 }
700
701 return headerSize+size;
702 }
703
704 /* swap any data (except a .dat package) ------------------------------------ */
705
706 static const struct {
707 uint8_t dataFormat[4];
708 UDataSwapFn *swapFn;
709 } swapFns[]={
710 { { 0x52, 0x65, 0x73, 0x42 }, ures_swap }, /* dataFormat="ResB" */
711 #if !UCONFIG_NO_LEGACY_CONVERSION
712 { { 0x63, 0x6e, 0x76, 0x74 }, ucnv_swap }, /* dataFormat="cnvt" */
713 #endif
714 #if !UCONFIG_NO_CONVERSION
715 { { 0x43, 0x76, 0x41, 0x6c }, ucnv_swapAliases }, /* dataFormat="CvAl" */
716 #endif
717 #if !UCONFIG_NO_IDNA
718 { { 0x53, 0x50, 0x52, 0x50 }, usprep_swap }, /* dataFormat="SPRP" */
719 #endif
720 /* insert data formats here, descending by expected frequency of occurrence */
721 { { 0x55, 0x50, 0x72, 0x6f }, uprops_swap }, /* dataFormat="UPro" */
722
723 { { UCASE_FMT_0, UCASE_FMT_1, UCASE_FMT_2, UCASE_FMT_3 },
724 ucase_swap }, /* dataFormat="cAsE" */
725
726 { { UBIDI_FMT_0, UBIDI_FMT_1, UBIDI_FMT_2, UBIDI_FMT_3 },
727 ubidi_swap }, /* dataFormat="BiDi" */
728
729 #if !UCONFIG_NO_NORMALIZATION
730 { { 0x4e, 0x6f, 0x72, 0x6d }, unorm_swap }, /* dataFormat="Norm" */
731 { { 0x4e, 0x72, 0x6d, 0x32 }, unorm2_swap }, /* dataFormat="Nrm2" */
732 #endif
733 #if !UCONFIG_NO_COLLATION
734 { { 0x55, 0x43, 0x6f, 0x6c }, ucol_swap }, /* dataFormat="UCol" */
735 { { 0x49, 0x6e, 0x76, 0x43 }, ucol_swapInverseUCA },/* dataFormat="InvC" */
736 #endif
737 #if !UCONFIG_NO_BREAK_ITERATION
738 { { 0x42, 0x72, 0x6b, 0x20 }, ubrk_swap }, /* dataFormat="Brk " */
739 { { 0x44, 0x69, 0x63, 0x74 }, udict_swap }, /* dataFormat="Dict" */
740 #endif
741 { { 0x70, 0x6e, 0x61, 0x6d }, upname_swap }, /* dataFormat="pnam" */
742 { { 0x75, 0x6e, 0x61, 0x6d }, uchar_swapNames }, /* dataFormat="unam" */
743 #if !UCONFIG_NO_NORMALIZATION
744 { { 0x43, 0x66, 0x75, 0x20 }, uspoof_swap }, /* dataFormat="Cfu " */
745 #endif
746 { { 0x54, 0x65, 0x73, 0x74 }, test_swap } /* dataFormat="Test" */
747 };
748
749 U_CAPI int32_t U_EXPORT2
udata_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)750 udata_swap(const UDataSwapper *ds,
751 const void *inData, int32_t length, void *outData,
752 UErrorCode *pErrorCode) {
753 char dataFormatChars[4];
754 const UDataInfo *pInfo;
755 int32_t i, swappedLength;
756
757 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
758 return 0;
759 }
760
761 /*
762 * Preflight the header first; checks for illegal arguments, too.
763 * Do not swap the header right away because the format-specific swapper
764 * will swap it, get the headerSize again, and also use the header
765 * information. Otherwise we would have to pass some of the information
766 * and not be able to use the UDataSwapFn signature.
767 */
768 udata_swapDataHeader(ds, inData, -1, NULL, pErrorCode);
769
770 /*
771 * If we wanted udata_swap() to also handle non-loadable data like a UTrie,
772 * then we could check here for further known magic values and structures.
773 */
774 if(U_FAILURE(*pErrorCode)) {
775 return 0; /* the data format was not recognized */
776 }
777
778 pInfo=(const UDataInfo *)((const char *)inData+4);
779
780 {
781 /* convert the data format from ASCII to Unicode to the system charset */
782 UChar u[4]={
783 pInfo->dataFormat[0], pInfo->dataFormat[1],
784 pInfo->dataFormat[2], pInfo->dataFormat[3]
785 };
786
787 if(uprv_isInvariantUString(u, 4)) {
788 u_UCharsToChars(u, dataFormatChars, 4);
789 } else {
790 dataFormatChars[0]=dataFormatChars[1]=dataFormatChars[2]=dataFormatChars[3]='?';
791 }
792 }
793
794 /* dispatch to the swap function for the dataFormat */
795 for(i=0; i<UPRV_LENGTHOF(swapFns); ++i) {
796 if(0==memcmp(swapFns[i].dataFormat, pInfo->dataFormat, 4)) {
797 swappedLength=swapFns[i].swapFn(ds, inData, length, outData, pErrorCode);
798
799 if(U_FAILURE(*pErrorCode)) {
800 udata_printError(ds, "udata_swap(): failure swapping data format %02x.%02x.%02x.%02x (\"%c%c%c%c\") - %s\n",
801 pInfo->dataFormat[0], pInfo->dataFormat[1],
802 pInfo->dataFormat[2], pInfo->dataFormat[3],
803 dataFormatChars[0], dataFormatChars[1],
804 dataFormatChars[2], dataFormatChars[3],
805 u_errorName(*pErrorCode));
806 } else if(swappedLength<(length-15)) {
807 /* swapped less than expected */
808 udata_printError(ds, "udata_swap() warning: swapped only %d out of %d bytes - data format %02x.%02x.%02x.%02x (\"%c%c%c%c\")\n",
809 swappedLength, length,
810 pInfo->dataFormat[0], pInfo->dataFormat[1],
811 pInfo->dataFormat[2], pInfo->dataFormat[3],
812 dataFormatChars[0], dataFormatChars[1],
813 dataFormatChars[2], dataFormatChars[3],
814 u_errorName(*pErrorCode));
815 }
816
817 return swappedLength;
818 }
819 }
820
821 /* the dataFormat was not recognized */
822 udata_printError(ds, "udata_swap(): unknown data format %02x.%02x.%02x.%02x (\"%c%c%c%c\")\n",
823 pInfo->dataFormat[0], pInfo->dataFormat[1],
824 pInfo->dataFormat[2], pInfo->dataFormat[3],
825 dataFormatChars[0], dataFormatChars[1],
826 dataFormatChars[2], dataFormatChars[3]);
827
828 *pErrorCode=U_UNSUPPORTED_ERROR;
829 return 0;
830 }
831