1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 2003-2015, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: ucol_swp.cpp
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2003sep10
14 * created by: Markus W. Scherer
15 *
16 * Swap collation binaries.
17 */
18
19 #include "unicode/udata.h" /* UDataInfo */
20 #include "utrie.h"
21 #include "utrie2.h"
22 #include "udataswp.h"
23 #include "cmemory.h"
24 #include "ucol_data.h"
25 #include "ucol_swp.h"
26
27 /* swapping ----------------------------------------------------------------- */
28
29 /*
30 * This performs data swapping for a folded trie (see utrie.c for details).
31 */
32
33 U_CAPI int32_t U_EXPORT2
utrie_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)34 utrie_swap(const UDataSwapper *ds,
35 const void *inData, int32_t length, void *outData,
36 UErrorCode *pErrorCode) {
37 const UTrieHeader *inTrie;
38 UTrieHeader trie;
39 int32_t size;
40 UBool dataIs32;
41
42 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
43 return 0;
44 }
45 if(ds==NULL || inData==NULL || (length>=0 && outData==NULL)) {
46 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
47 return 0;
48 }
49
50 /* setup and swapping */
51 if(length>=0 && (uint32_t)length<sizeof(UTrieHeader)) {
52 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
53 return 0;
54 }
55
56 inTrie=(const UTrieHeader *)inData;
57 trie.signature=ds->readUInt32(inTrie->signature);
58 trie.options=ds->readUInt32(inTrie->options);
59 trie.indexLength=udata_readInt32(ds, inTrie->indexLength);
60 trie.dataLength=udata_readInt32(ds, inTrie->dataLength);
61
62 if( trie.signature!=0x54726965 ||
63 (trie.options&UTRIE_OPTIONS_SHIFT_MASK)!=UTRIE_SHIFT ||
64 ((trie.options>>UTRIE_OPTIONS_INDEX_SHIFT)&UTRIE_OPTIONS_SHIFT_MASK)!=UTRIE_INDEX_SHIFT ||
65 trie.indexLength<UTRIE_BMP_INDEX_LENGTH ||
66 (trie.indexLength&(UTRIE_SURROGATE_BLOCK_COUNT-1))!=0 ||
67 trie.dataLength<UTRIE_DATA_BLOCK_LENGTH ||
68 (trie.dataLength&(UTRIE_DATA_GRANULARITY-1))!=0 ||
69 ((trie.options&UTRIE_OPTIONS_LATIN1_IS_LINEAR)!=0 && trie.dataLength<(UTRIE_DATA_BLOCK_LENGTH+0x100))
70 ) {
71 *pErrorCode=U_INVALID_FORMAT_ERROR; /* not a UTrie */
72 return 0;
73 }
74
75 dataIs32=(UBool)((trie.options&UTRIE_OPTIONS_DATA_IS_32_BIT)!=0);
76 size=sizeof(UTrieHeader)+trie.indexLength*2+trie.dataLength*(dataIs32?4:2);
77
78 if(length>=0) {
79 UTrieHeader *outTrie;
80
81 if(length<size) {
82 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
83 return 0;
84 }
85
86 outTrie=(UTrieHeader *)outData;
87
88 /* swap the header */
89 ds->swapArray32(ds, inTrie, sizeof(UTrieHeader), outTrie, pErrorCode);
90
91 /* swap the index and the data */
92 if(dataIs32) {
93 ds->swapArray16(ds, inTrie+1, trie.indexLength*2, outTrie+1, pErrorCode);
94 ds->swapArray32(ds, (const uint16_t *)(inTrie+1)+trie.indexLength, trie.dataLength*4,
95 (uint16_t *)(outTrie+1)+trie.indexLength, pErrorCode);
96 } else {
97 ds->swapArray16(ds, inTrie+1, (trie.indexLength+trie.dataLength)*2, outTrie+1, pErrorCode);
98 }
99 }
100
101 return size;
102 }
103
104 #if !UCONFIG_NO_COLLATION
105
106 U_CAPI UBool U_EXPORT2
ucol_looksLikeCollationBinary(const UDataSwapper * ds,const void * inData,int32_t length)107 ucol_looksLikeCollationBinary(const UDataSwapper *ds,
108 const void *inData, int32_t length) {
109 if(ds==NULL || inData==NULL || length<-1) {
110 return FALSE;
111 }
112
113 // First check for format version 4+ which has a standard data header.
114 UErrorCode errorCode=U_ZERO_ERROR;
115 (void)udata_swapDataHeader(ds, inData, -1, NULL, &errorCode);
116 if(U_SUCCESS(errorCode)) {
117 const UDataInfo &info=*(const UDataInfo *)((const char *)inData+4);
118 if(info.dataFormat[0]==0x55 && // dataFormat="UCol"
119 info.dataFormat[1]==0x43 &&
120 info.dataFormat[2]==0x6f &&
121 info.dataFormat[3]==0x6c) {
122 return TRUE;
123 }
124 }
125
126 // Else check for format version 3.
127 const UCATableHeader *inHeader=(const UCATableHeader *)inData;
128
129 /*
130 * The collation binary must contain at least the UCATableHeader,
131 * starting with its size field.
132 * sizeof(UCATableHeader)==42*4 in ICU 2.8
133 * check the length against the header size before reading the size field
134 */
135 UCATableHeader header;
136 uprv_memset(&header, 0, sizeof(header));
137 if(length<0) {
138 header.size=udata_readInt32(ds, inHeader->size);
139 } else if((length<(42*4) || length<(header.size=udata_readInt32(ds, inHeader->size)))) {
140 return FALSE;
141 }
142
143 header.magic=ds->readUInt32(inHeader->magic);
144 if(!(
145 header.magic==UCOL_HEADER_MAGIC &&
146 inHeader->formatVersion[0]==3 /*&&
147 inHeader->formatVersion[1]>=0*/
148 )) {
149 return FALSE;
150 }
151
152 if(inHeader->isBigEndian!=ds->inIsBigEndian || inHeader->charSetFamily!=ds->inCharset) {
153 return FALSE;
154 }
155
156 return TRUE;
157 }
158
159 namespace {
160
161 /* swap a header-less collation formatVersion=3 binary, inside a resource bundle or ucadata.icu */
162 int32_t
swapFormatVersion3(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)163 swapFormatVersion3(const UDataSwapper *ds,
164 const void *inData, int32_t length, void *outData,
165 UErrorCode *pErrorCode) {
166 const uint8_t *inBytes;
167 uint8_t *outBytes;
168
169 const UCATableHeader *inHeader;
170 UCATableHeader *outHeader;
171 UCATableHeader header;
172
173 uint32_t count;
174
175 /* argument checking in case we were not called from ucol_swap() */
176 if(U_FAILURE(*pErrorCode)) {
177 return 0;
178 }
179 if(ds==NULL || inData==NULL || length<-1 || (length>0 && outData==NULL)) {
180 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
181 return 0;
182 }
183
184 inBytes=(const uint8_t *)inData;
185 outBytes=(uint8_t *)outData;
186
187 inHeader=(const UCATableHeader *)inData;
188 outHeader=(UCATableHeader *)outData;
189
190 /*
191 * The collation binary must contain at least the UCATableHeader,
192 * starting with its size field.
193 * sizeof(UCATableHeader)==42*4 in ICU 2.8
194 * check the length against the header size before reading the size field
195 */
196 uprv_memset(&header, 0, sizeof(header));
197 if(length<0) {
198 header.size=udata_readInt32(ds, inHeader->size);
199 } else if((length<(42*4) || length<(header.size=udata_readInt32(ds, inHeader->size)))) {
200 udata_printError(ds, "ucol_swap(formatVersion=3): too few bytes (%d after header) for collation data\n",
201 length);
202 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
203 return 0;
204 }
205
206 header.magic=ds->readUInt32(inHeader->magic);
207 if(!(
208 header.magic==UCOL_HEADER_MAGIC &&
209 inHeader->formatVersion[0]==3 /*&&
210 inHeader->formatVersion[1]>=0*/
211 )) {
212 udata_printError(ds, "ucol_swap(formatVersion=3): magic 0x%08x or format version %02x.%02x is not a collation binary\n",
213 header.magic,
214 inHeader->formatVersion[0], inHeader->formatVersion[1]);
215 *pErrorCode=U_UNSUPPORTED_ERROR;
216 return 0;
217 }
218
219 if(inHeader->isBigEndian!=ds->inIsBigEndian || inHeader->charSetFamily!=ds->inCharset) {
220 udata_printError(ds, "ucol_swap(formatVersion=3): endianness %d or charset %d does not match the swapper\n",
221 inHeader->isBigEndian, inHeader->charSetFamily);
222 *pErrorCode=U_INVALID_FORMAT_ERROR;
223 return 0;
224 }
225
226 if(length>=0) {
227 /* copy everything, takes care of data that needs no swapping */
228 if(inBytes!=outBytes) {
229 uprv_memcpy(outBytes, inBytes, header.size);
230 }
231
232 /* swap the necessary pieces in the order of their occurrence in the data */
233
234 /* read more of the UCATableHeader (the size field was read above) */
235 header.options= ds->readUInt32(inHeader->options);
236 header.UCAConsts= ds->readUInt32(inHeader->UCAConsts);
237 header.contractionUCACombos= ds->readUInt32(inHeader->contractionUCACombos);
238 header.mappingPosition= ds->readUInt32(inHeader->mappingPosition);
239 header.expansion= ds->readUInt32(inHeader->expansion);
240 header.contractionIndex= ds->readUInt32(inHeader->contractionIndex);
241 header.contractionCEs= ds->readUInt32(inHeader->contractionCEs);
242 header.contractionSize= ds->readUInt32(inHeader->contractionSize);
243 header.endExpansionCE= ds->readUInt32(inHeader->endExpansionCE);
244 header.expansionCESize= ds->readUInt32(inHeader->expansionCESize);
245 header.endExpansionCECount= udata_readInt32(ds, inHeader->endExpansionCECount);
246 header.contractionUCACombosSize=udata_readInt32(ds, inHeader->contractionUCACombosSize);
247 header.scriptToLeadByte= ds->readUInt32(inHeader->scriptToLeadByte);
248 header.leadByteToScript= ds->readUInt32(inHeader->leadByteToScript);
249
250 /* swap the 32-bit integers in the header */
251 ds->swapArray32(ds, inHeader, (int32_t)((const char *)&inHeader->jamoSpecial-(const char *)inHeader),
252 outHeader, pErrorCode);
253 ds->swapArray32(ds, &(inHeader->scriptToLeadByte), sizeof(header.scriptToLeadByte) + sizeof(header.leadByteToScript),
254 &(outHeader->scriptToLeadByte), pErrorCode);
255 /* set the output platform properties */
256 outHeader->isBigEndian=ds->outIsBigEndian;
257 outHeader->charSetFamily=ds->outCharset;
258
259 /* swap the options */
260 if(header.options!=0) {
261 ds->swapArray32(ds, inBytes+header.options, header.expansion-header.options,
262 outBytes+header.options, pErrorCode);
263 }
264
265 /* swap the expansions */
266 if(header.mappingPosition!=0 && header.expansion!=0) {
267 if(header.contractionIndex!=0) {
268 /* expansions bounded by contractions */
269 count=header.contractionIndex-header.expansion;
270 } else {
271 /* no contractions: expansions bounded by the main trie */
272 count=header.mappingPosition-header.expansion;
273 }
274 ds->swapArray32(ds, inBytes+header.expansion, (int32_t)count,
275 outBytes+header.expansion, pErrorCode);
276 }
277
278 /* swap the contractions */
279 if(header.contractionSize!=0) {
280 /* contractionIndex: UChar[] */
281 ds->swapArray16(ds, inBytes+header.contractionIndex, header.contractionSize*2,
282 outBytes+header.contractionIndex, pErrorCode);
283
284 /* contractionCEs: CEs[] */
285 ds->swapArray32(ds, inBytes+header.contractionCEs, header.contractionSize*4,
286 outBytes+header.contractionCEs, pErrorCode);
287 }
288
289 /* swap the main trie */
290 if(header.mappingPosition!=0) {
291 count=header.endExpansionCE-header.mappingPosition;
292 utrie_swap(ds, inBytes+header.mappingPosition, (int32_t)count,
293 outBytes+header.mappingPosition, pErrorCode);
294 }
295
296 /* swap the max expansion table */
297 if(header.endExpansionCECount!=0) {
298 ds->swapArray32(ds, inBytes+header.endExpansionCE, header.endExpansionCECount*4,
299 outBytes+header.endExpansionCE, pErrorCode);
300 }
301
302 /* expansionCESize, unsafeCP, contrEndCP: uint8_t[], no need to swap */
303
304 /* swap UCA constants */
305 if(header.UCAConsts!=0) {
306 /*
307 * if UCAConsts!=0 then contractionUCACombos because we are swapping
308 * the UCA data file, and we know that the UCA contains contractions
309 */
310 ds->swapArray32(ds, inBytes+header.UCAConsts, header.contractionUCACombos-header.UCAConsts,
311 outBytes+header.UCAConsts, pErrorCode);
312 }
313
314 /* swap UCA contractions */
315 if(header.contractionUCACombosSize!=0) {
316 count=header.contractionUCACombosSize*inHeader->contractionUCACombosWidth*U_SIZEOF_UCHAR;
317 ds->swapArray16(ds, inBytes+header.contractionUCACombos, (int32_t)count,
318 outBytes+header.contractionUCACombos, pErrorCode);
319 }
320
321 /* swap the script to lead bytes */
322 if(header.scriptToLeadByte!=0) {
323 int indexCount = ds->readUInt16(*((uint16_t*)(inBytes+header.scriptToLeadByte))); // each entry = 2 * uint16
324 int dataCount = ds->readUInt16(*((uint16_t*)(inBytes+header.scriptToLeadByte + 2))); // each entry = uint16
325 ds->swapArray16(ds, inBytes+header.scriptToLeadByte,
326 4 + (4 * indexCount) + (2 * dataCount),
327 outBytes+header.scriptToLeadByte, pErrorCode);
328 }
329
330 /* swap the lead byte to scripts */
331 if(header.leadByteToScript!=0) {
332 int indexCount = ds->readUInt16(*((uint16_t*)(inBytes+header.leadByteToScript))); // each entry = uint16
333 int dataCount = ds->readUInt16(*((uint16_t*)(inBytes+header.leadByteToScript + 2))); // each entry = uint16
334 ds->swapArray16(ds, inBytes+header.leadByteToScript,
335 4 + (2 * indexCount) + (2 * dataCount),
336 outBytes+header.leadByteToScript, pErrorCode);
337 }
338 }
339
340 return header.size;
341 }
342
343 // swap formatVersion 4 or 5 ----------------------------------------------- ***
344
345 // The following are copied from CollationDataReader, trading an awkward copy of constants
346 // for an awkward relocation of the i18n collationdatareader.h file into the common library.
347 // Keep them in sync!
348
349 enum {
350 IX_INDEXES_LENGTH, // 0
351 IX_OPTIONS,
352 IX_RESERVED2,
353 IX_RESERVED3,
354
355 IX_JAMO_CE32S_START, // 4
356 IX_REORDER_CODES_OFFSET,
357 IX_REORDER_TABLE_OFFSET,
358 IX_TRIE_OFFSET,
359
360 IX_RESERVED8_OFFSET, // 8
361 IX_CES_OFFSET,
362 IX_RESERVED10_OFFSET,
363 IX_CE32S_OFFSET,
364
365 IX_ROOT_ELEMENTS_OFFSET, // 12
366 IX_CONTEXTS_OFFSET,
367 IX_UNSAFE_BWD_OFFSET,
368 IX_FAST_LATIN_TABLE_OFFSET,
369
370 IX_SCRIPTS_OFFSET, // 16
371 IX_COMPRESSIBLE_BYTES_OFFSET,
372 IX_RESERVED18_OFFSET,
373 IX_TOTAL_SIZE
374 };
375
376 int32_t
swapFormatVersion4(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode & errorCode)377 swapFormatVersion4(const UDataSwapper *ds,
378 const void *inData, int32_t length, void *outData,
379 UErrorCode &errorCode) {
380 if(U_FAILURE(errorCode)) { return 0; }
381
382 const uint8_t *inBytes=(const uint8_t *)inData;
383 uint8_t *outBytes=(uint8_t *)outData;
384
385 const int32_t *inIndexes=(const int32_t *)inBytes;
386 int32_t indexes[IX_TOTAL_SIZE+1];
387
388 // Need at least IX_INDEXES_LENGTH and IX_OPTIONS.
389 if(0<=length && length<8) {
390 udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
391 "(%d after header) for collation data\n",
392 length);
393 errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
394 return 0;
395 }
396
397 int32_t indexesLength=indexes[0]=udata_readInt32(ds, inIndexes[0]);
398 if(0<=length && length<(indexesLength*4)) {
399 udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
400 "(%d after header) for collation data\n",
401 length);
402 errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
403 return 0;
404 }
405
406 for(int32_t i=1; i<=IX_TOTAL_SIZE && i<indexesLength; ++i) {
407 indexes[i]=udata_readInt32(ds, inIndexes[i]);
408 }
409 for(int32_t i=indexesLength; i<=IX_TOTAL_SIZE; ++i) {
410 indexes[i]=-1;
411 }
412 inIndexes=NULL; // Make sure we do not accidentally use these instead of indexes[].
413
414 // Get the total length of the data.
415 int32_t size;
416 if(indexesLength>IX_TOTAL_SIZE) {
417 size=indexes[IX_TOTAL_SIZE];
418 } else if(indexesLength>IX_REORDER_CODES_OFFSET) {
419 size=indexes[indexesLength-1];
420 } else {
421 size=indexesLength*4;
422 }
423 if(length<0) { return size; }
424
425 if(length<size) {
426 udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
427 "(%d after header) for collation data\n",
428 length);
429 errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
430 return 0;
431 }
432
433 // Copy the data for inaccessible bytes and arrays of bytes.
434 if(inBytes!=outBytes) {
435 uprv_memcpy(outBytes, inBytes, size);
436 }
437
438 // Swap the int32_t indexes[].
439 ds->swapArray32(ds, inBytes, indexesLength * 4, outBytes, &errorCode);
440
441 // The following is a modified version of CollationDataReader::read().
442 // Here we use indexes[] not inIndexes[] because
443 // the inIndexes[] may not be in this machine's endianness.
444 int32_t index; // one of the indexes[] slots
445 int32_t offset; // byte offset for the index part
446 // int32_t length; // number of bytes in the index part
447
448 index = IX_REORDER_CODES_OFFSET;
449 offset = indexes[index];
450 length = indexes[index + 1] - offset;
451 if(length > 0) {
452 ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
453 }
454
455 // Skip the IX_REORDER_TABLE_OFFSET byte array.
456
457 index = IX_TRIE_OFFSET;
458 offset = indexes[index];
459 length = indexes[index + 1] - offset;
460 if(length > 0) {
461 utrie2_swap(ds, inBytes + offset, length, outBytes + offset, &errorCode);
462 }
463
464 index = IX_RESERVED8_OFFSET;
465 offset = indexes[index];
466 length = indexes[index + 1] - offset;
467 if(length > 0) {
468 udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED8_OFFSET\n", length);
469 errorCode = U_UNSUPPORTED_ERROR;
470 return 0;
471 }
472
473 index = IX_CES_OFFSET;
474 offset = indexes[index];
475 length = indexes[index + 1] - offset;
476 if(length > 0) {
477 ds->swapArray64(ds, inBytes + offset, length, outBytes + offset, &errorCode);
478 }
479
480 index = IX_RESERVED10_OFFSET;
481 offset = indexes[index];
482 length = indexes[index + 1] - offset;
483 if(length > 0) {
484 udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED10_OFFSET\n", length);
485 errorCode = U_UNSUPPORTED_ERROR;
486 return 0;
487 }
488
489 index = IX_CE32S_OFFSET;
490 offset = indexes[index];
491 length = indexes[index + 1] - offset;
492 if(length > 0) {
493 ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
494 }
495
496 index = IX_ROOT_ELEMENTS_OFFSET;
497 offset = indexes[index];
498 length = indexes[index + 1] - offset;
499 if(length > 0) {
500 ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
501 }
502
503 index = IX_CONTEXTS_OFFSET;
504 offset = indexes[index];
505 length = indexes[index + 1] - offset;
506 if(length > 0) {
507 ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
508 }
509
510 index = IX_UNSAFE_BWD_OFFSET;
511 offset = indexes[index];
512 length = indexes[index + 1] - offset;
513 if(length > 0) {
514 ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
515 }
516
517 index = IX_FAST_LATIN_TABLE_OFFSET;
518 offset = indexes[index];
519 length = indexes[index + 1] - offset;
520 if(length > 0) {
521 ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
522 }
523
524 index = IX_SCRIPTS_OFFSET;
525 offset = indexes[index];
526 length = indexes[index + 1] - offset;
527 if(length > 0) {
528 ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
529 }
530
531 // Skip the IX_COMPRESSIBLE_BYTES_OFFSET byte array.
532
533 index = IX_RESERVED18_OFFSET;
534 offset = indexes[index];
535 length = indexes[index + 1] - offset;
536 if(length > 0) {
537 udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED18_OFFSET\n", length);
538 errorCode = U_UNSUPPORTED_ERROR;
539 return 0;
540 }
541
542 return size;
543 }
544
545 } // namespace
546
547 /* swap ICU collation data like ucadata.icu */
548 U_CAPI int32_t U_EXPORT2
ucol_swap(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)549 ucol_swap(const UDataSwapper *ds,
550 const void *inData, int32_t length, void *outData,
551 UErrorCode *pErrorCode) {
552 if(U_FAILURE(*pErrorCode)) { return 0; }
553
554 /* udata_swapDataHeader checks the arguments */
555 int32_t headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
556 if(U_FAILURE(*pErrorCode)) {
557 // Try to swap the old format version which did not have a standard data header.
558 *pErrorCode=U_ZERO_ERROR;
559 return swapFormatVersion3(ds, inData, length, outData, pErrorCode);
560 }
561
562 /* check data format and format version */
563 const UDataInfo &info=*(const UDataInfo *)((const char *)inData+4);
564 if(!(
565 info.dataFormat[0]==0x55 && // dataFormat="UCol"
566 info.dataFormat[1]==0x43 &&
567 info.dataFormat[2]==0x6f &&
568 info.dataFormat[3]==0x6c &&
569 (3<=info.formatVersion[0] && info.formatVersion[0]<=5)
570 )) {
571 udata_printError(ds, "ucol_swap(): data format %02x.%02x.%02x.%02x "
572 "(format version %02x.%02x) is not recognized as collation data\n",
573 info.dataFormat[0], info.dataFormat[1],
574 info.dataFormat[2], info.dataFormat[3],
575 info.formatVersion[0], info.formatVersion[1]);
576 *pErrorCode=U_UNSUPPORTED_ERROR;
577 return 0;
578 }
579
580 inData=(const char *)inData+headerSize;
581 if(length>=0) { length-=headerSize; }
582 outData=(char *)outData+headerSize;
583 int32_t collationSize;
584 if(info.formatVersion[0]>=4) {
585 collationSize=swapFormatVersion4(ds, inData, length, outData, *pErrorCode);
586 } else {
587 collationSize=swapFormatVersion3(ds, inData, length, outData, pErrorCode);
588 }
589 if(U_SUCCESS(*pErrorCode)) {
590 return headerSize+collationSize;
591 } else {
592 return 0;
593 }
594 }
595
596 /* swap inverse UCA collation data (invuca.icu) */
597 U_CAPI int32_t U_EXPORT2
ucol_swapInverseUCA(const UDataSwapper * ds,const void * inData,int32_t length,void * outData,UErrorCode * pErrorCode)598 ucol_swapInverseUCA(const UDataSwapper *ds,
599 const void *inData, int32_t length, void *outData,
600 UErrorCode *pErrorCode) {
601 const UDataInfo *pInfo;
602 int32_t headerSize;
603
604 const uint8_t *inBytes;
605 uint8_t *outBytes;
606
607 const InverseUCATableHeader *inHeader;
608 InverseUCATableHeader *outHeader;
609 InverseUCATableHeader header={ 0,0,0,0,0,{0,0,0,0},{0,0,0,0,0,0,0,0} };
610
611 /* udata_swapDataHeader checks the arguments */
612 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
613 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
614 return 0;
615 }
616
617 /* check data format and format version */
618 pInfo=(const UDataInfo *)((const char *)inData+4);
619 if(!(
620 pInfo->dataFormat[0]==0x49 && /* dataFormat="InvC" */
621 pInfo->dataFormat[1]==0x6e &&
622 pInfo->dataFormat[2]==0x76 &&
623 pInfo->dataFormat[3]==0x43 &&
624 pInfo->formatVersion[0]==2 &&
625 pInfo->formatVersion[1]>=1
626 )) {
627 udata_printError(ds, "ucol_swapInverseUCA(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not an inverse UCA collation file\n",
628 pInfo->dataFormat[0], pInfo->dataFormat[1],
629 pInfo->dataFormat[2], pInfo->dataFormat[3],
630 pInfo->formatVersion[0], pInfo->formatVersion[1]);
631 *pErrorCode=U_UNSUPPORTED_ERROR;
632 return 0;
633 }
634
635 inBytes=(const uint8_t *)inData+headerSize;
636 outBytes=(uint8_t *)outData+headerSize;
637
638 inHeader=(const InverseUCATableHeader *)inBytes;
639 outHeader=(InverseUCATableHeader *)outBytes;
640
641 /*
642 * The inverse UCA collation binary must contain at least the InverseUCATableHeader,
643 * starting with its size field.
644 * sizeof(UCATableHeader)==8*4 in ICU 2.8
645 * check the length against the header size before reading the size field
646 */
647 if(length<0) {
648 header.byteSize=udata_readInt32(ds, inHeader->byteSize);
649 } else if(
650 ((length-headerSize)<(8*4) ||
651 (uint32_t)(length-headerSize)<(header.byteSize=udata_readInt32(ds, inHeader->byteSize)))
652 ) {
653 udata_printError(ds, "ucol_swapInverseUCA(): too few bytes (%d after header) for inverse UCA collation data\n",
654 length);
655 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
656 return 0;
657 }
658
659 if(length>=0) {
660 /* copy everything, takes care of data that needs no swapping */
661 if(inBytes!=outBytes) {
662 uprv_memcpy(outBytes, inBytes, header.byteSize);
663 }
664
665 /* swap the necessary pieces in the order of their occurrence in the data */
666
667 /* read more of the InverseUCATableHeader (the byteSize field was read above) */
668 header.tableSize= ds->readUInt32(inHeader->tableSize);
669 header.contsSize= ds->readUInt32(inHeader->contsSize);
670 header.table= ds->readUInt32(inHeader->table);
671 header.conts= ds->readUInt32(inHeader->conts);
672
673 /* swap the 32-bit integers in the header */
674 ds->swapArray32(ds, inHeader, 5*4, outHeader, pErrorCode);
675
676 /* swap the inverse table; tableSize counts uint32_t[3] rows */
677 ds->swapArray32(ds, inBytes+header.table, header.tableSize*3*4,
678 outBytes+header.table, pErrorCode);
679
680 /* swap the continuation table; contsSize counts UChars */
681 ds->swapArray16(ds, inBytes+header.conts, header.contsSize*U_SIZEOF_UCHAR,
682 outBytes+header.conts, pErrorCode);
683 }
684
685 return headerSize+header.byteSize;
686 }
687
688 #endif /* #if !UCONFIG_NO_COLLATION */
689