../deps/icu-small/source/common/uresbund.cpp

Bug Summary

File:	out/../deps/icu-small/source/common/uresbund.cpp
Warning:	line 2404, column 12 2nd function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name uresbund.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/common/uresbund.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5* Copyright (C) 1997-2016, International Business Machines Corporation and
6* others. All Rights Reserved.
7******************************************************************************
8*
9* File uresbund.cpp
10*
11* Modification History:
12*
13*   Date        Name        Description
14*   04/01/97    aliu        Creation.
15*   06/14/99    stephen     Removed functions taking a filename suffix.
16*   07/20/99    stephen     Changed for UResourceBundle typedef'd to void*
17*   11/09/99    weiv            Added ures_getLocale()
18*   March 2000  weiv        Total overhaul - using data in DLLs
19*   06/20/2000  helena      OS/400 port changes; mostly typecast.
20*   06/24/02    weiv        Added support for resource sharing
21******************************************************************************
22*/

24#include "unicode/ures.h"
25#include "unicode/ustring.h"
26#include "unicode/ucnv.h"
27#include "charstr.h"
28#include "uresimp.h"
29#include "ustr_imp.h"
30#include "cwchar.h"
31#include "ucln_cmn.h"
32#include "cmemory.h"
33#include "cstring.h"
34#include "mutex.h"
35#include "uhash.h"
36#include "unicode/uenum.h"
37#include "uenumimp.h"
38#include "ulocimp.h"
39#include "umutex.h"
40#include "putilimp.h"
41#include "uassert.h"
42#include "uresdata.h"

44using namespace icu;

46/*
47Static cache for already opened resource bundles - mostly for keeping fallback info
48TODO: This cache should probably be removed when the deprecated code is
    completely removed.
50*/
51static UHashtable *cache = NULL__null;
52static icu::UInitOnce gCacheInitOnce = U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR};

54static UMutex resbMutex;

56/* INTERNAL: hashes an entry  */
57static int32_t U_CALLCONV hashEntry(const UHashTok parm) {
  UResourceDataEntry *b = (UResourceDataEntry *)parm.pointer;
  UHashTok namekey, pathkey;
  namekey.pointer = b->fName;
  pathkey.pointer = b->fPath;
  return uhash_hashCharsuhash_hashChars_71(namekey)+37u*uhash_hashCharsuhash_hashChars_71(pathkey);
63}

65/* INTERNAL: compares two entries */
66static UBool U_CALLCONV compareEntries(const UHashTok p1, const UHashTok p2) {
  UResourceDataEntry *b1 = (UResourceDataEntry *)p1.pointer;
  UResourceDataEntry *b2 = (UResourceDataEntry *)p2.pointer;
  UHashTok name1, name2, path1, path2;
  name1.pointer = b1->fName;
  name2.pointer = b2->fName;
  path1.pointer = b1->fPath;
  path2.pointer = b2->fPath;
  return (UBool)(uhash_compareCharsuhash_compareChars_71(name1, name2) &&
      uhash_compareCharsuhash_compareChars_71(path1, path2));
76}


79/**
*  Internal function, gets parts of locale name according 
*  to the position of '_' character
*/
83static UBool chopLocale(char *name) {
  char *i = uprv_strrchr(name, '_'):: strrchr(name, '_');

  if(i != NULL__null) {
      *i = '\0';
      return TRUE1;
  }

  return FALSE0;
92}

94/**
*  Called to check whether a name without '_' needs to be checked for a parent.
*  Some code had assumed that locale IDs with '_' could not have a non-root parent.
*  We may want a better way of doing this.
*/
99static UBool mayHaveParent(char *name) {
  return (name[0] != 0 && uprv_strstr("nb nn",name):: strstr("nb nn", name) != nullptr);
101}

103/**
*  Internal function
*/
106static void entryIncrease(UResourceDataEntry *entry) {
  Mutex lock(&resbMutex);
  entry->fCountExisting++;
  while(entry->fParent != NULL__null) {
    entry = entry->fParent;
    entry->fCountExisting++;
  }
113}

115/**
*  Internal function. Tries to find a resource in given Resource
*  Bundle, as well as in its parents
*/
119static UResourceDataEntry *getFallbackData(
      const UResourceBundle *resBundle,
      const char **resTag, Resource *res, UErrorCode *status) {
  UResourceDataEntry *dataEntry = resBundle->fData;
  int32_t indexR = -1;
  int32_t i = 0;
  *res = RES_BOGUS0xffffffff;
  if(dataEntry == nullptr) {
      *status = U_MISSING_RESOURCE_ERROR;
      return nullptr;
  }
  if(dataEntry->fBogus == U_ZERO_ERROR) { /* if this resource is real, */
      *res = res_getTableItemByKeyres_getTableItemByKey_71(&(dataEntry->fData), dataEntry->fData.rootRes, &indexR, resTag); /* try to get data from there */
      i++;
  }
  if(resBundle->fHasFallback) {
      // Otherwise, we'll look in parents.
      while(*res == RES_BOGUS0xffffffff && dataEntry->fParent != nullptr) {
          dataEntry = dataEntry->fParent;
          if(dataEntry->fBogus == U_ZERO_ERROR) {
              i++;
              *res = res_getTableItemByKeyres_getTableItemByKey_71(&(dataEntry->fData), dataEntry->fData.rootRes, &indexR, resTag);
          }
      }
  }

  if(*res == RES_BOGUS0xffffffff) {
      // If the resource is not found, we need to give an error.
      *status = U_MISSING_RESOURCE_ERROR;
      return nullptr;
  }
  // If the resource is found in parents, we need to adjust the error.
  if(i>1) {
      if(uprv_strcmp(dataEntry->fName, uloc_getDefault()):: strcmp(dataEntry->fName, uloc_getDefault_71())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName):: strcmp(dataEntry->fName, "root")==0) {
          *status = U_USING_DEFAULT_WARNING;
      } else {
          *status = U_USING_FALLBACK_WARNING;
      }
  }
  return dataEntry;
159}

161static void
162free_entry(UResourceDataEntry *entry) {
  UResourceDataEntry *alias;
  res_unloadres_unload_71(&(entry->fData));
  if(entry->fName != NULL__null && entry->fName != entry->fNameBuffer) {
      uprv_freeuprv_free_71(entry->fName);
  }
  if(entry->fPath != NULL__null) {
      uprv_freeuprv_free_71(entry->fPath);
  }
  if(entry->fPool != NULL__null) {
      --entry->fPool->fCountExisting;
  }
  alias = entry->fAlias;
  if(alias != NULL__null) {
      while(alias->fAlias != NULL__null) {
          alias = alias->fAlias;
      }
      --alias->fCountExisting;
  }
  uprv_freeuprv_free_71(entry);
182}

184/* Works just like ucnv_flushCache() */
185static int32_t ures_flushCache()
186{
  UResourceDataEntry *resB;
  int32_t pos;
  int32_t rbDeletedNum = 0;
  const UHashElement *e;
  UBool deletedMore;

  /*if shared data hasn't even been lazy evaluated yet
  * return 0
  */
  Mutex lock(&resbMutex);
  if (cache == NULL__null) {
      return 0;
  }

  do {
      deletedMore = FALSE0;
      /*creates an enumeration to iterate through every element in the table */
      pos = UHASH_FIRST(-1);
      while ((e = uhash_nextElementuhash_nextElement_71(cache, &pos)) != NULL__null)
      {
          resB = (UResourceDataEntry *) e->value.pointer;
          /* Deletes only if reference counter == 0
           * Don't worry about the children of this node.
           * Those will eventually get deleted too, if not already.
           * Don't worry about the parents of this node.
           * Those will eventually get deleted too, if not already.
           */
          /* 04/05/2002 [weiv] fCountExisting should now be accurate. If it's not zero, that means that    */
          /* some resource bundles are still open somewhere. */

          if (resB->fCountExisting == 0) {
              rbDeletedNum++;
              deletedMore = TRUE1;
              uhash_removeElementuhash_removeElement_71(cache, e);
              free_entry(resB);
          }
      }
      /*
       * Do it again to catch bundles (aliases, pool bundle) whose fCountExisting
       * got decremented by free_entry().
       */
  } while(deletedMore);

  return rbDeletedNum;
231}

233#ifdef URES_DEBUG
234#include <stdio.h>

236U_CAPIextern "C" UBool U_EXPORT2 ures_dumpCacheContents(void) {
UBool cacheNotEmpty = FALSE0;
int32_t pos = UHASH_FIRST(-1);
const UHashElement *e;
UResourceDataEntry *resB;

  Mutex lock(&resbMutex);
  if (cache == NULL__null) {
    fprintf(stderrstderr,"%s:%d: RB Cache is NULL.\n", __FILE__"../deps/icu-small/source/common/uresbund.cpp", __LINE__244);
    return FALSE0;
  }

  while ((e = uhash_nextElementuhash_nextElement_71(cache, &pos)) != NULL__null) {
    cacheNotEmpty=TRUE1;
    resB = (UResourceDataEntry *) e->value.pointer;
    fprintf(stderrstderr,"%s:%d: RB Cache: Entry @0x%p, refcount %d, name %s:%s.  Pool 0x%p, alias 0x%p, parent 0x%p\n",
            __FILE__"../deps/icu-small/source/common/uresbund.cpp", __LINE__252,
            (void*)resB, resB->fCountExisting,
            resB->fName?resB->fName:"NULL",
            resB->fPath?resB->fPath:"NULL",
            (void*)resB->fPool,
            (void*)resB->fAlias,
            (void*)resB->fParent);       
  }
  
  fprintf(stderrstderr,"%s:%d: RB Cache still contains %d items.\n", __FILE__"../deps/icu-small/source/common/uresbund.cpp", __LINE__261, uhash_countuhash_count_71(cache));
  return cacheNotEmpty;
263}

265#endif

267static UBool U_CALLCONV ures_cleanup(void)
268{
  if (cache != NULL__null) {
      ures_flushCache();
      uhash_closeuhash_close_71(cache);
      cache = NULL__null;
  }
  gCacheInitOnce.reset();
  return TRUE1;
276}

278/** INTERNAL: Initializes the cache for resources */
279static void U_CALLCONV createCache(UErrorCode &status) {
  U_ASSERT(cache == NULL)(void)0;
  cache = uhash_openuhash_open_71(hashEntry, compareEntries, NULL__null, &status);
  ucln_common_registerCleanupucln_common_registerCleanup_71(UCLN_COMMON_URES, ures_cleanup);
283}
   
285static void initCache(UErrorCode *status) {
  umtx_initOnce(gCacheInitOnce, &createCache, *status);
287}

289/** INTERNAL: sets the name (locale) of the resource bundle to given name */

291static void setEntryName(UResourceDataEntry *res, const char *name, UErrorCode *status) {
  int32_t len = (int32_t)uprv_strlen(name):: strlen(name);
  if(res->fName != NULL__null && res->fName != res->fNameBuffer) {
      uprv_freeuprv_free_71(res->fName);
  }
  if (len < (int32_t)sizeof(res->fNameBuffer)) {
      res->fName = res->fNameBuffer;
  }
  else {
      res->fName = (char *)uprv_mallocuprv_malloc_71(len+1);
  }
  if(res->fName == NULL__null) {
      *status = U_MEMORY_ALLOCATION_ERROR;
  } else {
      uprv_strcpy(res->fName, name):: strcpy(res->fName, name);
  }
307}

309static UResourceDataEntry *
310getPoolEntry(const char *path, UErrorCode *status);

312/**
*  INTERNAL: Inits and opens an entry from a data DLL.
*    CAUTION:  resbMutex must be locked when calling this function.
*/
316static UResourceDataEntry *init_entry(const char *localeID, const char *path, UErrorCode *status) {
  UResourceDataEntry *r = NULL__null;
  UResourceDataEntry find;
  /*int32_t hashValue;*/
  const char *name;
  char aliasName[100] = { 0 };
  int32_t aliasLen = 0;
  /*UBool isAlias = FALSE;*/
  /*UHashTok hashkey; */

  if(U_FAILURE(*status)) {
      return NULL__null;
  }

  /* here we try to deduce the right locale name */
  if(localeID == NULL__null) { /* if localeID is NULL, we're trying to open default locale */
      name = uloc_getDefaultuloc_getDefault_71();
  } else if(*localeID == 0) { /* if localeID is "" then we try to open root locale */
      name = kRootLocaleName"root";
  } else { /* otherwise, we'll open what we're given */
      name = localeID;
  }

  find.fName = (char *)name;
  find.fPath = (char *)path;

  /* calculate the hash value of the entry */
  /*hashkey.pointer = (void *)&find;*/
  /*hashValue = hashEntry(hashkey);*/

  /* check to see if we already have this entry */
  r = (UResourceDataEntry *)uhash_getuhash_get_71(cache, &find);
  if(r == NULL__null) {
      /* if the entry is not yet in the hash table, we'll try to construct a new one */
      r = (UResourceDataEntry *) uprv_mallocuprv_malloc_71(sizeof(UResourceDataEntry));
      if(r == NULL__null) {
          *status = U_MEMORY_ALLOCATION_ERROR;
          return NULL__null;
      }

      uprv_memset(r, 0, sizeof(UResourceDataEntry)):: memset(r, 0, sizeof(UResourceDataEntry));
      /*r->fHashKey = hashValue;*/

      setEntryName(r, name, status);
      if (U_FAILURE(*status)) {
          uprv_freeuprv_free_71(r);
          return NULL__null;
      }

      if(path != NULL__null) {
          r->fPath = (char *)uprv_strdupuprv_strdup_71(path);
          if(r->fPath == NULL__null) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              uprv_freeuprv_free_71(r);
              return NULL__null;
          }
      }

      /* this is the actual loading */
      res_loadres_load_71(&(r->fData), r->fPath, r->fName, status);

      if (U_FAILURE(*status)) {
          /* if we failed to load due to an out-of-memory error, exit early. */
          if (*status == U_MEMORY_ALLOCATION_ERROR) {
              uprv_freeuprv_free_71(r);
              return NULL__null;
          }
          /* we have no such entry in dll, so it will always use fallback */
          *status = U_USING_FALLBACK_WARNING;
          r->fBogus = U_USING_FALLBACK_WARNING;
      } else { /* if we have a regular entry */
          Resource aliasres;
          if (r->fData.usesPoolBundle) {
              r->fPool = getPoolEntry(r->fPath, status);
              if (U_SUCCESS(*status)) {
                  const int32_t *poolIndexes = r->fPool->fData.pRoot + 1;
                  if(r->fData.pRoot[1 + URES_INDEX_POOL_CHECKSUM] == poolIndexes[URES_INDEX_POOL_CHECKSUM]) {
                      r->fData.poolBundleKeys = (const char *)(poolIndexes + (poolIndexes[URES_INDEX_LENGTH] & 0xff));
                      r->fData.poolBundleStrings = r->fPool->fData.p16BitUnits;
                  } else {
                      r->fBogus = *status = U_INVALID_FORMAT_ERROR;
                  }
              } else {
                  r->fBogus = *status;
              }
          }
          if (U_SUCCESS(*status)) {
              /* handle the alias by trying to get out the %%Alias tag.*/
              /* We'll try to get alias string from the bundle */
              aliasres = res_getResourceres_getResource_71(&(r->fData), "%%ALIAS");
              if (aliasres != RES_BOGUS0xffffffff) {
                  // No tracing: called during initial data loading
                  const UChar *alias = res_getStringNoTraceres_getStringNoTrace_71(&(r->fData), aliasres, &aliasLen);
                  if(alias != NULL__null && aliasLen > 0) { /* if there is actual alias - unload and load new data */
                      u_UCharsToCharsu_UCharsToChars_71(alias, aliasName, aliasLen+1);
                      r->fAlias = init_entry(aliasName, path, status);
                  }
              }
          }
      }

      {
          UResourceDataEntry *oldR = NULL__null;
          if((oldR = (UResourceDataEntry *)uhash_getuhash_get_71(cache, r)) == NULL__null) { /* if the data is not cached */
              /* just insert it in the cache */
              UErrorCode cacheStatus = U_ZERO_ERROR;
              uhash_putuhash_put_71(cache, (void *)r, r, &cacheStatus);
              if (U_FAILURE(cacheStatus)) {
                  *status = cacheStatus;
                  free_entry(r);
                  r = NULL__null;
              }
          } else {
              /* somebody have already inserted it while we were working, discard newly opened data */
              /* Also, we could get here IF we opened an alias */
              free_entry(r);
              r = oldR;
          }
      }

  }
  if(r != NULL__null) {
      /* return the real bundle */
      while(r->fAlias != NULL__null) {
          r = r->fAlias;
      }
      r->fCountExisting++; /* we increase its reference count */
      /* if the resource has a warning */
      /* we don't want to overwrite a status with no error */
      if(r->fBogus != U_ZERO_ERROR && U_SUCCESS(*status)) {
           *status = r->fBogus; /* set the returning status */
      }
  }
  return r;
450}

452static UResourceDataEntry *
453getPoolEntry(const char *path, UErrorCode *status) {
  UResourceDataEntry *poolBundle = init_entry(kPoolBundleName"pool", path, status);
  if( U_SUCCESS(*status) &&
      (poolBundle == NULL__null || poolBundle->fBogus != U_ZERO_ERROR || !poolBundle->fData.isPoolBundle)
  ) {
      *status = U_INVALID_FORMAT_ERROR;
  }
  return poolBundle;
461}

463/* INTERNAL: */
464/*   CAUTION:  resbMutex must be locked when calling this function! */
465static UResourceDataEntry *
466findFirstExisting(const char* path, char* name, const char* defaultLocale,
                UBool *isRoot, UBool *hasChopped, UBool *isDefault, UErrorCode* status) {
  UResourceDataEntry *r = NULL__null;
  UBool hasRealData = FALSE0;
  *hasChopped = TRUE1; /* we're starting with a fresh name */

  while(*hasChopped && !hasRealData) {
      r = init_entry(name, path, status);
      /* Null pointer test */
      if (U_FAILURE(*status)) {
          return NULL__null;
      }
      *isDefault = (UBool)(uprv_strncmp(name, defaultLocale, uprv_strlen(name)):: strncmp(name, defaultLocale, :: strlen(name)) == 0);
      hasRealData = (UBool)(r->fBogus == U_ZERO_ERROR);
      if(!hasRealData) {
          /* this entry is not real. We will discard it. */
          /* However, the parent line for this entry is  */
          /* not to be used - as there might be parent   */
          /* lines in cache from previous openings that  */
          /* are not updated yet. */
          r->fCountExisting--;
          /*entryCloseInt(r);*/
          r = NULL__null;
          *status = U_USING_FALLBACK_WARNING;
      } else {
          uprv_strcpy(name, r->fName):: strcpy(name, r->fName); /* this is needed for supporting aliases */
      }

      *isRoot = (UBool)(uprv_strcmp(name, kRootLocaleName):: strcmp(name, "root") == 0);

      /*Fallback data stuff*/
      *hasChopped = chopLocale(name);
      if (*hasChopped && *name == '\0') {
          uprv_strcpy(name, "und"):: strcpy(name, "und");
      }
  }
  return r;
503}

505static void ures_setIsStackObject( UResourceBundle* resB, UBool state) {
  if(state) {
      resB->fMagic1 = 0;
      resB->fMagic2 = 0;
  } else {
      resB->fMagic1 = MAGIC119700503;
      resB->fMagic2 = MAGIC219641227;
  }
513}

515static UBool ures_isStackObject(const UResourceBundle* resB) {
return((resB->fMagic1 == MAGIC119700503 && resB->fMagic2 == MAGIC219641227)?FALSE0:TRUE1);
517}


520U_CFUNCextern "C" void ures_initStackObjectures_initStackObject_71(UResourceBundle* resB) {
uprv_memset(resB, 0, sizeof(UResourceBundle)):: memset(resB, 0, sizeof(UResourceBundle));
ures_setIsStackObject(resB, TRUE1);
523}

525U_NAMESPACE_BEGINnamespace icu_71 {

527StackUResourceBundle::StackUResourceBundle() {
  ures_initStackObjectures_initStackObject_71(&bundle);
529}

531StackUResourceBundle::~StackUResourceBundle() {
  ures_closeures_close_71(&bundle);
533}

535U_NAMESPACE_END}

537static UBool  // returns U_SUCCESS(*status)
538loadParentsExceptRoot(UResourceDataEntry *&t1,
                    char name[], int32_t nameCapacity,
                    UBool usingUSRData, char usrDataPath[], UErrorCode *status) {
  if (U_FAILURE(*status)) { return FALSE0; }
  UBool checkParent = TRUE1;
  while (checkParent && t1->fParent == NULL__null && !t1->fData.noFallback &&
          res_getResourceres_getResource_71(&t1->fData,"%%ParentIsRoot") == RES_BOGUS0xffffffff) {
      Resource parentRes = res_getResourceres_getResource_71(&t1->fData, "%%Parent");
      if (parentRes != RES_BOGUS0xffffffff) {  // An explicit parent was found.
          int32_t parentLocaleLen = 0;
          // No tracing: called during initial data loading
          const UChar *parentLocaleName = res_getStringNoTraceres_getStringNoTrace_71(&(t1->fData), parentRes, &parentLocaleLen);
          if(parentLocaleName != NULL__null && 0 < parentLocaleLen && parentLocaleLen < nameCapacity) {
              u_UCharsToCharsu_UCharsToChars_71(parentLocaleName, name, parentLocaleLen + 1);
              if (uprv_strcmp(name, kRootLocaleName):: strcmp(name, "root") == 0) {
                  return TRUE1;
              }
          }
      }
      // Insert regular parents.
      UErrorCode parentStatus = U_ZERO_ERROR;
      UResourceDataEntry *t2 = init_entry(name, t1->fPath, &parentStatus);
      if (U_FAILURE(parentStatus)) {
          *status = parentStatus;
          return FALSE0;
      }
      UResourceDataEntry *u2 = NULL__null;
      UErrorCode usrStatus = U_ZERO_ERROR;
      if (usingUSRData) {  // This code inserts user override data into the inheritance chain.
          u2 = init_entry(name, usrDataPath, &usrStatus);
          // If we failed due to out-of-memory, report that to the caller and exit early.
          if (usrStatus == U_MEMORY_ALLOCATION_ERROR) {
              *status = usrStatus;
              return FALSE0;
          }
      }

      if (usingUSRData && U_SUCCESS(usrStatus) && u2->fBogus == U_ZERO_ERROR) {
          t1->fParent = u2;
          u2->fParent = t2;
      } else {
          t1->fParent = t2;
          if (usingUSRData) {
              // The USR override data wasn't found, set it to be deleted.
              u2->fCountExisting = 0;
          }
      }
      t1 = t2;
      checkParent = chopLocale(name) || mayHaveParent(name);
  }
  return TRUE1;
589}

591static UBool  // returns U_SUCCESS(*status)
592insertRootBundle(UResourceDataEntry *&t1, UErrorCode *status) {
  if (U_FAILURE(*status)) { return FALSE0; }
  UErrorCode parentStatus = U_ZERO_ERROR;
  UResourceDataEntry *t2 = init_entry(kRootLocaleName"root", t1->fPath, &parentStatus);
  if (U_FAILURE(parentStatus)) {
      *status = parentStatus;
      return FALSE0;
  }
  t1->fParent = t2;
  t1 = t2;
  return TRUE1;
603}

605enum UResOpenType {
  /**
   * Open a resource bundle for the locale;
   * if there is not even a base language bundle, then fall back to the default locale;
   * if there is no bundle for that either, then load the root bundle.
   *
   * This is the default bundle loading behavior.
   */
  URES_OPEN_LOCALE_DEFAULT_ROOT,
  // TODO: ICU ticket #11271 "consistent default locale across locale trees"
  // Add an option to look at the main locale tree for whether to
  // fall back to root directly (if the locale has main data) or
  // fall back to the default locale first (if the locale does not even have main data).
  /**
   * Open a resource bundle for the locale;
   * if there is not even a base language bundle, then load the root bundle;
   * never fall back to the default locale.
   *
   * This is used for algorithms that have good pan-Unicode default behavior,
   * such as case mappings, collation, and segmentation (BreakIterator).
   */
  URES_OPEN_LOCALE_ROOT,
  /**
   * Open a resource bundle for the exact bundle name as requested;
   * no fallbacks, do not load parent bundles.
   *
   * This is used for supplemental (non-locale) data.
   */
  URES_OPEN_DIRECT
634};
635typedef enum UResOpenType UResOpenType;

637static UResourceDataEntry *entryOpen(const char* path, const char* localeID,
                                   UResOpenType openType, UErrorCode* status) {
  U_ASSERT(openType != URES_OPEN_DIRECT)(void)0;
  UErrorCode intStatus = U_ZERO_ERROR;
  UResourceDataEntry *r = NULL__null;
  UResourceDataEntry *t1 = NULL__null;
  UBool isDefault = FALSE0;
  UBool isRoot = FALSE0;
  UBool hasRealData = FALSE0;
  UBool hasChopped = TRUE1;
  UBool usingUSRData = U_USE_USRDATA0 && ( path == NULL__null || uprv_strncmp(path,U_ICUDATA_NAME,8):: strncmp(path, "icudt" "71" "l", 8) == 0);

  char name[ULOC_FULLNAME_CAPACITY157];
  char usrDataPath[96];

  initCache(status);

  if(U_FAILURE(*status)) {
      return NULL__null;
  }

  uprv_strncpy(name, localeID, sizeof(name) - 1):: strncpy(name, localeID, sizeof(name) - 1);
  name[sizeof(name) - 1] = 0;

  if ( usingUSRData ) {
      if ( path == NULL__null ) {
          uprv_strcpy(usrDataPath, U_USRDATA_NAME):: strcpy(usrDataPath, "usrdt" "71" "l");
      } else {
          uprv_strncpy(usrDataPath, path, sizeof(usrDataPath) - 1):: strncpy(usrDataPath, path, sizeof(usrDataPath) - 1);
          usrDataPath[0] = 'u';
          usrDataPath[1] = 's';
          usrDataPath[2] = 'r';
          usrDataPath[sizeof(usrDataPath) - 1] = 0;
      }
  }

  // Note: We need to query the default locale *before* locking resbMutex.
  const char *defaultLocale = uloc_getDefaultuloc_getDefault_71();

  Mutex lock(&resbMutex);    // Lock resbMutex until the end of this function.

  /* We're going to skip all the locales that do not have any data */
  r = findFirstExisting(path, name, defaultLocale, &isRoot, &hasChopped, &isDefault, &intStatus);

  // If we failed due to out-of-memory, report the failure and exit early.
  if (intStatus == U_MEMORY_ALLOCATION_ERROR) {
      *status = intStatus;
      goto finish;
  }

  if(r != NULL__null) { /* if there is one real locale, we can look for parents. */
      t1 = r;
      hasRealData = TRUE1;
      if ( usingUSRData ) {  /* This code inserts user override data into the inheritance chain */
          UErrorCode usrStatus = U_ZERO_ERROR;
          UResourceDataEntry *u1 = init_entry(t1->fName, usrDataPath, &usrStatus);
          // If we failed due to out-of-memory, report the failure and exit early.
          if (intStatus == U_MEMORY_ALLOCATION_ERROR) {
              *status = intStatus;
              goto finish;
          }
          if ( u1 != NULL__null ) {
              if(u1->fBogus == U_ZERO_ERROR) {
                  u1->fParent = t1;
                  r = u1;
              } else {
                  /* the USR override data wasn't found, set it to be deleted */
                  u1->fCountExisting = 0;
              }
          }
      }
      if ((hasChopped || mayHaveParent(name)) && !isRoot) {
          if (!loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name)(int32_t)(sizeof(name)/sizeof((name)[0])), usingUSRData, usrDataPath, status)) {
              goto finish;
          }
      }
  }

  /* we could have reached this point without having any real data */
  /* if that is the case, we need to chain in the default locale   */
  if(r==NULL__null && openType == URES_OPEN_LOCALE_DEFAULT_ROOT && !isDefault && !isRoot) {
      /* insert default locale */
      uprv_strcpy(name, defaultLocale):: strcpy(name, defaultLocale);
      r = findFirstExisting(path, name, defaultLocale, &isRoot, &hasChopped, &isDefault, &intStatus);
      // If we failed due to out-of-memory, report the failure and exit early.
      if (intStatus == U_MEMORY_ALLOCATION_ERROR) {
          *status = intStatus;
          goto finish;
      }
      intStatus = U_USING_DEFAULT_WARNING;
      if(r != NULL__null) { /* the default locale exists */
          t1 = r;
          hasRealData = TRUE1;
          isDefault = TRUE1;
          // TODO: Why not if (usingUSRData) { ... } like in the non-default-locale code path?
          if ((hasChopped || mayHaveParent(name)) && !isRoot) {
              if (!loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name)(int32_t)(sizeof(name)/sizeof((name)[0])), usingUSRData, usrDataPath, status)) {
                  goto finish;
              }
          }
      }
  }

  /* we could still have r == NULL at this point - maybe even default locale is not */
  /* present */
  if(r == NULL__null) {
      uprv_strcpy(name, kRootLocaleName):: strcpy(name, "root");
      r = findFirstExisting(path, name, defaultLocale, &isRoot, &hasChopped, &isDefault, &intStatus);
      // If we failed due to out-of-memory, report the failure and exit early.
      if (intStatus == U_MEMORY_ALLOCATION_ERROR) {
          *status = intStatus;
          goto finish;
      }
      if(r != NULL__null) {
          t1 = r;
          intStatus = U_USING_DEFAULT_WARNING;
          hasRealData = TRUE1;
      } else { /* we don't even have the root locale */
          *status = U_MISSING_RESOURCE_ERROR;
          goto finish;
      }
  } else if(!isRoot && uprv_strcmp(t1->fName, kRootLocaleName):: strcmp(t1->fName, "root") != 0 &&
          t1->fParent == NULL__null && !r->fData.noFallback) {
      if (!insertRootBundle(t1, status)) {
          goto finish;
      }
      if(!hasRealData) {
          r->fBogus = U_USING_DEFAULT_WARNING;
      }
  }

  // TODO: Does this ever loop?
  while(r != NULL__null && !isRoot && t1->fParent != NULL__null) {
      t1->fParent->fCountExisting++;
      t1 = t1->fParent;
  }

774finish:
  if(U_SUCCESS(*status)) {
      if(intStatus != U_ZERO_ERROR) {
          *status = intStatus;  
      }
      return r;
  } else {
      return NULL__null;
  }
783}

785/**
* Version of entryOpen() and findFirstExisting() for ures_openDirect(),
* with no fallbacks.
* Parent and root locale bundles are loaded if
* the requested bundle does not have the "nofallback" flag.
*/
791static UResourceDataEntry *
792entryOpenDirect(const char* path, const char* localeID, UErrorCode* status) {
  initCache(status);
  if(U_FAILURE(*status)) {
      return NULL__null;
  }

  // Note: We need to query the default locale *before* locking resbMutex.
  // If the localeID is NULL, then we want to use the default locale.
  if (localeID == NULL__null) {
      localeID = uloc_getDefaultuloc_getDefault_71();
  } else if (*localeID == 0) {
      // If the localeID is "", then we want to use the root locale.
      localeID = kRootLocaleName"root";
  }

  Mutex lock(&resbMutex);

  // findFirstExisting() without fallbacks.
  UResourceDataEntry *r = init_entry(localeID, path, status);
  if(U_SUCCESS(*status)) {
      if(r->fBogus != U_ZERO_ERROR) {
          r->fCountExisting--;
          r = NULL__null;
      }
  } else {
      r = NULL__null;
  }

  // Some code depends on the ures_openDirect() bundle to have a parent bundle chain,
  // unless it is marked with "nofallback".
  UResourceDataEntry *t1 = r;
  if(r != NULL__null && uprv_strcmp(localeID, kRootLocaleName):: strcmp(localeID, "root") != 0 &&  // not root
          r->fParent == NULL__null && !r->fData.noFallback &&
          uprv_strlen(localeID):: strlen(localeID) < ULOC_FULLNAME_CAPACITY157) {
      char name[ULOC_FULLNAME_CAPACITY157];
      uprv_strcpy(name, localeID):: strcpy(name, localeID);
      if(!chopLocale(name) || uprv_strcmp(name, kRootLocaleName):: strcmp(name, "root") == 0 ||
              loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name)(int32_t)(sizeof(name)/sizeof((name)[0])), FALSE0, NULL__null, status)) {
          if(uprv_strcmp(t1->fName, kRootLocaleName):: strcmp(t1->fName, "root") != 0 && t1->fParent == NULL__null) {
              insertRootBundle(t1, status);
          }
      }
      if(U_FAILURE(*status)) {
          r = NULL__null;
      }
  }

  if(r != NULL__null) {
      // TODO: Does this ever loop?
      while(t1->fParent != NULL__null) {
          t1->fParent->fCountExisting++;
          t1 = t1->fParent;
      }
  }
  return r;
847}

849/**
* Functions to create and destroy resource bundles.
*     CAUTION:  resbMutex must be locked when calling this function.
*/
853/* INTERNAL: */
854static void entryCloseInt(UResourceDataEntry *resB) {
  UResourceDataEntry *p = resB;

  while(resB != NULL__null) {
      p = resB->fParent;
      resB->fCountExisting--;

      /* Entries are left in the cache. TODO: add ures_flushCache() to force a flush
       of the cache. */
863/*
      if(resB->fCountExisting <= 0) {
          uhash_remove(cache, resB);
          if(resB->fBogus == U_ZERO_ERROR) {
              res_unload(&(resB->fData));
          }
          if(resB->fName != NULL) {
              uprv_free(resB->fName);
          }
          if(resB->fPath != NULL) {
              uprv_free(resB->fPath);
          }
          uprv_free(resB);
      }
877*/

      resB = p;
  }
881}

883/** 
*  API: closes a resource bundle and cleans up.
*/

887static void entryClose(UResourceDataEntry *resB) {
Mutex lock(&resbMutex);
entryCloseInt(resB);
890}

892/*
893U_CFUNC void ures_setResPath(UResourceBundle *resB, const char* toAdd) {
if(resB->fResPath == NULL) {
  resB->fResPath = resB->fResBuf;
  *(resB->fResPath) = 0;
} 
resB->fResPathLen = uprv_strlen(toAdd);
if(RES_BUFSIZE <= resB->fResPathLen+1) {
  if(resB->fResPath == resB->fResBuf) {
    resB->fResPath = (char *)uprv_malloc((resB->fResPathLen+1)*sizeof(char));
  } else {
    resB->fResPath = (char *)uprv_realloc(resB->fResPath, (resB->fResPathLen+1)*sizeof(char));
  }
}
uprv_strcpy(resB->fResPath, toAdd);
907}
908*/
909static void ures_appendResPath(UResourceBundle *resB, const char* toAdd, int32_t lenToAdd, UErrorCode *status) {
  int32_t resPathLenOrig = resB->fResPathLen;
  if(resB->fResPath == NULL__null) {
      resB->fResPath = resB->fResBuf;
      *(resB->fResPath) = 0;
      resB->fResPathLen = 0;
  } 
  resB->fResPathLen += lenToAdd;
  if(RES_BUFSIZE64 <= resB->fResPathLen+1) {
      if(resB->fResPath == resB->fResBuf) {
          resB->fResPath = (char *)uprv_mallocuprv_malloc_71((resB->fResPathLen+1)*sizeof(char));
          /* Check that memory was allocated correctly. */
          if (resB->fResPath == NULL__null) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          uprv_strcpy(resB->fResPath, resB->fResBuf):: strcpy(resB->fResPath, resB->fResBuf);
      } else {
          char *temp = (char *)uprv_reallocuprv_realloc_71(resB->fResPath, (resB->fResPathLen+1)*sizeof(char));
          /* Check that memory was reallocated correctly. */
          if (temp == NULL__null) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          resB->fResPath = temp;
      }
  }
  uprv_strcpy(resB->fResPath + resPathLenOrig, toAdd):: strcpy(resB->fResPath + resPathLenOrig, toAdd);
937}

939static void ures_freeResPath(UResourceBundle *resB) {
  if (resB->fResPath && resB->fResPath != resB->fResBuf) {
      uprv_freeuprv_free_71(resB->fResPath);
  }
  resB->fResPath = NULL__null;
  resB->fResPathLen = 0;
945}

947static void
948ures_closeBundle(UResourceBundle* resB, UBool freeBundleObj)
949{
  if(resB != NULL__null) {
      if(resB->fData != NULL__null) {
          entryClose(resB->fData);
      }
      if(resB->fVersion != NULL__null) {
          uprv_freeuprv_free_71(resB->fVersion);
      }
      ures_freeResPath(resB);

      if(ures_isStackObject(resB) == FALSE0 && freeBundleObj) {
          uprv_freeuprv_free_71(resB);
      }
962#if 0 /*U_DEBUG*/
      else {
          /* poison the data */
          uprv_memset(resB, -1, sizeof(UResourceBundle)):: memset(resB, -1, sizeof(UResourceBundle));
      }
967#endif
  }
969}

971U_CAPIextern "C" void  U_EXPORT2
972ures_closeures_close_71(UResourceBundle* resB)
973{
  ures_closeBundle(resB, TRUE1);
975}

977namespace {

979UResourceBundle *init_resb_result(
      UResourceDataEntry *dataEntry, Resource r, const char *key, int32_t idx,
      UResourceDataEntry *validLocaleDataEntry, const char *containerResPath,
      int32_t recursionDepth,
      UResourceBundle *resB, UErrorCode *status);

985// TODO: Try to refactor further, so that we output a dataEntry + Resource + (optionally) resPath,
986// rather than a UResourceBundle.
987// May need to entryIncrease() the resulting dataEntry.
988UResourceBundle *getAliasTargetAsResourceBundle(
      const ResourceData &resData, Resource r, const char *key, int32_t idx,
      UResourceDataEntry *validLocaleDataEntry, const char *containerResPath,
      int32_t recursionDepth,
      UResourceBundle *resB, UErrorCode *status) {
  // TODO: When an error occurs: Should we return nullptr vs. resB?
  if (U_FAILURE(*status)) { return resB; }
  U_ASSERT(RES_GET_TYPE(r) == URES_ALIAS)(void)0;
  int32_t len = 0;
  const UChar *alias = res_getAliasres_getAlias_71(&resData, r, &len);
  if(len <= 0) {
      // bad alias
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return resB;
  }

  // Copy the UTF-16 alias string into an invariant-character string.
  //
  // We do this so that res_findResource() can modify the path,
  // which allows us to remove redundant _res_findResource() variants
  // in uresdata.c.
  // res_findResource() now NUL-terminates each segment so that table keys
  // can always be compared with strcmp() instead of strncmp().
  // Saves code there and simplifies testing and code coverage.
  //
  // markus 2003oct17
  CharString chAlias;
  chAlias.appendInvariantChars(alias, len, *status);
  if (U_FAILURE(*status)) {
      return nullptr;
  }

  // We have an alias, now let's cut it up.
  const char *path = nullptr, *locale = nullptr, *keyPath = nullptr;
  if(chAlias[0] == RES_PATH_SEPARATOR'/') {
      // There is a path included.
      char *chAliasData = chAlias.data();
      char *sep = chAliasData + 1;
      path = sep;
      sep = uprv_strchr(sep, RES_PATH_SEPARATOR):: strchr(sep, '/');
      if(sep != nullptr) {
          *sep++ = 0;
      }
      if(uprv_strcmp(path, "LOCALE"):: strcmp(path, "LOCALE") == 0) {
          // This is an XPath alias, starting with "/LOCALE/".
          // It contains the path to a resource which should be looked up
          // starting in the valid locale.
          // TODO: Can/should we forbid a /LOCALE alias without key path?
          //   It seems weird to alias to the same path, just starting from the valid locale.
          //   That will often yield an infinite loop.
          keyPath = sep;
          // Read from the valid locale which we already have.
          path = locale = nullptr;
      } else {
          if(uprv_strcmp(path, "ICUDATA"):: strcmp(path, "ICUDATA") == 0) { /* want ICU data */
              path = nullptr;
          }
          if (sep == nullptr) {
              // TODO: This ends up using the root bundle. Can/should we forbid this?
              locale = "";
          } else {
              locale = sep;
              sep = uprv_strchr(sep, RES_PATH_SEPARATOR):: strchr(sep, '/');
              if(sep != nullptr) {
                  *sep++ = 0;
              }
              keyPath = sep;
          }
      }
  } else {
      // No path, start with a locale.
      char *sep = chAlias.data();
      locale = sep;
      sep = uprv_strchr(sep, RES_PATH_SEPARATOR):: strchr(sep, '/');
      if(sep != nullptr) {
          *sep++ = 0;
      }
      keyPath = sep;
      path = validLocaleDataEntry->fPath;
  }

  // Got almost everything, let's try to open.
  // First, open the bundle with real data.
  LocalUResourceBundlePointer mainRes;
  UResourceDataEntry *dataEntry;
  if (locale == nullptr) {
      // alias = /LOCALE/keyPath
      // Read from the valid locale which we already have.
      dataEntry = validLocaleDataEntry;
  } else {
      UErrorCode intStatus = U_ZERO_ERROR;
      // TODO: Shouldn't we use ures_open() for locale data bundles (!noFallback)?
      mainRes.adoptInstead(ures_openDirectures_openDirect_71(path, locale, &intStatus));
      if(U_FAILURE(intStatus)) {
          // We failed to open the resource bundle we're aliasing to.
          *status = intStatus;
          return resB;
      }
      dataEntry = mainRes->fData;
  }

  const char* temp = nullptr;
  if(keyPath == nullptr) {
      // No key path. This means that we are going to to use the corresponding resource from
      // another bundle.
      // TODO: Why the special code path?
      //   Why not put together a key path from containerResPath + key or idx,
      //   as a comment below suggests, and go into the regular code branch?
      // First, we are going to get a corresponding container
      // resource to the one we are searching.
      r = dataEntry->fData.rootRes;
      if(containerResPath) {
          chAlias.clear().append(containerResPath, *status);
          if (U_FAILURE(*status)) {
              return nullptr;
          }
          char *aKey = chAlias.data();
          // TODO: should res_findResource() return a new dataEntry, too?
          r = res_findResourceres_findResource_71(&dataEntry->fData, r, &aKey, &temp);
      }
      if(key) {
          // We need to make keyPath from the containerResPath and
          // current key, if there is a key associated.
          chAlias.clear().append(key, *status);
          if (U_FAILURE(*status)) {
              return nullptr;
          }
          char *aKey = chAlias.data();
          r = res_findResourceres_findResource_71(&dataEntry->fData, r, &aKey, &temp);
      } else if(idx != -1) {
          // If there is no key, but there is an index, try to get by the index.
          // Here we have either a table or an array, so get the element.
          int32_t type = RES_GET_TYPE(r)((int32_t)((r)>>28UL));
          if(URES_IS_TABLE(type)((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16
 || (int32_t)(type)==URES_TABLE32)) {
              const char *aKey;
              r = res_getTableItemByIndexres_getTableItemByIndex_71(&dataEntry->fData, r, idx, &aKey);
          } else { /* array */
              r = res_getArrayItemres_getArrayItem_71(&dataEntry->fData, r, idx);
          }
      }
      if(r != RES_BOGUS0xffffffff) {
          resB = init_resb_result(
              dataEntry, r, temp, -1, validLocaleDataEntry, nullptr, recursionDepth+1,
              resB, status);
      } else {
          *status = U_MISSING_RESOURCE_ERROR;
      }
  } else {
      // This one is a bit trickier.
      // We start finding keys, but after we resolve one alias, the path might continue.
      // Consider:
      //     aliastest:alias { "testtypes/anotheralias/Sequence" }
      //     anotheralias:alias { "/ICUDATA/sh/CollationElements" }
      // aliastest resource should finally have the sequence, not collation elements.
      CharString pathBuf(keyPath, *status);
      if (U_FAILURE(*status)) {
          return nullptr;
      }
      char *myPath = pathBuf.data();
      containerResPath = nullptr;
      // Now we have fallback following here.
      for(;;) {
          r = dataEntry->fData.rootRes;
          // TODO: Move  containerResPath = nullptr  to here,
          // consistent with restarting from the rootRes of another bundle?!

          // This loop handles 'found' resources over several levels.
          while(*myPath && U_SUCCESS(*status)) {
              r = res_findResourceres_findResource_71(&(dataEntry->fData), r, &myPath, &temp);
              if(r == RES_BOGUS0xffffffff) {
                  // No resource found, we don't really want to look anymore on this level.
                  break;
              }
              // Found a resource, but it might be an indirection.
              resB = init_resb_result(
                  dataEntry, r, temp, -1,
                  validLocaleDataEntry, containerResPath, recursionDepth+1,
                  resB, status);
              if (U_FAILURE(*status)) {
                  break;
              }
              if (temp == nullptr || uprv_strcmp(keyPath, temp):: strcmp(keyPath, temp) != 0) {
                  // The call to init_resb_result() above will set resB->fKeyPath to be
                  // the same as resB->fKey,
                  // throwing away any additional path elements if we had them --
                  // if the key path wasn't just a single resource ID, clear out
                  // the bundle's key path and re-set it to be equal to keyPath.
                  ures_freeResPath(resB);
                  ures_appendResPath(resB, keyPath, (int32_t)uprv_strlen(keyPath):: strlen(keyPath), status);
                  if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR'/') {
                      ures_appendResPath(resB, RES_PATH_SEPARATOR_S"/", 1, status);
                  }
                  if (U_FAILURE(*status)) {
                      break;
                  }
              }
              r = resB->fRes; /* switch to a new resource, possibly a new tree */
              dataEntry = resB->fData;
              containerResPath = resB->fResPath;
          }
          if (U_FAILURE(*status) || r != RES_BOGUS0xffffffff) {
              break;
          }
          // Fall back to the parent bundle, if there is one.
          dataEntry = dataEntry->fParent;
          if (dataEntry == nullptr) {
              *status = U_MISSING_RESOURCE_ERROR;
              break;
          }
          // Copy the same keyPath again.
          myPath = pathBuf.data();
          uprv_strcpy(myPath, keyPath):: strcpy(myPath, keyPath);
      }
  }
  if(mainRes.getAlias() == resB) {
      mainRes.orphan();
  }
  ResourceTracer(resB).maybeTrace("getalias");
  return resB;
1207}

1209// Recursive function, should be called only by itself, by its simpler wrapper,
1210// or by getAliasTargetAsResourceBundle().
1211UResourceBundle *init_resb_result(
      UResourceDataEntry *dataEntry, Resource r, const char *key, int32_t idx,
      UResourceDataEntry *validLocaleDataEntry, const char *containerResPath,
      int32_t recursionDepth,
      UResourceBundle *resB, UErrorCode *status) {
  // TODO: When an error occurs: Should we return nullptr vs. resB?
  if(status == NULL__null || U_FAILURE(*status)) {
      return resB;
  }
  if (validLocaleDataEntry == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }
  if(RES_GET_TYPE(r)((int32_t)((r)>>28UL)) == URES_ALIAS) {
      // This is an alias, need to exchange with real data.
      if(recursionDepth >= URES_MAX_ALIAS_LEVEL256) {
          *status = U_TOO_MANY_ALIASES_ERROR;
          return resB;
      }
      return getAliasTargetAsResourceBundle(
          dataEntry->fData, r, key, idx,
          validLocaleDataEntry, containerResPath, recursionDepth, resB, status);
  }
  if(resB == NULL__null) {
      resB = (UResourceBundle *)uprv_mallocuprv_malloc_71(sizeof(UResourceBundle));
      if (resB == NULL__null) {
          *status = U_MEMORY_ALLOCATION_ERROR;
          return NULL__null;
      }
      ures_setIsStackObject(resB, FALSE0);
      resB->fResPath = NULL__null;
      resB->fResPathLen = 0;
  } else {
      if(resB->fData != NULL__null) {
          entryClose(resB->fData);
      }
      if(resB->fVersion != NULL__null) {
          uprv_freeuprv_free_71(resB->fVersion);
      }
      /* 
      weiv: if stack object was passed in, it doesn't really need to be reinited,
      since the purpose of initing is to remove stack junk. However, at this point 
      we would not do anything to an allocated object, so stack object should be
      treated the same
      */
      /*
      if(ures_isStackObject(resB) != FALSE) {
      ures_initStackObject(resB);
      }
      */
      if(containerResPath != resB->fResPath) {
          ures_freeResPath(resB);
      }
  }
  resB->fData = dataEntry;
  entryIncrease(resB->fData);
  resB->fHasFallback = FALSE0;
  resB->fIsTopLevel = FALSE0;
  resB->fIndex = -1;
  resB->fKey = key; 
  resB->fValidLocaleDataEntry = validLocaleDataEntry;
  if(containerResPath != resB->fResPath) {
      ures_appendResPath(
          resB, containerResPath, static_cast<int32_t>(uprv_strlen(containerResPath):: strlen(containerResPath)), status);
  }
  if(key != NULL__null) {
      ures_appendResPath(resB, key, (int32_t)uprv_strlen(key):: strlen(key), status);
      if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR'/') {
          ures_appendResPath(resB, RES_PATH_SEPARATOR_S"/", 1, status);
      }
  } else if(idx >= 0) {
      char buf[256];
      int32_t len = T_CString_integerToStringT_CString_integerToString_71(buf, idx, 10);
      ures_appendResPath(resB, buf, len, status);
      if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR'/') {
          ures_appendResPath(resB, RES_PATH_SEPARATOR_S"/", 1, status);
      }
  }
  /* Make sure that Purify doesn't complain about uninitialized memory copies. */
  {
      int32_t usedLen = ((resB->fResBuf == resB->fResPath) ? resB->fResPathLen : 0);
      uprv_memset(resB->fResBuf + usedLen, 0, sizeof(resB->fResBuf) - usedLen):: memset(resB->fResBuf + usedLen, 0, sizeof(resB->fResBuf
) - usedLen);
  }

  resB->fVersion = NULL__null;
  resB->fRes = r;
  resB->fSize = res_countArrayItemsres_countArrayItems_71(&resB->getResData(), resB->fRes);
  ResourceTracer(resB).trace("get");
  return resB;
1300}

1302UResourceBundle *init_resb_result(
      UResourceDataEntry *dataEntry, Resource r, const char *key, int32_t idx,
      // validLocaleDataEntry + containerResPath
      const UResourceBundle *container,
      UResourceBundle *resB, UErrorCode *status) {
  return init_resb_result(
      dataEntry, r, key, idx,
      container->fValidLocaleDataEntry, container->fResPath, 0, resB, status);
1310}

1312}  // namespace

1314UResourceBundle *ures_copyResbures_copyResb_71(UResourceBundle *r, const UResourceBundle *original, UErrorCode *status) {
  UBool isStackObject;
  if(U_FAILURE(*status) || r == original) {
      return r;
  }
  if(original != NULL__null) {
      if(r == NULL__null) {
          isStackObject = FALSE0;
          r = (UResourceBundle *)uprv_mallocuprv_malloc_71(sizeof(UResourceBundle));
          /* test for NULL */
          if (r == NULL__null) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              return NULL__null;
          }
      } else {
          isStackObject = ures_isStackObject(r);
          ures_closeBundle(r, FALSE0);
      }
      uprv_memcpy(r, original, sizeof(UResourceBundle))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(r, original
, sizeof(UResourceBundle)); } while (false);
      r->fResPath = NULL__null;
      r->fResPathLen = 0;
      if(original->fResPath) {
          ures_appendResPath(r, original->fResPath, original->fResPathLen, status);
      }
      ures_setIsStackObject(r, isStackObject);
      if(r->fData != NULL__null) {
          entryIncrease(r->fData);
      }
  }
  return r;
1344}

1346/**
* Functions to retrieve data from resource bundles.
*/

1350U_CAPIextern "C" const UChar* U_EXPORT2 ures_getStringures_getString_71(const UResourceBundle* resB, int32_t* len, UErrorCode* status) {
  const UChar *s;
  if (status==NULL__null || U_FAILURE(*status)) {
      return NULL__null;
  }
  if(resB == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }
  s = res_getString({resB}, &resB->getResData(), resB->fRes, len);
  if (s == NULL__null) {
      *status = U_RESOURCE_TYPE_MISMATCH;
  }
  return s;
1364}

1366static const char *
1367ures_toUTF8String(const UChar *s16, int32_t length16,
                char *dest, int32_t *pLength,
                UBool forceCopy,
                UErrorCode *status) {
  int32_t capacity;

  if (U_FAILURE(*status)) {
      return NULL__null;
  }
  if (pLength != NULL__null) {
      capacity = *pLength;
  } else {
      capacity = 0;
  }
  if (capacity < 0 || (capacity > 0 && dest == NULL__null)) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }

  if (length16 == 0) {
      /* empty string, return as read-only pointer */
      if (pLength != NULL__null) {
          *pLength = 0;
      }
      if (forceCopy) {
          u_terminateCharsu_terminateChars_71(dest, capacity, 0, status);
          return dest;
      } else {
          return "";
      }
  } else {
      /* We need to transform the string to the destination buffer. */
      if (capacity < length16) {
          /* No chance for the string to fit. Pure preflighting. */
          return u_strToUTF8u_strToUTF8_71(NULL__null, 0, pLength, s16, length16, status);
      }
      if (!forceCopy && (length16 <= 0x2aaaaaaa)) {
          /*
           * We know the string will fit into dest because each UChar turns
           * into at most three UTF-8 bytes. Fill the latter part of dest
           * so that callers do not expect to use dest as a string pointer,
           * hopefully leading to more robust code for when resource bundles
           * may store UTF-8 natively.
           * (In which case dest would not be used at all.)
           *
           * We do not do this if forceCopy=TRUE because then the caller
           * expects the string to start exactly at dest.
           *
           * The test above for <= 0x2aaaaaaa prevents overflows.
           * The +1 is for the NUL terminator.
           */
          int32_t maxLength = 3 * length16 + 1;
          if (capacity > maxLength) {
              dest += capacity - maxLength;
              capacity = maxLength;
          }
      }
      return u_strToUTF8u_strToUTF8_71(dest, capacity, pLength, s16, length16, status);
  }
1426}

1428U_CAPIextern "C" const char * U_EXPORT2
1429ures_getUTF8Stringures_getUTF8String_71(const UResourceBundle *resB,
                 char *dest, int32_t *pLength,
                 UBool forceCopy,
                 UErrorCode *status) {
  int32_t length16;
  const UChar *s16 = ures_getStringures_getString_71(resB, &length16, status);
  return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
1436}

1438U_CAPIextern "C" const uint8_t* U_EXPORT2 ures_getBinaryures_getBinary_71(const UResourceBundle* resB, int32_t* len, 
                                             UErrorCode*               status) {
const uint8_t *p;
if (status==NULL__null || U_FAILURE(*status)) {
  return NULL__null;
}
if(resB == NULL__null) {
  *status = U_ILLEGAL_ARGUMENT_ERROR;
  return NULL__null;
}
p = res_getBinary({resB}, &resB->getResData(), resB->fRes, len);
if (p == NULL__null) {
  *status = U_RESOURCE_TYPE_MISMATCH;
}
return p;
1453}

1455U_CAPIextern "C" const int32_t* U_EXPORT2 ures_getIntVectorures_getIntVector_71(const UResourceBundle* resB, int32_t* len, 
                                                 UErrorCode*               status) {
const int32_t *p;
if (status==NULL__null || U_FAILURE(*status)) {
  return NULL__null;
}
if(resB == NULL__null) {
  *status = U_ILLEGAL_ARGUMENT_ERROR;
  return NULL__null;
}
p = res_getIntVector({resB}, &resB->getResData(), resB->fRes, len);
if (p == NULL__null) {
  *status = U_RESOURCE_TYPE_MISMATCH;
}
return p;
1470}

1472/* this function returns a signed integer */ 
1473/* it performs sign extension */
1474U_CAPIextern "C" int32_t U_EXPORT2 ures_getIntures_getInt_71(const UResourceBundle* resB, UErrorCode *status) {
if (status==NULL__null || U_FAILURE(*status)) {
  return 0xffffffff;
}
if(resB == NULL__null) {
  *status = U_ILLEGAL_ARGUMENT_ERROR;
  return 0xffffffff;
}
if(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL)) != URES_INT) {
  *status = U_RESOURCE_TYPE_MISMATCH;
  return 0xffffffff;
}
return res_getInt({resB}, resB->fRes);
1487}

1489U_CAPIextern "C" uint32_t U_EXPORT2 ures_getUIntures_getUInt_71(const UResourceBundle* resB, UErrorCode *status) {
if (status==NULL__null || U_FAILURE(*status)) {
  return 0xffffffff;
}
if(resB == NULL__null) {
  *status = U_ILLEGAL_ARGUMENT_ERROR;
  return 0xffffffff;
}
if(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL)) != URES_INT) {
  *status = U_RESOURCE_TYPE_MISMATCH;
  return 0xffffffff;
}
return res_getUInt({resB}, resB->fRes);
1502}

1504U_CAPIextern "C" UResType U_EXPORT2 ures_getTypeures_getType_71(const UResourceBundle *resB) {
if(resB == NULL__null) {
  return URES_NONE;
}
return res_getPublicTyperes_getPublicType_71(resB->fRes);
1509}

1511U_CAPIextern "C" const char * U_EXPORT2 ures_getKeyures_getKey_71(const UResourceBundle *resB) {
//
// TODO: Trace ures_getKey? I guess not usually.
//
// We usually get the key string to decide whether we want the value, or to
// make a key-value pair. Tracing the value should suffice.
//
// However, I believe we have some data (e.g., in res_index) where the key
// strings are the data. Tracing the enclosing table should suffice.
//
if(resB == NULL__null) {
  return NULL__null;
}
return(resB->fKey);
1525}

1527U_CAPIextern "C" int32_t U_EXPORT2 ures_getSizeures_getSize_71(const UResourceBundle *resB) {
if(resB == NULL__null) {
  return 0;
}

return resB->fSize;
1533}

1535static const UChar* ures_getStringWithAlias(const UResourceBundle *resB, Resource r, int32_t sIndex, int32_t *len, UErrorCode *status) {
if(RES_GET_TYPE(r)((int32_t)((r)>>28UL)) == URES_ALIAS) {
  const UChar* result = 0;
  UResourceBundle *tempRes = ures_getByIndexures_getByIndex_71(resB, sIndex, NULL__null, status);
  result = ures_getStringures_getString_71(tempRes, len, status);
  ures_closeures_close_71(tempRes);
  return result;
} else {
  return res_getString({resB, sIndex}, &resB->getResData(), r, len); 
}
1545}

1547U_CAPIextern "C" void U_EXPORT2 ures_resetIteratorures_resetIterator_71(UResourceBundle *resB){
if(resB == NULL__null) {
  return;
}
resB->fIndex = -1;
1552}

1554U_CAPIextern "C" UBool U_EXPORT2 ures_hasNextures_hasNext_71(const UResourceBundle *resB) {
if(resB == NULL__null) {
  return FALSE0;
}
return (UBool)(resB->fIndex < resB->fSize-1);
1559}

1561U_CAPIextern "C" const UChar* U_EXPORT2 ures_getNextStringures_getNextString_71(UResourceBundle *resB, int32_t* len, const char ** key, UErrorCode *status) {
Resource r = RES_BOGUS0xffffffff;

if (status==NULL__null || U_FAILURE(*status)) {
  return NULL__null;
}
if(resB == NULL__null) {
  *status = U_ILLEGAL_ARGUMENT_ERROR;
  return NULL__null;
}

if(resB->fIndex == resB->fSize-1) {
  *status = U_INDEX_OUTOFBOUNDS_ERROR;
} else {
  resB->fIndex++;
  switch(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL))) {
  case URES_STRING:
  case URES_STRING_V2:
    return res_getString({resB}, &resB->getResData(), resB->fRes, len);
  case URES_TABLE:
  case URES_TABLE16:
  case URES_TABLE32:
    r = res_getTableItemByIndexres_getTableItemByIndex_71(&resB->getResData(), resB->fRes, resB->fIndex, key);
    if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
      /* TODO: do the fallback */
    }
    return ures_getStringWithAlias(resB, r, resB->fIndex, len, status);
  case URES_ARRAY:
  case URES_ARRAY16:
    r = res_getArrayItemres_getArrayItem_71(&resB->getResData(), resB->fRes, resB->fIndex);
    if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
      /* TODO: do the fallback */
    }
    return ures_getStringWithAlias(resB, r, resB->fIndex, len, status);
  case URES_ALIAS:
    return ures_getStringWithAlias(resB, resB->fRes, resB->fIndex, len, status);
  case URES_INT:
  case URES_BINARY:
  case URES_INT_VECTOR:
      *status = U_RESOURCE_TYPE_MISMATCH;
      U_FALLTHROUGH[[clang::fallthrough]];
  default:
    return NULL__null;
  }
}

return NULL__null;
1608}

1610U_CAPIextern "C" UResourceBundle* U_EXPORT2 ures_getNextResourceures_getNextResource_71(UResourceBundle *resB, UResourceBundle *fillIn, UErrorCode *status) {
  const char *key = NULL__null;
  Resource r = RES_BOGUS0xffffffff;

  if (status==NULL__null || U_FAILURE(*status)) {
          /*return NULL;*/
          return fillIn;
  }
  if(resB == NULL__null) {
          *status = U_ILLEGAL_ARGUMENT_ERROR;
          /*return NULL;*/
          return fillIn;
  }

  if(resB->fIndex == resB->fSize-1) {
    *status = U_INDEX_OUTOFBOUNDS_ERROR;
    /*return NULL;*/
  } else {
      resB->fIndex++;
      switch(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL))) {
      case URES_INT:
      case URES_BINARY:
      case URES_STRING:
      case URES_STRING_V2:
      case URES_INT_VECTOR:
          return ures_copyResbures_copyResb_71(fillIn, resB, status);
      case URES_TABLE:
      case URES_TABLE16:
      case URES_TABLE32:
          r = res_getTableItemByIndexres_getTableItemByIndex_71(&resB->getResData(), resB->fRes, resB->fIndex, &key);
          if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
              /* TODO: do the fallback */
          }
          return init_resb_result(resB->fData, r, key, resB->fIndex, resB, fillIn, status);
      case URES_ARRAY:
      case URES_ARRAY16:
          r = res_getArrayItemres_getArrayItem_71(&resB->getResData(), resB->fRes, resB->fIndex);
          if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
              /* TODO: do the fallback */
          }
          return init_resb_result(resB->fData, r, key, resB->fIndex, resB, fillIn, status);
      default:
          /*return NULL;*/
          return fillIn;
      }
  }
  /*return NULL;*/
  return fillIn;
1658}

1660U_CAPIextern "C" UResourceBundle* U_EXPORT2 ures_getByIndexures_getByIndex_71(const UResourceBundle *resB, int32_t indexR, UResourceBundle *fillIn, UErrorCode *status) {
  const char* key = NULL__null;
  Resource r = RES_BOGUS0xffffffff;

  if (status==NULL__null || U_FAILURE(*status)) {
      /*return NULL;*/
      return fillIn;
  }
  if(resB == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      /*return NULL;*/
      return fillIn;
  }

  if(indexR >= 0 && resB->fSize > indexR) {
      switch(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL))) {
      case URES_INT:
      case URES_BINARY:
      case URES_STRING:
      case URES_STRING_V2:
      case URES_INT_VECTOR:
          return ures_copyResbures_copyResb_71(fillIn, resB, status);
      case URES_TABLE:
      case URES_TABLE16:
      case URES_TABLE32:
          r = res_getTableItemByIndexres_getTableItemByIndex_71(&resB->getResData(), resB->fRes, indexR, &key);
          if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
              /* TODO: do the fallback */
          }
          return init_resb_result(resB->fData, r, key, indexR, resB, fillIn, status);
      case URES_ARRAY:
      case URES_ARRAY16:
          r = res_getArrayItemres_getArrayItem_71(&resB->getResData(), resB->fRes, indexR);
          if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
              /* TODO: do the fallback */
          }
          return init_resb_result(resB->fData, r, key, indexR, resB, fillIn, status);
      default:
          /*return NULL;*/
          return fillIn;
      }
  } else {
      *status = U_MISSING_RESOURCE_ERROR;
  }
  /*return NULL;*/
  return fillIn;
1706}

1708U_CAPIextern "C" const UChar* U_EXPORT2 ures_getStringByIndexures_getStringByIndex_71(const UResourceBundle *resB, int32_t indexS, int32_t* len, UErrorCode *status) {
  const char* key = NULL__null;
  Resource r = RES_BOGUS0xffffffff;

  if (status==NULL__null || U_FAILURE(*status)) {
      return NULL__null;
  }
  if(resB == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }

  if(indexS >= 0 && resB->fSize > indexS) {
      switch(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL))) {
      case URES_STRING:
      case URES_STRING_V2:
          return res_getString({resB}, &resB->getResData(), resB->fRes, len);
      case URES_TABLE:
      case URES_TABLE16:
      case URES_TABLE32:
          r = res_getTableItemByIndexres_getTableItemByIndex_71(&resB->getResData(), resB->fRes, indexS, &key);
          if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
              /* TODO: do the fallback */
          }
          return ures_getStringWithAlias(resB, r, indexS, len, status);
      case URES_ARRAY:
      case URES_ARRAY16:
          r = res_getArrayItemres_getArrayItem_71(&resB->getResData(), resB->fRes, indexS);
          if(r == RES_BOGUS0xffffffff && resB->fHasFallback) {
              /* TODO: do the fallback */
          }
          return ures_getStringWithAlias(resB, r, indexS, len, status);
      case URES_ALIAS:
          return ures_getStringWithAlias(resB, resB->fRes, indexS, len, status);
      case URES_INT:
      case URES_BINARY:
      case URES_INT_VECTOR:
          *status = U_RESOURCE_TYPE_MISMATCH;
          break;
      default:
        /* must not occur */
        *status = U_INTERNAL_PROGRAM_ERROR;
        break;
      }
  } else {
      *status = U_MISSING_RESOURCE_ERROR;
  }
  return NULL__null;
1756}

1758U_CAPIextern "C" const char * U_EXPORT2
1759ures_getUTF8StringByIndexures_getUTF8StringByIndex_71(const UResourceBundle *resB,
                        int32_t idx,
                        char *dest, int32_t *pLength,
                        UBool forceCopy,
                        UErrorCode *status) {
  int32_t length16;
  const UChar *s16 = ures_getStringByIndexures_getStringByIndex_71(resB, idx, &length16, status);
  return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
1767}

1769/*U_CAPI const char *ures_getResPath(UResourceBundle *resB) {
return resB->fResPath;
1771}*/

1773U_CAPIextern "C" UResourceBundle* U_EXPORT2
1774ures_findResourceures_findResource_71(const char* path, UResourceBundle *fillIn, UErrorCode *status) 
1775{
UResourceBundle *first = NULL__null; 
UResourceBundle *result = fillIn;
char *packageName = NULL__null;
char *pathToResource = NULL__null, *save = NULL__null;
char *locale = NULL__null, *localeEnd = NULL__null;
int32_t length;

if(status == NULL__null || U_FAILURE(*status)) {
  return result;
}

length = (int32_t)(uprv_strlen(path):: strlen(path)+1);
save = pathToResource = (char *)uprv_mallocuprv_malloc_71(length*sizeof(char));
/* test for NULL */
if(pathToResource == NULL__null) {
  *status = U_MEMORY_ALLOCATION_ERROR;
  return result;
}
uprv_memcpy(pathToResource, path, length)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(pathToResource
, path, length); } while (false);

locale = pathToResource;
if(*pathToResource == RES_PATH_SEPARATOR'/') { /* there is a path specification */
  pathToResource++;
  packageName = pathToResource;
  pathToResource = uprv_strchr(pathToResource, RES_PATH_SEPARATOR):: strchr(pathToResource, '/');
  if(pathToResource == NULL__null) {
    *status = U_ILLEGAL_ARGUMENT_ERROR;
  } else {
    *pathToResource = 0;
    locale = pathToResource+1;
  }
}

localeEnd = uprv_strchr(locale, RES_PATH_SEPARATOR):: strchr(locale, '/');
if(localeEnd != NULL__null) {
  *localeEnd = 0;
}

first = ures_openures_open_71(packageName, locale, status);

if(U_SUCCESS(*status)) {
  if(localeEnd) {
    result = ures_findSubResourceures_findSubResource_71(first, localeEnd+1, fillIn, status);
  } else {
    result = ures_copyResbures_copyResb_71(fillIn, first, status);
  }
  ures_closeures_close_71(first);
}
uprv_freeuprv_free_71(save);
return result;
1826}

1828U_CAPIextern "C" UResourceBundle* U_EXPORT2
1829ures_findSubResourceures_findSubResource_71(const UResourceBundle *resB, char* path, UResourceBundle *fillIn, UErrorCode *status) 
1830{
Resource res = RES_BOGUS0xffffffff;
UResourceBundle *result = fillIn;
const char *key;

if(status == NULL__null || U_FAILURE(*status)) {
  return result;
}

/* here we do looping and circular alias checking */
/* this loop is here because aliasing is resolved on this level, not on res level */
/* so, when we encounter an alias, it is not an aggregate resource, so we return */
do {
  res = res_findResourceres_findResource_71(&resB->getResData(), resB->fRes, &path, &key); 
  if(res != RES_BOGUS0xffffffff) {
      result = init_resb_result(resB->fData, res, key, -1, resB, fillIn, status);
      resB = result;
  } else {
      *status = U_MISSING_RESOURCE_ERROR;
      break;
  }
} while(*path); /* there is more stuff in the path */

return result;
1854}
1855U_CAPIextern "C" const UChar* U_EXPORT2 
1856ures_getStringByKeyWithFallbackures_getStringByKeyWithFallback_71(const UResourceBundle *resB, 
                              const char* inKey, 
                              int32_t* len,
                              UErrorCode *status) {

  UResourceBundle stack;
  const UChar* retVal = NULL__null;
  ures_initStackObjectures_initStackObject_71(&stack);
  ures_getByKeyWithFallbackures_getByKeyWithFallback_71(resB, inKey, &stack, status);
  int32_t length;
  retVal = ures_getStringures_getString_71(&stack, &length, status);
  ures_closeures_close_71(&stack);
  if (U_FAILURE(*status)) {
      return NULL__null;
  }
  if (length == 3 && retVal[0] == EMPTY_SET0x2205 && retVal[1] == EMPTY_SET0x2205 && retVal[2] == EMPTY_SET0x2205 ) {
      retVal = NULL__null;
      length = 0;
      *status = U_MISSING_RESOURCE_ERROR;
  }
  if (len != NULL__null) {
      *len = length;
  }
  return retVal;
1880}

1882/*
Like res_getTableItemByKey but accepts full paths like "NumberElements/latn/patternsShort".
1884*/  
1885static Resource getTableItemByKeyPath(const ResourceData *pResData, Resource table, const char *key) {
Resource resource = table;  /* The current resource */
icu::CharString path;
UErrorCode errorCode = U_ZERO_ERROR;
path.append(key, errorCode);
if (U_FAILURE(errorCode)) { return RES_BOGUS0xffffffff; }
char *pathPart = path.data();  /* Path from current resource to desired resource */
UResType type = (UResType)RES_GET_TYPE(resource)((int32_t)((resource)>>28UL));  /* the current resource type */
while (*pathPart && resource != RES_BOGUS0xffffffff && URES_IS_CONTAINER(type)(((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16
 || (int32_t)(type)==URES_TABLE32) || ((int32_t)(type)==URES_ARRAY
 || (int32_t)(type)==URES_ARRAY16))) {
  char *nextPathPart = uprv_strchr(pathPart, RES_PATH_SEPARATOR):: strchr(pathPart, '/');
  if (nextPathPart != NULL__null) {
    *nextPathPart = 0;  /* Terminating null for this part of path. */
    nextPathPart++;
  } else {
    nextPathPart = uprv_strchr(pathPart, 0):: strchr(pathPart, 0);
  }
  int32_t t;
  const char *pathP = pathPart;
  resource = res_getTableItemByKeyres_getTableItemByKey_71(pResData, resource, &t, &pathP);
  type = (UResType)RES_GET_TYPE(resource)((int32_t)((resource)>>28UL));
  pathPart = nextPathPart; 
}
if (*pathPart) {
  return RES_BOGUS0xffffffff;
}
return resource;
1911}

1913static void createPath(const char* origResPath,
                     int32_t     origResPathLen,
                     const char* resPath,
                     int32_t     resPathLen,
                     const char* inKey,
                     CharString& path,
                     UErrorCode* status) {
  // This is a utility function used by ures_getByKeyWithFallback() below.  This function builds a path from
  // resPath and inKey, returning the result in `path`.  Originally, this function just cleared `path` and
  // appended resPath and inKey to it, but that caused problems for horizontal inheritance.
  //
  // In normal cases, resPath is the same as origResPath, but if ures_getByKeyWithFallback() has followed an
  // alias, resPath may be different from origResPath.  Not only may the existing path elements be different,
  // but resPath may also have MORE path elements than origResPath did.  If it does, those additional path
  // elements SUPERSEDE the corresponding elements of inKey.  So this code counts the number of elements in
  // resPath and origResPath and, for each path element in resPath that doesn't have a counterpart in origResPath,
  // deletes a path element from the beginning of inKey.  The remainder of inKey is then appended to
  // resPath to form the result.  (We're not using uprv_strchr() here because resPath and origResPath may
  // not be zero-terminated.)
  path.clear();
  const char* key = inKey;
  if (resPathLen > 0) {
      path.append(resPath, resPathLen, *status);
      if (U_SUCCESS(*status)) {
          const char* resPathLimit = resPath + resPathLen;
          const char* origResPathLimit = origResPath + origResPathLen;
          const char* resPathPtr = resPath;
          const char* origResPathPtr = origResPath;
          
          // Remove from the beginning of resPath the number of segments that are contained in origResPath.
          // If origResPath has MORE segments than resPath, this will leave resPath as the empty string.
          while (origResPathPtr < origResPathLimit && resPathPtr < resPathLimit) {
              while (origResPathPtr < origResPathLimit && *origResPathPtr != RES_PATH_SEPARATOR'/') {
                  ++origResPathPtr;
              }
              if (origResPathPtr < origResPathLimit && *origResPathPtr == RES_PATH_SEPARATOR'/') {
                  ++origResPathPtr;
              }
              while (resPathPtr < resPathLimit && *resPathPtr != RES_PATH_SEPARATOR'/') {
                  ++resPathPtr;
              }
              if (resPathPtr < resPathLimit && *resPathPtr == RES_PATH_SEPARATOR'/') {
                  ++resPathPtr;
              }
          }
          
          // New remove from the beginning of `key` the number of segments remaining in resPath.
          // If resPath has more segments than `key` does, `key` will end up empty.
          while (resPathPtr < resPathLimit && *key != '\0') {
              while (resPathPtr < resPathLimit && *resPathPtr != RES_PATH_SEPARATOR'/') {
                  ++resPathPtr;
              }
              if (resPathPtr < resPathLimit && *resPathPtr == RES_PATH_SEPARATOR'/') {
                  ++resPathPtr;
              }
              while (*key != '\0' && *key != RES_PATH_SEPARATOR'/') {
                  ++key;
              }
              if (*key == RES_PATH_SEPARATOR'/') {
                  ++key;
              }
          }
      }
      // Finally, append what's left of `key` to `path`.  What you end up with here is `resPath`, plus
      // any pieces of `key` that aren't superseded by `resPath`.
      // Or, to put it another way, calculate <#-segments-in-key> - (<#-segments-in-resPath> - <#-segments-in-origResPath>),
      // and append that many segments from the end of `key` to `resPath` to produce the result.
      path.append(key, *status);
  } else {
      path.append(inKey, *status);
  }
1984}

1986U_CAPIextern "C" UResourceBundle* U_EXPORT2
1987ures_getByKeyWithFallbackures_getByKeyWithFallback_71(const UResourceBundle *resB,
                        const char* inKey,
                        UResourceBundle *fillIn,
                        UErrorCode *status) {
  Resource res = RES_BOGUS0xffffffff, rootRes = RES_BOGUS0xffffffff;
  UResourceBundle *helper = NULL__null;

  if (status==NULL__null || U_FAILURE(*status)) {
      return fillIn;
  }
  if(resB == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return fillIn;
  }

  int32_t type = RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL));
  if(URES_IS_TABLE(type)((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16
 || (int32_t)(type)==URES_TABLE32)) {
      const char* origResPath = resB->fResPath;
      int32_t origResPathLen = resB->fResPathLen;
      res = getTableItemByKeyPath(&resB->getResData(), resB->fRes, inKey);
      const char* key = inKey;
      bool didRootOnce = false;
      if(res == RES_BOGUS0xffffffff) {
          UResourceDataEntry *dataEntry = resB->fData;
          CharString path;
          char *myPath = NULL__null;
          const char* resPath = resB->fResPath;
          int32_t len = resB->fResPathLen;
          while(res == RES_BOGUS0xffffffff && (dataEntry->fParent != NULL__null || !didRootOnce)) { /* Otherwise, we'll look in parents */
              if (dataEntry->fParent != NULL__null) {
                  dataEntry = dataEntry->fParent;
              } else {
                  // We can't just stop when we get to a bundle whose fParent is NULL.  That'll work most of the time,
                  // but if the bundle that the caller passed to us was "root" (which happens in getAllItemsWithFallback(),
                  // this function will drop right out without doing anything if "root" doesn't contain the exact key path
                  // specified.  In that case, we need one extra time through this loop to make sure we follow any
                  // applicable aliases at the root level.
                  didRootOnce = true;
              }
              rootRes = dataEntry->fData.rootRes;

              if(dataEntry->fBogus == U_ZERO_ERROR) {
                  createPath(origResPath, origResPathLen, resPath, len, inKey, path, status);
                  if (U_FAILURE(*status)) {
                      ures_closeures_close_71(helper);
                      return fillIn;
                  }
                  myPath = path.data();
                  key = inKey;
                  do {
                      res = res_findResourceres_findResource_71(&(dataEntry->fData), rootRes, &myPath, &key);
                      if (RES_GET_TYPE(res)((int32_t)((res)>>28UL)) == URES_ALIAS && *myPath) {
                          /* We hit an alias, but we didn't finish following the path. */
                          helper = init_resb_result(dataEntry, res, NULL__null, -1, resB, helper, status);
                          /*helper = init_resb_result(dataEntry, res, inKey, -1, resB, helper, status);*/
                          if(helper) {
                            dataEntry = helper->fData;
                            rootRes = helper->fRes;
                            resPath = helper->fResPath;
                            len = helper->fResPathLen;

                          } else {
                            break;
                          }
                      } else if (res == RES_BOGUS0xffffffff) {
                          break;
                      }
                  } while(*myPath); /* Continue until the whole path is consumed */
              }
          }
          /*dataEntry = getFallbackData(resB, &key, &res, status);*/
          if(res != RES_BOGUS0xffffffff) {
            /* check if resB->fResPath gives the right name here */
              if(uprv_strcmp(dataEntry->fName, uloc_getDefault()):: strcmp(dataEntry->fName, uloc_getDefault_71())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName):: strcmp(dataEntry->fName, "root")==0) {
                  *status = U_USING_DEFAULT_WARNING;
              } else {
                  *status = U_USING_FALLBACK_WARNING;
              }

              fillIn = init_resb_result(dataEntry, res, key, -1, resB, fillIn, status);
              if (resPath != nullptr) {
                  createPath(origResPath, origResPathLen, resPath, len, inKey, path, status);
              } else {
                  const char* separator = nullptr;
                  if (fillIn->fResPath != nullptr) {
                      separator = uprv_strchr(fillIn->fResPath, RES_PATH_SEPARATOR):: strchr(fillIn->fResPath, '/');
                  }
                  if (separator != nullptr && separator[1] != '\0') {
                      createPath(origResPath, origResPathLen, fillIn->fResPath,
                                 static_cast<int32_t>(uprv_strlen(fillIn->fResPath):: strlen(fillIn->fResPath)), inKey, path, status);
                  } else {
                      createPath(origResPath, origResPathLen, "", 0, inKey, path, status);
                  }
              }
              ures_freeResPath(fillIn);
              ures_appendResPath(fillIn, path.data(), path.length(), status);
              if(fillIn->fResPath[fillIn->fResPathLen-1] != RES_PATH_SEPARATOR'/') {
                  ures_appendResPath(fillIn, RES_PATH_SEPARATOR_S"/", 1, status);
              }
          } else {
              *status = U_MISSING_RESOURCE_ERROR;
          }
      } else {
          fillIn = init_resb_result(resB->fData, res, key, -1, resB, fillIn, status);
      }
  } 
  else {
      *status = U_RESOURCE_TYPE_MISMATCH;
  }
  ures_closeures_close_71(helper);
  return fillIn;
2098}

2100namespace {

2102void getAllItemsWithFallback(
      const UResourceBundle *bundle, ResourceDataValue &value,
      ResourceSink &sink, UErrorCode &errorCode) {
  if (U_FAILURE(errorCode)) { return; }
  // We recursively enumerate child-first,
  // only storing parent items in the absence of child items.
  // The sink needs to store a placeholder value for the no-fallback/no-inheritance marker
  // to prevent a parent item from being stored.
  //
  // It would be possible to recursively enumerate parent-first,
  // overriding parent items with child items.
  // When the sink sees the no-fallback/no-inheritance marker,
  // then it would remove the parent's item.
  // We would deserialize parent values even though they are overridden in a child bundle.
  value.setData(bundle->getResData());
  value.setValidLocaleDataEntry(bundle->fValidLocaleDataEntry);
  UResourceDataEntry *parentEntry = bundle->fData->fParent;
  UBool hasParent = parentEntry != NULL__null && U_SUCCESS(parentEntry->fBogus);
  value.setResource(bundle->fRes, ResourceTracer(bundle));
  sink.put(bundle->fKey, value, !hasParent, errorCode);
  if (hasParent) {
      // We might try to query the sink whether
      // any fallback from the parent bundle is still possible.

      // Turn the parent UResourceDataEntry into a UResourceBundle,
      // much like in ures_openWithType().
      // TODO: See if we can refactor ures_getByKeyWithFallback()
      // and pull out an inner function that takes and returns a UResourceDataEntry
      // so that we need not create UResourceBundle objects.
      StackUResourceBundle parentBundle;
      UResourceBundle &parentRef = parentBundle.ref();
      parentRef.fData = parentEntry;
      parentRef.fValidLocaleDataEntry = bundle->fValidLocaleDataEntry;
      parentRef.fHasFallback = !parentRef.getResData().noFallback;
      parentRef.fIsTopLevel = TRUE1;
      parentRef.fRes = parentRef.getResData().rootRes;
      parentRef.fSize = res_countArrayItemsres_countArrayItems_71(&parentRef.getResData(), parentRef.fRes);
      parentRef.fIndex = -1;
      entryIncrease(parentEntry);

      // Look up the container item in the parent bundle.
      StackUResourceBundle containerBundle;
      const UResourceBundle *rb;
      UErrorCode pathErrorCode = U_ZERO_ERROR;  // Ignore if parents up to root do not have this path.
      if (bundle->fResPath == NULL__null || *bundle->fResPath == 0) {
          rb = parentBundle.getAlias();
      } else {
          rb = ures_getByKeyWithFallbackures_getByKeyWithFallback_71(parentBundle.getAlias(), bundle->fResPath,
                                         containerBundle.getAlias(), &pathErrorCode);
      }
      if (U_SUCCESS(pathErrorCode)) {
          getAllItemsWithFallback(rb, value, sink, errorCode);
      }
  }
2156}

2158struct GetAllChildrenSink : public ResourceSink {
  // Destination sink
  ResourceSink& dest;

  GetAllChildrenSink(ResourceSink& dest)
      : dest(dest) {}
  virtual ~GetAllChildrenSink() override;
  virtual void put(const char *key, ResourceValue &value, UBool isRoot,
         UErrorCode &errorCode) override {
      ResourceTable itemsTable = value.getTable(errorCode);
      if (U_FAILURE(errorCode)) { return; }
      for (int32_t i = 0; itemsTable.getKeyAndValue(i, key, value); ++i) {
          if (value.getType() == URES_ALIAS) {
              ResourceDataValue& rdv = static_cast<ResourceDataValue&>(value);
              StackUResourceBundle stackTempBundle;
              UResourceBundle* aliasRB = getAliasTargetAsResourceBundle(rdv.getData(), rdv.getResource(), nullptr, -1,
                                                                        rdv.getValidLocaleDataEntry(), nullptr, 0,
                                                                        stackTempBundle.getAlias(), &errorCode);
              if (U_SUCCESS(errorCode)) {
                  ResourceDataValue aliasedValue;
                  aliasedValue.setData(aliasRB->getResData());
                  aliasedValue.setValidLocaleDataEntry(aliasRB->fValidLocaleDataEntry);
                  aliasedValue.setResource(aliasRB->fRes, ResourceTracer(aliasRB));
                  dest.put(key, aliasedValue, isRoot, errorCode);
              }
          } else {
              dest.put(key, value, isRoot, errorCode);
          }
          if (U_FAILURE(errorCode)) { return; }
      }
  }
2189};

2191// Virtual destructors must be defined out of line.
2192GetAllChildrenSink::~GetAllChildrenSink() {}

2194U_CAPIextern "C" void U_EXPORT2
2195ures_getAllChildrenWithFallbackures_getAllChildrenWithFallback_71(const UResourceBundle *bundle, const char *path,
                              icu::ResourceSink &sink, UErrorCode &errorCode) {
  GetAllChildrenSink allChildrenSink(sink);
  ures_getAllItemsWithFallbackures_getAllItemsWithFallback_71(bundle, path, allChildrenSink, errorCode);
2199}

2201}  // namespace

2203// Requires a ResourceDataValue fill-in, so that we need not cast from a ResourceValue.
2204// Unfortunately, the caller must know which subclass to make and pass in.
2205// Alternatively, we could make it as polymorphic as in Java by
2206// returning a ResourceValue pointer (possibly wrapped into a LocalPointer)
2207// that the caller then owns.
2208//
2209// Also requires a UResourceBundle fill-in, so that the value's ResourceTracer
2210// can point to a non-local bundle.
2211// Without tracing, the child bundle could be a function-local object.
2212U_CAPIextern "C" void U_EXPORT2
2213ures_getValueWithFallbackures_getValueWithFallback_71(const UResourceBundle *bundle, const char *path,
                        UResourceBundle *tempFillIn,
                        ResourceDataValue &value, UErrorCode &errorCode) {
  if (U_FAILURE(errorCode)) { return; }
  if (path == nullptr) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  const UResourceBundle *rb;
  if (*path == 0) {
      // empty path
      rb = bundle;
  } else {
      rb = ures_getByKeyWithFallbackures_getByKeyWithFallback_71(bundle, path, tempFillIn, &errorCode);
      if (U_FAILURE(errorCode)) {
          return;
      }
  }
  value.setData(rb->getResData());
  value.setValidLocaleDataEntry(rb->fValidLocaleDataEntry);
  value.setResource(rb->fRes, ResourceTracer(rb));
2234}

2236U_CAPIextern "C" void U_EXPORT2
2237ures_getAllItemsWithFallbackures_getAllItemsWithFallback_71(const UResourceBundle *bundle, const char *path,
                           icu::ResourceSink &sink, UErrorCode &errorCode) {
  if (U_FAILURE(errorCode)) { return; }
  if (path == nullptr) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  StackUResourceBundle stackBundle;
  const UResourceBundle *rb;
  if (*path == 0) {
      // empty path
      rb = bundle;
  } else {
      rb = ures_getByKeyWithFallbackures_getByKeyWithFallback_71(bundle, path, stackBundle.getAlias(), &errorCode);
      if (U_FAILURE(errorCode)) {
          return;
      }
  }
  // Get all table items with fallback.
  ResourceDataValue value;
  getAllItemsWithFallback(rb, value, sink, errorCode);
2258}

2260U_CAPIextern "C" UResourceBundle* U_EXPORT2 ures_getByKeyures_getByKey_71(const UResourceBundle *resB, const char* inKey, UResourceBundle *fillIn, UErrorCode *status) {
  Resource res = RES_BOGUS0xffffffff;
  UResourceDataEntry *dataEntry = NULL__null;
  const char *key = inKey;

  if (status==NULL__null || U_FAILURE(*status)) {
      return fillIn;
  }
  if(resB == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return fillIn;
  }

  int32_t type = RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL));
  if(URES_IS_TABLE(type)((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16
 || (int32_t)(type)==URES_TABLE32)) {
      int32_t t;
      res = res_getTableItemByKeyres_getTableItemByKey_71(&resB->getResData(), resB->fRes, &t, &key);
      if(res == RES_BOGUS0xffffffff) {
          key = inKey;
          if(resB->fHasFallback == TRUE1) {
              dataEntry = getFallbackData(resB, &key, &res, status);
              if(U_SUCCESS(*status)) {
                  /* check if resB->fResPath gives the right name here */
                  return init_resb_result(dataEntry, res, key, -1, resB, fillIn, status);
              } else {
                  *status = U_MISSING_RESOURCE_ERROR;
              }
          } else {
              *status = U_MISSING_RESOURCE_ERROR;
          }
      } else {
          return init_resb_result(resB->fData, res, key, -1, resB, fillIn, status);
      }
  } 
2294#if 0
  /* this is a kind of TODO item. If we have an array with an index table, we could do this. */
  /* not currently */
  else if(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL)) == URES_ARRAY && resB->fHasFallback == TRUE1) {
      /* here should go a first attempt to locate the key using index table */
      dataEntry = getFallbackData(resB, &key, &res, status);
      if(U_SUCCESS(*status)) {
          return init_resb_result(dataEntry, res, key, resB, fillIn, status);
      } else {
          *status = U_MISSING_RESOURCE_ERROR;
      }
  }
2306#endif    
  else {
      *status = U_RESOURCE_TYPE_MISMATCH;
  }
  return fillIn;
2311}

2313U_CAPIextern "C" const UChar* U_EXPORT2 ures_getStringByKeyures_getStringByKey_71(const UResourceBundle *resB, const char* inKey, int32_t* len, UErrorCode *status) {
  Resource res = RES_BOGUS0xffffffff;
  UResourceDataEntry *dataEntry = NULL__null;
  const char* key = inKey;

  if (status==NULL__null || U_FAILURE(*status)) {
3
←
Assuming 'status' is equal to NULL→
      return NULL__null;
4
←
Returning without writing to '*len'→
  }
  if(resB == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }

  int32_t type = RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL));
  if(URES_IS_TABLE(type)((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16
 || (int32_t)(type)==URES_TABLE32)) {
      int32_t t=0;

      res = res_getTableItemByKeyres_getTableItemByKey_71(&resB->getResData(), resB->fRes, &t, &key);

      if(res == RES_BOGUS0xffffffff) {
          key = inKey;
          if(resB->fHasFallback == TRUE1) {
              dataEntry = getFallbackData(resB, &key, &res, status);
              if(U_SUCCESS(*status)) {
                  switch (RES_GET_TYPE(res)((int32_t)((res)>>28UL))) {
                  case URES_STRING:
                  case URES_STRING_V2:
                      return res_getString({resB, key}, &dataEntry->fData, res, len);
                  case URES_ALIAS:
                    {
                      const UChar* result = 0;
                      UResourceBundle *tempRes = ures_getByKeyures_getByKey_71(resB, inKey, NULL__null, status);
                      result = ures_getStringures_getString_71(tempRes, len, status);
                      ures_closeures_close_71(tempRes);
                      return result;
                    }
                  default:
                      *status = U_RESOURCE_TYPE_MISMATCH;
                  }
              } else {
                  *status = U_MISSING_RESOURCE_ERROR;
              }
          } else {
              *status = U_MISSING_RESOURCE_ERROR;
          }
      } else {
          switch (RES_GET_TYPE(res)((int32_t)((res)>>28UL))) {
          case URES_STRING:
          case URES_STRING_V2:
              return res_getString({resB, key}, &resB->getResData(), res, len);
          case URES_ALIAS:
            {
              const UChar* result = 0;
              UResourceBundle *tempRes = ures_getByKeyures_getByKey_71(resB, inKey, NULL__null, status);
              result = ures_getStringures_getString_71(tempRes, len, status);
              ures_closeures_close_71(tempRes);
              return result;
            }
          default:
              *status = U_RESOURCE_TYPE_MISMATCH;
          }
      }
  } 
2376#if 0 
  /* this is a kind of TODO item. If we have an array with an index table, we could do this. */
  /* not currently */   
  else if(RES_GET_TYPE(resB->fRes)((int32_t)((resB->fRes)>>28UL)) == URES_ARRAY && resB->fHasFallback == TRUE1) {
      /* here should go a first attempt to locate the key using index table */
      dataEntry = getFallbackData(resB, &key, &res, status);
      if(U_SUCCESS(*status)) {
          // TODO: Tracing
          return res_getString(rd, res, len);
      } else {
          *status = U_MISSING_RESOURCE_ERROR;
      }
  } 
2389#endif    
  else {
      *status = U_RESOURCE_TYPE_MISMATCH;
  }
  return NULL__null;
2394}

2396U_CAPIextern "C" const char * U_EXPORT2
2397ures_getUTF8StringByKeyures_getUTF8StringByKey_71(const UResourceBundle *resB,
                      const char *key,
                      char *dest, int32_t *pLength,
                      UBool forceCopy,
                      UErrorCode *status) {
  int32_t length16;
1
'length16' declared without an initial value→
  const UChar *s16 = ures_getStringByKeyures_getStringByKey_71(resB, key, &length16, status);
2
←
Calling 'ures_getStringByKey_71'→
5
←
Returning from 'ures_getStringByKey_71'→
  return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
6
←
2nd function call argument is an uninitialized value
2405}

2407/* TODO: clean from here down */

2409/**
*  INTERNAL: Get the name of the first real locale (not placeholder) 
*  that has resource bundle data.
*/
2413U_CAPIextern "C" const char*  U_EXPORT2
2414ures_getLocaleInternalures_getLocaleInternal_71(const UResourceBundle* resourceBundle, UErrorCode* status)
2415{
  if (status==NULL__null || U_FAILURE(*status)) {
      return NULL__null;
  }
  if (!resourceBundle) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  } else {
    return resourceBundle->fData->fName;
  }
2425}

2427U_CAPIextern "C" const char* U_EXPORT2 
2428ures_getLocaleures_getLocale_71(const UResourceBundle* resourceBundle, 
             UErrorCode* status)
2430{
return ures_getLocaleInternalures_getLocaleInternal_71(resourceBundle, status);
2432}


2435U_CAPIextern "C" const char* U_EXPORT2 
2436ures_getLocaleByTypeures_getLocaleByType_71(const UResourceBundle* resourceBundle, 
                   ULocDataLocaleType type, 
                   UErrorCode* status) {
  if (status==NULL__null || U_FAILURE(*status)) {
      return NULL__null;
  }
  if (!resourceBundle) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  } else {
      switch(type) {
      case ULOC_ACTUAL_LOCALE:
          return resourceBundle->fData->fName;
      case ULOC_VALID_LOCALE:
          return resourceBundle->fValidLocaleDataEntry->fName;
      case ULOC_REQUESTED_LOCALE:
      default:
          *status = U_ILLEGAL_ARGUMENT_ERROR;
          return NULL__null;
      }
  }
2457}

2459U_CFUNCextern "C" const char* ures_getNameures_getName_71(const UResourceBundle* resB) {
if(resB == NULL__null) {
  return NULL__null;
}

return resB->fData->fName;
2465}

2467#ifdef URES_DEBUG
2468U_CFUNCextern "C" const char* ures_getPath(const UResourceBundle* resB) {
if(resB == NULL__null) {
  return NULL__null;
}

return resB->fData->fPath;
2474}
2475#endif

2477static UResourceBundle*
2478ures_openWithType(UResourceBundle *r, const char* path, const char* localeID,
                UResOpenType openType, UErrorCode* status) {
  if(U_FAILURE(*status)) {
      return NULL__null;
  }

  UResourceDataEntry *entry;
  if(openType != URES_OPEN_DIRECT) {
      /* first "canonicalize" the locale ID */
      char canonLocaleID[ULOC_FULLNAME_CAPACITY157];
      uloc_getBaseNameuloc_getBaseName_71(localeID, canonLocaleID, UPRV_LENGTHOF(canonLocaleID)(int32_t)(sizeof(canonLocaleID)/sizeof((canonLocaleID)[0])), status);
      if(U_FAILURE(*status) || *status == U_STRING_NOT_TERMINATED_WARNING) {
          *status = U_ILLEGAL_ARGUMENT_ERROR;
          return NULL__null;
      }
      entry = entryOpen(path, canonLocaleID, openType, status);
  } else {
      entry = entryOpenDirect(path, localeID, status);
  }
  if(U_FAILURE(*status)) {
      return NULL__null;
  }
  if(entry == NULL__null) {
      *status = U_MISSING_RESOURCE_ERROR;
      return NULL__null;
  }

  UBool isStackObject;
  if(r == NULL__null) {
      r = (UResourceBundle *)uprv_mallocuprv_malloc_71(sizeof(UResourceBundle));
      if(r == NULL__null) {
          entryClose(entry);
          *status = U_MEMORY_ALLOCATION_ERROR;
          return NULL__null;
      }
      isStackObject = FALSE0;
  } else {  // fill-in
      isStackObject = ures_isStackObject(r);
      ures_closeBundle(r, FALSE0);
  }
  uprv_memset(r, 0, sizeof(UResourceBundle)):: memset(r, 0, sizeof(UResourceBundle));
  ures_setIsStackObject(r, isStackObject);

  r->fValidLocaleDataEntry = r->fData = entry;
  r->fHasFallback = openType != URES_OPEN_DIRECT && !r->getResData().noFallback;
  r->fIsTopLevel = TRUE1;
  r->fRes = r->getResData().rootRes;
  r->fSize = res_countArrayItemsres_countArrayItems_71(&r->getResData(), r->fRes);
  r->fIndex = -1;

  ResourceTracer(r).traceOpen();

  return r;
2531}

2533U_CAPIextern "C" UResourceBundle* U_EXPORT2
2534ures_openures_open_71(const char* path, const char* localeID, UErrorCode* status) {
  return ures_openWithType(NULL__null, path, localeID, URES_OPEN_LOCALE_DEFAULT_ROOT, status);
2536}

2538U_CAPIextern "C" UResourceBundle* U_EXPORT2
2539ures_openNoDefaultures_openNoDefault_71(const char* path, const char* localeID, UErrorCode* status) {
  return ures_openWithType(NULL__null, path, localeID, URES_OPEN_LOCALE_ROOT, status);
2541}

2543/**
*  Opens a resource bundle without "canonicalizing" the locale name. No fallback will be performed 
*  or sought. However, alias substitution will happen!
*/
2547U_CAPIextern "C" UResourceBundle*  U_EXPORT2
2548ures_openDirectures_openDirect_71(const char* path, const char* localeID, UErrorCode* status) {
  return ures_openWithType(NULL__null, path, localeID, URES_OPEN_DIRECT, status);
2550}

2552/**
*  Internal API: This function is used to open a resource bundle 
*  proper fallback chaining is executed while initialization. 
*  The result is stored in cache for later fallback search.
* 
* Same as ures_open(), but uses the fill-in parameter and does not allocate a new bundle.
*/
2559U_CAPIextern "C" void U_EXPORT2
2560ures_openFillInures_openFillIn_71(UResourceBundle *r, const char* path,
              const char* localeID, UErrorCode* status) {
  if(U_SUCCESS(*status) && r == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  ures_openWithType(r, path, localeID, URES_OPEN_LOCALE_DEFAULT_ROOT, status);
2567}

2569/**
* Same as ures_openDirect(), but uses the fill-in parameter and does not allocate a new bundle.
*/
2572U_CAPIextern "C" void U_EXPORT2
2573ures_openDirectFillInures_openDirectFillIn_71(UResourceBundle *r, const char* path, const char* localeID, UErrorCode* status) {
  if(U_SUCCESS(*status) && r == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  ures_openWithType(r, path, localeID, URES_OPEN_DIRECT, status);
2579}

2581/**
*  API: Counts members. For arrays and tables, returns number of resources.
*  For strings, returns 1.
*/
2585U_CAPIextern "C" int32_t  U_EXPORT2
2586ures_countArrayItemsures_countArrayItems_71(const UResourceBundle* resourceBundle,
                const char* resourceKey,
                UErrorCode* status)
2589{
  UResourceBundle resData;
  ures_initStackObjectures_initStackObject_71(&resData);
  if (status==NULL__null || U_FAILURE(*status)) {
      return 0;
  }
  if(resourceBundle == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  ures_getByKeyures_getByKey_71(resourceBundle, resourceKey, &resData, status);
  
  if(resData.getResData().data != NULL__null) {
      int32_t result = res_countArrayItemsres_countArrayItems_71(&resData.getResData(), resData.fRes);
      ures_closeures_close_71(&resData);
      return result;
  } else {
      *status = U_MISSING_RESOURCE_ERROR;
      ures_closeures_close_71(&resData);
      return 0;
  }
2610}

2612/**
* Internal function.
* Return the version number associated with this ResourceBundle as a string.
*
* @param resourceBundle The resource bundle for which the version is checked.
* @return  A version number string as specified in the resource bundle or its parent.
*          The caller does not own this string.
* @see ures_getVersion
* @internal
*/
2622U_CAPIextern "C" const char* U_EXPORT2 
2623ures_getVersionNumberInternalures_getVersionNumberInternal_71(const UResourceBundle *resourceBundle)
2624{
  if (!resourceBundle) return NULL__null;

  if(resourceBundle->fVersion == NULL__null) {

      /* If the version ID has not been built yet, then do so.  Retrieve */
      /* the minor version from the file. */
      UErrorCode status = U_ZERO_ERROR;
      int32_t minor_len = 0;
      int32_t len;

      const UChar* minor_version = ures_getStringByKeyures_getStringByKey_71(resourceBundle, kVersionTag"Version", &minor_len, &status);
      
      /* Determine the length of of the final version string.  This is */
      /* the length of the major part + the length of the separator */
      /* (==1) + the length of the minor part (+ 1 for the zero byte at */
      /* the end). */

      len = (minor_len > 0) ? minor_len : 1;
  
      /* Allocate the string, and build it up. */
      /* + 1 for zero byte */


      ((UResourceBundle *)resourceBundle)->fVersion = (char *)uprv_mallocuprv_malloc_71(1 + len); 
      /* Check for null pointer. */
      if (((UResourceBundle *)resourceBundle)->fVersion == NULL__null) {
          return NULL__null;
      }
     
      if(minor_len > 0) {
          u_UCharsToCharsu_UCharsToChars_71(minor_version, resourceBundle->fVersion , minor_len);
          resourceBundle->fVersion[len] =  '\0';
      }
      else {
          uprv_strcpy(resourceBundle->fVersion, kDefaultMinorVersion):: strcpy(resourceBundle->fVersion, "0");
      }
  }

  return resourceBundle->fVersion;
2664}

2666U_CAPIextern "C" const char*  U_EXPORT2
2667ures_getVersionNumberures_getVersionNumber_71(const UResourceBundle*   resourceBundle)
2668{
  return ures_getVersionNumberInternalures_getVersionNumberInternal_71(resourceBundle);
2670}

2672U_CAPIextern "C" void U_EXPORT2 ures_getVersionures_getVersion_71(const UResourceBundle* resB, UVersionInfo versionInfo) {
  if (!resB) return;

  u_versionFromStringu_versionFromString_71(versionInfo, ures_getVersionNumberInternalures_getVersionNumberInternal_71(resB));
2676}

2678/** Tree support functions *******************************/
2679#define INDEX_LOCALE_NAME"res_index" "res_index"
2680#define INDEX_TAG"InstalledLocales"         "InstalledLocales"
2681#define DEFAULT_TAG"default"       "default"

2683#if defined(URES_TREE_DEBUG)
2684#include <stdio.h>
2685#endif

2687typedef struct ULocalesContext {
  UResourceBundle installed;
  UResourceBundle curr;
2690} ULocalesContext;

2692static void U_CALLCONV
2693ures_loc_closeLocales(UEnumeration *enumerator) {
  ULocalesContext *ctx = (ULocalesContext *)enumerator->context;
  ures_closeures_close_71(&ctx->curr);
  ures_closeures_close_71(&ctx->installed);
  uprv_freeuprv_free_71(ctx);
  uprv_freeuprv_free_71(enumerator);
2699}

2701static int32_t U_CALLCONV
2702ures_loc_countLocales(UEnumeration *en, UErrorCode * /*status*/) {
  ULocalesContext *ctx = (ULocalesContext *)en->context;
  return ures_getSizeures_getSize_71(&ctx->installed);
2705}

2707U_CDECL_BEGINextern "C" {


2710static const char * U_CALLCONV
2711ures_loc_nextLocale(UEnumeration* en,
                  int32_t* resultLength,
                  UErrorCode* status) {
  ULocalesContext *ctx = (ULocalesContext *)en->context;
  UResourceBundle *res = &(ctx->installed);
  UResourceBundle *k = NULL__null;
  const char *result = NULL__null;
  int32_t len = 0;
  if(ures_hasNextures_hasNext_71(res) && (k = ures_getNextResourceures_getNextResource_71(res, &ctx->curr, status)) != 0) {
      result = ures_getKeyures_getKey_71(k);
      len = (int32_t)uprv_strlen(result):: strlen(result);
  }
  if (resultLength) {
      *resultLength = len;
  }
  return result;
2727}

2729static void U_CALLCONV 
2730ures_loc_resetLocales(UEnumeration* en, 
                    UErrorCode* /*status*/) {
  UResourceBundle *res = &((ULocalesContext *)en->context)->installed;
  ures_resetIteratorures_resetIterator_71(res);
2734}

2736U_CDECL_END}

2738static const UEnumeration gLocalesEnum = {
  NULL__null,
      NULL__null,
      ures_loc_closeLocales,
      ures_loc_countLocales,
      uenum_unextDefaultuenum_unextDefault_71,
      ures_loc_nextLocale,
      ures_loc_resetLocales
2746};


2749U_CAPIextern "C" UEnumeration* U_EXPORT2
2750ures_openAvailableLocalesures_openAvailableLocales_71(const char *path, UErrorCode *status)
2751{
  UResourceBundle *idx = NULL__null;
  UEnumeration *en = NULL__null;
  ULocalesContext *myContext = NULL__null;

  if(U_FAILURE(*status)) {
      return NULL__null;
  }
  myContext = static_cast<ULocalesContext *>(uprv_mallocuprv_malloc_71(sizeof(ULocalesContext)));
  en =  (UEnumeration *)uprv_mallocuprv_malloc_71(sizeof(UEnumeration));
  if(!en || !myContext) {
      *status = U_MEMORY_ALLOCATION_ERROR;
      uprv_freeuprv_free_71(en);
      uprv_freeuprv_free_71(myContext);
      return NULL__null;
  }
  uprv_memcpy(en, &gLocalesEnum, sizeof(UEnumeration))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(en, &
gLocalesEnum, sizeof(UEnumeration)); } while (false);

  ures_initStackObjectures_initStackObject_71(&myContext->installed);
  ures_initStackObjectures_initStackObject_71(&myContext->curr);
  idx = ures_openDirectures_openDirect_71(path, INDEX_LOCALE_NAME"res_index", status);
  ures_getByKeyures_getByKey_71(idx, INDEX_TAG"InstalledLocales", &myContext->installed, status);
  if(U_SUCCESS(*status)) {
2774#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "Got %s::%s::[%s] : %s\n", 
          path, INDEX_LOCALE_NAME"res_index", INDEX_TAG"InstalledLocales", ures_getKeyures_getKey_71(&myContext->installed));
2777#endif
      en->context = myContext;
  } else {
2780#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "%s open failed - %s\n", path, u_errorNameu_errorName_71(*status));
2782#endif
      ures_closeures_close_71(&myContext->installed);
      uprv_freeuprv_free_71(myContext);
      uprv_freeuprv_free_71(en);
      en = NULL__null;
  }
  
  ures_closeures_close_71(idx);
  
  return en;
2792}

2794static UBool isLocaleInList(UEnumeration *locEnum, const char *locToSearch, UErrorCode *status) {
  const char *loc;
  while ((loc = uenum_nextuenum_next_71(locEnum, NULL__null, status)) != NULL__null) {
      if (uprv_strcmp(loc, locToSearch):: strcmp(loc, locToSearch) == 0) {
          return TRUE1;
      }
  }
  return FALSE0;
2802}

2804U_CAPIextern "C" int32_t U_EXPORT2
2805ures_getFunctionalEquivalentures_getFunctionalEquivalent_71(char *result, int32_t resultCapacity,
                           const char *path, const char *resName, const char *keyword, const char *locid,
                           UBool *isAvailable, UBool omitDefault, UErrorCode *status)
2808{
  char kwVal[1024] = ""; /* value of keyword 'keyword' */
  char defVal[1024] = ""; /* default value for given locale */
  char defLoc[1024] = ""; /* default value for given locale */
  char base[1024] = ""; /* base locale */
  char found[1024] = "";
  char parent[1024] = "";
  char full[1024] = "";
  UResourceBundle bund1, bund2;
  UResourceBundle *res = NULL__null;
  UErrorCode subStatus = U_ZERO_ERROR;
  int32_t length = 0;
  if(U_FAILURE(*status)) return 0;
  uloc_getKeywordValueuloc_getKeywordValue_71(locid, keyword, kwVal, 1024-1,&subStatus);
  if(!uprv_strcmp(kwVal, DEFAULT_TAG):: strcmp(kwVal, "default")) {
      kwVal[0]=0;
  }
  uloc_getBaseNameuloc_getBaseName_71(locid, base, 1024-1,&subStatus);
2826#if defined(URES_TREE_DEBUG)
  fprintf(stderrstderr, "getFunctionalEquivalent: \"%s\" [%s=%s] in %s - %s\n", 
          locid, keyword, kwVal, base, u_errorNameu_errorName_71(subStatus));
2829#endif
  ures_initStackObjectures_initStackObject_71(&bund1);
  ures_initStackObjectures_initStackObject_71(&bund2);
  
  
  uprv_strcpy(parent, base):: strcpy(parent, base);
  uprv_strcpy(found, base):: strcpy(found, base);

  if(isAvailable) { 
      UEnumeration *locEnum = ures_openAvailableLocalesures_openAvailableLocales_71(path, &subStatus);
      *isAvailable = TRUE1;
      if (U_SUCCESS(subStatus)) {
          *isAvailable = isLocaleInList(locEnum, parent, &subStatus);
      }
      uenum_closeuenum_close_71(locEnum);
  }

  if(U_FAILURE(subStatus)) {
      *status = subStatus;
      return 0;
  }
  
  do {
      subStatus = U_ZERO_ERROR;
      res = ures_openures_open_71(path, parent, &subStatus);
      if(((subStatus == U_USING_FALLBACK_WARNING) ||
          (subStatus == U_USING_DEFAULT_WARNING)) && isAvailable)
      {
          *isAvailable = FALSE0;
      }
      isAvailable = NULL__null; /* only want to set this the first time around */
      
2861#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "%s;%s -> %s [%s]\n", path?path:"ICUDATA", parent, u_errorNameu_errorName_71(subStatus), ures_getLocaleures_getLocale_71(res, &subStatus));
2863#endif
      if(U_FAILURE(subStatus)) {
          *status = subStatus;
      } else if(subStatus == U_ZERO_ERROR) {
          ures_getByKeyures_getByKey_71(res,resName,&bund1, &subStatus);
          if(subStatus == U_ZERO_ERROR) {
              const UChar *defUstr;
              int32_t defLen;
              /* look for default item */
2872#if defined(URES_TREE_DEBUG)
              fprintf(stderrstderr, "%s;%s : loaded default -> %s\n",
                  path?path:"ICUDATA", parent, u_errorNameu_errorName_71(subStatus));
2875#endif
              defUstr = ures_getStringByKeyures_getStringByKey_71(&bund1, DEFAULT_TAG"default", &defLen, &subStatus);
              if(U_SUCCESS(subStatus) && defLen) {
                  u_UCharsToCharsu_UCharsToChars_71(defUstr, defVal, u_strlenu_strlen_71(defUstr));
2879#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "%s;%s -> default %s=%s,  %s\n", 
                      path?path:"ICUDATA", parent, keyword, defVal, u_errorNameu_errorName_71(subStatus));
2882#endif
                  uprv_strcpy(defLoc, parent):: strcpy(defLoc, parent);
                  if(kwVal[0]==0) {
                      uprv_strcpy(kwVal, defVal):: strcpy(kwVal, defVal);
2886#if defined(URES_TREE_DEBUG)
                      fprintf(stderrstderr, "%s;%s -> kwVal =  %s\n", 
                          path?path:"ICUDATA", parent, keyword, kwVal);
2889#endif
                  }
              }
          }
      }
      
      subStatus = U_ZERO_ERROR;

      if (res != NULL__null) {
          uprv_strcpy(found, ures_getLocaleByType(res, ULOC_VALID_LOCALE, &subStatus)):: strcpy(found, ures_getLocaleByType_71(res, ULOC_VALID_LOCALE
, &subStatus));
      }

      uloc_getParentuloc_getParent_71(found,parent,sizeof(parent),&subStatus);
      ures_closeures_close_71(res);
  } while(!defVal[0] && *found && uprv_strcmp(found, "root"):: strcmp(found, "root") != 0 && U_SUCCESS(*status));
  
  /* Now, see if we can find the kwVal collator.. start the search over.. */
  uprv_strcpy(parent, base):: strcpy(parent, base);
  uprv_strcpy(found, base):: strcpy(found, base);
  
  do {
      subStatus = U_ZERO_ERROR;
      res = ures_openures_open_71(path, parent, &subStatus);
      if((subStatus == U_USING_FALLBACK_WARNING) && isAvailable) {
          *isAvailable = FALSE0;
      }
      isAvailable = NULL__null; /* only want to set this the first time around */
      
2917#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "%s;%s -> %s (looking for %s)\n", 
          path?path:"ICUDATA", parent, u_errorNameu_errorName_71(subStatus), kwVal);
2920#endif
      if(U_FAILURE(subStatus)) {
          *status = subStatus;
      } else if(subStatus == U_ZERO_ERROR) {
          ures_getByKeyures_getByKey_71(res,resName,&bund1, &subStatus);
2925#if defined(URES_TREE_DEBUG)
2926/**/ fprintf(stderrstderr,"@%d [%s] %s\n", __LINE__2926, resName, u_errorNameu_errorName_71(subStatus));
2927#endif
          if(subStatus == U_ZERO_ERROR) {
              ures_getByKeyures_getByKey_71(&bund1, kwVal, &bund2, &subStatus);
2930#if defined(URES_TREE_DEBUG)
2931/**/ fprintf(stderrstderr,"@%d [%s] %s\n", __LINE__2931, kwVal, u_errorNameu_errorName_71(subStatus));
2932#endif
              if(subStatus == U_ZERO_ERROR) {
2934#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "%s;%s -> full0 %s=%s,  %s\n", 
                      path?path:"ICUDATA", parent, keyword, kwVal, u_errorNameu_errorName_71(subStatus));
2937#endif
                  uprv_strcpy(full, parent):: strcpy(full, parent);
                  if(*full == 0) {
                      uprv_strcpy(full, "root"):: strcpy(full, "root");
                  }
                      /* now, recalculate default kw if need be */
                      if(uprv_strlen(defLoc):: strlen(defLoc) > uprv_strlen(full):: strlen(full)) {
                        const UChar *defUstr;
                        int32_t defLen;
                        /* look for default item */
2947#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> recalculating Default0\n", 
                                  path?path:"ICUDATA", full);
2950#endif
                        defUstr = ures_getStringByKeyures_getStringByKey_71(&bund1, DEFAULT_TAG"default", &defLen, &subStatus);
                        if(U_SUCCESS(subStatus) && defLen) {
                          u_UCharsToCharsu_UCharsToChars_71(defUstr, defVal, u_strlenu_strlen_71(defUstr));
2954#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> default0 %s=%s,  %s\n", 
                                  path?path:"ICUDATA", full, keyword, defVal, u_errorNameu_errorName_71(subStatus));
2957#endif
                          uprv_strcpy(defLoc, full):: strcpy(defLoc, full);
                        }
                      } /* end of recalculate default KW */
2961#if defined(URES_TREE_DEBUG)
                      else {
                        fprintf(stderrstderr, "No trim0,  %s <= %s\n", defLoc, full);
                      }
2965#endif
              } else {
2967#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "err=%s in %s looking for %s\n", 
                      u_errorNameu_errorName_71(subStatus), parent, kwVal);
2970#endif
              }
          }
      }
      
      subStatus = U_ZERO_ERROR;
      
      uprv_strcpy(found, parent):: strcpy(found, parent);
      uloc_getParentuloc_getParent_71(found,parent,1023,&subStatus);
      ures_closeures_close_71(res);
  } while(!full[0] && *found && U_SUCCESS(*status));
  
  if((full[0]==0) && uprv_strcmp(kwVal, defVal):: strcmp(kwVal, defVal)) {
2983#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "Failed to locate kw %s - try default %s\n", kwVal, defVal);
2985#endif
      uprv_strcpy(kwVal, defVal):: strcpy(kwVal, defVal);
      uprv_strcpy(parent, base):: strcpy(parent, base);
      uprv_strcpy(found, base):: strcpy(found, base);
      
      do { /* search for 'default' named item */
          subStatus = U_ZERO_ERROR;
          res = ures_openures_open_71(path, parent, &subStatus);
          if((subStatus == U_USING_FALLBACK_WARNING) && isAvailable) {
              *isAvailable = FALSE0;
          }
          isAvailable = NULL__null; /* only want to set this the first time around */
          
2998#if defined(URES_TREE_DEBUG)
          fprintf(stderrstderr, "%s;%s -> %s (looking for default %s)\n",
              path?path:"ICUDATA", parent, u_errorNameu_errorName_71(subStatus), kwVal);
3001#endif
          if(U_FAILURE(subStatus)) {
              *status = subStatus;
          } else if(subStatus == U_ZERO_ERROR) {
              ures_getByKeyures_getByKey_71(res,resName,&bund1, &subStatus);
              if(subStatus == U_ZERO_ERROR) {
                  ures_getByKeyures_getByKey_71(&bund1, kwVal, &bund2, &subStatus);
                  if(subStatus == U_ZERO_ERROR) {
3009#if defined(URES_TREE_DEBUG)
                      fprintf(stderrstderr, "%s;%s -> full1 %s=%s,  %s\n", path?path:"ICUDATA",
                          parent, keyword, kwVal, u_errorNameu_errorName_71(subStatus));
3012#endif
                      uprv_strcpy(full, parent):: strcpy(full, parent);
                      if(*full == 0) {
                          uprv_strcpy(full, "root"):: strcpy(full, "root");
                      }
                      
                      /* now, recalculate default kw if need be */
                      if(uprv_strlen(defLoc):: strlen(defLoc) > uprv_strlen(full):: strlen(full)) {
                        const UChar *defUstr;
                        int32_t defLen;
                        /* look for default item */
3023#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> recalculating Default1\n", 
                                  path?path:"ICUDATA", full);
3026#endif
                        defUstr = ures_getStringByKeyures_getStringByKey_71(&bund1, DEFAULT_TAG"default", &defLen, &subStatus);
                        if(U_SUCCESS(subStatus) && defLen) {
                          u_UCharsToCharsu_UCharsToChars_71(defUstr, defVal, u_strlenu_strlen_71(defUstr));
3030#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> default %s=%s,  %s\n", 
                                  path?path:"ICUDATA", full, keyword, defVal, u_errorNameu_errorName_71(subStatus));
3033#endif
                          uprv_strcpy(defLoc, full):: strcpy(defLoc, full);
                        }
                      } /* end of recalculate default KW */
3037#if defined(URES_TREE_DEBUG)
                      else {
                        fprintf(stderrstderr, "No trim1,  %s <= %s\n", defLoc, full);
                      }
3041#endif
                  }
              }
          }
          subStatus = U_ZERO_ERROR;
          
          uprv_strcpy(found, parent):: strcpy(found, parent);
          uloc_getParentuloc_getParent_71(found,parent,1023,&subStatus);
          ures_closeures_close_71(res);
      } while(!full[0] && *found && U_SUCCESS(*status));
  }
  
  if(U_SUCCESS(*status)) {
      if(!full[0]) {
3055#if defined(URES_TREE_DEBUG)
        fprintf(stderrstderr, "Still could not load keyword %s=%s\n", keyword, kwVal);
3057#endif
        *status = U_MISSING_RESOURCE_ERROR;
      } else if(omitDefault) {
3060#if defined(URES_TREE_DEBUG)
        fprintf(stderrstderr,"Trim? full=%s, defLoc=%s, found=%s\n", full, defLoc, found);
3062#endif        
        if(uprv_strlen(defLoc):: strlen(defLoc) <= uprv_strlen(full):: strlen(full)) {
          /* found the keyword in a *child* of where the default tag was present. */
          if(!uprv_strcmp(kwVal, defVal):: strcmp(kwVal, defVal)) { /* if the requested kw is default, */
            /* and the default is in or in an ancestor of the current locale */
3067#if defined(URES_TREE_DEBUG)
            fprintf(stderrstderr, "Removing unneeded var %s=%s\n", keyword, kwVal);
3069#endif
            kwVal[0]=0;
          }
        }
      }
      uprv_strcpy(found, full):: strcpy(found, full);
      if(kwVal[0]) {
          uprv_strcat(found, "@"):: strcat(found, "@");
          uprv_strcat(found, keyword):: strcat(found, keyword);
          uprv_strcat(found, "="):: strcat(found, "=");
          uprv_strcat(found, kwVal):: strcat(found, kwVal);
      } else if(!omitDefault) {
          uprv_strcat(found, "@"):: strcat(found, "@");
          uprv_strcat(found, keyword):: strcat(found, keyword);
          uprv_strcat(found, "="):: strcat(found, "=");
          uprv_strcat(found, defVal):: strcat(found, defVal);
      }
  }
  /* we found the default locale - no need to repeat it.*/
  
  ures_closeures_close_71(&bund1);
  ures_closeures_close_71(&bund2);
  
  length = (int32_t)uprv_strlen(found):: strlen(found);

  if(U_SUCCESS(*status)) {
      int32_t copyLength = uprv_minuprv_min_71(length, resultCapacity);
      if(copyLength>0) {
          uprv_strncpy(result, found, copyLength):: strncpy(result, found, copyLength);
      }
      if(length == 0) {
        *status = U_MISSING_RESOURCE_ERROR; 
      }
  } else {
      length = 0;
      result[0]=0;
  }
  return u_terminateCharsu_terminateChars_71(result, resultCapacity, length, status);
3107}

3109U_CAPIextern "C" UEnumeration* U_EXPORT2
3110ures_getKeywordValuesures_getKeywordValues_71(const char *path, const char *keyword, UErrorCode *status)
3111{
3112#define VALUES_BUF_SIZE2048 2048
3113#define VALUES_LIST_SIZE512 512
  
  char       valuesBuf[VALUES_BUF_SIZE2048];
  int32_t    valuesIndex = 0;
  const char *valuesList[VALUES_LIST_SIZE512];
  int32_t    valuesCount = 0;
  
  const char *locale;
  int32_t     locLen;
  
  UEnumeration *locs = NULL__null;
  
  UResourceBundle    item;
  UResourceBundle    subItem;
  
  ures_initStackObjectures_initStackObject_71(&item);
  ures_initStackObjectures_initStackObject_71(&subItem);
  locs = ures_openAvailableLocalesures_openAvailableLocales_71(path, status);
  
  if(U_FAILURE(*status)) {
      ures_closeures_close_71(&item);
      ures_closeures_close_71(&subItem);
      return NULL__null;
  }
  
  valuesBuf[0]=0;
  valuesBuf[1]=0;
  
  while((locale = uenum_nextuenum_next_71(locs, &locLen, status)) != 0) {
      UResourceBundle   *bund = NULL__null;
      UResourceBundle   *subPtr = NULL__null;
      UErrorCode subStatus = U_ZERO_ERROR; /* don't fail if a bundle is unopenable */
      bund = ures_openures_open_71(path, locale, &subStatus);
      
3147#if defined(URES_TREE_DEBUG)
      if(!bund || U_FAILURE(subStatus)) {
          fprintf(stderrstderr, "%s-%s values: Can't open %s locale - skipping. (%s)\n", 
              path?path:"<ICUDATA>", keyword, locale, u_errorNameu_errorName_71(subStatus));
      }
3152#endif
      
      ures_getByKeyures_getByKey_71(bund, keyword, &item, &subStatus);
      
      if(!bund || U_FAILURE(subStatus)) {
3157#if defined(URES_TREE_DEBUG)
          fprintf(stderrstderr, "%s-%s values: Can't find in %s - skipping. (%s)\n", 
              path?path:"<ICUDATA>", keyword, locale, u_errorNameu_errorName_71(subStatus));
3160#endif
          ures_closeures_close_71(bund);
          bund = NULL__null;
          continue;
      }
      
      while((subPtr = ures_getNextResourceures_getNextResource_71(&item,&subItem,&subStatus)) != 0
          && U_SUCCESS(subStatus)) {
          const char *k;
          int32_t i;
          k = ures_getKeyures_getKey_71(subPtr);

3172#if defined(URES_TREE_DEBUG)
          /* fprintf(stderr, "%s | %s | %s | %s\n", path?path:"<ICUDATA>", keyword, locale, k); */
3174#endif
          if(k == NULL__null || *k == 0 ||
                  uprv_strcmp(k, DEFAULT_TAG):: strcmp(k, "default") == 0 || uprv_strncmp(k, "private-", 8):: strncmp(k, "private-", 8) == 0) {
              // empty or "default" or unlisted type
              continue;
          }
          for(i=0; i<valuesCount; i++) {
              if(!uprv_strcmp(valuesList[i],k):: strcmp(valuesList[i], k)) {
                  k = NULL__null; /* found duplicate */
                  break;
              }
          }
          if(k != NULL__null) {
              int32_t kLen = (int32_t)uprv_strlen(k):: strlen(k);
              if((valuesCount >= (VALUES_LIST_SIZE512-1)) ||       /* no more space in list .. */
                  ((valuesIndex+kLen+1+1) >= VALUES_BUF_SIZE2048)) { /* no more space in buffer (string + 2 nulls) */
                  *status = U_ILLEGAL_ARGUMENT_ERROR; /* out of space.. */
              } else {
                  uprv_strcpy(valuesBuf+valuesIndex, k):: strcpy(valuesBuf+valuesIndex, k);
                  valuesList[valuesCount++] = valuesBuf+valuesIndex;
                  valuesIndex += kLen;
3195#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "%s | %s | %s | [%s]   (UNIQUE)\n",
                      path?path:"<ICUDATA>", keyword, locale, k);
3198#endif
                  valuesBuf[valuesIndex++] = 0; /* terminate */
              }
          }
      }
      ures_closeures_close_71(bund);
  }
  valuesBuf[valuesIndex++] = 0; /* terminate */
  
  ures_closeures_close_71(&item);
  ures_closeures_close_71(&subItem);
  uenum_closeuenum_close_71(locs);
3210#if defined(URES_TREE_DEBUG)
  fprintf(stderrstderr, "%s:  size %d, #%d\n", u_errorNameu_errorName_71(*status), 
      valuesIndex, valuesCount);
3213#endif
  return uloc_openKeywordListuloc_openKeywordList_71(valuesBuf, valuesIndex, status);
3215}
3216#if 0
3217/* This code isn't needed, and given the documentation warnings the implementation is suspect */
3218U_CAPIextern "C" UBool U_EXPORT2
3219ures_equal(const UResourceBundle* res1, const UResourceBundle* res2){
  if(res1==NULL__null || res2==NULL__null){
      return res1==res2; /* pointer comparison */
  }
  if(res1->fKey==NULL__null||  res2->fKey==NULL__null){
      return (res1->fKey==res2->fKey);
  }else{
      if(uprv_strcmp(res1->fKey, res2->fKey):: strcmp(res1->fKey, res2->fKey)!=0){
          return FALSE0;
      }
  }
  if(uprv_strcmp(res1->fData->fName, res2->fData->fName):: strcmp(res1->fData->fName, res2->fData->fName)!=0){
      return FALSE0;
  }
  if(res1->fData->fPath == NULL__null||  res2->fData->fPath==NULL__null){
      return (res1->fData->fPath == res2->fData->fPath);
  }else{
      if(uprv_strcmp(res1->fData->fPath, res2->fData->fPath):: strcmp(res1->fData->fPath, res2->fData->fPath)!=0){
          return FALSE0;
      }
  }
  if(uprv_strcmp(res1->fData->fParent->fName, res2->fData->fParent->fName):: strcmp(res1->fData->fParent->fName, res2->fData
->fParent->fName)!=0){
      return FALSE0;
  }
  if(uprv_strcmp(res1->fData->fParent->fPath, res2->fData->fParent->fPath):: strcmp(res1->fData->fParent->fPath, res2->fData
->fParent->fPath)!=0){
      return FALSE0;
  }
  if(uprv_strncmp(res1->fResPath, res2->fResPath, res1->fResPathLen):: strncmp(res1->fResPath, res2->fResPath, res1->fResPathLen
)!=0){
      return FALSE0;
  }
  if(res1->fRes != res2->fRes){
      return FALSE0;
  }
  return TRUE1;
3253}
3254U_CAPIextern "C" UResourceBundle* U_EXPORT2
3255ures_clone(const UResourceBundle* res, UErrorCode* status){
  UResourceBundle* bundle = NULL__null;
  UResourceBundle* ret = NULL__null;
  if(U_FAILURE(*status) || res == NULL__null){
      return NULL__null;
  }
  bundle = ures_openures_open_71(res->fData->fPath, res->fData->fName, status);
  if(res->fResPath!=NULL__null){
      ret = ures_findSubResourceures_findSubResource_71(bundle, res->fResPath, NULL__null, status);
      ures_closeures_close_71(bundle);
  }else{
      ret = bundle;
  }
  return ret;
3269}
3270U_CAPIextern "C" const UResourceBundle* U_EXPORT2
3271ures_getParentBundle(const UResourceBundle* res){
  if(res==NULL__null){
      return NULL__null;
  }
  return res->fParentRes;
3276}
3277#endif

3279U_CAPIextern "C" void U_EXPORT2
3280ures_getVersionByKeyures_getVersionByKey_71(const UResourceBundle* res, const char *key, UVersionInfo ver, UErrorCode *status) {
const UChar *str;
int32_t len;
str = ures_getStringByKeyures_getStringByKey_71(res, key, &len, status);
if(U_SUCCESS(*status)) {
  u_versionFromUStringu_versionFromUString_71(ver, str);
} 
3287}

3289/* eof */