icuSources/tools/toolutil/swapimpl.cpp

   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
  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
 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
 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
 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
 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
 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
 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 }