Home | History | Annotate | Download | only in common
      1 /*
      2 ******************************************************************************
      3 * Copyright (C) 1997-2010, International Business Machines Corporation and   *
      4 * others. All Rights Reserved.                                               *
      5 ******************************************************************************
      6 *
      7 * File URESBUND.C
      8 *
      9 * Modification History:
     10 *
     11 *   Date        Name        Description
     12 *   04/01/97    aliu        Creation.
     13 *   06/14/99    stephen     Removed functions taking a filename suffix.
     14 *   07/20/99    stephen     Changed for UResourceBundle typedef'd to void*
     15 *   11/09/99    weiv            Added ures_getLocale()
     16 *   March 2000  weiv        Total overhaul - using data in DLLs
     17 *   06/20/2000  helena      OS/400 port changes; mostly typecast.
     18 *   06/24/02    weiv        Added support for resource sharing
     19 ******************************************************************************
     20 */
     21 
     22 #include "unicode/ustring.h"
     23 #include "unicode/ucnv.h"
     24 #include "uresimp.h"
     25 #include "ustr_imp.h"
     26 #include "cwchar.h"
     27 #include "ucln_cmn.h"
     28 #include "cmemory.h"
     29 #include "cstring.h"
     30 #include "uhash.h"
     31 #include "unicode/uenum.h"
     32 #include "uenumimp.h"
     33 #include "ulocimp.h"
     34 #include "umutex.h"
     35 #include "putilimp.h"
     36 
     37 
     38 /*
     39 Static cache for already opened resource bundles - mostly for keeping fallback info
     40 TODO: This cache should probably be removed when the deprecated code is
     41       completely removed.
     42 */
     43 static UHashtable *cache = NULL;
     44 
     45 static UMTX resbMutex = NULL;
     46 
     47 /* INTERNAL: hashes an entry  */
     48 static int32_t U_CALLCONV hashEntry(const UHashTok parm) {
     49     UResourceDataEntry *b = (UResourceDataEntry *)parm.pointer;
     50     UHashTok namekey, pathkey;
     51     namekey.pointer = b->fName;
     52     pathkey.pointer = b->fPath;
     53     return uhash_hashChars(namekey)+37*uhash_hashChars(pathkey);
     54 }
     55 
     56 /* INTERNAL: compares two entries */
     57 static UBool U_CALLCONV compareEntries(const UHashTok p1, const UHashTok p2) {
     58     UResourceDataEntry *b1 = (UResourceDataEntry *)p1.pointer;
     59     UResourceDataEntry *b2 = (UResourceDataEntry *)p2.pointer;
     60     UHashTok name1, name2, path1, path2;
     61     name1.pointer = b1->fName;
     62     name2.pointer = b2->fName;
     63     path1.pointer = b1->fPath;
     64     path2.pointer = b2->fPath;
     65     return (UBool)(uhash_compareChars(name1, name2) &&
     66         uhash_compareChars(path1, path2));
     67 }
     68 
     69 
     70 /**
     71  *  Internal function, gets parts of locale name according
     72  *  to the position of '_' character
     73  */
     74 static UBool chopLocale(char *name) {
     75     char *i = uprv_strrchr(name, '_');
     76 
     77     if(i != NULL) {
     78         *i = '\0';
     79         return TRUE;
     80     }
     81 
     82     return FALSE;
     83 }
     84 
     85 /**
     86  *  Internal function
     87  */
     88 static void entryIncrease(UResourceDataEntry *entry) {
     89     umtx_lock(&resbMutex);
     90     entry->fCountExisting++;
     91     while(entry->fParent != NULL) {
     92       entry = entry->fParent;
     93       entry->fCountExisting++;
     94     }
     95     umtx_unlock(&resbMutex);
     96 }
     97 
     98 /**
     99  *  Internal function. Tries to find a resource in given Resource
    100  *  Bundle, as well as in its parents
    101  */
    102 static const ResourceData *getFallbackData(const UResourceBundle* resBundle, const char* * resTag, UResourceDataEntry* *realData, Resource *res, UErrorCode *status) {
    103     UResourceDataEntry *resB = resBundle->fData;
    104     int32_t indexR = -1;
    105     int32_t i = 0;
    106     *res = RES_BOGUS;
    107     if(resB != NULL) {
    108         if(resB->fBogus == U_ZERO_ERROR) { /* if this resource is real, */
    109             *res = res_getTableItemByKey(&(resB->fData), resB->fData.rootRes, &indexR, resTag); /* try to get data from there */
    110             i++;
    111         }
    112         if(resBundle->fHasFallback == TRUE) {
    113             while(*res == RES_BOGUS && resB->fParent != NULL) { /* Otherwise, we'll look in parents */
    114                 resB = resB->fParent;
    115                 if(resB->fBogus == U_ZERO_ERROR) {
    116                     i++;
    117                     *res = res_getTableItemByKey(&(resB->fData), resB->fData.rootRes, &indexR, resTag);
    118                 }
    119             }
    120         }
    121 
    122         if(*res != RES_BOGUS) { /* If the resource is found in parents, we need to adjust the error */
    123             if(i>1) {
    124                 if(uprv_strcmp(resB->fName, uloc_getDefault())==0 || uprv_strcmp(resB->fName, kRootLocaleName)==0) {
    125                     *status = U_USING_DEFAULT_WARNING;
    126                 } else {
    127                     *status = U_USING_FALLBACK_WARNING;
    128                 }
    129             }
    130             *realData = resB;
    131             return (&(resB->fData));
    132         } else { /* If resource is not found, we need to give an error */
    133             *status = U_MISSING_RESOURCE_ERROR;
    134             return NULL;
    135         }
    136     } else {
    137             *status = U_MISSING_RESOURCE_ERROR;
    138             return NULL;
    139     }
    140 }
    141 
    142 static void
    143 free_entry(UResourceDataEntry *entry) {
    144     UResourceDataEntry *alias;
    145     res_unload(&(entry->fData));
    146     if(entry->fName != NULL && entry->fName != entry->fNameBuffer) {
    147         uprv_free(entry->fName);
    148     }
    149     if(entry->fPath != NULL) {
    150         uprv_free(entry->fPath);
    151     }
    152     if(entry->fPool != NULL) {
    153         --entry->fPool->fCountExisting;
    154     }
    155     alias = entry->fAlias;
    156     if(alias != NULL) {
    157         while(alias->fAlias != NULL) {
    158             alias = alias->fAlias;
    159         }
    160         --alias->fCountExisting;
    161     }
    162     uprv_free(entry);
    163 }
    164 
    165 /* Works just like ucnv_flushCache() */
    166 static int32_t ures_flushCache()
    167 {
    168     UResourceDataEntry *resB;
    169     int32_t pos;
    170     int32_t rbDeletedNum = 0;
    171     const UHashElement *e;
    172     UBool deletedMore;
    173 
    174     /*if shared data hasn't even been lazy evaluated yet
    175     * return 0
    176     */
    177     umtx_lock(&resbMutex);
    178     if (cache == NULL) {
    179         umtx_unlock(&resbMutex);
    180         return 0;
    181     }
    182 
    183     do {
    184         deletedMore = FALSE;
    185         /*creates an enumeration to iterate through every element in the table */
    186         pos = -1;
    187         while ((e = uhash_nextElement(cache, &pos)) != NULL)
    188         {
    189             resB = (UResourceDataEntry *) e->value.pointer;
    190             /* Deletes only if reference counter == 0
    191              * Don't worry about the children of this node.
    192              * Those will eventually get deleted too, if not already.
    193              * Don't worry about the parents of this node.
    194              * Those will eventually get deleted too, if not already.
    195              */
    196             /* 04/05/2002 [weiv] fCountExisting should now be accurate. If it's not zero, that means that    */
    197             /* some resource bundles are still open somewhere. */
    198 
    199             if (resB->fCountExisting == 0) {
    200                 rbDeletedNum++;
    201                 deletedMore = TRUE;
    202                 uhash_removeElement(cache, e);
    203                 free_entry(resB);
    204             }
    205         }
    206         /*
    207          * Do it again to catch bundles (aliases, pool bundle) whose fCountExisting
    208          * got decremented by free_entry().
    209          */
    210     } while(deletedMore);
    211     umtx_unlock(&resbMutex);
    212 
    213     return rbDeletedNum;
    214 }
    215 
    216 #ifdef URES_DEBUG
    217 #include <stdio.h>
    218 
    219 U_CAPI UBool U_EXPORT2 ures_dumpCacheContents(void) {
    220   UBool cacheNotEmpty = FALSE;
    221   int32_t pos = -1;
    222   const UHashElement *e;
    223   UResourceDataEntry *resB;
    224 
    225     umtx_lock(&resbMutex);
    226     if (cache == NULL) {
    227       umtx_unlock(&resbMutex);
    228       fprintf(stderr,"%s:%d: RB Cache is NULL.\n", __FILE__, __LINE__);
    229       return FALSE;
    230     }
    231 
    232     while ((e = uhash_nextElement(cache, &pos)) != NULL) {
    233       cacheNotEmpty=TRUE;
    234       resB = (UResourceDataEntry *) e->value.pointer;
    235       fprintf(stderr,"%s:%d: RB Cache: Entry @0x%p, refcount %d, name %s:%s.  Pool 0x%p, alias 0x%p, parent 0x%p\n",
    236               __FILE__, __LINE__,
    237               (void*)resB, resB->fCountExisting,
    238               resB->fName?resB->fName:"NULL",
    239               resB->fPath?resB->fPath:"NULL",
    240               (void*)resB->fPool,
    241               (void*)resB->fAlias,
    242               (void*)resB->fParent);
    243     }
    244 
    245     fprintf(stderr,"%s:%d: RB Cache still contains %d items.\n", __FILE__, __LINE__, uhash_count(cache));
    246 
    247     umtx_unlock(&resbMutex);
    248 
    249     return cacheNotEmpty;
    250 }
    251 
    252 #endif
    253 
    254 static UBool U_CALLCONV ures_cleanup(void)
    255 {
    256     if (cache != NULL) {
    257         ures_flushCache();
    258         if (cache != NULL && uhash_count(cache) == 0) {
    259             uhash_close(cache);
    260             cache = NULL;
    261         }
    262     }
    263     if (cache == NULL && resbMutex != NULL) {
    264         umtx_destroy(&resbMutex);
    265     }
    266     return (cache == NULL);
    267 }
    268 
    269 /** INTERNAL: Initializes the cache for resources */
    270 static void initCache(UErrorCode *status) {
    271     UBool makeCache = FALSE;
    272     UMTX_CHECK(&resbMutex, (cache ==  NULL), makeCache);
    273     if(makeCache) {
    274         UHashtable *newCache = uhash_open(hashEntry, compareEntries, NULL, status);
    275         if (U_FAILURE(*status)) {
    276             return;
    277         }
    278         umtx_lock(&resbMutex);
    279         if(cache == NULL) {
    280             cache = newCache;
    281             newCache = NULL;
    282             ucln_common_registerCleanup(UCLN_COMMON_URES, ures_cleanup);
    283         }
    284         umtx_unlock(&resbMutex);
    285         if(newCache != NULL) {
    286             uhash_close(newCache);
    287         }
    288     }
    289 }
    290 
    291 /** INTERNAL: sets the name (locale) of the resource bundle to given name */
    292 
    293 static void setEntryName(UResourceDataEntry *res, char *name, UErrorCode *status) {
    294     int32_t len = (int32_t)uprv_strlen(name);
    295     if(res->fName != NULL && res->fName != res->fNameBuffer) {
    296         uprv_free(res->fName);
    297     }
    298     if (len < (int32_t)sizeof(res->fNameBuffer)) {
    299         res->fName = res->fNameBuffer;
    300     }
    301     else {
    302         res->fName = (char *)uprv_malloc(len+1);
    303     }
    304     if(res->fName == NULL) {
    305         *status = U_MEMORY_ALLOCATION_ERROR;
    306     } else {
    307         uprv_strcpy(res->fName, name);
    308     }
    309 }
    310 
    311 static UResourceDataEntry *
    312 getPoolEntry(const char *path, UErrorCode *status);
    313 
    314 /**
    315  *  INTERNAL: Inits and opens an entry from a data DLL.
    316  *    CAUTION:  resbMutex must be locked when calling this function.
    317  */
    318 static UResourceDataEntry *init_entry(const char *localeID, const char *path, UErrorCode *status) {
    319     UResourceDataEntry *r = NULL;
    320     UResourceDataEntry find;
    321     /*int32_t hashValue;*/
    322     char name[96];
    323     char aliasName[100] = { 0 };
    324     int32_t aliasLen = 0;
    325     /*UBool isAlias = FALSE;*/
    326     UHashTok hashkey;
    327 
    328     if(U_FAILURE(*status)) {
    329         return NULL;
    330     }
    331 
    332     /* here we try to deduce the right locale name */
    333     if(localeID == NULL) { /* if localeID is NULL, we're trying to open default locale */
    334         uprv_strcpy(name, uloc_getDefault());
    335     } else if(*localeID == 0) { /* if localeID is "" then we try to open root locale */
    336         uprv_strcpy(name, kRootLocaleName);
    337     } else { /* otherwise, we'll open what we're given */
    338         uprv_strcpy(name, localeID);
    339     }
    340 
    341     find.fName = name;
    342     find.fPath = (char *)path;
    343 
    344     /* calculate the hash value of the entry */
    345     hashkey.pointer = (void *)&find;
    346     /*hashValue = hashEntry(hashkey);*/
    347 
    348     /* check to see if we already have this entry */
    349     r = (UResourceDataEntry *)uhash_get(cache, &find);
    350     if(r == NULL) {
    351         /* if the entry is not yet in the hash table, we'll try to construct a new one */
    352         r = (UResourceDataEntry *) uprv_malloc(sizeof(UResourceDataEntry));
    353         if(r == NULL) {
    354             *status = U_MEMORY_ALLOCATION_ERROR;
    355             return NULL;
    356         }
    357 
    358         uprv_memset(r, 0, sizeof(UResourceDataEntry));
    359         /*r->fHashKey = hashValue;*/
    360 
    361         setEntryName(r, name, status);
    362         if (U_FAILURE(*status)) {
    363             uprv_free(r);
    364             return NULL;
    365         }
    366 
    367         if(path != NULL) {
    368             r->fPath = (char *)uprv_strdup(path);
    369             if(r->fPath == NULL) {
    370                 *status = U_MEMORY_ALLOCATION_ERROR;
    371                 uprv_free(r);
    372                 return NULL;
    373             }
    374         }
    375 
    376         /* this is the actual loading */
    377         res_load(&(r->fData), r->fPath, r->fName, status);
    378 
    379         if (U_FAILURE(*status)) {
    380             /* we have no such entry in dll, so it will always use fallback */
    381             *status = U_USING_FALLBACK_WARNING;
    382             r->fBogus = U_USING_FALLBACK_WARNING;
    383         } else { /* if we have a regular entry */
    384             Resource aliasres;
    385             if (r->fData.usesPoolBundle) {
    386                 r->fPool = getPoolEntry(r->fPath, status);
    387                 if (U_SUCCESS(*status)) {
    388                     const int32_t *poolIndexes = r->fPool->fData.pRoot + 1;
    389                     if(r->fData.pRoot[1 + URES_INDEX_POOL_CHECKSUM] == poolIndexes[URES_INDEX_POOL_CHECKSUM]) {
    390                         r->fData.poolBundleKeys = (const char *)(poolIndexes + (poolIndexes[URES_INDEX_LENGTH] & 0xff));
    391                     } else {
    392                         r->fBogus = *status = U_INVALID_FORMAT_ERROR;
    393                     }
    394                 } else {
    395                     r->fBogus = *status;
    396                 }
    397             }
    398             if (U_SUCCESS(*status)) {
    399                 /* handle the alias by trying to get out the %%Alias tag.*/
    400                 /* We'll try to get alias string from the bundle */
    401                 aliasres = res_getResource(&(r->fData), "%%ALIAS");
    402                 if (aliasres != RES_BOGUS) {
    403                     const UChar *alias = res_getString(&(r->fData), aliasres, &aliasLen);
    404                     if(alias != NULL && aliasLen > 0) { /* if there is actual alias - unload and load new data */
    405                         u_UCharsToChars(alias, aliasName, aliasLen+1);
    406                         r->fAlias = init_entry(aliasName, path, status);
    407                     }
    408                 }
    409             }
    410         }
    411 
    412         {
    413             UResourceDataEntry *oldR = NULL;
    414             if((oldR = (UResourceDataEntry *)uhash_get(cache, r)) == NULL) { /* if the data is not cached */
    415                 /* just insert it in the cache */
    416                 UErrorCode cacheStatus = U_ZERO_ERROR;
    417                 uhash_put(cache, (void *)r, r, &cacheStatus);
    418                 if (U_FAILURE(cacheStatus)) {
    419                     *status = cacheStatus;
    420                     free_entry(r);
    421                     r = NULL;
    422                 }
    423             } else {
    424                 /* somebody have already inserted it while we were working, discard newly opened data */
    425                 /* Also, we could get here IF we opened an alias */
    426                 free_entry(r);
    427                 r = oldR;
    428             }
    429         }
    430 
    431     }
    432     if(r != NULL) {
    433         /* return the real bundle */
    434         while(r->fAlias != NULL) {
    435             r = r->fAlias;
    436         }
    437         r->fCountExisting++; /* we increase its reference count */
    438         /* if the resource has a warning */
    439         /* we don't want to overwrite a status with no error */
    440         if(r->fBogus != U_ZERO_ERROR && U_SUCCESS(*status)) {
    441              *status = r->fBogus; /* set the returning status */
    442         }
    443     }
    444     return r;
    445 }
    446 
    447 static UResourceDataEntry *
    448 getPoolEntry(const char *path, UErrorCode *status) {
    449     UResourceDataEntry *poolBundle = init_entry(kPoolBundleName, path, status);
    450     if( U_SUCCESS(*status) &&
    451         (poolBundle == NULL || poolBundle->fBogus != U_ZERO_ERROR || !poolBundle->fData.isPoolBundle)
    452     ) {
    453         *status = U_INVALID_FORMAT_ERROR;
    454     }
    455     return poolBundle;
    456 }
    457 
    458 /* INTERNAL: */
    459 /*   CAUTION:  resbMutex must be locked when calling this function! */
    460 static UResourceDataEntry *findFirstExisting(const char* path, char* name, UBool *isRoot, UBool *hasChopped, UBool *isDefault, UErrorCode* status) {
    461     UResourceDataEntry *r = NULL;
    462     UBool hasRealData = FALSE;
    463     const char *defaultLoc = uloc_getDefault();
    464     *hasChopped = TRUE; /* we're starting with a fresh name */
    465 
    466     while(*hasChopped && !hasRealData) {
    467         r = init_entry(name, path, status);
    468         /* Null pointer test */
    469         if (U_FAILURE(*status)) {
    470             return NULL;
    471         }
    472         *isDefault = (UBool)(uprv_strncmp(name, defaultLoc, uprv_strlen(name)) == 0);
    473         hasRealData = (UBool)(r->fBogus == U_ZERO_ERROR);
    474         if(!hasRealData) {
    475             /* this entry is not real. We will discard it. */
    476             /* However, the parent line for this entry is  */
    477             /* not to be used - as there might be parent   */
    478             /* lines in cache from previous openings that  */
    479             /* are not updated yet. */
    480             r->fCountExisting--;
    481             /*entryCloseInt(r);*/
    482             r = NULL;
    483             *status = U_USING_FALLBACK_WARNING;
    484         } else {
    485             uprv_strcpy(name, r->fName); /* this is needed for supporting aliases */
    486         }
    487 
    488         *isRoot = (UBool)(uprv_strcmp(name, kRootLocaleName) == 0);
    489 
    490         /*Fallback data stuff*/
    491         *hasChopped = chopLocale(name);
    492     }
    493     return r;
    494 }
    495 
    496 static void ures_setIsStackObject( UResourceBundle* resB, UBool state) {
    497     if(state) {
    498         resB->fMagic1 = 0;
    499         resB->fMagic2 = 0;
    500     } else {
    501         resB->fMagic1 = MAGIC1;
    502         resB->fMagic2 = MAGIC2;
    503     }
    504 }
    505 
    506 static UBool ures_isStackObject(const UResourceBundle* resB) {
    507   return((resB->fMagic1 == MAGIC1 && resB->fMagic2 == MAGIC2)?FALSE:TRUE);
    508 }
    509 
    510 
    511 U_CFUNC void ures_initStackObject(UResourceBundle* resB) {
    512   uprv_memset(resB, 0, sizeof(UResourceBundle));
    513   ures_setIsStackObject(resB, TRUE);
    514 }
    515 
    516 static UResourceDataEntry *entryOpen(const char* path, const char* localeID, UErrorCode* status) {
    517     UErrorCode intStatus = U_ZERO_ERROR;
    518     UErrorCode parentStatus = U_ZERO_ERROR;
    519     UErrorCode usrStatus = U_ZERO_ERROR;
    520     UResourceDataEntry *r = NULL;
    521     UResourceDataEntry *t1 = NULL;
    522     UResourceDataEntry *t2 = NULL;
    523     UResourceDataEntry *u1 = NULL;
    524     UResourceDataEntry *u2 = NULL;
    525     UBool isDefault = FALSE;
    526     UBool isRoot = FALSE;
    527     UBool hasRealData = FALSE;
    528     UBool hasChopped = TRUE;
    529     UBool usingUSRData = U_USE_USRDATA && ( path == NULL || uprv_strncmp(path,U_ICUDATA_NAME,8) == 0);
    530 
    531     char name[96];
    532     char usrDataPath[96];
    533 
    534     initCache(status);
    535 
    536     if(U_FAILURE(*status)) {
    537         return NULL;
    538     }
    539 
    540     uprv_strcpy(name, localeID);
    541 
    542     if ( usingUSRData ) {
    543         if ( path == NULL ) {
    544            uprv_strcpy(usrDataPath,U_USRDATA_NAME);
    545         } else {
    546            uprv_strcpy(usrDataPath,path);
    547            usrDataPath[0] = 'u';
    548            usrDataPath[1] = 's';
    549            usrDataPath[2] = 'r';
    550         }
    551     }
    552 
    553     umtx_lock(&resbMutex);
    554     { /* umtx_lock */
    555         /* We're going to skip all the locales that do not have any data */
    556         r = findFirstExisting(path, name, &isRoot, &hasChopped, &isDefault, &intStatus);
    557 
    558         if(r != NULL) { /* if there is one real locale, we can look for parents. */
    559             t1 = r;
    560             hasRealData = TRUE;
    561             if ( usingUSRData ) {  /* This code inserts user override data into the inheritance chain */
    562                u1 = init_entry(t1->fName, usrDataPath, &usrStatus);
    563                if ( u1 != NULL ) {
    564                  if(u1->fBogus == U_ZERO_ERROR) {
    565                    u1->fParent = t1;
    566                    r = u1;
    567                  } else {
    568                    /* the USR override data wasn't found, set it to be deleted */
    569                    u1->fCountExisting = 0;
    570                  }
    571                }
    572             }
    573             while (hasChopped && !isRoot && t1->fParent == NULL && !t1->fData.noFallback) {
    574                 /* insert regular parents */
    575                 t2 = init_entry(name, t1->fPath, &parentStatus);
    576                 if ( usingUSRData ) {  /* This code inserts user override data into the inheritance chain */
    577                     usrStatus = U_ZERO_ERROR;
    578                     u2 = init_entry(name, usrDataPath, &usrStatus);
    579                 }
    580                 /* Check for null pointer. */
    581                 if (t2 == NULL || ( usingUSRData && u2 == NULL)) {
    582                     *status = U_MEMORY_ALLOCATION_ERROR;
    583                     goto finishUnlock;
    584                 }
    585 
    586                 if ( res_getResource(&t1->fData,"%%ParentIsRoot") == RES_BOGUS) {
    587                     if ( usingUSRData && u2->fBogus == U_ZERO_ERROR ) {
    588                         t1->fParent = u2;
    589                         u2->fParent = t2;
    590                     } else {
    591                         t1->fParent = t2;
    592                         if(usingUSRData) {
    593                             /* the USR override data wasn't found, set it to be deleted */
    594                             u2->fCountExisting = 0;
    595                         }
    596                     }
    597                     t1 = t2;
    598                 } else {
    599                     if (usingUSRData) {
    600                         /* the USR override data wasn't found, set it to be deleted */
    601                         u2->fCountExisting = 0;
    602                     }
    603                     /* t2->fCountExisting have to be decremented since the call to init_entry increments
    604                      * it and if we hit this code, that means it is not set as the parent.
    605                      */
    606                     t2->fCountExisting--;
    607                 }
    608                 hasChopped = chopLocale(name);
    609             }
    610         }
    611 
    612         /* we could have reached this point without having any real data */
    613         /* if that is the case, we need to chain in the default locale   */
    614         if(r==NULL && !isDefault && !isRoot /*&& t1->fParent == NULL*/) {
    615             /* insert default locale */
    616             uprv_strcpy(name, uloc_getDefault());
    617             r = findFirstExisting(path, name, &isRoot, &hasChopped, &isDefault, &intStatus);
    618             intStatus = U_USING_DEFAULT_WARNING;
    619             if(r != NULL) { /* the default locale exists */
    620                 t1 = r;
    621                 hasRealData = TRUE;
    622                 isDefault = TRUE;
    623                 while (hasChopped && t1->fParent == NULL) {
    624                     /* insert chopped defaults */
    625                     t2 = init_entry(name, t1->fPath, &parentStatus);
    626                     /* Check for null pointer. */
    627                     if (t2 == NULL) {
    628                         *status = U_MEMORY_ALLOCATION_ERROR;
    629                         goto finishUnlock;
    630                     }
    631 
    632                     if ( res_getResource(&t1->fData,"%%ParentIsRoot") == RES_BOGUS) {
    633                         t1->fParent = t2;
    634                         t1 = t2;
    635                     }
    636                     hasChopped = chopLocale(name);
    637                 }
    638             }
    639         }
    640 
    641         /* we could still have r == NULL at this point - maybe even default locale is not */
    642         /* present */
    643         if(r == NULL) {
    644             uprv_strcpy(name, kRootLocaleName);
    645             r = findFirstExisting(path, name, &isRoot, &hasChopped, &isDefault, &intStatus);
    646             if(r != NULL) {
    647                 t1 = r;
    648                 intStatus = U_USING_DEFAULT_WARNING;
    649                 hasRealData = TRUE;
    650             } else { /* we don't even have the root locale */
    651                 *status = U_MISSING_RESOURCE_ERROR;
    652                 goto finishUnlock;
    653             }
    654         } else if(!isRoot && uprv_strcmp(t1->fName, kRootLocaleName) != 0 && t1->fParent == NULL && !r->fData.noFallback) {
    655             /* insert root locale */
    656             t2 = init_entry(kRootLocaleName, t1->fPath, &parentStatus);
    657             /* Check for null pointer. */
    658             if (t2 == NULL) {
    659                 *status = U_MEMORY_ALLOCATION_ERROR;
    660                 goto finishUnlock;
    661             }
    662             if(!hasRealData) {
    663                 r->fBogus = U_USING_DEFAULT_WARNING;
    664             }
    665             hasRealData = (UBool)((t2->fBogus == U_ZERO_ERROR) || hasRealData);
    666             t1->fParent = t2;
    667             t1 = t2;
    668         }
    669 
    670         while(r != NULL && !isRoot && t1->fParent != NULL) {
    671             t1->fParent->fCountExisting++;
    672             t1 = t1->fParent;
    673             hasRealData = (UBool)((t1->fBogus == U_ZERO_ERROR) || hasRealData);
    674         }
    675     } /* umtx_lock */
    676 finishUnlock:
    677     umtx_unlock(&resbMutex);
    678 
    679     if(U_SUCCESS(*status)) {
    680         if(U_SUCCESS(parentStatus)) {
    681             if(intStatus != U_ZERO_ERROR) {
    682                 *status = intStatus;
    683             }
    684             return r;
    685         } else {
    686             *status = parentStatus;
    687             return NULL;
    688         }
    689     } else {
    690         return NULL;
    691     }
    692 }
    693 
    694 
    695 /**
    696  * Functions to create and destroy resource bundles.
    697  *     CAUTION:  resbMutex must be locked when calling this function.
    698  */
    699 /* INTERNAL: */
    700 static void entryCloseInt(UResourceDataEntry *resB) {
    701     UResourceDataEntry *p = resB;
    702 
    703     while(resB != NULL) {
    704         p = resB->fParent;
    705         resB->fCountExisting--;
    706 
    707         /* Entries are left in the cache. TODO: add ures_flushCache() to force a flush
    708          of the cache. */
    709 /*
    710         if(resB->fCountExisting <= 0) {
    711             uhash_remove(cache, resB);
    712             if(resB->fBogus == U_ZERO_ERROR) {
    713                 res_unload(&(resB->fData));
    714             }
    715             if(resB->fName != NULL) {
    716                 uprv_free(resB->fName);
    717             }
    718             if(resB->fPath != NULL) {
    719                 uprv_free(resB->fPath);
    720             }
    721             uprv_free(resB);
    722         }
    723 */
    724 
    725         resB = p;
    726     }
    727 }
    728 
    729 /**
    730  *  API: closes a resource bundle and cleans up.
    731  */
    732 
    733 static void entryClose(UResourceDataEntry *resB) {
    734   umtx_lock(&resbMutex);
    735   entryCloseInt(resB);
    736   umtx_unlock(&resbMutex);
    737 }
    738 
    739 /*
    740 U_CFUNC void ures_setResPath(UResourceBundle *resB, const char* toAdd) {
    741   if(resB->fResPath == NULL) {
    742     resB->fResPath = resB->fResBuf;
    743     *(resB->fResPath) = 0;
    744   }
    745   resB->fResPathLen = uprv_strlen(toAdd);
    746   if(RES_BUFSIZE <= resB->fResPathLen+1) {
    747     if(resB->fResPath == resB->fResBuf) {
    748       resB->fResPath = (char *)uprv_malloc((resB->fResPathLen+1)*sizeof(char));
    749     } else {
    750       resB->fResPath = (char *)uprv_realloc(resB->fResPath, (resB->fResPathLen+1)*sizeof(char));
    751     }
    752   }
    753   uprv_strcpy(resB->fResPath, toAdd);
    754 }
    755 */
    756 static void ures_appendResPath(UResourceBundle *resB, const char* toAdd, int32_t lenToAdd, UErrorCode *status) {
    757     int32_t resPathLenOrig = resB->fResPathLen;
    758     if(resB->fResPath == NULL) {
    759         resB->fResPath = resB->fResBuf;
    760         *(resB->fResPath) = 0;
    761         resB->fResPathLen = 0;
    762     }
    763     resB->fResPathLen += lenToAdd;
    764     if(RES_BUFSIZE <= resB->fResPathLen+1) {
    765         if(resB->fResPath == resB->fResBuf) {
    766             resB->fResPath = (char *)uprv_malloc((resB->fResPathLen+1)*sizeof(char));
    767             /* Check that memory was allocated correctly. */
    768             if (resB->fResPath == NULL) {
    769                 *status = U_MEMORY_ALLOCATION_ERROR;
    770                 return;
    771             }
    772             uprv_strcpy(resB->fResPath, resB->fResBuf);
    773         } else {
    774             char *temp = (char *)uprv_realloc(resB->fResPath, (resB->fResPathLen+1)*sizeof(char));
    775             /* Check that memory was reallocated correctly. */
    776             if (temp == NULL) {
    777                 *status = U_MEMORY_ALLOCATION_ERROR;
    778                 return;
    779             }
    780             resB->fResPath = temp;
    781         }
    782     }
    783     uprv_strcpy(resB->fResPath + resPathLenOrig, toAdd);
    784 }
    785 
    786 static void ures_freeResPath(UResourceBundle *resB) {
    787     if (resB->fResPath && resB->fResPath != resB->fResBuf) {
    788         uprv_free(resB->fResPath);
    789     }
    790     resB->fResPath = NULL;
    791     resB->fResPathLen = 0;
    792 }
    793 
    794 static void
    795 ures_closeBundle(UResourceBundle* resB, UBool freeBundleObj)
    796 {
    797     if(resB != NULL) {
    798         if(resB->fData != NULL) {
    799             entryClose(resB->fData);
    800         }
    801         if(resB->fVersion != NULL) {
    802             uprv_free(resB->fVersion);
    803         }
    804         ures_freeResPath(resB);
    805 
    806         if(ures_isStackObject(resB) == FALSE && freeBundleObj) {
    807             uprv_free(resB);
    808         }
    809 #if 0 /*U_DEBUG*/
    810         else {
    811             /* poison the data */
    812             uprv_memset(resB, -1, sizeof(UResourceBundle));
    813         }
    814 #endif
    815     }
    816 }
    817 
    818 U_CAPI void  U_EXPORT2
    819 ures_close(UResourceBundle* resB)
    820 {
    821     ures_closeBundle(resB, TRUE);
    822 }
    823 
    824 static UResourceBundle *init_resb_result(const ResourceData *rdata, Resource r,
    825                                          const char *key, int32_t idx, UResourceDataEntry *realData,
    826                                          const UResourceBundle *parent, int32_t noAlias,
    827                                          UResourceBundle *resB, UErrorCode *status)
    828 {
    829     if(status == NULL || U_FAILURE(*status)) {
    830         return resB;
    831     }
    832     if (parent == NULL) {
    833         *status = U_ILLEGAL_ARGUMENT_ERROR;
    834         return NULL;
    835     }
    836     if(RES_GET_TYPE(r) == URES_ALIAS) { /* This is an alias, need to exchange with real data */
    837         if(noAlias < URES_MAX_ALIAS_LEVEL) {
    838             int32_t len = 0;
    839             const UChar *alias = res_getAlias(rdata, r, &len);
    840             if(len > 0) {
    841                 /* we have an alias, now let's cut it up */
    842                 char stackAlias[200];
    843                 char *chAlias = NULL, *path = NULL, *locale = NULL, *keyPath = NULL;
    844                 int32_t capacity;
    845 
    846                 /*
    847                 * Allocate enough space for both the char * version
    848                 * of the alias and parent->fResPath.
    849                 *
    850                 * We do this so that res_findResource() can modify the path,
    851                 * which allows us to remove redundant _res_findResource() variants
    852                 * in uresdata.c.
    853                 * res_findResource() now NUL-terminates each segment so that table keys
    854                 * can always be compared with strcmp() instead of strncmp().
    855                 * Saves code there and simplifies testing and code coverage.
    856                 *
    857                 * markus 2003oct17
    858                 */
    859                 ++len; /* count the terminating NUL */
    860                 if(parent->fResPath != NULL) {
    861                     capacity = (int32_t)uprv_strlen(parent->fResPath) + 1;
    862                 } else {
    863                     capacity = 0;
    864                 }
    865                 if(capacity < len) {
    866                     capacity = len;
    867                 }
    868                 if(capacity <= sizeof(stackAlias)) {
    869                     capacity = sizeof(stackAlias);
    870                     chAlias = stackAlias;
    871                 } else {
    872                     chAlias = (char *)uprv_malloc(capacity);
    873                     /* test for NULL */
    874                     if(chAlias == NULL) {
    875                         *status = U_MEMORY_ALLOCATION_ERROR;
    876                         return NULL;
    877                     }
    878                 }
    879                 u_UCharsToChars(alias, chAlias, len);
    880 
    881                 if(*chAlias == RES_PATH_SEPARATOR) {
    882                     /* there is a path included */
    883                     locale = uprv_strchr(chAlias+1, RES_PATH_SEPARATOR);
    884                     if(locale == NULL) {
    885                         locale = uprv_strchr(chAlias, 0); /* avoid locale == NULL to make code below work */
    886                     } else {
    887                         *locale = 0;
    888                         locale++;
    889                     }
    890                     path = chAlias+1;
    891                     if(uprv_strcmp(path, "LOCALE") == 0) {
    892                         /* this is an XPath alias, starting with "/LOCALE/" */
    893                         /* it contains the path to a resource which should be looked up */
    894                         /* starting in the requested locale */
    895                         keyPath = locale;
    896                         locale = parent->fTopLevelData->fName; /* this is the requested locale's name */
    897                         path = realData->fPath; /* we will be looking in the same package */
    898                     } else {
    899                         if(uprv_strcmp(path, "ICUDATA") == 0) { /* want ICU data */
    900                             path = NULL;
    901                         }
    902                         keyPath = uprv_strchr(locale, RES_PATH_SEPARATOR);
    903                         if(keyPath) {
    904                             *keyPath = 0;
    905                             keyPath++;
    906                         }
    907                     }
    908                 } else {
    909                     /* no path, start with a locale */
    910                     locale = chAlias;
    911                     keyPath = uprv_strchr(locale, RES_PATH_SEPARATOR);
    912                     if(keyPath) {
    913                         *keyPath = 0;
    914                         keyPath++;
    915                     }
    916                     path = realData->fPath;
    917                 }
    918 
    919 
    920                 {
    921                     /* got almost everything, let's try to open */
    922                     /* first, open the bundle with real data */
    923                     UResourceBundle *result = resB;
    924                     const char* temp = NULL;
    925                     UErrorCode intStatus = U_ZERO_ERROR;
    926                     UResourceBundle *mainRes = ures_openDirect(path, locale, &intStatus);
    927                     if(U_SUCCESS(intStatus)) {
    928                         if(keyPath == NULL) {
    929                             /* no key path. This means that we are going to
    930                             * to use the corresponding resource from
    931                             * another bundle
    932                             */
    933                             /* first, we are going to get a corresponding parent
    934                             * resource to the one we are searching.
    935                             */
    936                             char *aKey = parent->fResPath;
    937                             if(aKey) {
    938                                 uprv_strcpy(chAlias, aKey); /* allocated large enough above */
    939                                 aKey = chAlias;
    940                                 r = res_findResource(&(mainRes->fResData), mainRes->fRes, &aKey, &temp);
    941                             } else {
    942                                 r = mainRes->fRes;
    943                             }
    944                             if(key) {
    945                                 /* we need to make keyPath from parent's fResPath and
    946                                 * current key, if there is a key associated
    947                                 */
    948                                 len = (int32_t)(uprv_strlen(key) + 1);
    949                                 if(len > capacity) {
    950                                     capacity = len;
    951                                     if(chAlias == stackAlias) {
    952                                         chAlias = (char *)uprv_malloc(capacity);
    953                                     } else {
    954                                         chAlias = (char *)uprv_realloc(chAlias, capacity);
    955                                     }
    956                                     if(chAlias == NULL) {
    957                                         ures_close(mainRes);
    958                                         *status = U_MEMORY_ALLOCATION_ERROR;
    959                                         return NULL;
    960                                     }
    961                                 }
    962                                 uprv_memcpy(chAlias, key, len);
    963                                 aKey = chAlias;
    964                                 r = res_findResource(&(mainRes->fResData), r, &aKey, &temp);
    965                             } else if(idx != -1) {
    966                                 /* if there is no key, but there is an index, try to get by the index */
    967                                 /* here we have either a table or an array, so get the element */
    968                                 UResType type = RES_GET_TYPE(r);
    969                                 if(URES_IS_TABLE(type)) {
    970                                     r = res_getTableItemByIndex(&(mainRes->fResData), r, idx, (const char **)&aKey);
    971                                 } else { /* array */
    972                                     r = res_getArrayItem(&(mainRes->fResData), r, idx);
    973                                 }
    974                             }
    975                             if(r != RES_BOGUS) {
    976                                 result = init_resb_result(&(mainRes->fResData), r, temp, -1, mainRes->fData, mainRes, noAlias+1, resB, status);
    977                             } else {
    978                                 *status = U_MISSING_RESOURCE_ERROR;
    979                                 result = resB;
    980                             }
    981                         } else {
    982                             /* this one is a bit trickier.
    983                             * we start finding keys, but after we resolve one alias, the path might continue.
    984                             * Consider:
    985                             *     aliastest:alias { "testtypes/anotheralias/Sequence" }
    986                             *     anotheralias:alias { "/ICUDATA/sh/CollationElements" }
    987                             * aliastest resource should finally have the sequence, not collation elements.
    988                             */
    989                             UResourceDataEntry *dataEntry = mainRes->fData;
    990                             char stackPath[URES_MAX_BUFFER_SIZE];
    991                             char *pathBuf = stackPath, *myPath = pathBuf;
    992                             if(uprv_strlen(keyPath) > URES_MAX_BUFFER_SIZE) {
    993                                 pathBuf = (char *)uprv_malloc((uprv_strlen(keyPath)+1)*sizeof(char));
    994                                 if(pathBuf == NULL) {
    995                                     *status = U_MEMORY_ALLOCATION_ERROR;
    996                                     return NULL;
    997                                 }
    998                             }
    999                             uprv_strcpy(pathBuf, keyPath);
   1000                             result = mainRes;
   1001                             /* now we have fallback following here */
   1002                             do {
   1003                                 r = dataEntry->fData.rootRes;
   1004                                 /* this loop handles 'found' resources over several levels */
   1005                                 while(*myPath && U_SUCCESS(*status)) {
   1006                                     r = res_findResource(&(dataEntry->fData), r, &myPath, &temp);
   1007                                     if(r != RES_BOGUS) { /* found a resource, but it might be an indirection */
   1008                                         resB = init_resb_result(&(dataEntry->fData), r, temp, -1, dataEntry, result, noAlias+1, resB, status);
   1009                                         result = resB;
   1010                                         if(result) {
   1011                                             r = result->fRes; /* switch to a new resource, possibly a new tree */
   1012                                             dataEntry = result->fData;
   1013                                         }
   1014                                     } else { /* no resource found, we don't really want to look anymore on this level */
   1015                                         break;
   1016                                     }
   1017                                 }
   1018                                 dataEntry = dataEntry->fParent;
   1019                                 uprv_strcpy(pathBuf, keyPath);
   1020                                 myPath = pathBuf;
   1021                             } while(r == RES_BOGUS && dataEntry != NULL);
   1022                             if(r == RES_BOGUS) {
   1023                                 *status = U_MISSING_RESOURCE_ERROR;
   1024                                 result = resB;
   1025                             }
   1026                             if(pathBuf != stackPath) {
   1027                                 uprv_free(pathBuf);
   1028                             }
   1029                         }
   1030                     } else { /* we failed to open the resource we're aliasing to */
   1031                         *status = intStatus;
   1032                     }
   1033                     if(chAlias != stackAlias) {
   1034                         uprv_free(chAlias);
   1035                     }
   1036                     if(mainRes != result) {
   1037                         ures_close(mainRes);
   1038                     }
   1039                     return result;
   1040                 }
   1041             } else {
   1042                 /* bad alias, should be an error */
   1043                 *status = U_ILLEGAL_ARGUMENT_ERROR;
   1044                 return resB;
   1045             }
   1046         } else {
   1047             *status = U_TOO_MANY_ALIASES_ERROR;
   1048             return resB;
   1049         }
   1050     }
   1051     if(resB == NULL) {
   1052         resB = (UResourceBundle *)uprv_malloc(sizeof(UResourceBundle));
   1053         /* test for NULL */
   1054         if (resB == NULL) {
   1055             *status = U_MEMORY_ALLOCATION_ERROR;
   1056             return NULL;
   1057         }
   1058         ures_setIsStackObject(resB, FALSE);
   1059         resB->fResPath = NULL;
   1060         resB->fResPathLen = 0;
   1061     } else {
   1062         if(resB->fData != NULL) {
   1063             entryClose(resB->fData);
   1064         }
   1065         if(resB->fVersion != NULL) {
   1066             uprv_free(resB->fVersion);
   1067         }
   1068         /*
   1069         weiv: if stack object was passed in, it doesn't really need to be reinited,
   1070         since the purpose of initing is to remove stack junk. However, at this point
   1071         we would not do anything to an allocated object, so stack object should be
   1072         treated the same
   1073         */
   1074         /*
   1075         if(ures_isStackObject(resB) != FALSE) {
   1076         ures_initStackObject(resB);
   1077         }
   1078         */
   1079         if(parent != resB) {
   1080             ures_freeResPath(resB);
   1081         }
   1082     }
   1083     resB->fData = realData;
   1084     entryIncrease(resB->fData);
   1085     resB->fHasFallback = FALSE;
   1086     resB->fIsTopLevel = FALSE;
   1087     resB->fIndex = -1;
   1088     resB->fKey = key;
   1089     /*resB->fParentRes = parent;*/
   1090     resB->fTopLevelData = parent->fTopLevelData;
   1091     if(parent->fResPath && parent != resB) {
   1092         ures_appendResPath(resB, parent->fResPath, parent->fResPathLen, status);
   1093     }
   1094     if(key != NULL) {
   1095         ures_appendResPath(resB, key, (int32_t)uprv_strlen(key), status);
   1096         if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) {
   1097             ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status);
   1098         }
   1099     } else if(idx >= 0) {
   1100         char buf[256];
   1101         int32_t len = T_CString_integerToString(buf, idx, 10);
   1102         ures_appendResPath(resB, buf, len, status);
   1103         if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) {
   1104             ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status);
   1105         }
   1106     }
   1107     /* Make sure that Purify doesn't complain about uninitialized memory copies. */
   1108     {
   1109         int32_t usedLen = ((resB->fResBuf == resB->fResPath) ? resB->fResPathLen : 0);
   1110         uprv_memset(resB->fResBuf + usedLen, 0, sizeof(resB->fResBuf) - usedLen);
   1111     }
   1112 
   1113     resB->fVersion = NULL;
   1114     resB->fRes = r;
   1115     /*resB->fParent = parent->fRes;*/
   1116     uprv_memmove(&resB->fResData, rdata, sizeof(ResourceData));
   1117     resB->fSize = res_countArrayItems(&(resB->fResData), resB->fRes);
   1118     return resB;
   1119 }
   1120 
   1121 UResourceBundle *ures_copyResb(UResourceBundle *r, const UResourceBundle *original, UErrorCode *status) {
   1122     UBool isStackObject;
   1123     if(U_FAILURE(*status) || r == original) {
   1124         return r;
   1125     }
   1126     if(original != NULL) {
   1127         if(r == NULL) {
   1128             isStackObject = FALSE;
   1129             r = (UResourceBundle *)uprv_malloc(sizeof(UResourceBundle));
   1130             /* test for NULL */
   1131             if (r == NULL) {
   1132                 *status = U_MEMORY_ALLOCATION_ERROR;
   1133                 return NULL;
   1134             }
   1135         } else {
   1136             isStackObject = ures_isStackObject(r);
   1137             ures_closeBundle(r, FALSE);
   1138         }
   1139         uprv_memcpy(r, original, sizeof(UResourceBundle));
   1140         r->fResPath = NULL;
   1141         r->fResPathLen = 0;
   1142         if(original->fResPath) {
   1143             ures_appendResPath(r, original->fResPath, original->fResPathLen, status);
   1144         }
   1145         ures_setIsStackObject(r, isStackObject);
   1146         if(r->fData != NULL) {
   1147             entryIncrease(r->fData);
   1148         }
   1149     }
   1150     return r;
   1151 }
   1152 
   1153 /**
   1154  * Functions to retrieve data from resource bundles.
   1155  */
   1156 
   1157 U_CAPI const UChar* U_EXPORT2 ures_getString(const UResourceBundle* resB, int32_t* len, UErrorCode* status) {
   1158     const UChar *s;
   1159     if (status==NULL || U_FAILURE(*status)) {
   1160         return NULL;
   1161     }
   1162     if(resB == NULL) {
   1163         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1164         return NULL;
   1165     }
   1166     s = res_getString(&(resB->fResData), resB->fRes, len);
   1167     if (s == NULL) {
   1168         *status = U_RESOURCE_TYPE_MISMATCH;
   1169     }
   1170     return s;
   1171 }
   1172 
   1173 static const char *
   1174 ures_toUTF8String(const UChar *s16, int32_t length16,
   1175                   char *dest, int32_t *pLength,
   1176                   UBool forceCopy,
   1177                   UErrorCode *status) {
   1178     int32_t capacity;
   1179 
   1180     if (U_FAILURE(*status)) {
   1181         return NULL;
   1182     }
   1183     if (pLength != NULL) {
   1184         capacity = *pLength;
   1185     } else {
   1186         capacity = 0;
   1187     }
   1188     if (capacity < 0 || (capacity > 0 && dest == NULL)) {
   1189         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1190         return NULL;
   1191     }
   1192 
   1193     if (length16 == 0) {
   1194         /* empty string, return as read-only pointer */
   1195         if (pLength != NULL) {
   1196             *pLength = 0;
   1197         }
   1198         if (forceCopy) {
   1199             u_terminateChars(dest, capacity, 0, status);
   1200             return dest;
   1201         } else {
   1202             return "";
   1203         }
   1204     } else {
   1205         /* We need to transform the string to the destination buffer. */
   1206         if (capacity < length16) {
   1207             /* No chance for the string to fit. Pure preflighting. */
   1208             return u_strToUTF8(NULL, 0, pLength, s16, length16, status);
   1209         }
   1210         if (!forceCopy && (length16 <= 0x2aaaaaaa)) {
   1211             /*
   1212              * We know the string will fit into dest because each UChar turns
   1213              * into at most three UTF-8 bytes. Fill the latter part of dest
   1214              * so that callers do not expect to use dest as a string pointer,
   1215              * hopefully leading to more robust code for when resource bundles
   1216              * may store UTF-8 natively.
   1217              * (In which case dest would not be used at all.)
   1218              *
   1219              * We do not do this if forceCopy=TRUE because then the caller
   1220              * expects the string to start exactly at dest.
   1221              *
   1222              * The test above for <= 0x2aaaaaaa prevents overflows.
   1223              * The +1 is for the NUL terminator.
   1224              */
   1225             int32_t maxLength = 3 * length16 + 1;
   1226             if (capacity > maxLength) {
   1227                 dest += capacity - maxLength;
   1228                 capacity = maxLength;
   1229             }
   1230         }
   1231         return u_strToUTF8(dest, capacity, pLength, s16, length16, status);
   1232     }
   1233 }
   1234 
   1235 U_CAPI const char * U_EXPORT2
   1236 ures_getUTF8String(const UResourceBundle *resB,
   1237                    char *dest, int32_t *pLength,
   1238                    UBool forceCopy,
   1239                    UErrorCode *status) {
   1240     int32_t length16;
   1241     const UChar *s16 = ures_getString(resB, &length16, status);
   1242     return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
   1243 }
   1244 
   1245 U_CAPI const uint8_t* U_EXPORT2 ures_getBinary(const UResourceBundle* resB, int32_t* len,
   1246                                                UErrorCode*               status) {
   1247   const uint8_t *p;
   1248   if (status==NULL || U_FAILURE(*status)) {
   1249     return NULL;
   1250   }
   1251   if(resB == NULL) {
   1252     *status = U_ILLEGAL_ARGUMENT_ERROR;
   1253     return NULL;
   1254   }
   1255   p = res_getBinary(&(resB->fResData), resB->fRes, len);
   1256   if (p == NULL) {
   1257     *status = U_RESOURCE_TYPE_MISMATCH;
   1258   }
   1259   return p;
   1260 }
   1261 
   1262 U_CAPI const int32_t* U_EXPORT2 ures_getIntVector(const UResourceBundle* resB, int32_t* len,
   1263                                                    UErrorCode*               status) {
   1264   const int32_t *p;
   1265   if (status==NULL || U_FAILURE(*status)) {
   1266     return NULL;
   1267   }
   1268   if(resB == NULL) {
   1269     *status = U_ILLEGAL_ARGUMENT_ERROR;
   1270     return NULL;
   1271   }
   1272   p = res_getIntVector(&(resB->fResData), resB->fRes, len);
   1273   if (p == NULL) {
   1274     *status = U_RESOURCE_TYPE_MISMATCH;
   1275   }
   1276   return p;
   1277 }
   1278 
   1279 /* this function returns a signed integer */
   1280 /* it performs sign extension */
   1281 U_CAPI int32_t U_EXPORT2 ures_getInt(const UResourceBundle* resB, UErrorCode *status) {
   1282   if (status==NULL || U_FAILURE(*status)) {
   1283     return 0xffffffff;
   1284   }
   1285   if(resB == NULL) {
   1286     *status = U_ILLEGAL_ARGUMENT_ERROR;
   1287     return 0xffffffff;
   1288   }
   1289   if(RES_GET_TYPE(resB->fRes) != URES_INT) {
   1290     *status = U_RESOURCE_TYPE_MISMATCH;
   1291     return 0xffffffff;
   1292   }
   1293   return RES_GET_INT(resB->fRes);
   1294 }
   1295 
   1296 U_CAPI uint32_t U_EXPORT2 ures_getUInt(const UResourceBundle* resB, UErrorCode *status) {
   1297   if (status==NULL || U_FAILURE(*status)) {
   1298     return 0xffffffff;
   1299   }
   1300   if(resB == NULL) {
   1301     *status = U_ILLEGAL_ARGUMENT_ERROR;
   1302     return 0xffffffff;
   1303   }
   1304   if(RES_GET_TYPE(resB->fRes) != URES_INT) {
   1305     *status = U_RESOURCE_TYPE_MISMATCH;
   1306     return 0xffffffff;
   1307   }
   1308   return RES_GET_UINT(resB->fRes);
   1309 }
   1310 
   1311 U_CAPI UResType U_EXPORT2 ures_getType(const UResourceBundle *resB) {
   1312   if(resB == NULL) {
   1313     return URES_NONE;
   1314   }
   1315   return res_getPublicType(resB->fRes);
   1316 }
   1317 
   1318 U_CAPI const char * U_EXPORT2 ures_getKey(const UResourceBundle *resB) {
   1319   if(resB == NULL) {
   1320     return NULL;
   1321   }
   1322 
   1323   return(resB->fKey);
   1324 }
   1325 
   1326 U_CAPI int32_t U_EXPORT2 ures_getSize(const UResourceBundle *resB) {
   1327   if(resB == NULL) {
   1328     return 0;
   1329   }
   1330 
   1331   return resB->fSize;
   1332 }
   1333 
   1334 static const UChar* ures_getStringWithAlias(const UResourceBundle *resB, Resource r, int32_t sIndex, int32_t *len, UErrorCode *status) {
   1335   if(RES_GET_TYPE(r) == URES_ALIAS) {
   1336     const UChar* result = 0;
   1337     UResourceBundle *tempRes = ures_getByIndex(resB, sIndex, NULL, status);
   1338     result = ures_getString(tempRes, len, status);
   1339     ures_close(tempRes);
   1340     return result;
   1341   } else {
   1342     return res_getString(&(resB->fResData), r, len);
   1343   }
   1344 }
   1345 
   1346 U_CAPI void U_EXPORT2 ures_resetIterator(UResourceBundle *resB){
   1347   if(resB == NULL) {
   1348     return;
   1349   }
   1350   resB->fIndex = -1;
   1351 }
   1352 
   1353 U_CAPI UBool U_EXPORT2 ures_hasNext(const UResourceBundle *resB) {
   1354   if(resB == NULL) {
   1355     return FALSE;
   1356   }
   1357   return (UBool)(resB->fIndex < resB->fSize-1);
   1358 }
   1359 
   1360 U_CAPI const UChar* U_EXPORT2 ures_getNextString(UResourceBundle *resB, int32_t* len, const char ** key, UErrorCode *status) {
   1361   Resource r = RES_BOGUS;
   1362 
   1363   if (status==NULL || U_FAILURE(*status)) {
   1364     return NULL;
   1365   }
   1366   if(resB == NULL) {
   1367     *status = U_ILLEGAL_ARGUMENT_ERROR;
   1368     return NULL;
   1369   }
   1370 
   1371   if(resB->fIndex == resB->fSize-1) {
   1372     *status = U_INDEX_OUTOFBOUNDS_ERROR;
   1373   } else {
   1374     resB->fIndex++;
   1375     switch(RES_GET_TYPE(resB->fRes)) {
   1376     case URES_STRING:
   1377     case URES_STRING_V2:
   1378       return res_getString(&(resB->fResData), resB->fRes, len);
   1379     case URES_TABLE:
   1380     case URES_TABLE16:
   1381     case URES_TABLE32:
   1382       r = res_getTableItemByIndex(&(resB->fResData), resB->fRes, resB->fIndex, key);
   1383       if(r == RES_BOGUS && resB->fHasFallback) {
   1384         /* TODO: do the fallback */
   1385       }
   1386       return ures_getStringWithAlias(resB, r, resB->fIndex, len, status);
   1387     case URES_ARRAY:
   1388     case URES_ARRAY16:
   1389       r = res_getArrayItem(&(resB->fResData), resB->fRes, resB->fIndex);
   1390       if(r == RES_BOGUS && resB->fHasFallback) {
   1391         /* TODO: do the fallback */
   1392       }
   1393       return ures_getStringWithAlias(resB, r, resB->fIndex, len, status);
   1394     case URES_ALIAS:
   1395       return ures_getStringWithAlias(resB, resB->fRes, resB->fIndex, len, status);
   1396     case URES_INT:
   1397     case URES_BINARY:
   1398     case URES_INT_VECTOR:
   1399         *status = U_RESOURCE_TYPE_MISMATCH;
   1400     default:
   1401       return NULL;
   1402     }
   1403   }
   1404 
   1405   return NULL;
   1406 }
   1407 
   1408 U_CAPI UResourceBundle* U_EXPORT2 ures_getNextResource(UResourceBundle *resB, UResourceBundle *fillIn, UErrorCode *status) {
   1409     const char *key = NULL;
   1410     Resource r = RES_BOGUS;
   1411 
   1412     if (status==NULL || U_FAILURE(*status)) {
   1413             /*return NULL;*/
   1414             return fillIn;
   1415     }
   1416     if(resB == NULL) {
   1417             *status = U_ILLEGAL_ARGUMENT_ERROR;
   1418             /*return NULL;*/
   1419             return fillIn;
   1420     }
   1421 
   1422     if(resB->fIndex == resB->fSize-1) {
   1423       *status = U_INDEX_OUTOFBOUNDS_ERROR;
   1424       /*return NULL;*/
   1425     } else {
   1426         resB->fIndex++;
   1427         switch(RES_GET_TYPE(resB->fRes)) {
   1428         case URES_INT:
   1429         case URES_BINARY:
   1430         case URES_STRING:
   1431         case URES_STRING_V2:
   1432         case URES_INT_VECTOR:
   1433             return ures_copyResb(fillIn, resB, status);
   1434         case URES_TABLE:
   1435         case URES_TABLE16:
   1436         case URES_TABLE32:
   1437             r = res_getTableItemByIndex(&(resB->fResData), resB->fRes, resB->fIndex, &key);
   1438             if(r == RES_BOGUS && resB->fHasFallback) {
   1439                 /* TODO: do the fallback */
   1440             }
   1441             return init_resb_result(&(resB->fResData), r, key, resB->fIndex, resB->fData, resB, 0, fillIn, status);
   1442         case URES_ARRAY:
   1443         case URES_ARRAY16:
   1444             r = res_getArrayItem(&(resB->fResData), resB->fRes, resB->fIndex);
   1445             if(r == RES_BOGUS && resB->fHasFallback) {
   1446                 /* TODO: do the fallback */
   1447             }
   1448             return init_resb_result(&(resB->fResData), r, key, resB->fIndex, resB->fData, resB, 0, fillIn, status);
   1449         default:
   1450             /*return NULL;*/
   1451             return fillIn;
   1452         }
   1453     }
   1454     /*return NULL;*/
   1455     return fillIn;
   1456 }
   1457 
   1458 U_CAPI UResourceBundle* U_EXPORT2 ures_getByIndex(const UResourceBundle *resB, int32_t indexR, UResourceBundle *fillIn, UErrorCode *status) {
   1459     const char* key = NULL;
   1460     Resource r = RES_BOGUS;
   1461 
   1462     if (status==NULL || U_FAILURE(*status)) {
   1463         /*return NULL;*/
   1464         return fillIn;
   1465     }
   1466     if(resB == NULL) {
   1467         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1468         /*return NULL;*/
   1469         return fillIn;
   1470     }
   1471 
   1472     if(indexR >= 0 && resB->fSize > indexR) {
   1473         switch(RES_GET_TYPE(resB->fRes)) {
   1474         case URES_INT:
   1475         case URES_BINARY:
   1476         case URES_STRING:
   1477         case URES_STRING_V2:
   1478         case URES_INT_VECTOR:
   1479             return ures_copyResb(fillIn, resB, status);
   1480         case URES_TABLE:
   1481         case URES_TABLE16:
   1482         case URES_TABLE32:
   1483             r = res_getTableItemByIndex(&(resB->fResData), resB->fRes, indexR, &key);
   1484             if(r == RES_BOGUS && resB->fHasFallback) {
   1485                 /* TODO: do the fallback */
   1486             }
   1487             return init_resb_result(&(resB->fResData), r, key, indexR, resB->fData, resB, 0, fillIn, status);
   1488         case URES_ARRAY:
   1489         case URES_ARRAY16:
   1490             r = res_getArrayItem(&(resB->fResData), resB->fRes, indexR);
   1491             if(r == RES_BOGUS && resB->fHasFallback) {
   1492                 /* TODO: do the fallback */
   1493             }
   1494             return init_resb_result(&(resB->fResData), r, key, indexR, resB->fData, resB, 0, fillIn, status);
   1495         default:
   1496             /*return NULL;*/
   1497             return fillIn;
   1498         }
   1499     } else {
   1500         *status = U_MISSING_RESOURCE_ERROR;
   1501     }
   1502     /*return NULL;*/
   1503     return fillIn;
   1504 }
   1505 
   1506 U_CAPI const UChar* U_EXPORT2 ures_getStringByIndex(const UResourceBundle *resB, int32_t indexS, int32_t* len, UErrorCode *status) {
   1507     const char* key = NULL;
   1508     Resource r = RES_BOGUS;
   1509 
   1510     if (status==NULL || U_FAILURE(*status)) {
   1511         return NULL;
   1512     }
   1513     if(resB == NULL) {
   1514         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1515         return NULL;
   1516     }
   1517 
   1518     if(indexS >= 0 && resB->fSize > indexS) {
   1519         switch(RES_GET_TYPE(resB->fRes)) {
   1520         case URES_STRING:
   1521         case URES_STRING_V2:
   1522             return res_getString(&(resB->fResData), resB->fRes, len);
   1523         case URES_TABLE:
   1524         case URES_TABLE16:
   1525         case URES_TABLE32:
   1526             r = res_getTableItemByIndex(&(resB->fResData), resB->fRes, indexS, &key);
   1527             if(r == RES_BOGUS && resB->fHasFallback) {
   1528                 /* TODO: do the fallback */
   1529             }
   1530             return ures_getStringWithAlias(resB, r, indexS, len, status);
   1531         case URES_ARRAY:
   1532         case URES_ARRAY16:
   1533             r = res_getArrayItem(&(resB->fResData), resB->fRes, indexS);
   1534             if(r == RES_BOGUS && resB->fHasFallback) {
   1535                 /* TODO: do the fallback */
   1536             }
   1537             return ures_getStringWithAlias(resB, r, indexS, len, status);
   1538         case URES_ALIAS:
   1539             return ures_getStringWithAlias(resB, resB->fRes, indexS, len, status);
   1540         case URES_INT:
   1541         case URES_BINARY:
   1542         case URES_INT_VECTOR:
   1543             *status = U_RESOURCE_TYPE_MISMATCH;
   1544             break;
   1545         default:
   1546           /* must not occur */
   1547           *status = U_INTERNAL_PROGRAM_ERROR;
   1548           break;
   1549         }
   1550     } else {
   1551         *status = U_MISSING_RESOURCE_ERROR;
   1552     }
   1553     return NULL;
   1554 }
   1555 
   1556 U_CAPI const char * U_EXPORT2
   1557 ures_getUTF8StringByIndex(const UResourceBundle *resB,
   1558                           int32_t idx,
   1559                           char *dest, int32_t *pLength,
   1560                           UBool forceCopy,
   1561                           UErrorCode *status) {
   1562     int32_t length16;
   1563     const UChar *s16 = ures_getStringByIndex(resB, idx, &length16, status);
   1564     return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
   1565 }
   1566 
   1567 /*U_CAPI const char *ures_getResPath(UResourceBundle *resB) {
   1568   return resB->fResPath;
   1569 }*/
   1570 
   1571 U_CAPI UResourceBundle* U_EXPORT2
   1572 ures_findResource(const char* path, UResourceBundle *fillIn, UErrorCode *status)
   1573 {
   1574   UResourceBundle *first = NULL;
   1575   UResourceBundle *result = fillIn;
   1576   char *packageName = NULL;
   1577   char *pathToResource = NULL, *save = NULL;
   1578   char *locale = NULL, *localeEnd = NULL;
   1579   int32_t length;
   1580 
   1581   if(status == NULL || U_FAILURE(*status)) {
   1582     return result;
   1583   }
   1584 
   1585   length = (int32_t)(uprv_strlen(path)+1);
   1586   save = pathToResource = (char *)uprv_malloc(length*sizeof(char));
   1587   /* test for NULL */
   1588   if(pathToResource == NULL) {
   1589     *status = U_MEMORY_ALLOCATION_ERROR;
   1590     return result;
   1591   }
   1592   uprv_memcpy(pathToResource, path, length);
   1593 
   1594   locale = pathToResource;
   1595   if(*pathToResource == RES_PATH_SEPARATOR) { /* there is a path specification */
   1596     pathToResource++;
   1597     packageName = pathToResource;
   1598     pathToResource = uprv_strchr(pathToResource, RES_PATH_SEPARATOR);
   1599     if(pathToResource == NULL) {
   1600       *status = U_ILLEGAL_ARGUMENT_ERROR;
   1601     } else {
   1602       *pathToResource = 0;
   1603       locale = pathToResource+1;
   1604     }
   1605   }
   1606 
   1607   localeEnd = uprv_strchr(locale, RES_PATH_SEPARATOR);
   1608   if(localeEnd != NULL) {
   1609     *localeEnd = 0;
   1610   }
   1611 
   1612   first = ures_open(packageName, locale, status);
   1613 
   1614   if(U_SUCCESS(*status)) {
   1615     if(localeEnd) {
   1616       result = ures_findSubResource(first, localeEnd+1, fillIn, status);
   1617     } else {
   1618       result = ures_copyResb(fillIn, first, status);
   1619     }
   1620     ures_close(first);
   1621   }
   1622   uprv_free(save);
   1623   return result;
   1624 }
   1625 
   1626 U_CAPI UResourceBundle* U_EXPORT2
   1627 ures_findSubResource(const UResourceBundle *resB, char* path, UResourceBundle *fillIn, UErrorCode *status)
   1628 {
   1629   Resource res = RES_BOGUS;
   1630   UResourceBundle *result = fillIn;
   1631   const char *key;
   1632 
   1633   if(status == NULL || U_FAILURE(*status)) {
   1634     return result;
   1635   }
   1636 
   1637   /* here we do looping and circular alias checking */
   1638   /* this loop is here because aliasing is resolved on this level, not on res level */
   1639   /* so, when we encounter an alias, it is not an aggregate resource, so we return */
   1640   do {
   1641     res = res_findResource(&(resB->fResData), resB->fRes, &path, &key);
   1642     if(res != RES_BOGUS) {
   1643         result = init_resb_result(&(resB->fResData), res, key, -1, resB->fData, resB, 0, fillIn, status);
   1644         resB = result;
   1645     } else {
   1646         *status = U_MISSING_RESOURCE_ERROR;
   1647         break;
   1648     }
   1649   } while(*path); /* there is more stuff in the path */
   1650 
   1651   return result;
   1652 }
   1653 U_INTERNAL const UChar* U_EXPORT2
   1654 ures_getStringByKeyWithFallback(const UResourceBundle *resB,
   1655                                 const char* inKey,
   1656                                 int32_t* len,
   1657                                 UErrorCode *status) {
   1658 
   1659     UResourceBundle stack;
   1660     const UChar* retVal = NULL;
   1661     ures_initStackObject(&stack);
   1662     ures_getByKeyWithFallback(resB, inKey, &stack, status);
   1663     retVal = ures_getString(&stack, len, status);
   1664     ures_close(&stack);
   1665     return retVal;
   1666 }
   1667 
   1668 U_CAPI UResourceBundle* U_EXPORT2
   1669 ures_getByKeyWithFallback(const UResourceBundle *resB,
   1670                           const char* inKey,
   1671                           UResourceBundle *fillIn,
   1672                           UErrorCode *status) {
   1673     Resource res = RES_BOGUS, rootRes = RES_BOGUS;
   1674     /*UResourceDataEntry *realData = NULL;*/
   1675     const char *key = inKey;
   1676     UResourceBundle *helper = NULL;
   1677     UResType type;
   1678 
   1679     if (status==NULL || U_FAILURE(*status)) {
   1680         return fillIn;
   1681     }
   1682     if(resB == NULL) {
   1683         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1684         return fillIn;
   1685     }
   1686 
   1687     type = RES_GET_TYPE(resB->fRes);
   1688     if(URES_IS_TABLE(type)) {
   1689         int32_t t;
   1690         res = res_getTableItemByKey(&(resB->fResData), resB->fRes, &t, &key);
   1691         if(res == RES_BOGUS) {
   1692             UResourceDataEntry *dataEntry = resB->fData;
   1693             char path[256];
   1694             char* myPath = path;
   1695             const char* resPath = resB->fResPath;
   1696             int32_t len = resB->fResPathLen;
   1697 
   1698             while(res == RES_BOGUS && dataEntry->fParent != NULL) { /* Otherwise, we'll look in parents */
   1699                 dataEntry = dataEntry->fParent;
   1700                 rootRes = dataEntry->fData.rootRes;
   1701 
   1702                 if(dataEntry->fBogus == U_ZERO_ERROR) {
   1703                     uprv_strncpy(path, resPath, len);
   1704                     uprv_strcpy(path+len, inKey);
   1705                     myPath = path;
   1706                     key = inKey;
   1707                     do {
   1708                         res = res_findResource(&(dataEntry->fData), rootRes, &myPath, &key);
   1709                         if (RES_GET_TYPE(res) == URES_ALIAS && *myPath) {
   1710                             /* We hit an alias, but we didn't finish following the path. */
   1711                             helper = init_resb_result(&(dataEntry->fData), res, NULL, -1, dataEntry, resB, 0, helper, status);
   1712                             /*helper = init_resb_result(&(dataEntry->fData), res, inKey, -1, dataEntry, resB, 0, helper, status);*/
   1713                             if(helper) {
   1714                               dataEntry = helper->fData;
   1715                               rootRes = helper->fRes;
   1716                               resPath = helper->fResPath;
   1717                               len = helper->fResPathLen;
   1718 
   1719                             } else {
   1720                               break;
   1721                             }
   1722                         }
   1723                     } while(*myPath); /* Continue until the whole path is consumed */
   1724                 }
   1725             }
   1726             /*const ResourceData *rd = getFallbackData(resB, &key, &realData, &res, status);*/
   1727             if(res != RES_BOGUS) {
   1728               /* check if resB->fResPath gives the right name here */
   1729                 if(uprv_strcmp(dataEntry->fName, uloc_getDefault())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName)==0) {
   1730                     *status = U_USING_DEFAULT_WARNING;
   1731                 } else {
   1732                     *status = U_USING_FALLBACK_WARNING;
   1733                 }
   1734 
   1735                 fillIn = init_resb_result(&(dataEntry->fData), res, inKey, -1, dataEntry, resB, 0, fillIn, status);
   1736             } else {
   1737                 *status = U_MISSING_RESOURCE_ERROR;
   1738             }
   1739         } else {
   1740             fillIn = init_resb_result(&(resB->fResData), res, key, -1, resB->fData, resB, 0, fillIn, status);
   1741         }
   1742     }
   1743     else {
   1744         *status = U_RESOURCE_TYPE_MISMATCH;
   1745     }
   1746     ures_close(helper);
   1747     return fillIn;
   1748 }
   1749 
   1750 
   1751 U_CAPI UResourceBundle* U_EXPORT2 ures_getByKey(const UResourceBundle *resB, const char* inKey, UResourceBundle *fillIn, UErrorCode *status) {
   1752     Resource res = RES_BOGUS;
   1753     UResourceDataEntry *realData = NULL;
   1754     const char *key = inKey;
   1755     UResType type;
   1756 
   1757     if (status==NULL || U_FAILURE(*status)) {
   1758         return fillIn;
   1759     }
   1760     if(resB == NULL) {
   1761         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1762         return fillIn;
   1763     }
   1764 
   1765     type = RES_GET_TYPE(resB->fRes);
   1766     if(URES_IS_TABLE(type)) {
   1767         int32_t t;
   1768         res = res_getTableItemByKey(&(resB->fResData), resB->fRes, &t, &key);
   1769         if(res == RES_BOGUS) {
   1770             key = inKey;
   1771             if(resB->fHasFallback == TRUE) {
   1772                 const ResourceData *rd = getFallbackData(resB, &key, &realData, &res, status);
   1773                 if(U_SUCCESS(*status)) {
   1774                   /* check if resB->fResPath gives the right name here */
   1775                     return init_resb_result(rd, res, key, -1, realData, resB, 0, fillIn, status);
   1776                 } else {
   1777                     *status = U_MISSING_RESOURCE_ERROR;
   1778                 }
   1779             } else {
   1780                 *status = U_MISSING_RESOURCE_ERROR;
   1781             }
   1782         } else {
   1783             return init_resb_result(&(resB->fResData), res, key, -1, resB->fData, resB, 0, fillIn, status);
   1784         }
   1785     }
   1786 #if 0
   1787     /* this is a kind of TODO item. If we have an array with an index table, we could do this. */
   1788     /* not currently */
   1789     else if(RES_GET_TYPE(resB->fRes) == URES_ARRAY && resB->fHasFallback == TRUE) {
   1790         /* here should go a first attempt to locate the key using index table */
   1791         const ResourceData *rd = getFallbackData(resB, &key, &realData, &res, status);
   1792         if(U_SUCCESS(*status)) {
   1793             return init_resb_result(rd, res, key, realData, resB, fillIn, status);
   1794         } else {
   1795             *status = U_MISSING_RESOURCE_ERROR;
   1796         }
   1797     }
   1798 #endif
   1799     else {
   1800         *status = U_RESOURCE_TYPE_MISMATCH;
   1801     }
   1802     return fillIn;
   1803 }
   1804 
   1805 U_CAPI const UChar* U_EXPORT2 ures_getStringByKey(const UResourceBundle *resB, const char* inKey, int32_t* len, UErrorCode *status) {
   1806     Resource res = RES_BOGUS;
   1807     UResourceDataEntry *realData = NULL;
   1808     const char* key = inKey;
   1809     UResType type;
   1810 
   1811     if (status==NULL || U_FAILURE(*status)) {
   1812         return NULL;
   1813     }
   1814     if(resB == NULL) {
   1815         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1816         return NULL;
   1817     }
   1818 
   1819     type = RES_GET_TYPE(resB->fRes);
   1820     if(URES_IS_TABLE(type)) {
   1821         int32_t t=0;
   1822 
   1823         res = res_getTableItemByKey(&(resB->fResData), resB->fRes, &t, &key);
   1824 
   1825         if(res == RES_BOGUS) {
   1826             key = inKey;
   1827             if(resB->fHasFallback == TRUE) {
   1828                 const ResourceData *rd = getFallbackData(resB, &key, &realData, &res, status);
   1829                 if(U_SUCCESS(*status)) {
   1830                     switch (RES_GET_TYPE(res)) {
   1831                     case URES_STRING:
   1832                     case URES_STRING_V2:
   1833                         return res_getString(rd, res, len);
   1834                     case URES_ALIAS:
   1835                       {
   1836                         const UChar* result = 0;
   1837                         UResourceBundle *tempRes = ures_getByKey(resB, inKey, NULL, status);
   1838                         result = ures_getString(tempRes, len, status);
   1839                         ures_close(tempRes);
   1840                         return result;
   1841                       }
   1842                     default:
   1843                         *status = U_RESOURCE_TYPE_MISMATCH;
   1844                     }
   1845                 } else {
   1846                     *status = U_MISSING_RESOURCE_ERROR;
   1847                 }
   1848             } else {
   1849                 *status = U_MISSING_RESOURCE_ERROR;
   1850             }
   1851         } else {
   1852             switch (RES_GET_TYPE(res)) {
   1853             case URES_STRING:
   1854             case URES_STRING_V2:
   1855                 return res_getString(&(resB->fResData), res, len);
   1856             case URES_ALIAS:
   1857               {
   1858                 const UChar* result = 0;
   1859                 UResourceBundle *tempRes = ures_getByKey(resB, inKey, NULL, status);
   1860                 result = ures_getString(tempRes, len, status);
   1861                 ures_close(tempRes);
   1862                 return result;
   1863               }
   1864             default:
   1865                 *status = U_RESOURCE_TYPE_MISMATCH;
   1866             }
   1867         }
   1868     }
   1869 #if 0
   1870     /* this is a kind of TODO item. If we have an array with an index table, we could do this. */
   1871     /* not currently */
   1872     else if(RES_GET_TYPE(resB->fRes) == URES_ARRAY && resB->fHasFallback == TRUE) {
   1873         /* here should go a first attempt to locate the key using index table */
   1874         const ResourceData *rd = getFallbackData(resB, &key, &realData, &res, status);
   1875         if(U_SUCCESS(*status)) {
   1876             return res_getString(rd, res, len);
   1877         } else {
   1878             *status = U_MISSING_RESOURCE_ERROR;
   1879         }
   1880     }
   1881 #endif
   1882     else {
   1883         *status = U_RESOURCE_TYPE_MISMATCH;
   1884     }
   1885     return NULL;
   1886 }
   1887 
   1888 U_CAPI const char * U_EXPORT2
   1889 ures_getUTF8StringByKey(const UResourceBundle *resB,
   1890                         const char *key,
   1891                         char *dest, int32_t *pLength,
   1892                         UBool forceCopy,
   1893                         UErrorCode *status) {
   1894     int32_t length16;
   1895     const UChar *s16 = ures_getStringByKey(resB, key, &length16, status);
   1896     return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
   1897 }
   1898 
   1899 /* TODO: clean from here down */
   1900 
   1901 /**
   1902  *  INTERNAL: Get the name of the first real locale (not placeholder)
   1903  *  that has resource bundle data.
   1904  */
   1905 U_INTERNAL const char*  U_EXPORT2
   1906 ures_getLocaleInternal(const UResourceBundle* resourceBundle, UErrorCode* status)
   1907 {
   1908     if (status==NULL || U_FAILURE(*status)) {
   1909         return NULL;
   1910     }
   1911     if (!resourceBundle) {
   1912         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1913         return NULL;
   1914     } else {
   1915       return resourceBundle->fData->fName;
   1916     }
   1917 }
   1918 
   1919 U_CAPI const char* U_EXPORT2
   1920 ures_getLocale(const UResourceBundle* resourceBundle,
   1921                UErrorCode* status)
   1922 {
   1923   return ures_getLocaleInternal(resourceBundle, status);
   1924 }
   1925 
   1926 
   1927 U_CAPI const char* U_EXPORT2
   1928 ures_getLocaleByType(const UResourceBundle* resourceBundle,
   1929                      ULocDataLocaleType type,
   1930                      UErrorCode* status) {
   1931     if (status==NULL || U_FAILURE(*status)) {
   1932         return NULL;
   1933     }
   1934     if (!resourceBundle) {
   1935         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1936         return NULL;
   1937     } else {
   1938         switch(type) {
   1939         case ULOC_ACTUAL_LOCALE:
   1940             return resourceBundle->fData->fName;
   1941         case ULOC_VALID_LOCALE:
   1942             return resourceBundle->fTopLevelData->fName;
   1943         case ULOC_REQUESTED_LOCALE:
   1944             return NULL;
   1945         default:
   1946             *status = U_ILLEGAL_ARGUMENT_ERROR;
   1947             return NULL;
   1948         }
   1949     }
   1950 }
   1951 
   1952 U_CFUNC const char* ures_getName(const UResourceBundle* resB) {
   1953   if(resB == NULL) {
   1954     return NULL;
   1955   }
   1956 
   1957   return resB->fData->fName;
   1958 }
   1959 
   1960 #ifdef URES_DEBUG
   1961 U_CFUNC const char* ures_getPath(const UResourceBundle* resB) {
   1962   if(resB == NULL) {
   1963     return NULL;
   1964   }
   1965 
   1966   return resB->fData->fPath;
   1967 }
   1968 #endif
   1969 
   1970 /* OLD API implementation */
   1971 
   1972 /**
   1973  *  API: This function is used to open a resource bundle
   1974  *  proper fallback chaining is executed while initialization.
   1975  *  The result is stored in cache for later fallback search.
   1976  */
   1977 U_CAPI void  U_EXPORT2
   1978 ures_openFillIn(UResourceBundle *r, const char* path,
   1979                     const char* localeID, UErrorCode* status) {
   1980     if(r == NULL) {
   1981         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1982     } else {
   1983         UResourceDataEntry *firstData;
   1984         UBool isStackObject = ures_isStackObject(r);
   1985 
   1986         ures_closeBundle(r, FALSE);
   1987         uprv_memset(r, 0, sizeof(UResourceBundle));
   1988         ures_setIsStackObject(r, isStackObject);
   1989         r->fHasFallback = TRUE;
   1990         r->fIsTopLevel = TRUE;
   1991         r->fIndex = -1;
   1992         r->fData = entryOpen(path, localeID, status);
   1993         if(U_FAILURE(*status)) {
   1994             return;
   1995         }
   1996         /* this is a quick fix to get regular data in bundle - until construction is cleaned up */
   1997         firstData = r->fData;
   1998         while(firstData->fBogus != U_ZERO_ERROR && firstData->fParent != NULL) {
   1999             firstData = firstData->fParent;
   2000         }
   2001         uprv_memcpy(&r->fResData, &firstData->fData, sizeof(ResourceData));
   2002         r->fHasFallback=(UBool)!r->fResData.noFallback;
   2003         r->fRes = r->fResData.rootRes;
   2004         r->fSize = res_countArrayItems(&(r->fResData), r->fRes);
   2005         r->fTopLevelData = r->fData;
   2006     }
   2007 }
   2008 
   2009 U_CAPI UResourceBundle*  U_EXPORT2
   2010 ures_open(const char* path,
   2011                     const char* localeID,
   2012                     UErrorCode* status)
   2013 {
   2014     char canonLocaleID[100];
   2015     UResourceDataEntry *hasData = NULL;
   2016     UResourceBundle *r;
   2017 
   2018     if(status == NULL || U_FAILURE(*status)) {
   2019         return NULL;
   2020     }
   2021 
   2022     /* first "canonicalize" the locale ID */
   2023     uloc_getBaseName(localeID, canonLocaleID, sizeof(canonLocaleID), status);
   2024     if(U_FAILURE(*status) || *status == U_STRING_NOT_TERMINATED_WARNING) {
   2025         *status = U_ILLEGAL_ARGUMENT_ERROR;
   2026         return NULL;
   2027     }
   2028 
   2029     r = (UResourceBundle *)uprv_malloc(sizeof(UResourceBundle));
   2030     if(r == NULL) {
   2031         *status = U_MEMORY_ALLOCATION_ERROR;
   2032         return NULL;
   2033     }
   2034 
   2035     uprv_memset(r, 0, sizeof(UResourceBundle));
   2036     r->fHasFallback = TRUE;
   2037     r->fIsTopLevel = TRUE;
   2038     ures_setIsStackObject(r, FALSE);
   2039     r->fIndex = -1;
   2040     r->fData = entryOpen(path, canonLocaleID, status);
   2041     if(U_FAILURE(*status)) {
   2042         uprv_free(r);
   2043         return NULL;
   2044     }
   2045     r->fTopLevelData = r->fData;
   2046 
   2047     hasData = r->fData;
   2048     while(hasData->fBogus != U_ZERO_ERROR) {
   2049         hasData = hasData->fParent;
   2050         if(hasData == NULL) {
   2051           /* This can happen only if fallback chain gets broken by an act of God */
   2052           /* TODO: this unlikely to happen, consider removing it */
   2053             entryClose(r->fData);
   2054             uprv_free(r);
   2055             *status = U_MISSING_RESOURCE_ERROR;
   2056             return NULL;
   2057         }
   2058     }
   2059 
   2060     uprv_memcpy(&r->fResData, &hasData->fData, sizeof(ResourceData));
   2061     r->fHasFallback=(UBool)!r->fResData.noFallback;
   2062     r->fRes = r->fResData.rootRes;
   2063     r->fSize = res_countArrayItems(&(r->fResData), r->fRes);
   2064     /*
   2065     if(r->fData->fPath != NULL) {
   2066       ures_setResPath(r, r->fData->fPath);
   2067       ures_appendResPath(r, RES_PATH_PACKAGE_S);
   2068       ures_appendResPath(r, r->fData->fName);
   2069     } else {
   2070       ures_setResPath(r, r->fData->fName);
   2071     }
   2072     */
   2073 
   2074 
   2075     return r;
   2076 }
   2077 
   2078 /**
   2079  *  Opens a resource bundle without "canonicalizing" the locale name. No fallback will be performed
   2080  *  or sought. However, alias substitution will happen!
   2081  */
   2082 U_CAPI UResourceBundle*  U_EXPORT2
   2083 ures_openDirect(const char* path, const char* localeID, UErrorCode* status) {
   2084     UResourceBundle *r;
   2085     UErrorCode subStatus = U_ZERO_ERROR;
   2086 
   2087     if(status == NULL || U_FAILURE(*status)) {
   2088         return NULL;
   2089     }
   2090 
   2091     r = (UResourceBundle *)uprv_malloc(sizeof(UResourceBundle));
   2092     if(r == NULL) {
   2093         *status = U_MEMORY_ALLOCATION_ERROR;
   2094         return NULL;
   2095     }
   2096 
   2097     r->fHasFallback = FALSE;
   2098     r->fIsTopLevel = TRUE;
   2099     ures_setIsStackObject(r, FALSE);
   2100     r->fIndex = -1;
   2101     r->fData = entryOpen(path, localeID, &subStatus);
   2102     if(U_FAILURE(subStatus)) {
   2103         *status = subStatus;
   2104         uprv_free(r);
   2105         return NULL;
   2106     }
   2107     if(subStatus != U_ZERO_ERROR /*r->fData->fBogus != U_ZERO_ERROR*/) {
   2108       /* we didn't find one we were looking for - so openDirect */
   2109       /* should fail */
   2110         entryClose(r->fData);
   2111         uprv_free(r);
   2112         *status = U_MISSING_RESOURCE_ERROR;
   2113         return NULL;
   2114     }
   2115 
   2116     r->fKey = NULL;
   2117     r->fVersion = NULL;
   2118     uprv_memcpy(&r->fResData, &r->fData->fData, sizeof(ResourceData));
   2119     /* r->fHasFallback remains FALSE here in ures_openDirect() */
   2120     r->fRes = r->fResData.rootRes;
   2121     /*r->fParent = RES_BOGUS;*/
   2122     r->fSize = res_countArrayItems(&(r->fResData), r->fRes);
   2123     r->fResPath = NULL;
   2124     r->fResPathLen = 0;
   2125     /*r->fParentRes = NULL;*/
   2126     r->fTopLevelData = r->fData;
   2127 
   2128     return r;
   2129 }
   2130 
   2131 /**
   2132  *  API: Counts members. For arrays and tables, returns number of resources.
   2133  *  For strings, returns 1.
   2134  */
   2135 U_CAPI int32_t  U_EXPORT2
   2136 ures_countArrayItems(const UResourceBundle* resourceBundle,
   2137                   const char* resourceKey,
   2138                   UErrorCode* status)
   2139 {
   2140     UResourceBundle resData;
   2141     ures_initStackObject(&resData);
   2142     if (status==NULL || U_FAILURE(*status)) {
   2143         return 0;
   2144     }
   2145     if(resourceBundle == NULL) {
   2146         *status = U_ILLEGAL_ARGUMENT_ERROR;
   2147         return 0;
   2148     }
   2149     ures_getByKey(resourceBundle, resourceKey, &resData, status);
   2150 
   2151     if(resData.fResData.data != NULL) {
   2152         int32_t result = res_countArrayItems(&resData.fResData, resData.fRes);
   2153         ures_close(&resData);
   2154         return result;
   2155     } else {
   2156         *status = U_MISSING_RESOURCE_ERROR;
   2157         ures_close(&resData);
   2158         return 0;
   2159     }
   2160 }
   2161 
   2162 /**
   2163  * Internal function.
   2164  * Return the version number associated with this ResourceBundle as a string.
   2165  *
   2166  * @param resourceBundle The resource bundle for which the version is checked.
   2167  * @return  A version number string as specified in the resource bundle or its parent.
   2168  *          The caller does not own this string.
   2169  * @see ures_getVersion
   2170  * @internal
   2171  */
   2172 U_INTERNAL const char* U_EXPORT2
   2173 ures_getVersionNumberInternal(const UResourceBundle *resourceBundle)
   2174 {
   2175     if (!resourceBundle) return NULL;
   2176 
   2177     if(resourceBundle->fVersion == NULL) {
   2178 
   2179         /* If the version ID has not been built yet, then do so.  Retrieve */
   2180         /* the minor version from the file. */
   2181         UErrorCode status = U_ZERO_ERROR;
   2182         int32_t minor_len = 0;
   2183         int32_t len;
   2184 
   2185         const UChar* minor_version = ures_getStringByKey(resourceBundle, kVersionTag, &minor_len, &status);
   2186 
   2187         /* Determine the length of of the final version string.  This is */
   2188         /* the length of the major part + the length of the separator */
   2189         /* (==1) + the length of the minor part (+ 1 for the zero byte at */
   2190         /* the end). */
   2191 
   2192         len = (minor_len > 0) ? minor_len : 1;
   2193 
   2194         /* Allocate the string, and build it up. */
   2195         /* + 1 for zero byte */
   2196 
   2197 
   2198         ((UResourceBundle *)resourceBundle)->fVersion = (char *)uprv_malloc(1 + len);
   2199         /* Check for null pointer. */
   2200         if (((UResourceBundle *)resourceBundle)->fVersion == NULL) {
   2201             return NULL;
   2202         }
   2203 
   2204         if(minor_len > 0) {
   2205             u_UCharsToChars(minor_version, resourceBundle->fVersion , minor_len);
   2206             resourceBundle->fVersion[len] =  '\0';
   2207         }
   2208         else {
   2209             uprv_strcpy(resourceBundle->fVersion, kDefaultMinorVersion);
   2210         }
   2211     }
   2212 
   2213     return resourceBundle->fVersion;
   2214 }
   2215 
   2216 U_CAPI const char*  U_EXPORT2
   2217 ures_getVersionNumber(const UResourceBundle*   resourceBundle)
   2218 {
   2219     return ures_getVersionNumberInternal(resourceBundle);
   2220 }
   2221 
   2222 U_CAPI void U_EXPORT2 ures_getVersion(const UResourceBundle* resB, UVersionInfo versionInfo) {
   2223     if (!resB) return;
   2224 
   2225     u_versionFromString(versionInfo, ures_getVersionNumberInternal(resB));
   2226 }
   2227 
   2228 /** Tree support functions *******************************/
   2229 #define INDEX_LOCALE_NAME "res_index"
   2230 #define INDEX_TAG         "InstalledLocales"
   2231 #define DEFAULT_TAG       "default"
   2232 
   2233 #if defined(URES_TREE_DEBUG)
   2234 #include <stdio.h>
   2235 #endif
   2236 
   2237 typedef struct ULocalesContext {
   2238     UResourceBundle installed;
   2239     UResourceBundle curr;
   2240 } ULocalesContext;
   2241 
   2242 static void U_CALLCONV
   2243 ures_loc_closeLocales(UEnumeration *enumerator) {
   2244     ULocalesContext *ctx = (ULocalesContext *)enumerator->context;
   2245     ures_close(&ctx->curr);
   2246     ures_close(&ctx->installed);
   2247     uprv_free(ctx);
   2248     uprv_free(enumerator);
   2249 }
   2250 
   2251 static int32_t U_CALLCONV
   2252 ures_loc_countLocales(UEnumeration *en, UErrorCode *status) {
   2253     ULocalesContext *ctx = (ULocalesContext *)en->context;
   2254     return ures_getSize(&ctx->installed);
   2255 }
   2256 
   2257 static const char* U_CALLCONV
   2258 ures_loc_nextLocale(UEnumeration* en,
   2259                     int32_t* resultLength,
   2260                     UErrorCode* status) {
   2261     ULocalesContext *ctx = (ULocalesContext *)en->context;
   2262     UResourceBundle *res = &(ctx->installed);
   2263     UResourceBundle *k = NULL;
   2264     const char *result = NULL;
   2265     int32_t len = 0;
   2266     if(ures_hasNext(res) && (k = ures_getNextResource(res, &ctx->curr, status))) {
   2267         result = ures_getKey(k);
   2268         len = (int32_t)uprv_strlen(result);
   2269     }
   2270     if (resultLength) {
   2271         *resultLength = len;
   2272     }
   2273     return result;
   2274 }
   2275 
   2276 static void U_CALLCONV
   2277 ures_loc_resetLocales(UEnumeration* en,
   2278                       UErrorCode* status) {
   2279     UResourceBundle *res = &((ULocalesContext *)en->context)->installed;
   2280     ures_resetIterator(res);
   2281 }
   2282 
   2283 
   2284 static const UEnumeration gLocalesEnum = {
   2285     NULL,
   2286         NULL,
   2287         ures_loc_closeLocales,
   2288         ures_loc_countLocales,
   2289         uenum_unextDefault,
   2290         ures_loc_nextLocale,
   2291         ures_loc_resetLocales
   2292 };
   2293 
   2294 
   2295 U_CAPI UEnumeration* U_EXPORT2
   2296 ures_openAvailableLocales(const char *path, UErrorCode *status)
   2297 {
   2298     UResourceBundle *idx = NULL;
   2299     UEnumeration *en = NULL;
   2300     ULocalesContext *myContext = NULL;
   2301 
   2302     if(U_FAILURE(*status)) {
   2303         return NULL;
   2304     }
   2305     myContext = uprv_malloc(sizeof(ULocalesContext));
   2306     en =  (UEnumeration *)uprv_malloc(sizeof(UEnumeration));
   2307     if(!en || !myContext) {
   2308         *status = U_MEMORY_ALLOCATION_ERROR;
   2309         uprv_free(en);
   2310         uprv_free(myContext);
   2311         return NULL;
   2312     }
   2313     uprv_memcpy(en, &gLocalesEnum, sizeof(UEnumeration));
   2314 
   2315     ures_initStackObject(&myContext->installed);
   2316     ures_initStackObject(&myContext->curr);
   2317     idx = ures_openDirect(path, INDEX_LOCALE_NAME, status);
   2318     ures_getByKey(idx, INDEX_TAG, &myContext->installed, status);
   2319     if(U_SUCCESS(*status)) {
   2320 #if defined(URES_TREE_DEBUG)
   2321         fprintf(stderr, "Got %s::%s::[%s] : %s\n",
   2322             path, INDEX_LOCALE_NAME, INDEX_TAG, ures_getKey(&myContext->installed));
   2323 #endif
   2324         en->context = myContext;
   2325     } else {
   2326 #if defined(URES_TREE_DEBUG)
   2327         fprintf(stderr, "%s open failed - %s\n", path, u_errorName(*status));
   2328 #endif
   2329         ures_close(&myContext->installed);
   2330         uprv_free(myContext);
   2331         uprv_free(en);
   2332         en = NULL;
   2333     }
   2334 
   2335     ures_close(idx);
   2336 
   2337     return en;
   2338 }
   2339 
   2340 static UBool isLocaleInList(UEnumeration *locEnum, const char *locToSearch, UErrorCode *status) {
   2341     const char *loc;
   2342     while ((loc = uenum_next(locEnum, NULL, status)) != NULL) {
   2343         if (uprv_strcmp(loc, locToSearch) == 0) {
   2344             return TRUE;
   2345         }
   2346     }
   2347     return FALSE;
   2348 }
   2349 
   2350 U_CAPI int32_t U_EXPORT2
   2351 ures_getFunctionalEquivalent(char *result, int32_t resultCapacity,
   2352                              const char *path, const char *resName, const char *keyword, const char *locid,
   2353                              UBool *isAvailable, UBool omitDefault, UErrorCode *status)
   2354 {
   2355     char kwVal[1024] = ""; /* value of keyword 'keyword' */
   2356     char defVal[1024] = ""; /* default value for given locale */
   2357     char defLoc[1024] = ""; /* default value for given locale */
   2358     char base[1024] = ""; /* base locale */
   2359     char found[1024];
   2360     char parent[1024];
   2361     char full[1024] = "";
   2362     UResourceBundle bund1, bund2;
   2363     UResourceBundle *res = NULL;
   2364     UErrorCode subStatus = U_ZERO_ERROR;
   2365     int32_t length = 0;
   2366     if(U_FAILURE(*status)) return 0;
   2367     uloc_getKeywordValue(locid, keyword, kwVal, 1024-1,&subStatus);
   2368     if(!uprv_strcmp(kwVal, DEFAULT_TAG)) {
   2369         kwVal[0]=0;
   2370     }
   2371     uloc_getBaseName(locid, base, 1024-1,&subStatus);
   2372 #if defined(URES_TREE_DEBUG)
   2373     fprintf(stderr, "getFunctionalEquivalent: \"%s\" [%s=%s] in %s - %s\n",
   2374             locid, keyword, kwVal, base, u_errorName(subStatus));
   2375 #endif
   2376     ures_initStackObject(&bund1);
   2377     ures_initStackObject(&bund2);
   2378 
   2379 
   2380     uprv_strcpy(parent, base);
   2381     uprv_strcpy(found, base);
   2382 
   2383     if(isAvailable) {
   2384         UEnumeration *locEnum = ures_openAvailableLocales(path, &subStatus);
   2385         *isAvailable = TRUE;
   2386         if (U_SUCCESS(subStatus)) {
   2387             *isAvailable = isLocaleInList(locEnum, parent, &subStatus);
   2388         }
   2389         uenum_close(locEnum);
   2390     }
   2391 
   2392     if(U_FAILURE(subStatus)) {
   2393         *status = subStatus;
   2394         return 0;
   2395     }
   2396 
   2397     do {
   2398         subStatus = U_ZERO_ERROR;
   2399         res = ures_open(path, parent, &subStatus);
   2400         if(((subStatus == U_USING_FALLBACK_WARNING) ||
   2401             (subStatus == U_USING_DEFAULT_WARNING)) && isAvailable)
   2402         {
   2403             *isAvailable = FALSE;
   2404         }
   2405         isAvailable = NULL; /* only want to set this the first time around */
   2406 
   2407 #if defined(URES_TREE_DEBUG)
   2408         fprintf(stderr, "%s;%s -> %s [%s]\n", path?path:"ICUDATA", parent, u_errorName(subStatus), ures_getLocale(res, &subStatus));
   2409 #endif
   2410         if(U_FAILURE(subStatus)) {
   2411             *status = subStatus;
   2412         } else if(subStatus == U_ZERO_ERROR) {
   2413             ures_getByKey(res,resName,&bund1, &subStatus);
   2414             if(subStatus == U_ZERO_ERROR) {
   2415                 const UChar *defUstr;
   2416                 int32_t defLen;
   2417                 /* look for default item */
   2418 #if defined(URES_TREE_DEBUG)
   2419                 fprintf(stderr, "%s;%s : loaded default -> %s\n",
   2420                     path?path:"ICUDATA", parent, u_errorName(subStatus));
   2421 #endif
   2422                 defUstr = ures_getStringByKey(&bund1, DEFAULT_TAG, &defLen, &subStatus);
   2423                 if(U_SUCCESS(subStatus) && defLen) {
   2424                     u_UCharsToChars(defUstr, defVal, u_strlen(defUstr));
   2425 #if defined(URES_TREE_DEBUG)
   2426                     fprintf(stderr, "%s;%s -> default %s=%s,  %s\n",
   2427                         path?path:"ICUDATA", parent, keyword, defVal, u_errorName(subStatus));
   2428 #endif
   2429                     uprv_strcpy(defLoc, parent);
   2430                     if(kwVal[0]==0) {
   2431                         uprv_strcpy(kwVal, defVal);
   2432 #if defined(URES_TREE_DEBUG)
   2433                         fprintf(stderr, "%s;%s -> kwVal =  %s\n",
   2434                             path?path:"ICUDATA", parent, keyword, kwVal);
   2435 #endif
   2436                     }
   2437                 }
   2438             }
   2439         }
   2440 
   2441         subStatus = U_ZERO_ERROR;
   2442 
   2443         if (res != NULL) {
   2444             uprv_strcpy(found, ures_getLocaleByType(res, ULOC_VALID_LOCALE, &subStatus));
   2445         }
   2446 
   2447         uloc_getParent(found,parent,sizeof(parent),&subStatus);
   2448         ures_close(res);
   2449     } while(!defVal[0] && *found && uprv_strcmp(found, "root") != 0 && U_SUCCESS(*status));
   2450 
   2451     /* Now, see if we can find the kwVal collator.. start the search over.. */
   2452     uprv_strcpy(parent, base);
   2453     uprv_strcpy(found, base);
   2454 
   2455     do {
   2456         subStatus = U_ZERO_ERROR;
   2457         res = ures_open(path, parent, &subStatus);
   2458         if((subStatus == U_USING_FALLBACK_WARNING) && isAvailable) {
   2459             *isAvailable = FALSE;
   2460         }
   2461         isAvailable = NULL; /* only want to set this the first time around */
   2462 
   2463 #if defined(URES_TREE_DEBUG)
   2464         fprintf(stderr, "%s;%s -> %s (looking for %s)\n",
   2465             path?path:"ICUDATA", parent, u_errorName(subStatus), kwVal);
   2466 #endif
   2467         if(U_FAILURE(subStatus)) {
   2468             *status = subStatus;
   2469         } else if(subStatus == U_ZERO_ERROR) {
   2470             ures_getByKey(res,resName,&bund1, &subStatus);
   2471 #if defined(URES_TREE_DEBUG)
   2472 /**/ fprintf(stderr,"@%d [%s] %s\n", __LINE__, resName, u_errorName(subStatus));
   2473 #endif
   2474             if(subStatus == U_ZERO_ERROR) {
   2475                 ures_getByKey(&bund1, kwVal, &bund2, &subStatus);
   2476 #if defined(URES_TREE_DEBUG)
   2477 /**/ fprintf(stderr,"@%d [%s] %s\n", __LINE__, kwVal, u_errorName(subStatus));
   2478 #endif
   2479                 if(subStatus == U_ZERO_ERROR) {
   2480 #if defined(URES_TREE_DEBUG)
   2481                     fprintf(stderr, "%s;%s -> full0 %s=%s,  %s\n",
   2482                         path?path:"ICUDATA", parent, keyword, kwVal, u_errorName(subStatus));
   2483 #endif
   2484                     uprv_strcpy(full, parent);
   2485                     if(*full == 0) {
   2486                         uprv_strcpy(full, "root");
   2487                     }
   2488                         /* now, recalculate default kw if need be */
   2489                         if(uprv_strlen(defLoc) > uprv_strlen(full)) {
   2490                           const UChar *defUstr;
   2491                           int32_t defLen;
   2492                           /* look for default item */
   2493 #if defined(URES_TREE_DEBUG)
   2494                             fprintf(stderr, "%s;%s -> recalculating Default0\n",
   2495                                     path?path:"ICUDATA", full);
   2496 #endif
   2497                           defUstr = ures_getStringByKey(&bund1, DEFAULT_TAG, &defLen, &subStatus);
   2498                           if(U_SUCCESS(subStatus) && defLen) {
   2499                             u_UCharsToChars(defUstr, defVal, u_strlen(defUstr));
   2500 #if defined(URES_TREE_DEBUG)
   2501                             fprintf(stderr, "%s;%s -> default0 %s=%s,  %s\n",
   2502                                     path?path:"ICUDATA", full, keyword, defVal, u_errorName(subStatus));
   2503 #endif
   2504                             uprv_strcpy(defLoc, full);
   2505                           }
   2506                         } /* end of recalculate default KW */
   2507 #if defined(URES_TREE_DEBUG)
   2508                         else {
   2509                           fprintf(stderr, "No trim0,  %s <= %s\n", defLoc, full);
   2510                         }
   2511 #endif
   2512                 } else {
   2513 #if defined(URES_TREE_DEBUG)
   2514                     fprintf(stderr, "err=%s in %s looking for %s\n",
   2515                         u_errorName(subStatus), parent, kwVal);
   2516 #endif
   2517                 }
   2518             }
   2519         }
   2520 
   2521         subStatus = U_ZERO_ERROR;
   2522 
   2523         uprv_strcpy(found, parent);
   2524         uloc_getParent(found,parent,1023,&subStatus);
   2525         ures_close(res);
   2526     } while(!full[0] && *found && U_SUCCESS(*status));
   2527 
   2528     if((full[0]==0) && uprv_strcmp(kwVal, defVal)) {
   2529 #if defined(URES_TREE_DEBUG)
   2530         fprintf(stderr, "Failed to locate kw %s - try default %s\n", kwVal, defVal);
   2531 #endif
   2532         uprv_strcpy(kwVal, defVal);
   2533         uprv_strcpy(parent, base);
   2534         uprv_strcpy(found, base);
   2535 
   2536         do { /* search for 'default' named item */
   2537             subStatus = U_ZERO_ERROR;
   2538             res = ures_open(path, parent, &subStatus);
   2539             if((subStatus == U_USING_FALLBACK_WARNING) && isAvailable) {
   2540                 *isAvailable = FALSE;
   2541             }
   2542             isAvailable = NULL; /* only want to set this the first time around */
   2543 
   2544 #if defined(URES_TREE_DEBUG)
   2545             fprintf(stderr, "%s;%s -> %s (looking for default %s)\n",
   2546                 path?path:"ICUDATA", parent, u_errorName(subStatus), kwVal);
   2547 #endif
   2548             if(U_FAILURE(subStatus)) {
   2549                 *status = subStatus;
   2550             } else if(subStatus == U_ZERO_ERROR) {
   2551                 ures_getByKey(res,resName,&bund1, &subStatus);
   2552                 if(subStatus == U_ZERO_ERROR) {
   2553                     ures_getByKey(&bund1, kwVal, &bund2, &subStatus);
   2554                     if(subStatus == U_ZERO_ERROR) {
   2555 #if defined(URES_TREE_DEBUG)
   2556                         fprintf(stderr, "%s;%s -> full1 %s=%s,  %s\n", path?path:"ICUDATA",
   2557                             parent, keyword, kwVal, u_errorName(subStatus));
   2558 #endif
   2559                         uprv_strcpy(full, parent);
   2560                         if(*full == 0) {
   2561                             uprv_strcpy(full, "root");
   2562                         }
   2563 
   2564                         /* now, recalculate default kw if need be */
   2565                         if(uprv_strlen(defLoc) > uprv_strlen(full)) {
   2566                           const UChar *defUstr;
   2567                           int32_t defLen;
   2568                           /* look for default item */
   2569 #if defined(URES_TREE_DEBUG)
   2570                             fprintf(stderr, "%s;%s -> recalculating Default1\n",
   2571                                     path?path:"ICUDATA", full);
   2572 #endif
   2573                           defUstr = ures_getStringByKey(&bund1, DEFAULT_TAG, &defLen, &subStatus);
   2574                           if(U_SUCCESS(subStatus) && defLen) {
   2575                             u_UCharsToChars(defUstr, defVal, u_strlen(defUstr));
   2576 #if defined(URES_TREE_DEBUG)
   2577                             fprintf(stderr, "%s;%s -> default %s=%s,  %s\n",
   2578                                     path?path:"ICUDATA", full, keyword, defVal, u_errorName(subStatus));
   2579 #endif
   2580                             uprv_strcpy(defLoc, full);
   2581                           }
   2582                         } /* end of recalculate default KW */
   2583 #if defined(URES_TREE_DEBUG)
   2584                         else {
   2585                           fprintf(stderr, "No trim1,  %s <= %s\n", defLoc, full);
   2586                         }
   2587 #endif
   2588                     }
   2589                 }
   2590             }
   2591             subStatus = U_ZERO_ERROR;
   2592 
   2593             uprv_strcpy(found, parent);
   2594             uloc_getParent(found,parent,1023,&subStatus);
   2595             ures_close(res);
   2596         } while(!full[0] && *found && U_SUCCESS(*status));
   2597     }
   2598 
   2599     if(U_SUCCESS(*status)) {
   2600         if(!full[0]) {
   2601 #if defined(URES_TREE_DEBUG)
   2602           fprintf(stderr, "Still could not load keyword %s=%s\n", keyword, kwVal);
   2603 #endif
   2604           *status = U_MISSING_RESOURCE_ERROR;
   2605         } else if(omitDefault) {
   2606 #if defined(URES_TREE_DEBUG)
   2607           fprintf(stderr,"Trim? full=%s, defLoc=%s, found=%s\n", full, defLoc, found);
   2608 #endif
   2609           if(uprv_strlen(defLoc) <= uprv_strlen(full)) {
   2610             /* found the keyword in a *child* of where the default tag was present. */
   2611             if(!uprv_strcmp(kwVal, defVal)) { /* if the requested kw is default, */
   2612               /* and the default is in or in an ancestor of the current locale */
   2613 #if defined(URES_TREE_DEBUG)
   2614               fprintf(stderr, "Removing unneeded var %s=%s\n", keyword, kwVal);
   2615 #endif
   2616               kwVal[0]=0;
   2617             }
   2618           }
   2619         }
   2620         uprv_strcpy(found, full);
   2621         if(kwVal[0]) {
   2622             uprv_strcat(found, "@");
   2623             uprv_strcat(found, keyword);
   2624             uprv_strcat(found, "=");
   2625             uprv_strcat(found, kwVal);
   2626         } else if(!omitDefault) {
   2627             uprv_strcat(found, "@");
   2628             uprv_strcat(found, keyword);
   2629             uprv_strcat(found, "=");
   2630             uprv_strcat(found, defVal);
   2631         }
   2632     }
   2633     /* we found the default locale - no need to repeat it.*/
   2634 
   2635     ures_close(&bund1);
   2636     ures_close(&bund2);
   2637 
   2638     length = (int32_t)uprv_strlen(found);
   2639 
   2640     if(U_SUCCESS(*status)) {
   2641         int32_t copyLength = uprv_min(length, resultCapacity);
   2642         if(copyLength>0) {
   2643             uprv_strncpy(result, found, copyLength);
   2644         }
   2645         if(length == 0) {
   2646           *status = U_MISSING_RESOURCE_ERROR;
   2647         }
   2648     } else {
   2649         length = 0;
   2650         result[0]=0;
   2651     }
   2652     return u_terminateChars(result, resultCapacity, length, status);
   2653 }
   2654 
   2655 U_CAPI UEnumeration* U_EXPORT2
   2656 ures_getKeywordValues(const char *path, const char *keyword, UErrorCode *status)
   2657 {
   2658 #define VALUES_BUF_SIZE 2048
   2659 #define VALUES_LIST_SIZE 512
   2660 
   2661     char       valuesBuf[VALUES_BUF_SIZE];
   2662     int32_t    valuesIndex = 0;
   2663     const char *valuesList[VALUES_LIST_SIZE];
   2664     int32_t    valuesCount = 0;
   2665 
   2666     const char *locale;
   2667     int32_t     locLen;
   2668 
   2669     UEnumeration *locs = NULL;
   2670 
   2671     UResourceBundle    item;
   2672     UResourceBundle    subItem;
   2673 
   2674     ures_initStackObject(&item);
   2675     ures_initStackObject(&subItem);
   2676     locs = ures_openAvailableLocales(path, status);
   2677 
   2678     if(U_FAILURE(*status)) {
   2679         ures_close(&item);
   2680         ures_close(&subItem);
   2681         return NULL;
   2682     }
   2683 
   2684     valuesBuf[0]=0;
   2685     valuesBuf[1]=0;
   2686 
   2687     while((locale = uenum_next(locs, &locLen, status))) {
   2688         UResourceBundle   *bund = NULL;
   2689         UResourceBundle   *subPtr = NULL;
   2690         UErrorCode subStatus = U_ZERO_ERROR; /* don't fail if a bundle is unopenable */
   2691         bund = ures_openDirect(path, locale, &subStatus);
   2692 
   2693 #if defined(URES_TREE_DEBUG)
   2694         if(!bund || U_FAILURE(subStatus)) {
   2695             fprintf(stderr, "%s-%s values: Can't open %s locale - skipping. (%s)\n",
   2696                 path?path:"<ICUDATA>", keyword, locale, u_errorName(subStatus));
   2697         }
   2698 #endif
   2699 
   2700         ures_getByKey(bund, keyword, &item, &subStatus);
   2701 
   2702         if(!bund || U_FAILURE(subStatus)) {
   2703 #if defined(URES_TREE_DEBUG)
   2704             fprintf(stderr, "%s-%s values: Can't find in %s - skipping. (%s)\n",
   2705                 path?path:"<ICUDATA>", keyword, locale, u_errorName(subStatus));
   2706 #endif
   2707             ures_close(bund);
   2708             bund = NULL;
   2709             continue;
   2710         }
   2711 
   2712         while((subPtr = ures_getNextResource(&item,&subItem,&subStatus))
   2713             && U_SUCCESS(subStatus)) {
   2714             const char *k;
   2715             int32_t i;
   2716             k = ures_getKey(subPtr);
   2717 
   2718 #if defined(URES_TREE_DEBUG)
   2719             /* fprintf(stderr, "%s | %s | %s | %s\n", path?path:"<ICUDATA>", keyword, locale, k); */
   2720 #endif
   2721             for(i=0;k&&i<valuesCount;i++) {
   2722                 if(!uprv_strcmp(valuesList[i],k)) {
   2723                     k = NULL; /* found duplicate */
   2724                 }
   2725             }
   2726             if(k && *k) {
   2727                 int32_t kLen = (int32_t)uprv_strlen(k);
   2728                 if(!uprv_strcmp(k,DEFAULT_TAG)) {
   2729                     continue; /* don't need 'default'. */
   2730                 }
   2731                 if((valuesCount >= (VALUES_LIST_SIZE-1)) ||       /* no more space in list .. */
   2732                     ((valuesIndex+kLen+1+1) >= VALUES_BUF_SIZE)) { /* no more space in buffer (string + 2 nulls) */
   2733                     *status = U_ILLEGAL_ARGUMENT_ERROR; /* out of space.. */
   2734                 } else {
   2735                     uprv_strcpy(valuesBuf+valuesIndex, k);
   2736                     valuesList[valuesCount++] = valuesBuf+valuesIndex;
   2737                     valuesIndex += kLen;
   2738 #if defined(URES_TREE_DEBUG)
   2739                     fprintf(stderr, "%s | %s | %s | [%s]   (UNIQUE)\n",
   2740                         path?path:"<ICUDATA>", keyword, locale, k);
   2741 #endif
   2742                     valuesBuf[valuesIndex++] = 0; /* terminate */
   2743                 }
   2744             }
   2745         }
   2746         ures_close(bund);
   2747     }
   2748     valuesBuf[valuesIndex++] = 0; /* terminate */
   2749 
   2750     ures_close(&item);
   2751     ures_close(&subItem);
   2752     uenum_close(locs);
   2753 #if defined(URES_TREE_DEBUG)
   2754     fprintf(stderr, "%s:  size %d, #%d\n", u_errorName(*status),
   2755         valuesIndex, valuesCount);
   2756 #endif
   2757     return uloc_openKeywordList(valuesBuf, valuesIndex, status);
   2758 }
   2759 #if 0
   2760 /* This code isn't needed, and given the documentation warnings the implementation is suspect */
   2761 U_INTERNAL UBool U_EXPORT2
   2762 ures_equal(const UResourceBundle* res1, const UResourceBundle* res2){
   2763     if(res1==NULL || res2==NULL){
   2764         return res1==res2; /* pointer comparision */
   2765     }
   2766     if(res1->fKey==NULL||  res2->fKey==NULL){
   2767         return (res1->fKey==res2->fKey);
   2768     }else{
   2769         if(uprv_strcmp(res1->fKey, res2->fKey)!=0){
   2770             return FALSE;
   2771         }
   2772     }
   2773     if(uprv_strcmp(res1->fData->fName, res2->fData->fName)!=0){
   2774         return FALSE;
   2775     }
   2776     if(res1->fData->fPath == NULL||  res2->fData->fPath==NULL){
   2777         return (res1->fData->fPath == res2->fData->fPath);
   2778     }else{
   2779         if(uprv_strcmp(res1->fData->fPath, res2->fData->fPath)!=0){
   2780             return FALSE;
   2781         }
   2782     }
   2783     if(uprv_strcmp(res1->fData->fParent->fName, res2->fData->fParent->fName)!=0){
   2784         return FALSE;
   2785     }
   2786     if(uprv_strcmp(res1->fData->fParent->fPath, res2->fData->fParent->fPath)!=0){
   2787         return FALSE;
   2788     }
   2789     if(uprv_strncmp(res1->fResPath, res2->fResPath, res1->fResPathLen)!=0){
   2790         return FALSE;
   2791     }
   2792     if(res1->fRes != res2->fRes){
   2793         return FALSE;
   2794     }
   2795     return TRUE;
   2796 }
   2797 U_INTERNAL UResourceBundle* U_EXPORT2
   2798 ures_clone(const UResourceBundle* res, UErrorCode* status){
   2799     UResourceBundle* bundle = NULL;
   2800     UResourceBundle* ret = NULL;
   2801     if(U_FAILURE(*status) || res == NULL){
   2802         return NULL;
   2803     }
   2804     bundle = ures_open(res->fData->fPath, res->fData->fName, status);
   2805     if(res->fResPath!=NULL){
   2806         ret = ures_findSubResource(bundle, res->fResPath, NULL, status);
   2807         ures_close(bundle);
   2808     }else{
   2809         ret = bundle;
   2810     }
   2811     return ret;
   2812 }
   2813 U_INTERNAL const UResourceBundle* U_EXPORT2
   2814 ures_getParentBundle(const UResourceBundle* res){
   2815     if(res==NULL){
   2816         return NULL;
   2817     }
   2818     return res->fParentRes;
   2819 }
   2820 #endif
   2821 
   2822 U_INTERNAL void U_EXPORT2
   2823 ures_getVersionByKey(const UResourceBundle* res, const char *key, UVersionInfo ver, UErrorCode *status) {
   2824   const UChar *str;
   2825   int32_t len;
   2826   str = ures_getStringByKey(res, key, &len, status);
   2827   if(U_SUCCESS(*status)) {
   2828     u_versionFromUString(ver, str);
   2829   }
   2830 }
   2831 
   2832 /* eof */
   2833