ICU 56 update step 1

source/common/uresdata.c

 /*
 *******************************************************************************
-* Copyright (C) 1999-2014, International Business Machines Corporation
+* Copyright (C) 1999-2015, International Business Machines Corporation
 *               and others. All Rights Reserved.
 *******************************************************************************
 *   file name:  uresdata.c
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 1999dec08
 *   created by: Markus W. Scherer
 * Modification History:
@@ skipping 124 matching lines @@
     uprv_memcpy(context, pInfo->formatVersion, 4);
     return (UBool)(
         pInfo->size>=20 &&
         pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
         pInfo->charsetFamily==U_CHARSET_FAMILY &&
         pInfo->sizeofUChar==U_SIZEOF_UCHAR &&
         pInfo->dataFormat[0]==0x52 &&   /* dataFormat="ResB" */
         pInfo->dataFormat[1]==0x65 &&
         pInfo->dataFormat[2]==0x73 &&
         pInfo->dataFormat[3]==0x42 &&
-        (pInfo->formatVersion[0]==1 || pInfo->formatVersion[0]==2));
+        (1<=pInfo->formatVersion[0] && pInfo->formatVersion[0]<=3));
 }
 
 /* semi-public functions ---------------------------------------------------- */
 
 static void
 res_init(ResourceData *pResData,
          UVersionInfo formatVersion, const void *inBytes, int32_t length,
          UErrorCode *errorCode) {
     UResType rootType;
 
@@ skipping 32 matching lines @@
             (length<((1+indexLength)<<2) ||
              length<(indexes[URES_INDEX_BUNDLE_TOP]<<2))
         ) {
             *errorCode=U_INVALID_FORMAT_ERROR;
             res_unload(pResData);
             return;
         }
         if(indexes[URES_INDEX_KEYS_TOP]>(1+indexLength)) {
             pResData->localKeyLimit=indexes[URES_INDEX_KEYS_TOP]<<2;
         }
+        if(formatVersion[0]>=3) {
+            // In formatVersion 1, the indexLength took up this whole int.
+            // In version 2, bits 31..8 were reserved and always 0.
+            // In version 3, they contain bits 23..0 of the poolStringIndexLimit.
+            // Bits 27..24 are in indexes[URES_INDEX_ATTRIBUTES] bits 15..12.
+            pResData->poolStringIndexLimit=(int32_t)((uint32_t)indexes[URES_INDEX_LENGTH]>>8);
+        }
         if(indexLength>URES_INDEX_ATTRIBUTES) {
             int32_t att=indexes[URES_INDEX_ATTRIBUTES];
             pResData->noFallback=(UBool)(att&URES_ATT_NO_FALLBACK);
             pResData->isPoolBundle=(UBool)((att&URES_ATT_IS_POOL_BUNDLE)!=0);
             pResData->usesPoolBundle=(UBool)((att&URES_ATT_USES_POOL_BUNDLE)!=0);
+            pResData->poolStringIndexLimit|=(att&0xf000)<<12;  // bits 15..12 -> 27..24
+            pResData->poolStringIndex16Limit=(int32_t)((uint32_t)att>>16);
         }
         if((pResData->isPoolBundle || pResData->usesPoolBundle) && indexLength<=URES_INDEX_POOL_CHECKSUM) {
             *errorCode=U_INVALID_FORMAT_ERROR;
             res_unload(pResData);
             return;
         }
         if( indexLength>URES_INDEX_16BIT_TOP &&
             indexes[URES_INDEX_16BIT_TOP]>indexes[URES_INDEX_KEYS_TOP]
         ) {
             pResData->p16BitUnits=(const uint16_t *)(pResData->pRoot+indexes[URES_INDEX_KEYS_TOP]);
@@ skipping 78 matching lines @@
     return (UResType)gPublicTypes[RES_GET_TYPE(res)];
 }
 
 U_CAPI const UChar * U_EXPORT2
 res_getString(const ResourceData *pResData, Resource res, int32_t *pLength) {
     const UChar *p;
     uint32_t offset=RES_GET_OFFSET(res);
     int32_t length;
     if(RES_GET_TYPE(res)==URES_STRING_V2) {
         int32_t first;
-        p=(const UChar *)(pResData->p16BitUnits+offset);
+        if(offset<pResData->poolStringIndexLimit) {
+            p=(const UChar *)pResData->poolBundleStrings+offset;
+        } else {
+            p=(const UChar *)pResData->p16BitUnits+(offset-pResData->poolStringIndexLimit);
+        }
         first=*p;
         if(!U16_IS_TRAIL(first)) {
             length=u_strlen(p);
         } else if(first<0xdfef) {
             length=first&0x3ff;
             ++p;
         } else if(first<0xdfff) {
             length=((first-0xdfef)<<16)|p[1];
             p+=2;
         } else {
@@ skipping 88 matching lines @@
     case URES_TABLE:
         return offset==0 ? 0 : *((const uint16_t *)(pResData->pRoot+offset));
     case URES_ARRAY16:
     case URES_TABLE16:
         return pResData->p16BitUnits[offset];
     default:
         return 0;
     }
 }
 
+static Resource
+makeResourceFrom16(const ResourceData *pResData, int32_t res16) {
+    if(res16<pResData->poolStringIndex16Limit) {
+        // Pool string, nothing to do.
+    } else {
+        // Local string, adjust the 16-bit offset to a regular one,
+        // with a larger pool string index limit.
+        res16=res16-pResData->poolStringIndex16Limit+pResData->poolStringIndexLimit;
+    }
+    return URES_MAKE_RESOURCE(URES_STRING_V2, res16);
+}
+
 U_CAPI Resource U_EXPORT2
 res_getTableItemByKey(const ResourceData *pResData, Resource table,
                       int32_t *indexR, const char **key) {
     uint32_t offset=RES_GET_OFFSET(table);
     int32_t length;
     int32_t idx;
     if(key == NULL || *key == NULL) {
         return RES_BOGUS;
     }
     switch(RES_GET_TYPE(table)) {
     case URES_TABLE: {
         if (offset!=0) { /* empty if offset==0 */
             const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset);
             length=*p++;
             *indexR=idx=_res_findTableItem(pResData, p, length, *key, key);
             if(idx>=0) {
                 const Resource *p32=(const Resource *)(p+length+(~length&1));
                 return p32[idx];
             }
         }
         break;
     }
     case URES_TABLE16: {
         const uint16_t *p=pResData->p16BitUnits+offset;
         length=*p++;
         *indexR=idx=_res_findTableItem(pResData, p, length, *key, key);
         if(idx>=0) {
-            return URES_MAKE_RESOURCE(URES_STRING_V2, p[length+idx]);
+            return makeResourceFrom16(pResData, p[length+idx]);
         }
         break;
     }
     case URES_TABLE32: {
         if (offset!=0) { /* empty if offset==0 */
             const int32_t *p= pResData->pRoot+offset;
             length=*p++;
             *indexR=idx=_res_findTable32Item(pResData, p, length, *key, key);
             if(idx>=0) {
                 return (Resource)p[length+idx];
@@ skipping 28 matching lines @@
         }
         break;
     }
     case URES_TABLE16: {
         const uint16_t *p=pResData->p16BitUnits+offset;
         length=*p++;
         if(indexR<length) {
             if(key!=NULL) {
                 *key=RES_GET_KEY16(pResData, p[indexR]);
             }
-            return URES_MAKE_RESOURCE(URES_STRING_V2, p[length+indexR]);
+            return makeResourceFrom16(pResData, p[length+indexR]);
         }
         break;
     }
     case URES_TABLE32: {
         if (offset != 0) { /* empty if offset==0 */
             const int32_t *p= pResData->pRoot+offset;
             length=*p++;
             if(indexR<length) {
                 if(key!=NULL) {
                     *key=RES_GET_KEY32(pResData, p[indexR]);
@@ skipping 26 matching lines @@
             const int32_t *p= pResData->pRoot+offset;
             if(indexR<*p) {
                 return (Resource)p[1+indexR];
             }
         }
         break;
     }
     case URES_ARRAY16: {
         const uint16_t *p=pResData->p16BitUnits+offset;
         if(indexR<*p) {
-            return URES_MAKE_RESOURCE(URES_STRING_V2, p[1+indexR]);
+            return makeResourceFrom16(pResData, p[1+indexR]);
         }
         break;
     }
     default:
         break;
     }
     return RES_BOGUS;
 }
 
 U_CFUNC Resource
@@ skipping 436 matching lines @@
         return 0;
     }
 
     /* check data format and format version */
     pInfo=(const UDataInfo *)((const char *)inData+4);
     if(!(
         pInfo->dataFormat[0]==0x52 &&   /* dataFormat="ResB" */
         pInfo->dataFormat[1]==0x65 &&
         pInfo->dataFormat[2]==0x73 &&
         pInfo->dataFormat[3]==0x42 &&
-        ((pInfo->formatVersion[0]==1 && pInfo->formatVersion[1]>=1) ||  /* formatVersion 1.1+ or 2.x */
-         pInfo->formatVersion[0]==2)
+        /* formatVersion 1.1+ or 2.x or 3.x */
+        ((pInfo->formatVersion[0]==1 && pInfo->formatVersion[1]>=1) ||
+            pInfo->formatVersion[0]==2 || pInfo->formatVersion[0]==3)
     )) {
         udata_printError(ds, "ures_swap(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not a resource bundle\n",
                          pInfo->dataFormat[0], pInfo->dataFormat[1],
                          pInfo->dataFormat[2], pInfo->dataFormat[3],
                          pInfo->formatVersion[0], pInfo->formatVersion[1]);
         *pErrorCode=U_UNSUPPORTED_ERROR;
         return 0;
     }
     tempTable.majorFormatVersion=pInfo->formatVersion[0];
 
@@ skipping 129 matching lines @@
         if(tempTable.resFlags!=stackResFlags) {
             uprv_free(tempTable.resFlags);
         }
 
         /* swap the root resource and indexes */
         ds->swapArray32(ds, inBundle, keysBottom*4, outBundle, pErrorCode);
     }
 
     return headerSize+4*top;
 }