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