source/common/uresdata.cpp

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 1999-2016, International Business Machines Corporation
   6 *               and others. All Rights Reserved.
   7 *******************************************************************************
   8 *   file name:  uresdata.cpp
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 1999dec08
  14 *   created by: Markus W. Scherer
  15 * Modification History:
  16 *
  17 *   Date        Name        Description
  18 *   06/20/2000  helena      OS/400 port changes; mostly typecast.
  19 *   06/24/02    weiv        Added support for resource sharing
  20 */
  21
  22 #include "unicode/utypes.h"
  23 #include "unicode/udata.h"
  24 #include "unicode/ustring.h"
  25 #include "unicode/utf16.h"
  26 #include "cmemory.h"
  27 #include "cstring.h"
  28 #include "resource.h"
  29 #include "uarrsort.h"
  30 #include "uassert.h"
  31 #include "ucol_swp.h"
  32 #include "udataswp.h"
  33 #include "uinvchar.h"
  34 #include "uresdata.h"
  35 #include "uresimp.h"
  36
  37 /*
  38  * Resource access helpers
  39  */
  40
  41 /* get a const char* pointer to the key with the keyOffset byte offset from pRoot */
  42 #define RES_GET_KEY16(pResData, keyOffset) \
  43     ((keyOffset)<(pResData)->localKeyLimit ? \
  44         (const char *)(pResData)->pRoot+(keyOffset) : \
  45         (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit)
  46
  47 #define RES_GET_KEY32(pResData, keyOffset) \
  48     ((keyOffset)>=0 ? \
  49         (const char *)(pResData)->pRoot+(keyOffset) : \
  50         (pResData)->poolBundleKeys+((keyOffset)&0x7fffffff))
  51
  52 #define URESDATA_ITEM_NOT_FOUND -1
  53
  54 /* empty resources, returned when the resource offset is 0 */
  55 static const uint16_t gEmpty16=0;
  56
  57 static const struct {
  58     int32_t length;
  59     int32_t res;
  60 } gEmpty32={ 0, 0 };
  61
  62 static const struct {
  63     int32_t length;
  64     UChar nul;
  65     UChar pad;
  66 } gEmptyString={ 0, 0, 0 };
  67
  68 /*
  69  * All the type-access functions assume that
  70  * the resource is of the expected type.
  71  */
  72
  73 static int32_t
  74 _res_findTableItem(const ResourceData *pResData, const uint16_t *keyOffsets, int32_t length,
  75                    const char *key, const char **realKey) {
  76     const char *tableKey;
  77     int32_t mid, start, limit;
  78     int result;
  79
  80     /* do a binary search for the key */
  81     start=0;
  82     limit=length;
  83     while(start<limit) {
  84         mid = (start + limit) / 2;
  85         tableKey = RES_GET_KEY16(pResData, keyOffsets[mid]);
  86         if (pResData->useNativeStrcmp) {
  87             result = uprv_strcmp(key, tableKey);
  88         } else {
  89             result = uprv_compareInvCharsAsAscii(key, tableKey);
  90         }
  91         if (result < 0) {
  92             limit = mid;
  93         } else if (result > 0) {
  94             start = mid + 1;
  95         } else {
  96             /* We found it! */
  97             *realKey=tableKey;
  98             return mid;
  99         }
 100     }
 101     return URESDATA_ITEM_NOT_FOUND;  /* not found or table is empty. */
 102 }
 103
 104 static int32_t
 105 _res_findTable32Item(const ResourceData *pResData, const int32_t *keyOffsets, int32_t length,
 106                      const char *key, const char **realKey) {
 107     const char *tableKey;
 108     int32_t mid, start, limit;
 109     int result;
 110
 111     /* do a binary search for the key */
 112     start=0;
 113     limit=length;
 114     while(start<limit) {
 115         mid = (start + limit) / 2;
 116         tableKey = RES_GET_KEY32(pResData, keyOffsets[mid]);
 117         if (pResData->useNativeStrcmp) {
 118             result = uprv_strcmp(key, tableKey);
 119         } else {
 120             result = uprv_compareInvCharsAsAscii(key, tableKey);
 121         }
 122         if (result < 0) {
 123             limit = mid;
 124         } else if (result > 0) {
 125             start = mid + 1;
 126         } else {
 127             /* We found it! */
 128             *realKey=tableKey;
 129             return mid;
 130         }
 131     }
 132     return URESDATA_ITEM_NOT_FOUND;  /* not found or table is empty. */
 133 }
 134
 135 /* helper for res_load() ---------------------------------------------------- */
 136
 137 static UBool U_CALLCONV
 138 isAcceptable(void *context,
 139              const char * /*type*/, const char * /*name*/,
 140              const UDataInfo *pInfo) {
 141     uprv_memcpy(context, pInfo->formatVersion, 4);
 142     return (UBool)(
 143         pInfo->size>=20 &&
 144         pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
 145         pInfo->charsetFamily==U_CHARSET_FAMILY &&
 146         pInfo->sizeofUChar==U_SIZEOF_UCHAR &&
 147         pInfo->dataFormat[0]==0x52 &&   /* dataFormat="ResB" */
 148         pInfo->dataFormat[1]==0x65 &&
 149         pInfo->dataFormat[2]==0x73 &&
 150         pInfo->dataFormat[3]==0x42 &&
 151         (1<=pInfo->formatVersion[0] && pInfo->formatVersion[0]<=3));
 152 }
 153
 154 /* semi-public functions ---------------------------------------------------- */
 155
 156 static void
 157 res_init(ResourceData *pResData,
 158          UVersionInfo formatVersion, const void *inBytes, int32_t length,
 159          UErrorCode *errorCode) {
 160     UResType rootType;
 161
 162     /* get the root resource */
 163     pResData->pRoot=(const int32_t *)inBytes;
 164     pResData->rootRes=(Resource)*pResData->pRoot;
 165     pResData->p16BitUnits=&gEmpty16;
 166
 167     /* formatVersion 1.1 must have a root item and at least 5 indexes */
 168     if(length>=0 && (length/4)<((formatVersion[0]==1 && formatVersion[1]==0) ? 1 : 1+5)) {
 169         *errorCode=U_INVALID_FORMAT_ERROR;
 170         res_unload(pResData);
 171         return;
 172     }
 173
 174     /* currently, we accept only resources that have a Table as their roots */
 175     rootType=(UResType)RES_GET_TYPE(pResData->rootRes);
 176     if(!URES_IS_TABLE(rootType)) {
 177         *errorCode=U_INVALID_FORMAT_ERROR;
 178         res_unload(pResData);
 179         return;
 180     }
 181
 182     if(formatVersion[0]==1 && formatVersion[1]==0) {
 183         pResData->localKeyLimit=0x10000;  /* greater than any 16-bit key string offset */
 184     } else {
 185         /* bundles with formatVersion 1.1 and later contain an indexes[] array */
 186         const int32_t *indexes=pResData->pRoot+1;
 187         int32_t indexLength=indexes[URES_INDEX_LENGTH]&0xff;
 188         if(indexLength<=URES_INDEX_MAX_TABLE_LENGTH) {
 189             *errorCode=U_INVALID_FORMAT_ERROR;
 190             res_unload(pResData);
 191             return;
 192         }
 193         if( length>=0 &&
 194             (length<((1+indexLength)<<2) ||
 195              length<(indexes[URES_INDEX_BUNDLE_TOP]<<2))
 196         ) {
 197             *errorCode=U_INVALID_FORMAT_ERROR;
 198             res_unload(pResData);
 199             return;
 200         }
 201         if(indexes[URES_INDEX_KEYS_TOP]>(1+indexLength)) {
 202             pResData->localKeyLimit=indexes[URES_INDEX_KEYS_TOP]<<2;
 203         }
 204         if(formatVersion[0]>=3) {
 205             // In formatVersion 1, the indexLength took up this whole int.
 206             // In version 2, bits 31..8 were reserved and always 0.
 207             // In version 3, they contain bits 23..0 of the poolStringIndexLimit.
 208             // Bits 27..24 are in indexes[URES_INDEX_ATTRIBUTES] bits 15..12.
 209             pResData->poolStringIndexLimit=(int32_t)((uint32_t)indexes[URES_INDEX_LENGTH]>>8);
 210         }
 211         if(indexLength>URES_INDEX_ATTRIBUTES) {
 212             int32_t att=indexes[URES_INDEX_ATTRIBUTES];
 213             pResData->noFallback=(UBool)(att&URES_ATT_NO_FALLBACK);
 214             pResData->isPoolBundle=(UBool)((att&URES_ATT_IS_POOL_BUNDLE)!=0);
 215             pResData->usesPoolBundle=(UBool)((att&URES_ATT_USES_POOL_BUNDLE)!=0);
 216             pResData->poolStringIndexLimit|=(att&0xf000)<<12;  // bits 15..12 -> 27..24
 217             pResData->poolStringIndex16Limit=(int32_t)((uint32_t)att>>16);
 218         }
 219         if((pResData->isPoolBundle || pResData->usesPoolBundle) && indexLength<=URES_INDEX_POOL_CHECKSUM) {
 220             *errorCode=U_INVALID_FORMAT_ERROR;
 221             res_unload(pResData);
 222             return;
 223         }
 224         if( indexLength>URES_INDEX_16BIT_TOP &&
 225             indexes[URES_INDEX_16BIT_TOP]>indexes[URES_INDEX_KEYS_TOP]
 226         ) {
 227             pResData->p16BitUnits=(const uint16_t *)(pResData->pRoot+indexes[URES_INDEX_KEYS_TOP]);
 228         }
 229     }
 230
 231     if(formatVersion[0]==1 || U_CHARSET_FAMILY==U_ASCII_FAMILY) {
 232         /*
 233          * formatVersion 1: compare key strings in native-charset order
 234          * formatVersion 2 and up: compare key strings in ASCII order
 235          */
 236         pResData->useNativeStrcmp=TRUE;
 237     }
 238 }
 239
 240 U_CAPI void U_EXPORT2
 241 res_read(ResourceData *pResData,
 242          const UDataInfo *pInfo, const void *inBytes, int32_t length,
 243          UErrorCode *errorCode) {
 244     UVersionInfo formatVersion;
 245
 246     uprv_memset(pResData, 0, sizeof(ResourceData));
 247     if(U_FAILURE(*errorCode)) {
 248         return;
 249     }
 250     if(!isAcceptable(formatVersion, NULL, NULL, pInfo)) {
 251         *errorCode=U_INVALID_FORMAT_ERROR;
 252         return;
 253     }
 254     res_init(pResData, formatVersion, inBytes, length, errorCode);
 255 }
 256
 257 U_CFUNC void
 258 res_load(ResourceData *pResData,
 259          const char *path, const char *name, UErrorCode *errorCode) {
 260     UVersionInfo formatVersion;
 261
 262     uprv_memset(pResData, 0, sizeof(ResourceData));
 263
 264     /* load the ResourceBundle file */
 265     pResData->data=udata_openChoice(path, "res", name, isAcceptable, formatVersion, errorCode);
 266     if(U_FAILURE(*errorCode)) {
 267         return;
 268     }
 269
 270     /* get its memory and initialize *pResData */
 271     res_init(pResData, formatVersion, udata_getMemory(pResData->data), -1, errorCode);
 272 }
 273
 274 U_CFUNC void
 275 res_unload(ResourceData *pResData) {
 276     if(pResData->data!=NULL) {
 277         udata_close(pResData->data);
 278         pResData->data=NULL;
 279     }
 280 }
 281
 282 static const int8_t gPublicTypes[URES_LIMIT] = {
 283     URES_STRING,
 284     URES_BINARY,
 285     URES_TABLE,
 286     URES_ALIAS,
 287
 288     URES_TABLE,     /* URES_TABLE32 */
 289     URES_TABLE,     /* URES_TABLE16 */
 290     URES_STRING,    /* URES_STRING_V2 */
 291     URES_INT,
 292
 293     URES_ARRAY,
 294     URES_ARRAY,     /* URES_ARRAY16 */
 295     URES_NONE,
 296     URES_NONE,
 297
 298     URES_NONE,
 299     URES_NONE,
 300     URES_INT_VECTOR,
 301     URES_NONE
 302 };
 303
 304 U_CAPI UResType U_EXPORT2
 305 res_getPublicType(Resource res) {
 306     return (UResType)gPublicTypes[RES_GET_TYPE(res)];
 307 }
 308
 309 U_CAPI const UChar * U_EXPORT2
 310 res_getString(const ResourceData *pResData, Resource res, int32_t *pLength) {
 311     const UChar *p;
 312     uint32_t offset=RES_GET_OFFSET(res);
 313     int32_t length;
 314     if(RES_GET_TYPE(res)==URES_STRING_V2) {
 315         int32_t first;
 316         if((int32_t)offset<pResData->poolStringIndexLimit) {
 317             p=(const UChar *)pResData->poolBundleStrings+offset;
 318         } else {
 319             p=(const UChar *)pResData->p16BitUnits+(offset-pResData->poolStringIndexLimit);
 320         }
 321         first=*p;
 322         if(!U16_IS_TRAIL(first)) {
 323             length=u_strlen(p);
 324         } else if(first<0xdfef) {
 325             length=first&0x3ff;
 326             ++p;
 327         } else if(first<0xdfff) {
 328             length=((first-0xdfef)<<16)|p[1];
 329             p+=2;
 330         } else {
 331             length=((int32_t)p[1]<<16)|p[2];
 332             p+=3;
 333         }
 334     } else if(res==offset) /* RES_GET_TYPE(res)==URES_STRING */ {
 335         const int32_t *p32= res==0 ? &gEmptyString.length : pResData->pRoot+res;
 336         length=*p32++;
 337         p=(const UChar *)p32;
 338     } else {
 339         p=NULL;
 340         length=0;
 341     }
 342     if(pLength) {
 343         *pLength=length;
 344     }
 345     return p;
 346 }
 347
 348 namespace {
 349
 350 /**
 351  * CLDR string value (three empty-set symbols)=={2205, 2205, 2205}
 352  * prevents fallback to the parent bundle.
 353  * TODO: combine with other code that handles this marker, use EMPTY_SET constant.
 354  * TODO: maybe move to uresbund.cpp?
 355  */
 356 UBool isNoInheritanceMarker(const ResourceData *pResData, Resource res) {
 357     uint32_t offset=RES_GET_OFFSET(res);
 358     if (offset == 0) {
 359         // empty string
 360     } else if (res == offset) {
 361         const int32_t *p32=pResData->pRoot+res;
 362         int32_t length=*p32;
 363         const UChar *p=(const UChar *)p32;
 364         return length == 3 && p[2] == 0x2205 && p[3] == 0x2205 && p[4] == 0x2205;
 365     } else if (RES_GET_TYPE(res) == URES_STRING_V2) {
 366         const UChar *p;
 367         if((int32_t)offset<pResData->poolStringIndexLimit) {
 368             p=(const UChar *)pResData->poolBundleStrings+offset;
 369         } else {
 370             p=(const UChar *)pResData->p16BitUnits+(offset-pResData->poolStringIndexLimit);
 371         }
 372         int32_t first=*p;
 373         if (first == 0x2205) {  // implicit length
 374             return p[1] == 0x2205 && p[2] == 0x2205 && p[3] == 0;
 375         } else if (first == 0xdc03) {  // explicit length 3 (should not occur)
 376             return p[1] == 0x2205 && p[2] == 0x2205 && p[3] == 0x2205;
 377         } else {
 378             // Assume that the string has not been stored with more length units than necessary.
 379             return FALSE;
 380         }
 381     }
 382     return FALSE;
 383 }
 384
 385 int32_t getStringArray(const ResourceData *pResData, const icu::ResourceArray &array,
 386                        icu::UnicodeString *dest, int32_t capacity,
 387                        UErrorCode &errorCode) {
 388     if(U_FAILURE(errorCode)) {
 389         return 0;
 390     }
 391     if(dest == NULL ? capacity != 0 : capacity < 0) {
 392         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 393         return 0;
 394     }
 395     int32_t length = array.getSize();
 396     if(length == 0) {
 397         return 0;
 398     }
 399     if(length > capacity) {
 400         errorCode = U_BUFFER_OVERFLOW_ERROR;
 401         return length;
 402     }
 403     for(int32_t i = 0; i < length; ++i) {
 404         int32_t sLength;
 405         const UChar *s = res_getString(pResData, array.internalGetResource(pResData, i), &sLength);
 406         if(s == NULL) {
 407             errorCode = U_RESOURCE_TYPE_MISMATCH;
 408             return 0;
 409         }
 410         dest[i].setTo(TRUE, s, sLength);
 411     }
 412     return length;
 413 }
 414
 415 }  // namespace
 416
 417 U_CAPI const UChar * U_EXPORT2
 418 res_getAlias(const ResourceData *pResData, Resource res, int32_t *pLength) {
 419     const UChar *p;
 420     uint32_t offset=RES_GET_OFFSET(res);
 421     int32_t length;
 422     if(RES_GET_TYPE(res)==URES_ALIAS) {
 423         const int32_t *p32= offset==0 ? &gEmptyString.length : pResData->pRoot+offset;
 424         length=*p32++;
 425         p=(const UChar *)p32;
 426     } else {
 427         p=NULL;
 428         length=0;
 429     }
 430     if(pLength) {
 431         *pLength=length;
 432     }
 433     return p;
 434 }
 435
 436 U_CAPI const uint8_t * U_EXPORT2
 437 res_getBinary(const ResourceData *pResData, Resource res, int32_t *pLength) {
 438     const uint8_t *p;
 439     uint32_t offset=RES_GET_OFFSET(res);
 440     int32_t length;
 441     if(RES_GET_TYPE(res)==URES_BINARY) {
 442         const int32_t *p32= offset==0 ? (const int32_t*)&gEmpty32 : pResData->pRoot+offset;
 443         length=*p32++;
 444         p=(const uint8_t *)p32;
 445     } else {
 446         p=NULL;
 447         length=0;
 448     }
 449     if(pLength) {
 450         *pLength=length;
 451     }
 452     return p;
 453 }
 454
 455
 456 U_CAPI const int32_t * U_EXPORT2
 457 res_getIntVector(const ResourceData *pResData, Resource res, int32_t *pLength) {
 458     const int32_t *p;
 459     uint32_t offset=RES_GET_OFFSET(res);
 460     int32_t length;
 461     if(RES_GET_TYPE(res)==URES_INT_VECTOR) {
 462         p= offset==0 ? (const int32_t *)&gEmpty32 : pResData->pRoot+offset;
 463         length=*p++;
 464     } else {
 465         p=NULL;
 466         length=0;
 467     }
 468     if(pLength) {
 469         *pLength=length;
 470     }
 471     return p;
 472 }
 473
 474 U_CAPI int32_t U_EXPORT2
 475 res_countArrayItems(const ResourceData *pResData, Resource res) {
 476     uint32_t offset=RES_GET_OFFSET(res);
 477     switch(RES_GET_TYPE(res)) {
 478     case URES_STRING:
 479     case URES_STRING_V2:
 480     case URES_BINARY:
 481     case URES_ALIAS:
 482     case URES_INT:
 483     case URES_INT_VECTOR:
 484         return 1;
 485     case URES_ARRAY:
 486     case URES_TABLE32:
 487         return offset==0 ? 0 : *(pResData->pRoot+offset);
 488     case URES_TABLE:
 489         return offset==0 ? 0 : *((const uint16_t *)(pResData->pRoot+offset));
 490     case URES_ARRAY16:
 491     case URES_TABLE16:
 492         return pResData->p16BitUnits[offset];
 493     default:
 494         return 0;
 495     }
 496 }
 497
 498 U_NAMESPACE_BEGIN
 499
 500 ResourceDataValue::~ResourceDataValue() {}
 501
 502 UResType ResourceDataValue::getType() const {
 503     return res_getPublicType(res);
 504 }
 505
 506 const UChar *ResourceDataValue::getString(int32_t &length, UErrorCode &errorCode) const {
 507     if(U_FAILURE(errorCode)) {
 508         return NULL;
 509     }
 510     const UChar *s = res_getString(pResData, res, &length);
 511     if(s == NULL) {
 512         errorCode = U_RESOURCE_TYPE_MISMATCH;
 513     }
 514     return s;
 515 }
 516
 517 const UChar *ResourceDataValue::getAliasString(int32_t &length, UErrorCode &errorCode) const {
 518     if(U_FAILURE(errorCode)) {
 519         return NULL;
 520     }
 521     const UChar *s = res_getAlias(pResData, res, &length);
 522     if(s == NULL) {
 523         errorCode = U_RESOURCE_TYPE_MISMATCH;
 524     }
 525     return s;
 526 }
 527
 528 int32_t ResourceDataValue::getInt(UErrorCode &errorCode) const {
 529     if(U_FAILURE(errorCode)) {
 530         return 0;
 531     }
 532     if(RES_GET_TYPE(res) != URES_INT) {
 533         errorCode = U_RESOURCE_TYPE_MISMATCH;
 534     }
 535     return RES_GET_INT(res);
 536 }
 537
 538 uint32_t ResourceDataValue::getUInt(UErrorCode &errorCode) const {
 539     if(U_FAILURE(errorCode)) {
 540         return 0;
 541     }
 542     if(RES_GET_TYPE(res) != URES_INT) {
 543         errorCode = U_RESOURCE_TYPE_MISMATCH;
 544     }
 545     return RES_GET_UINT(res);
 546 }
 547
 548 const int32_t *ResourceDataValue::getIntVector(int32_t &length, UErrorCode &errorCode) const {
 549     if(U_FAILURE(errorCode)) {
 550         return NULL;
 551     }
 552     const int32_t *iv = res_getIntVector(pResData, res, &length);
 553     if(iv == NULL) {
 554         errorCode = U_RESOURCE_TYPE_MISMATCH;
 555     }
 556     return iv;
 557 }
 558
 559 const uint8_t *ResourceDataValue::getBinary(int32_t &length, UErrorCode &errorCode) const {
 560     if(U_FAILURE(errorCode)) {
 561         return NULL;
 562     }
 563     const uint8_t *b = res_getBinary(pResData, res, &length);
 564     if(b == NULL) {
 565         errorCode = U_RESOURCE_TYPE_MISMATCH;
 566     }
 567     return b;
 568 }
 569
 570 ResourceArray ResourceDataValue::getArray(UErrorCode &errorCode) const {
 571     if(U_FAILURE(errorCode)) {
 572         return ResourceArray();
 573     }
 574     const uint16_t *items16 = NULL;
 575     const Resource *items32 = NULL;
 576     uint32_t offset=RES_GET_OFFSET(res);
 577     int32_t length = 0;
 578     switch(RES_GET_TYPE(res)) {
 579     case URES_ARRAY:
 580         if (offset!=0) {  // empty if offset==0
 581             items32 = (const Resource *)pResData->pRoot+offset;
 582             length = *items32++;
 583         }
 584         break;
 585     case URES_ARRAY16:
 586         items16 = pResData->p16BitUnits+offset;
 587         length = *items16++;
 588         break;
 589     default:
 590         errorCode = U_RESOURCE_TYPE_MISMATCH;
 591         return ResourceArray();
 592     }
 593     return ResourceArray(items16, items32, length);
 594 }
 595
 596 ResourceTable ResourceDataValue::getTable(UErrorCode &errorCode) const {
 597     if(U_FAILURE(errorCode)) {
 598         return ResourceTable();
 599     }
 600     const uint16_t *keys16 = NULL;
 601     const int32_t *keys32 = NULL;
 602     const uint16_t *items16 = NULL;
 603     const Resource *items32 = NULL;
 604     uint32_t offset = RES_GET_OFFSET(res);
 605     int32_t length = 0;
 606     switch(RES_GET_TYPE(res)) {
 607     case URES_TABLE:
 608         if (offset != 0) {  // empty if offset==0
 609             keys16 = (const uint16_t *)(pResData->pRoot+offset);
 610             length = *keys16++;
 611             items32 = (const Resource *)(keys16+length+(~length&1));
 612         }
 613         break;
 614     case URES_TABLE16:
 615         keys16 = pResData->p16BitUnits+offset;
 616         length = *keys16++;
 617         items16 = keys16 + length;
 618         break;
 619     case URES_TABLE32:
 620         if (offset != 0) {  // empty if offset==0
 621             keys32 = pResData->pRoot+offset;
 622             length = *keys32++;
 623             items32 = (const Resource *)keys32 + length;
 624         }
 625         break;
 626     default:
 627         errorCode = U_RESOURCE_TYPE_MISMATCH;
 628         return ResourceTable();
 629     }
 630     return ResourceTable(keys16, keys32, items16, items32, length);
 631 }
 632
 633 UBool ResourceDataValue::isNoInheritanceMarker() const {
 634     return ::isNoInheritanceMarker(pResData, res);
 635 }
 636
 637 int32_t ResourceDataValue::getStringArray(UnicodeString *dest, int32_t capacity,
 638                                           UErrorCode &errorCode) const {
 639     return ::getStringArray(pResData, getArray(errorCode), dest, capacity, errorCode);
 640 }
 641
 642 int32_t ResourceDataValue::getStringArrayOrStringAsArray(UnicodeString *dest, int32_t capacity,
 643                                                          UErrorCode &errorCode) const {
 644     if(URES_IS_ARRAY(res)) {
 645         return ::getStringArray(pResData, getArray(errorCode), dest, capacity, errorCode);
 646     }
 647     if(U_FAILURE(errorCode)) {
 648         return 0;
 649     }
 650     if(dest == NULL ? capacity != 0 : capacity < 0) {
 651         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 652         return 0;
 653     }
 654     if(capacity < 1) {
 655         errorCode = U_BUFFER_OVERFLOW_ERROR;
 656         return 1;
 657     }
 658     int32_t sLength;
 659     const UChar *s = res_getString(pResData, res, &sLength);
 660     if(s != NULL) {
 661         dest[0].setTo(TRUE, s, sLength);
 662         return 1;
 663     }
 664     errorCode = U_RESOURCE_TYPE_MISMATCH;
 665     return 0;
 666 }
 667
 668 UnicodeString ResourceDataValue::getStringOrFirstOfArray(UErrorCode &errorCode) const {
 669     UnicodeString us;
 670     if(U_FAILURE(errorCode)) {
 671         return us;
 672     }
 673     int32_t sLength;
 674     const UChar *s = res_getString(pResData, res, &sLength);
 675     if(s != NULL) {
 676         us.setTo(TRUE, s, sLength);
 677         return us;
 678     }
 679     ResourceArray array = getArray(errorCode);
 680     if(U_FAILURE(errorCode)) {
 681         return us;
 682     }
 683     if(array.getSize() > 0) {
 684         s = res_getString(pResData, array.internalGetResource(pResData, 0), &sLength);
 685         if(s != NULL) {
 686             us.setTo(TRUE, s, sLength);
 687             return us;
 688         }
 689     }
 690     errorCode = U_RESOURCE_TYPE_MISMATCH;
 691     return us;
 692 }
 693
 694 U_NAMESPACE_END
 695
 696 static Resource
 697 makeResourceFrom16(const ResourceData *pResData, int32_t res16) {
 698     if(res16<pResData->poolStringIndex16Limit) {
 699         // Pool string, nothing to do.
 700     } else {
 701         // Local string, adjust the 16-bit offset to a regular one,
 702         // with a larger pool string index limit.
 703         res16=res16-pResData->poolStringIndex16Limit+pResData->poolStringIndexLimit;
 704     }
 705     return URES_MAKE_RESOURCE(URES_STRING_V2, res16);
 706 }
 707
 708 U_CAPI Resource U_EXPORT2
 709 res_getTableItemByKey(const ResourceData *pResData, Resource table,
 710                       int32_t *indexR, const char **key) {
 711     uint32_t offset=RES_GET_OFFSET(table);
 712     int32_t length;
 713     int32_t idx;
 714     if(key == NULL || *key == NULL) {
 715         return RES_BOGUS;
 716     }
 717     switch(RES_GET_TYPE(table)) {
 718     case URES_TABLE: {
 719         if (offset!=0) { /* empty if offset==0 */
 720             const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset);
 721             length=*p++;
 722             *indexR=idx=_res_findTableItem(pResData, p, length, *key, key);
 723             if(idx>=0) {
 724                 const Resource *p32=(const Resource *)(p+length+(~length&1));
 725                 return p32[idx];
 726             }
 727         }
 728         break;
 729     }
 730     case URES_TABLE16: {
 731         const uint16_t *p=pResData->p16BitUnits+offset;
 732         length=*p++;
 733         *indexR=idx=_res_findTableItem(pResData, p, length, *key, key);
 734         if(idx>=0) {
 735             return makeResourceFrom16(pResData, p[length+idx]);
 736         }
 737         break;
 738     }
 739     case URES_TABLE32: {
 740         if (offset!=0) { /* empty if offset==0 */
 741             const int32_t *p= pResData->pRoot+offset;
 742             length=*p++;
 743             *indexR=idx=_res_findTable32Item(pResData, p, length, *key, key);
 744             if(idx>=0) {
 745                 return (Resource)p[length+idx];
 746             }
 747         }
 748         break;
 749     }
 750     default:
 751         break;
 752     }
 753     return RES_BOGUS;
 754 }
 755
 756 U_CAPI Resource U_EXPORT2
 757 res_getTableItemByIndex(const ResourceData *pResData, Resource table,
 758                         int32_t indexR, const char **key) {
 759     uint32_t offset=RES_GET_OFFSET(table);
 760     int32_t length;
 761     U_ASSERT(indexR>=0); /* to ensure the index is not negative */
 762     switch(RES_GET_TYPE(table)) {
 763     case URES_TABLE: {
 764         if (offset != 0) { /* empty if offset==0 */
 765             const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset);
 766             length=*p++;
 767             if(indexR<length) {
 768                 const Resource *p32=(const Resource *)(p+length+(~length&1));
 769                 if(key!=NULL) {
 770                     *key=RES_GET_KEY16(pResData, p[indexR]);
 771                 }
 772                 return p32[indexR];
 773             }
 774         }
 775         break;
 776     }
 777     case URES_TABLE16: {
 778         const uint16_t *p=pResData->p16BitUnits+offset;
 779         length=*p++;
 780         if(indexR<length) {
 781             if(key!=NULL) {
 782                 *key=RES_GET_KEY16(pResData, p[indexR]);
 783             }
 784             return makeResourceFrom16(pResData, p[length+indexR]);
 785         }
 786         break;
 787     }
 788     case URES_TABLE32: {
 789         if (offset != 0) { /* empty if offset==0 */
 790             const int32_t *p= pResData->pRoot+offset;
 791             length=*p++;
 792             if(indexR<length) {
 793                 if(key!=NULL) {
 794                     *key=RES_GET_KEY32(pResData, p[indexR]);
 795                 }
 796                 return (Resource)p[length+indexR];
 797             }
 798         }
 799         break;
 800     }
 801     default:
 802         break;
 803     }
 804     return RES_BOGUS;
 805 }
 806
 807 U_CAPI Resource U_EXPORT2
 808 res_getResource(const ResourceData *pResData, const char *key) {
 809     const char *realKey=key;
 810     int32_t idx;
 811     return res_getTableItemByKey(pResData, pResData->rootRes, &idx, &realKey);
 812 }
 813
 814
 815 UBool icu::ResourceTable::getKeyAndValue(int32_t i,
 816                                          const char *&key, icu::ResourceValue &value) const {
 817     if(0 <= i && i < length) {
 818         icu::ResourceDataValue &rdValue = static_cast<icu::ResourceDataValue &>(value);
 819         if (keys16 != NULL) {
 820             key = RES_GET_KEY16(rdValue.pResData, keys16[i]);
 821         } else {
 822             key = RES_GET_KEY32(rdValue.pResData, keys32[i]);
 823         }
 824         Resource res;
 825         if (items16 != NULL) {
 826             res = makeResourceFrom16(rdValue.pResData, items16[i]);
 827         } else {
 828             res = items32[i];
 829         }
 830         rdValue.setResource(res);
 831         return TRUE;
 832     }
 833     return FALSE;
 834 }
 835
 836 U_CAPI Resource U_EXPORT2
 837 res_getArrayItem(const ResourceData *pResData, Resource array, int32_t indexR) {
 838     uint32_t offset=RES_GET_OFFSET(array);
 839     U_ASSERT(indexR>=0); /* to ensure the index is not negative */
 840     switch(RES_GET_TYPE(array)) {
 841     case URES_ARRAY: {
 842         if (offset!=0) { /* empty if offset==0 */
 843             const int32_t *p= pResData->pRoot+offset;
 844             if(indexR<*p) {
 845                 return (Resource)p[1+indexR];
 846             }
 847         }
 848         break;
 849     }
 850     case URES_ARRAY16: {
 851         const uint16_t *p=pResData->p16BitUnits+offset;
 852         if(indexR<*p) {
 853             return makeResourceFrom16(pResData, p[1+indexR]);
 854         }
 855         break;
 856     }
 857     default:
 858         break;
 859     }
 860     return RES_BOGUS;
 861 }
 862
 863 uint32_t icu::ResourceArray::internalGetResource(const ResourceData *pResData, int32_t i) const {
 864     if (items16 != NULL) {
 865         return makeResourceFrom16(pResData, items16[i]);
 866     } else {
 867         return items32[i];
 868     }
 869 }
 870
 871 UBool icu::ResourceArray::getValue(int32_t i, icu::ResourceValue &value) const {
 872     if(0 <= i && i < length) {
 873         icu::ResourceDataValue &rdValue = static_cast<icu::ResourceDataValue &>(value);
 874         rdValue.setResource(internalGetResource(rdValue.pResData, i));
 875         return TRUE;
 876     }
 877     return FALSE;
 878 }
 879
 880 U_CFUNC Resource
 881 res_findResource(const ResourceData *pResData, Resource r, char** path, const char** key) {
 882   char *pathP = *path, *nextSepP = *path;
 883   char *closeIndex = NULL;
 884   Resource t1 = r;
 885   Resource t2;
 886   int32_t indexR = 0;
 887   UResType type = (UResType)RES_GET_TYPE(t1);
 888
 889   /* if you come in with an empty path, you'll be getting back the same resource */
 890   if(!uprv_strlen(pathP)) {
 891       return r;
 892   }
 893
 894   /* one needs to have an aggregate resource in order to search in it */
 895   if(!URES_IS_CONTAINER(type)) {
 896       return RES_BOGUS;
 897   }
 898
 899   while(nextSepP && *pathP && t1 != RES_BOGUS && URES_IS_CONTAINER(type)) {
 900     /* Iteration stops if: the path has been consumed, we found a non-existing
 901      * resource (t1 == RES_BOGUS) or we found a scalar resource (including alias)
 902      */
 903     nextSepP = uprv_strchr(pathP, RES_PATH_SEPARATOR);
 904     /* if there are more separators, terminate string
 905      * and set path to the remaining part of the string
 906      */
 907     if(nextSepP != NULL) {
 908       if(nextSepP == pathP) {
 909         // Empty key string.
 910         return RES_BOGUS;
 911       }
 912       *nextSepP = 0; /* overwrite the separator with a NUL to terminate the key */
 913       *path = nextSepP+1;
 914     } else {
 915       *path = uprv_strchr(pathP, 0);
 916     }
 917
 918     /* if the resource is a table */
 919     /* try the key based access */
 920     if(URES_IS_TABLE(type)) {
 921       *key = pathP;
 922       t2 = res_getTableItemByKey(pResData, t1, &indexR, key);
 923       if(t2 == RES_BOGUS) {
 924         /* if we fail to get the resource by key, maybe we got an index */
 925         indexR = uprv_strtol(pathP, &closeIndex, 10);
 926         if(*closeIndex == 0) {
 927           /* if we indeed have an index, try to get the item by index */
 928           t2 = res_getTableItemByIndex(pResData, t1, indexR, key);
 929         }
 930       }
 931     } else if(URES_IS_ARRAY(type)) {
 932       indexR = uprv_strtol(pathP, &closeIndex, 10);
 933       if(*closeIndex == 0) {
 934         t2 = res_getArrayItem(pResData, t1, indexR);
 935       } else {
 936         t2 = RES_BOGUS; /* have an array, but don't have a valid index */
 937       }
 938       *key = NULL;
 939     } else { /* can't do much here, except setting t2 to bogus */
 940       t2 = RES_BOGUS;
 941     }
 942     t1 = t2;
 943     type = (UResType)RES_GET_TYPE(t1);
 944     /* position pathP to next resource key/index */
 945     pathP = *path;
 946   }
 947
 948   return t1;
 949 }
 950
 951 /* resource bundle swapping ------------------------------------------------- */
 952
 953 /*
 954  * Need to always enumerate the entire item tree,
 955  * track the lowest address of any item to use as the limit for char keys[],
 956  * track the highest address of any item to return the size of the data.
 957  *
 958  * We should have thought of storing those in the data...
 959  * It is possible to extend the data structure by putting additional values
 960  * in places that are inaccessible by ordinary enumeration of the item tree.
 961  * For example, additional integers could be stored at the beginning or
 962  * end of the key strings; this could be indicated by a minor version number,
 963  * and the data swapping would have to know about these values.
 964  *
 965  * The data structure does not forbid keys to be shared, so we must swap
 966  * all keys once instead of each key when it is referenced.
 967  *
 968  * These swapping functions assume that a resource bundle always has a length
 969  * that is a multiple of 4 bytes.
 970  * Currently, this is trivially true because genrb writes bundle tree leaves
 971  * physically first, before their branches, so that the root table with its
 972  * array of resource items (uint32_t values) is always last.
 973  */
 974
 975 /* definitions for table sorting ------------------------ */
 976
 977 /*
 978  * row of a temporary array
 979  *
 980  * gets platform-endian key string indexes and sorting indexes;
 981  * after sorting this array by keys, the actual key/value arrays are permutated
 982  * according to the sorting indexes
 983  */
 984 typedef struct Row {
 985     int32_t keyIndex, sortIndex;
 986 } Row;
 987
 988 static int32_t U_CALLCONV
 989 ures_compareRows(const void *context, const void *left, const void *right) {
 990     const char *keyChars=(const char *)context;
 991     return (int32_t)uprv_strcmp(keyChars+((const Row *)left)->keyIndex,
 992                                 keyChars+((const Row *)right)->keyIndex);
 993 }
 994
 995 typedef struct TempTable {
 996     const char *keyChars;
 997     Row *rows;
 998     int32_t *resort;
 999     uint32_t *resFlags;
1000     int32_t localKeyLimit;
1001     uint8_t majorFormatVersion;
1002 } TempTable;
1003
1004 enum {
1005     STACK_ROW_CAPACITY=200
1006 };
1007
1008 /* The table item key string is not locally available. */
1009 static const char *const gUnknownKey="";
1010
1011 /* resource table key for collation binaries: "%%CollationBin" */
1012 static const UChar gCollationBinKey[]={
1013     0x25, 0x25,
1014     0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
1015     0x42, 0x69, 0x6e,
1016     0
1017 };
1018
1019 /*
1020  * swap one resource item
1021  */
1022 static void
1023 ures_swapResource(const UDataSwapper *ds,
1024                   const Resource *inBundle, Resource *outBundle,
1025                   Resource res, /* caller swaps res itself */
1026                   const char *key,
1027                   TempTable *pTempTable,
1028                   UErrorCode *pErrorCode) {
1029     const Resource *p;
1030     Resource *q;
1031     int32_t offset, count;
1032
1033     switch(RES_GET_TYPE(res)) {
1034     case URES_TABLE16:
1035     case URES_STRING_V2:
1036     case URES_INT:
1037     case URES_ARRAY16:
1038         /* integer, or points to 16-bit units, nothing to do here */
1039         return;
1040     default:
1041         break;
1042     }
1043
1044     /* all other types use an offset to point to their data */
1045     offset=(int32_t)RES_GET_OFFSET(res);
1046     if(offset==0) {
1047         /* special offset indicating an empty item */
1048         return;
1049     }
1050     if(pTempTable->resFlags[offset>>5]&((uint32_t)1<<(offset&0x1f))) {
1051         /* we already swapped this resource item */
1052         return;
1053     } else {
1054         /* mark it as swapped now */
1055         pTempTable->resFlags[offset>>5]|=((uint32_t)1<<(offset&0x1f));
1056     }
1057
1058     p=inBundle+offset;
1059     q=outBundle+offset;
1060
1061     switch(RES_GET_TYPE(res)) {
1062     case URES_ALIAS:
1063         /* physically same value layout as string, fall through */
1064         U_FALLTHROUGH;
1065     case URES_STRING:
1066         count=udata_readInt32(ds, (int32_t)*p);
1067         /* swap length */
1068         ds->swapArray32(ds, p, 4, q, pErrorCode);
1069         /* swap each UChar (the terminating NUL would not change) */
1070         ds->swapArray16(ds, p+1, 2*count, q+1, pErrorCode);
1071         break;
1072     case URES_BINARY:
1073         count=udata_readInt32(ds, (int32_t)*p);
1074         /* swap length */
1075         ds->swapArray32(ds, p, 4, q, pErrorCode);
1076         /* no need to swap or copy bytes - ures_swap() copied them all */
1077
1078         /* swap known formats */
1079 #if !UCONFIG_NO_COLLATION
1080         if( key!=NULL &&  /* the binary is in a table */
1081             (key!=gUnknownKey ?
1082                 /* its table key string is "%%CollationBin" */
1083                 0==ds->compareInvChars(ds, key, -1,
1084                                        gCollationBinKey, UPRV_LENGTHOF(gCollationBinKey)-1) :
1085                 /* its table key string is unknown but it looks like a collation binary */
1086                 ucol_looksLikeCollationBinary(ds, p+1, count))
1087         ) {
1088             ucol_swap(ds, p+1, count, q+1, pErrorCode);
1089         }
1090 #endif
1091         break;
1092     case URES_TABLE:
1093     case URES_TABLE32:
1094         {
1095             const uint16_t *pKey16;
1096             uint16_t *qKey16;
1097
1098             const int32_t *pKey32;
1099             int32_t *qKey32;
1100
1101             Resource item;
1102             int32_t i, oldIndex;
1103
1104             if(RES_GET_TYPE(res)==URES_TABLE) {
1105                 /* get table item count */
1106                 pKey16=(const uint16_t *)p;
1107                 qKey16=(uint16_t *)q;
1108                 count=ds->readUInt16(*pKey16);
1109
1110                 pKey32=qKey32=NULL;
1111
1112                 /* swap count */
1113                 ds->swapArray16(ds, pKey16++, 2, qKey16++, pErrorCode);
1114
1115                 offset+=((1+count)+1)/2;
1116             } else {
1117                 /* get table item count */
1118                 pKey32=(const int32_t *)p;
1119                 qKey32=(int32_t *)q;
1120                 count=udata_readInt32(ds, *pKey32);
1121
1122                 pKey16=qKey16=NULL;
1123
1124                 /* swap count */
1125                 ds->swapArray32(ds, pKey32++, 4, qKey32++, pErrorCode);
1126
1127                 offset+=1+count;
1128             }
1129
1130             if(count==0) {
1131                 break;
1132             }
1133
1134             p=inBundle+offset; /* pointer to table resources */
1135             q=outBundle+offset;
1136
1137             /* recurse */
1138             for(i=0; i<count; ++i) {
1139                 const char *itemKey=gUnknownKey;
1140                 if(pKey16!=NULL) {
1141                     int32_t keyOffset=ds->readUInt16(pKey16[i]);
1142                     if(keyOffset<pTempTable->localKeyLimit) {
1143                         itemKey=(const char *)outBundle+keyOffset;
1144                     }
1145                 } else {
1146                     int32_t keyOffset=udata_readInt32(ds, pKey32[i]);
1147                     if(keyOffset>=0) {
1148                         itemKey=(const char *)outBundle+keyOffset;
1149                     }
1150                 }
1151                 item=ds->readUInt32(p[i]);
1152                 ures_swapResource(ds, inBundle, outBundle, item, itemKey, pTempTable, pErrorCode);
1153                 if(U_FAILURE(*pErrorCode)) {
1154                     udata_printError(ds, "ures_swapResource(table res=%08x)[%d].recurse(%08x) failed\n",
1155                                      res, i, item);
1156                     return;
1157                 }
1158             }
1159
1160             if(pTempTable->majorFormatVersion>1 || ds->inCharset==ds->outCharset) {
1161                 /* no need to sort, just swap the offset/value arrays */
1162                 if(pKey16!=NULL) {
1163                     ds->swapArray16(ds, pKey16, count*2, qKey16, pErrorCode);
1164                     ds->swapArray32(ds, p, count*4, q, pErrorCode);
1165                 } else {
1166                     /* swap key offsets and items as one array */
1167                     ds->swapArray32(ds, pKey32, count*2*4, qKey32, pErrorCode);
1168                 }
1169                 break;
1170             }
1171
1172             /*
1173              * We need to sort tables by outCharset key strings because they
1174              * sort differently for different charset families.
1175              * ures_swap() already set pTempTable->keyChars appropriately.
1176              * First we set up a temporary table with the key indexes and
1177              * sorting indexes and sort that.
1178              * Then we permutate and copy/swap the actual values.
1179              */
1180             if(pKey16!=NULL) {
1181                 for(i=0; i<count; ++i) {
1182                     pTempTable->rows[i].keyIndex=ds->readUInt16(pKey16[i]);
1183                     pTempTable->rows[i].sortIndex=i;
1184                 }
1185             } else {
1186                 for(i=0; i<count; ++i) {
1187                     pTempTable->rows[i].keyIndex=udata_readInt32(ds, pKey32[i]);
1188                     pTempTable->rows[i].sortIndex=i;
1189                 }
1190             }
1191             uprv_sortArray(pTempTable->rows, count, sizeof(Row),
1192                            ures_compareRows, pTempTable->keyChars,
1193                            FALSE, pErrorCode);
1194             if(U_FAILURE(*pErrorCode)) {
1195                 udata_printError(ds, "ures_swapResource(table res=%08x).uprv_sortArray(%d items) failed\n",
1196                                  res, count);
1197                 return;
1198             }
1199
1200             /*
1201              * copy/swap/permutate items
1202              *
1203              * If we swap in-place, then the permutation must use another
1204              * temporary array (pTempTable->resort)
1205              * before the results are copied to the outBundle.
1206              */
1207             /* keys */
1208             if(pKey16!=NULL) {
1209                 uint16_t *rKey16;
1210
1211                 if(pKey16!=qKey16) {
1212                     rKey16=qKey16;
1213                 } else {
1214                     rKey16=(uint16_t *)pTempTable->resort;
1215                 }
1216                 for(i=0; i<count; ++i) {
1217                     oldIndex=pTempTable->rows[i].sortIndex;
1218                     ds->swapArray16(ds, pKey16+oldIndex, 2, rKey16+i, pErrorCode);
1219                 }
1220                 if(qKey16!=rKey16) {
1221                     uprv_memcpy(qKey16, rKey16, 2*count);
1222                 }
1223             } else {
1224                 int32_t *rKey32;
1225
1226                 if(pKey32!=qKey32) {
1227                     rKey32=qKey32;
1228                 } else {
1229                     rKey32=pTempTable->resort;
1230                 }
1231                 for(i=0; i<count; ++i) {
1232                     oldIndex=pTempTable->rows[i].sortIndex;
1233                     ds->swapArray32(ds, pKey32+oldIndex, 4, rKey32+i, pErrorCode);
1234                 }
1235                 if(qKey32!=rKey32) {
1236                     uprv_memcpy(qKey32, rKey32, 4*count);
1237                 }
1238             }
1239
1240             /* resources */
1241             {
1242                 Resource *r;
1243
1244
1245                 if(p!=q) {
1246                     r=q;
1247                 } else {
1248                     r=(Resource *)pTempTable->resort;
1249                 }
1250                 for(i=0; i<count; ++i) {
1251                     oldIndex=pTempTable->rows[i].sortIndex;
1252                     ds->swapArray32(ds, p+oldIndex, 4, r+i, pErrorCode);
1253                 }
1254                 if(q!=r) {
1255                     uprv_memcpy(q, r, 4*count);
1256                 }
1257             }
1258         }
1259         break;
1260     case URES_ARRAY:
1261         {
1262             Resource item;
1263             int32_t i;
1264
1265             count=udata_readInt32(ds, (int32_t)*p);
1266             /* swap length */
1267             ds->swapArray32(ds, p++, 4, q++, pErrorCode);
1268
1269             /* recurse */
1270             for(i=0; i<count; ++i) {
1271                 item=ds->readUInt32(p[i]);
1272                 ures_swapResource(ds, inBundle, outBundle, item, NULL, pTempTable, pErrorCode);
1273                 if(U_FAILURE(*pErrorCode)) {
1274                     udata_printError(ds, "ures_swapResource(array res=%08x)[%d].recurse(%08x) failed\n",
1275                                      res, i, item);
1276                     return;
1277                 }
1278             }
1279
1280             /* swap items */
1281             ds->swapArray32(ds, p, 4*count, q, pErrorCode);
1282         }
1283         break;
1284     case URES_INT_VECTOR:
1285         count=udata_readInt32(ds, (int32_t)*p);
1286         /* swap length and each integer */
1287         ds->swapArray32(ds, p, 4*(1+count), q, pErrorCode);
1288         break;
1289     default:
1290         /* also catches RES_BOGUS */
1291         *pErrorCode=U_UNSUPPORTED_ERROR;
1292         break;
1293     }
1294 }
1295
1296 U_CAPI int32_t U_EXPORT2
1297 ures_swap(const UDataSwapper *ds,
1298           const void *inData, int32_t length, void *outData,
1299           UErrorCode *pErrorCode) {
1300     const UDataInfo *pInfo;
1301     const Resource *inBundle;
1302     Resource rootRes;
1303     int32_t headerSize, maxTableLength;
1304
1305     Row rows[STACK_ROW_CAPACITY];
1306     int32_t resort[STACK_ROW_CAPACITY];
1307     TempTable tempTable;
1308
1309     const int32_t *inIndexes;
1310
1311     /* the following integers count Resource item offsets (4 bytes each), not bytes */
1312     int32_t bundleLength, indexLength, keysBottom, keysTop, resBottom, top;
1313
1314     /* udata_swapDataHeader checks the arguments */
1315     headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
1316     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
1317         return 0;
1318     }
1319
1320     /* check data format and format version */
1321     pInfo=(const UDataInfo *)((const char *)inData+4);
1322     if(!(
1323         pInfo->dataFormat[0]==0x52 &&   /* dataFormat="ResB" */
1324         pInfo->dataFormat[1]==0x65 &&
1325         pInfo->dataFormat[2]==0x73 &&
1326         pInfo->dataFormat[3]==0x42 &&
1327         /* formatVersion 1.1+ or 2.x or 3.x */
1328         ((pInfo->formatVersion[0]==1 && pInfo->formatVersion[1]>=1) ||
1329             pInfo->formatVersion[0]==2 || pInfo->formatVersion[0]==3)
1330     )) {
1331         udata_printError(ds, "ures_swap(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not a resource bundle\n",
1332                          pInfo->dataFormat[0], pInfo->dataFormat[1],
1333                          pInfo->dataFormat[2], pInfo->dataFormat[3],
1334                          pInfo->formatVersion[0], pInfo->formatVersion[1]);
1335         *pErrorCode=U_UNSUPPORTED_ERROR;
1336         return 0;
1337     }
1338     tempTable.majorFormatVersion=pInfo->formatVersion[0];
1339
1340     /* a resource bundle must contain at least one resource item */
1341     if(length<0) {
1342         bundleLength=-1;
1343     } else {
1344         bundleLength=(length-headerSize)/4;
1345
1346         /* formatVersion 1.1 must have a root item and at least 5 indexes */
1347         if(bundleLength<(1+5)) {
1348             udata_printError(ds, "ures_swap(): too few bytes (%d after header) for a resource bundle\n",
1349                              length-headerSize);
1350             *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1351             return 0;
1352         }
1353     }
1354
1355     inBundle=(const Resource *)((const char *)inData+headerSize);
1356     rootRes=ds->readUInt32(*inBundle);
1357
1358     /* formatVersion 1.1 adds the indexes[] array */
1359     inIndexes=(const int32_t *)(inBundle+1);
1360
1361     indexLength=udata_readInt32(ds, inIndexes[URES_INDEX_LENGTH])&0xff;
1362     if(indexLength<=URES_INDEX_MAX_TABLE_LENGTH) {
1363         udata_printError(ds, "ures_swap(): too few indexes for a 1.1+ resource bundle\n");
1364         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1365         return 0;
1366     }
1367     keysBottom=1+indexLength;
1368     keysTop=udata_readInt32(ds, inIndexes[URES_INDEX_KEYS_TOP]);
1369     if(indexLength>URES_INDEX_16BIT_TOP) {
1370         resBottom=udata_readInt32(ds, inIndexes[URES_INDEX_16BIT_TOP]);
1371     } else {
1372         resBottom=keysTop;
1373     }
1374     top=udata_readInt32(ds, inIndexes[URES_INDEX_BUNDLE_TOP]);
1375     maxTableLength=udata_readInt32(ds, inIndexes[URES_INDEX_MAX_TABLE_LENGTH]);
1376
1377     if(0<=bundleLength && bundleLength<top) {
1378         udata_printError(ds, "ures_swap(): resource top %d exceeds bundle length %d\n",
1379                          top, bundleLength);
1380         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1381         return 0;
1382     }
1383     if(keysTop>(1+indexLength)) {
1384         tempTable.localKeyLimit=keysTop<<2;
1385     } else {
1386         tempTable.localKeyLimit=0;
1387     }
1388
1389     if(length>=0) {
1390         Resource *outBundle=(Resource *)((char *)outData+headerSize);
1391
1392         /* track which resources we have already swapped */
1393         uint32_t stackResFlags[STACK_ROW_CAPACITY];
1394         int32_t resFlagsLength;
1395
1396         /*
1397          * We need one bit per 4 resource bundle bytes so that we can track
1398          * every possible Resource for whether we have swapped it already.
1399          * Multiple Resource words can refer to the same bundle offsets
1400          * for sharing identical values.
1401          * We could optimize this by allocating only for locations above
1402          * where Resource values are stored (above keys & strings).
1403          */
1404         resFlagsLength=(length+31)>>5;          /* number of bytes needed */
1405         resFlagsLength=(resFlagsLength+3)&~3;   /* multiple of 4 bytes for uint32_t */
1406         if(resFlagsLength<=(int32_t)sizeof(stackResFlags)) {
1407             tempTable.resFlags=stackResFlags;
1408         } else {
1409             tempTable.resFlags=(uint32_t *)uprv_malloc(resFlagsLength);
1410             if(tempTable.resFlags==NULL) {
1411                 udata_printError(ds, "ures_swap(): unable to allocate memory for tracking resources\n");
1412                 *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
1413                 return 0;
1414             }
1415         }
1416         uprv_memset(tempTable.resFlags, 0, resFlagsLength);
1417
1418         /* copy the bundle for binary and inaccessible data */
1419         if(inData!=outData) {
1420             uprv_memcpy(outBundle, inBundle, 4*top);
1421         }
1422
1423         /* swap the key strings, but not the padding bytes (0xaa) after the last string and its NUL */
1424         udata_swapInvStringBlock(ds, inBundle+keysBottom, 4*(keysTop-keysBottom),
1425                                     outBundle+keysBottom, pErrorCode);
1426         if(U_FAILURE(*pErrorCode)) {
1427             udata_printError(ds, "ures_swap().udata_swapInvStringBlock(keys[%d]) failed\n", 4*(keysTop-keysBottom));
1428             return 0;
1429         }
1430
1431         /* swap the 16-bit units (strings, table16, array16) */
1432         if(keysTop<resBottom) {
1433             ds->swapArray16(ds, inBundle+keysTop, (resBottom-keysTop)*4, outBundle+keysTop, pErrorCode);
1434             if(U_FAILURE(*pErrorCode)) {
1435                 udata_printError(ds, "ures_swap().swapArray16(16-bit units[%d]) failed\n", 2*(resBottom-keysTop));
1436                 return 0;
1437             }
1438         }
1439
1440         /* allocate the temporary table for sorting resource tables */
1441         tempTable.keyChars=(const char *)outBundle; /* sort by outCharset */
1442         if(tempTable.majorFormatVersion>1 || maxTableLength<=STACK_ROW_CAPACITY) {
1443             tempTable.rows=rows;
1444             tempTable.resort=resort;
1445         } else {
1446             tempTable.rows=(Row *)uprv_malloc(maxTableLength*sizeof(Row)+maxTableLength*4);
1447             if(tempTable.rows==NULL) {
1448                 udata_printError(ds, "ures_swap(): unable to allocate memory for sorting tables (max length: %d)\n",
1449                                  maxTableLength);
1450                 *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
1451                 if(tempTable.resFlags!=stackResFlags) {
1452                     uprv_free(tempTable.resFlags);
1453                 }
1454                 return 0;
1455             }
1456             tempTable.resort=(int32_t *)(tempTable.rows+maxTableLength);
1457         }
1458
1459         /* swap the resources */
1460         ures_swapResource(ds, inBundle, outBundle, rootRes, NULL, &tempTable, pErrorCode);
1461         if(U_FAILURE(*pErrorCode)) {
1462             udata_printError(ds, "ures_swapResource(root res=%08x) failed\n",
1463                              rootRes);
1464         }
1465
1466         if(tempTable.rows!=rows) {
1467             uprv_free(tempTable.rows);
1468         }
1469         if(tempTable.resFlags!=stackResFlags) {
1470             uprv_free(tempTable.resFlags);
1471         }
1472
1473         /* swap the root resource and indexes */
1474         ds->swapArray32(ds, inBundle, keysBottom*4, outBundle, pErrorCode);
1475     }
1476
1477     return headerSize+4*top;
1478 }