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