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