icuSources/tools/toolutil/swapimpl.cpp

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