/root/firefox-clang/intl/icu/source/common/uresimp.h

Bug Summary

File:	root/firefox-clang/intl/icu/source/common/uresimp.h
Warning:	line 94, column 53 Returning null reference

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -D U_COMMON_IMPLEMENTATION -D _LIBCPP_DISABLE_DEPRECATION_WARNINGS -D U_USING_ICU_NAMESPACE=0 -D U_NO_DEFAULT_INCLUDE_UTF_HEADERS=1 -D U_HIDE_OBSOLETE_UTF_OLD_H=1 -D UCONFIG_NO_LEGACY_CONVERSION -D UCONFIG_NO_TRANSLITERATION -D UCONFIG_NO_REGULAR_EXPRESSIONS -D UCONFIG_NO_BREAK_ITERATION -D UCONFIG_NO_IDNA -D UCONFIG_NO_MF2 -D U_CHARSET_IS_UTF8 -D UNISTR_FROM_CHAR_EXPLICIT=explicit -D UNISTR_FROM_STRING_EXPLICIT=explicit -D U_ENABLE_DYLOAD=0 -D U_DEBUG=1 -I /root/firefox-clang/config/external/icu/common -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -I /root/firefox-clang/intl/icu/source/i18n -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -Wno-comma -Wno-implicit-const-int-float-conversion -Wno-macro-redefined -Wno-microsoft-include -Wno-tautological-unsigned-enum-zero-compare -Wno-unreachable-code-loop-increment -Wno-unreachable-code-return -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c++ /root/firefox-clang/intl/icu/source/common/uresbund.cpp

/root/firefox-clang/intl/icu/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 "bytesinkutil.h"
28#include "charstr.h"
29#include "uresimp.h"
30#include "ustr_imp.h"
31#include "cwchar.h"
32#include "ucln_cmn.h"
33#include "cmemory.h"
34#include "cstring.h"
35#include "mutex.h"
36#include "uhash.h"
37#include "unicode/uenum.h"
38#include "uenumimp.h"
39#include "ulocimp.h"
40#include "umutex.h"
41#include "putilimp.h"
42#include "uassert.h"
43#include "uresdata.h"

45using namespace icu;

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

55static UMutex resbMutex;

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

66/* INTERNAL: compares two entries */
67static UBool U_CALLCONV compareEntries(const UHashTok p1, const UHashTok p2) {
  UResourceDataEntry* b1 = static_cast<UResourceDataEntry*>(p1.pointer);
  UResourceDataEntry* b2 = static_cast<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 uhash_compareCharsuhash_compareChars_77(name1, name2) && uhash_compareCharsuhash_compareChars_77(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 != nullptr) {
      *i = '\0';
      return true;
  }

  return false;
92}

94static UBool hasVariant(const char* localeID) {
  UErrorCode err = U_ZERO_ERROR;
  CheckedArrayByteSink sink(nullptr, 0);
  ulocimp_getSubtagsulocimp_getSubtags_77(
          localeID,
          nullptr,
          nullptr,
          nullptr,
          &sink,
          nullptr,
          err);
  return sink.NumberOfBytesAppended() != 0;
106}

108// This file contains the tables for doing locale fallback, which are generated
109// by the CLDR-to-ICU process directly from the CLDR data.  This file should only
110// ever be included from here.
111#define INCLUDED_FROM_URESBUND_CPP
112#include "localefallback_data.h"

114static const char* performFallbackLookup(const char* key,
                                       const char* keyStrs,
                                       const char* valueStrs,
                                       const int32_t* lookupTable,
                                       int32_t lookupTableLength) {
  const int32_t* bottom = lookupTable;
  const int32_t* top = lookupTable + lookupTableLength;

  while (bottom < top) {
      // Effectively, divide by 2 and round down to an even index
      const int32_t* middle = bottom + (((top - bottom) / 4) * 2);
      const char* entryKey = &(keyStrs[*middle]);
      int32_t strcmpResult = uprv_strcmp(key, entryKey):: strcmp(key, entryKey);
      if (strcmpResult == 0) {
          return &(valueStrs[middle[1]]);
      } else if (strcmpResult < 0) {
          top = middle;
      } else {
          bottom = middle + 2;
      }
  }
  return nullptr;
136}

138static CharString getDefaultScript(const CharString& language, const CharString& region) {
  const char* defaultScript = nullptr;
  UErrorCode err = U_ZERO_ERROR;
  
  // the default script will be "Latn" if we don't find the locale ID in the tables
  CharString result("Latn", err);
  
  // if we were passed both language and region, make them into a locale ID and look that up in the default
  // script table
  if (!region.isEmpty()) {
      CharString localeID;
      localeID.append(language, err).append("_", err).append(region, err);
      if (U_FAILURE(err)) {
          return result;
      }
      defaultScript = performFallbackLookup(localeID.data(), dsLocaleIDChars, scriptCodeChars, defaultScriptTable, UPRV_LENGTHOF(defaultScriptTable)(int32_t)(sizeof(defaultScriptTable)/sizeof((defaultScriptTable
)[0])));
  }
  
  // if we didn't find anything, look up just the language in the default script table
  if (defaultScript == nullptr) {
      defaultScript = performFallbackLookup(language.data(), dsLocaleIDChars, scriptCodeChars, defaultScriptTable, UPRV_LENGTHOF(defaultScriptTable)(int32_t)(sizeof(defaultScriptTable)/sizeof((defaultScriptTable
)[0])));
  }
  
  // if either lookup above succeeded, copy the result from "defaultScript" into "result"; otherwise, return "Latn"
  if (defaultScript != nullptr) {
      result.clear();
      result.append(defaultScript, err);
  }
  return result;
167}

169enum 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
198};
199typedef enum UResOpenType UResOpenType;

201/**
*  Internal function, determines the search path for resource bundle files.
*  Currently, this function is used only by findFirstExisting() to help search for resource bundle files when a bundle for the specified
*  locale doesn't exist.  The code that supports inheritance of resources between existing resource bundle files continues to
*  use chopLocale() below.
*  @param name In-out parameter: On input, the locale ID to get a parent locale ID for (this is a locale's base name, without keywords); on output, the
*  requested parent locale ID.
*  @param origName The original locale ID the caller of findFirstExisting() requested.  This is the same as `name` on the first call to this function,
*  but as findFirstExisting() ascends the resource bundle's parent tree, this parameter will continue to be the original locale ID requested.
*/
211static bool getParentLocaleID(char *name, const char *origName, UResOpenType openType) {
  // early out if the locale ID has a variant code or ends with _
  size_t nameLen = uprv_strlen(name):: strlen(name);
  if (!nameLen || name[nameLen - 1] == '_' || hasVariant(name)) {
      return chopLocale(name);
  }
  
  UErrorCode err = U_ZERO_ERROR;
  CharString language;
  CharString script;
  CharString region;
  ulocimp_getSubtagsulocimp_getSubtags_77(name, &language, &script, &region, nullptr, nullptr, err);

  if (U_FAILURE(err)) {
      // hopefully this never happens...
      return chopLocale(name);
  }
  
  // if the open type is URES_OPEN_LOCALE_DEFAULT_ROOT, first look the locale ID up in the parent locale table;
  // if that table specifies a parent for it, return that  (we don't do this for the other open types-- if we're not
  // falling back through the system default locale, we also want to do straight truncation fallback instead
  // of looking things up in the parent locale table-- see https://www.unicode.org/reports/tr35/tr35.html#Parent_Locales:
  // "Collation data, however, is an exception...")
  if (openType == URES_OPEN_LOCALE_DEFAULT_ROOT) {
      const char* parentID = performFallbackLookup(name, parentLocaleChars, parentLocaleChars, parentLocaleTable, UPRV_LENGTHOF(parentLocaleTable)(int32_t)(sizeof(parentLocaleTable)/sizeof((parentLocaleTable
)[0])));
      if (parentID != nullptr) {
          uprv_strcpy(name, parentID):: strcpy(name, parentID);
          return true;
      }
  }

  CharString workingLocale;

  // if it's not in the parent locale table, figure out the fallback script algorithmically
  // (see CLDR-15265 for an explanation of the algorithm)
  if (!script.isEmpty() && !region.isEmpty()) {
      // if "name" has both script and region, is the script the default script?
      // - if so, remove it and keep the region
      // - if not, remove the region and keep the script
      if (getDefaultScript(language, region) == script) {
          workingLocale.append(language, err).append("_", err).append(region, err);
      } else {
          workingLocale.append(language, err).append("_", err).append(script, err);
      }
  } else if (!region.isEmpty()) {
      // if "name" has region but not script, did the original locale ID specify a script?
      // - if yes, replace the region with the script from the original locale ID
      // - if no, replace the region with the default script for that language and region
      UErrorCode err = U_ZERO_ERROR;
      CharString origNameLanguage;
      CharString origNameScript;
      ulocimp_getSubtagsulocimp_getSubtags_77(origName, &origNameLanguage, &origNameScript, nullptr, nullptr, nullptr, err);
      if (!origNameScript.isEmpty()) {
          workingLocale.append(language, err).append("_", err).append(origNameScript, err);
      } else {
          workingLocale.append(language, err).append("_", err).append(getDefaultScript(language, region), err);
      }
  } else if (!script.isEmpty()) {
      // if "name" has script but not region (and our open type if URES_OPEN_LOCALE_DEFAULT_ROOT), is the script
      // the default script for the language?
      // - if so, remove it from the locale ID
      // - if not, return false to continue up the chain
      // (we don't do this for other open types for the same reason we don't look things up in the parent
      // locale table for other open types-- see the reference to UTS #35 above)
      if (openType != URES_OPEN_LOCALE_DEFAULT_ROOT || getDefaultScript(language, CharString()) == script) {
          workingLocale.append(language, err);
      } else {
          return false;
      }
  } else {
      // if "name" just contains a language code, return false so the calling code falls back to "root"
      return false;
  }
  if (U_SUCCESS(err) && !workingLocale.isEmpty()) {
      uprv_strcpy(name, workingLocale.data()):: strcpy(name, workingLocale.data());
      return true;
  } else {
      return false;
  }
290}

292/**
*  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.
*/
297static UBool mayHaveParent(char *name) {
  return (name[0] != 0 && uprv_strstr("nb nn",name):: strstr("nb nn", name) != nullptr);
299}

301/**
*  Internal function
*/
304static void entryIncrease(UResourceDataEntry *entry) {
  Mutex lock(&resbMutex);
  entry->fCountExisting++;
  while(entry->fParent != nullptr) {
    entry = entry->fParent;
    entry->fCountExisting++;
  }
311}

313/**
*  Internal function. Tries to find a resource in given Resource
*  Bundle, as well as in its parents
*/
317static 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_77(&(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_77(&(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_77())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName):: strcmp(dataEntry->fName, "root")==0) {
          *status = U_USING_DEFAULT_WARNING;
      } else {
          *status = U_USING_FALLBACK_WARNING;
      }
  }
  return dataEntry;
357}

359static void
360free_entry(UResourceDataEntry *entry) {
  UResourceDataEntry *alias;
  res_unloadres_unload_77(&(entry->fData));
  if(entry->fName != nullptr && entry->fName != entry->fNameBuffer) {
      uprv_freeuprv_free_77(entry->fName);
  }
  if(entry->fPath != nullptr) {
      uprv_freeuprv_free_77(entry->fPath);
  }
  if(entry->fPool != nullptr) {
      --entry->fPool->fCountExisting;
  }
  alias = entry->fAlias;
  if(alias != nullptr) {
      while(alias->fAlias != nullptr) {
          alias = alias->fAlias;
      }
      --alias->fCountExisting;
  }
  uprv_freeuprv_free_77(entry);
380}

382/* Works just like ucnv_flushCache() */
383static int32_t ures_flushCache()
384{
  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 == nullptr) {
      return 0;
  }

  do {
      deletedMore = false;
      /*creates an enumeration to iterate through every element in the table */
      pos = UHASH_FIRST(-1);
      while ((e = uhash_nextElementuhash_nextElement_77(cache, &pos)) != nullptr)
      {
          resB = static_cast<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 = true;
              uhash_removeElementuhash_removeElement_77(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;
429}

431#ifdef URES_DEBUG
432#include <stdio.h>

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

  Mutex lock(&resbMutex);
  if (cache == nullptr) {
    fprintf(stderrstderr,"%s:%d: RB Cache is nullptr.\n", __FILE__"/root/firefox-clang/intl/icu/source/common/uresbund.cpp", __LINE__442);
    return false;
  }

  while ((e = uhash_nextElementuhash_nextElement_77(cache, &pos)) != nullptr) {
    cacheNotEmpty=true;
    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__"/root/firefox-clang/intl/icu/source/common/uresbund.cpp", __LINE__450,
            (void*)resB, resB->fCountExisting,
            resB->fName?resB->fName:"nullptr",
            resB->fPath?resB->fPath:"nullptr",
            (void*)resB->fPool,
            (void*)resB->fAlias,
            (void*)resB->fParent);       
  }
  
  fprintf(stderrstderr,"%s:%d: RB Cache still contains %d items.\n", __FILE__"/root/firefox-clang/intl/icu/source/common/uresbund.cpp", __LINE__459, uhash_countuhash_count_77(cache));
  return cacheNotEmpty;
461}

463#endif

465static UBool U_CALLCONV ures_cleanup()
466{
  if (cache != nullptr) {
      ures_flushCache();
      uhash_closeuhash_close_77(cache);
      cache = nullptr;
  }
  gCacheInitOnce.reset();
  return true;
474}

476/** INTERNAL: Initializes the cache for resources */
477static void U_CALLCONV createCache(UErrorCode &status) {
  U_ASSERT(cache == nullptr)(static_cast <bool> (cache == nullptr) ? void (0) : __assert_fail
 ("cache == nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  cache = uhash_openuhash_open_77(hashEntry, compareEntries, nullptr, &status);
  ucln_common_registerCleanupucln_common_registerCleanup_77(UCLN_COMMON_URES, ures_cleanup);
481}
   
483static void initCache(UErrorCode *status) {
  umtx_initOnce(gCacheInitOnce, &createCache, *status);
485}

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

489static void setEntryName(UResourceDataEntry *res, const char *name, UErrorCode *status) {
  int32_t len = static_cast<int32_t>(uprv_strlen(name):: strlen(name));
  if(res->fName != nullptr && res->fName != res->fNameBuffer) {
      uprv_freeuprv_free_77(res->fName);
  }
  if (len < static_cast<int32_t>(sizeof(res->fNameBuffer))) {
      res->fName = res->fNameBuffer;
  }
  else {
      res->fName = static_cast<char*>(uprv_mallocuprv_malloc_77(len + 1));
  }
  if(res->fName == nullptr) {
      *status = U_MEMORY_ALLOCATION_ERROR;
  } else {
      uprv_strcpy(res->fName, name):: strcpy(res->fName, name);
  }
505}

507static UResourceDataEntry *
508getPoolEntry(const char *path, UErrorCode *status);

510/**
*  INTERNAL: Inits and opens an entry from a data DLL.
*    CAUTION:  resbMutex must be locked when calling this function.
*/
514static UResourceDataEntry *init_entry(const char *localeID, const char *path, UErrorCode *status) {
  UResourceDataEntry *r = nullptr;
  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 nullptr;
  }

  /* here we try to deduce the right locale name */
  if(localeID == nullptr) { /* if localeID is nullptr, we're trying to open default locale */
      name = uloc_getDefaultuloc_getDefault_77();
  } 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 = const_cast<char*>(name);
  find.fPath = const_cast<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 = static_cast<UResourceDataEntry*>(uhash_getuhash_get_77(cache, &find));
  if(r == nullptr) {
      /* if the entry is not yet in the hash table, we'll try to construct a new one */
      r = static_cast<UResourceDataEntry*>(uprv_mallocuprv_malloc_77(sizeof(UResourceDataEntry)));
      if(r == nullptr) {
          *status = U_MEMORY_ALLOCATION_ERROR;
          return nullptr;
      }

      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_77(r);
          return nullptr;
      }

      if(path != nullptr) {
          r->fPath = uprv_strdupuprv_strdup_77(path);
          if(r->fPath == nullptr) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              uprv_freeuprv_free_77(r);
              return nullptr;
          }
      }

      /* this is the actual loading */
      res_loadres_load_77(&(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_77(r);
              return nullptr;
          }
          /* 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 = reinterpret_cast<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_77(&(r->fData), "%%ALIAS");
              if (aliasres != RES_BOGUS0xffffffff) {
                  // No tracing: called during initial data loading
                  const char16_t *alias = res_getStringNoTraceres_getStringNoTrace_77(&(r->fData), aliasres, &aliasLen);
                  if(alias != nullptr && aliasLen > 0) { /* if there is actual alias - unload and load new data */
                      u_UCharsToCharsu_UCharsToChars_77(alias, aliasName, aliasLen+1);
                      r->fAlias = init_entry(aliasName, path, status);
                  }
              }
          }
      }

      {
          UResourceDataEntry *oldR = nullptr;
          if ((oldR = static_cast<UResourceDataEntry*>(uhash_getuhash_get_77(cache, r))) == nullptr) { /* if the data is not cached */
              /* just insert it in the cache */
              UErrorCode cacheStatus = U_ZERO_ERROR;
              uhash_putuhash_put_77(cache, (void *)r, r, &cacheStatus);
              if (U_FAILURE(cacheStatus)) {
                  *status = cacheStatus;
                  free_entry(r);
                  r = nullptr;
              }
          } 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 != nullptr) {
      /* return the real bundle */
      while(r->fAlias != nullptr) {
          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;
648}

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

661/* INTERNAL: */
662/*   CAUTION:  resbMutex must be locked when calling this function! */
663static UResourceDataEntry *
664findFirstExisting(const char* path, char* name, const char* defaultLocale, UResOpenType openType,
                UBool *isRoot, UBool *foundParent, UBool *isDefault, UErrorCode* status) {
  UResourceDataEntry *r = nullptr;
  UBool hasRealData = false;
  *foundParent = true; /* we're starting with a fresh name */
  char origName[ULOC_FULLNAME_CAPACITY157];

  uprv_strcpy(origName, name):: strcpy(origName, name);
  while(*foundParent && !hasRealData) {
      r = init_entry(name, path, status);
      /* Null pointer test */
      if (U_FAILURE(*status)) {
          return nullptr;
      }
      *isDefault = static_cast<UBool>(uprv_strncmp(name, defaultLocale, uprv_strlen(name)):: strncmp(name, defaultLocale, :: strlen(name)) == 0);
      hasRealData = static_cast<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 = nullptr;
          *status = U_USING_FALLBACK_WARNING;
      } else {
          uprv_strcpy(name, r->fName):: strcpy(name, r->fName); /* this is needed for supporting aliases */
      }

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

      /*Fallback data stuff*/
      if (!hasRealData) {
          *foundParent = getParentLocaleID(name, origName, openType);
      } else {
          // we've already found a real resource file; what we return to the caller is the parent
          // locale ID for inheritance, which should come from chopLocale(), not getParentLocaleID()
          *foundParent = chopLocale(name);
      }
      if (*foundParent && *name == '\0') {
          uprv_strcpy(name, "und"):: strcpy(name, "und");
      }
  }
  return r;
709}

711static void ures_setIsStackObject( UResourceBundle* resB, UBool state) {
  if(state19.1
'state' is 1
1
'state' is 1
) {
20
←
Taking true branch→
      resB->fMagic1 = 0;
      resB->fMagic2 = 0;
  } else {
      resB->fMagic1 = MAGIC119700503;
      resB->fMagic2 = MAGIC219641227;
  }
719}
21
←
Returning without writing to 'resB->fData'→

721static UBool ures_isStackObject(const UResourceBundle* resB) {
return((resB->fMagic1 == MAGIC119700503 && resB->fMagic2 == MAGIC219641227)?false:true);
723}


726U_CFUNCextern "C" void ures_initStackObjectures_initStackObject_77(UResourceBundle* resB) {
uprv_memset(resB, 0, sizeof(UResourceBundle)):: memset(resB, 0, sizeof(UResourceBundle));
18
←
Null pointer value stored to 'stackTempBundle.bundle.fData'→
ures_setIsStackObject(resB, true);
19
←
Calling 'ures_setIsStackObject'→
22
←
Returning from 'ures_setIsStackObject'→
729}

731U_NAMESPACE_BEGINnamespace icu_77 {

733StackUResourceBundle::StackUResourceBundle() {
  ures_initStackObjectures_initStackObject_77(&bundle);
17
←
Calling 'ures_initStackObject_77'→
23
←
Returning from 'ures_initStackObject_77'→
735}

737StackUResourceBundle::~StackUResourceBundle() {
  ures_closeures_close_77(&bundle);
739}

741U_NAMESPACE_END}

743static UBool  // returns U_SUCCESS(*status)
744loadParentsExceptRoot(UResourceDataEntry *&t1,
                    char name[], int32_t nameCapacity,
                    UBool usingUSRData, char usrDataPath[], UErrorCode *status) {
  if (U_FAILURE(*status)) { return false; }
  UBool checkParent = true;
  while (checkParent && t1->fParent == nullptr && !t1->fData.noFallback &&
          res_getResourceres_getResource_77(&t1->fData,"%%ParentIsRoot") == RES_BOGUS0xffffffff) {
      Resource parentRes = res_getResourceres_getResource_77(&t1->fData, "%%Parent");
      if (parentRes != RES_BOGUS0xffffffff) {  // An explicit parent was found.
          int32_t parentLocaleLen = 0;
          // No tracing: called during initial data loading
          const char16_t *parentLocaleName = res_getStringNoTraceres_getStringNoTrace_77(&(t1->fData), parentRes, &parentLocaleLen);
          if(parentLocaleName != nullptr && 0 < parentLocaleLen && parentLocaleLen < nameCapacity) {
              u_UCharsToCharsu_UCharsToChars_77(parentLocaleName, name, parentLocaleLen + 1);
              if (uprv_strcmp(name, kRootLocaleName):: strcmp(name, "root") == 0) {
                  return true;
              }
          }
      }
      // Insert regular parents.
      UErrorCode parentStatus = U_ZERO_ERROR;
      UResourceDataEntry *t2 = init_entry(name, t1->fPath, &parentStatus);
      if (U_FAILURE(parentStatus)) {
          *status = parentStatus;
          return false;
      }
      UResourceDataEntry *u2 = nullptr;
      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 false;
          }
      }

      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 true;
795}

797static UBool  // returns U_SUCCESS(*status)
798insertRootBundle(UResourceDataEntry *&t1, UErrorCode *status) {
  if (U_FAILURE(*status)) { return false; }
  UErrorCode parentStatus = U_ZERO_ERROR;
  UResourceDataEntry *t2 = init_entry(kRootLocaleName"root", t1->fPath, &parentStatus);
  if (U_FAILURE(parentStatus)) {
      *status = parentStatus;
      return false;
  }
  t1->fParent = t2;
  t1 = t2;
  return true;
809}

811static UResourceDataEntry *entryOpen(const char* path, const char* localeID,
                                   UResOpenType openType, UErrorCode* status) {
  U_ASSERT(openType != URES_OPEN_DIRECT)(static_cast <bool> (openType != URES_OPEN_DIRECT) ? void
 (0) : __assert_fail ("openType != URES_OPEN_DIRECT", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
  UErrorCode intStatus = U_ZERO_ERROR;
  UResourceDataEntry *r = nullptr;
  UResourceDataEntry *t1 = nullptr;
  UBool isDefault = false;
  UBool isRoot = false;
  UBool hasRealData = false;
  UBool hasChopped = true;
  UBool usingUSRData = U_USE_USRDATA0 && ( path == nullptr || uprv_strncmp(path,U_ICUDATA_NAME,8):: strncmp(path, "icudt" "77" "l", 8) == 0);

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

  initCache(status);

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

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

  if ( usingUSRData ) {
      if ( path == nullptr ) {
          uprv_strcpy(usrDataPath, U_USRDATA_NAME):: strcpy(usrDataPath, "usrdt" "77" "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_77();

  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, openType, &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 != nullptr) { /* if there is one real locale, we can look for parents. */
      t1 = r;
      hasRealData = true;
      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 != nullptr ) {
              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==nullptr && openType == URES_OPEN_LOCALE_DEFAULT_ROOT && !isDefault && !isRoot) {
      /* insert default locale */
      uprv_strcpy(name, defaultLocale):: strcpy(name, defaultLocale);
      r = findFirstExisting(path, name, defaultLocale, openType, &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 != nullptr) { /* the default locale exists */
          t1 = r;
          hasRealData = true;
          isDefault = true;
          // 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 == nullptr at this point - maybe even default locale is not */
  /* present */
  if(r == nullptr) {
      uprv_strcpy(name, kRootLocaleName):: strcpy(name, "root");
      r = findFirstExisting(path, name, defaultLocale, openType, &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 != nullptr) {
          t1 = r;
          intStatus = U_USING_DEFAULT_WARNING;
          hasRealData = true;
      } 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 == nullptr && !r->fData.noFallback) {
      if (!insertRootBundle(t1, status)) {
          goto finish;
      }
      if(!hasRealData) {
          r->fBogus = U_USING_DEFAULT_WARNING;
      }
  }

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

948finish:
  if(U_SUCCESS(*status)) {
      if(intStatus != U_ZERO_ERROR) {
          *status = intStatus;  
      }
      return r;
  } else {
      return nullptr;
  }
957}

959/**
* 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.
*/
965static UResourceDataEntry *
966entryOpenDirect(const char* path, const char* localeID, UErrorCode* status) {
  initCache(status);
  if(U_FAILURE(*status)) {
      return nullptr;
  }

  // Note: We need to query the default locale *before* locking resbMutex.
  // If the localeID is nullptr, then we want to use the default locale.
  if (localeID == nullptr) {
      localeID = uloc_getDefaultuloc_getDefault_77();
  } 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 = nullptr;
      }
  } else {
      r = nullptr;
  }

  // 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 != nullptr && uprv_strcmp(localeID, kRootLocaleName):: strcmp(localeID, "root") != 0 &&  // not root
          r->fParent == nullptr && !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])), false, nullptr, status)) {
          if(uprv_strcmp(t1->fName, kRootLocaleName):: strcmp(t1->fName, "root") != 0 && t1->fParent == nullptr) {
              insertRootBundle(t1, status);
          }
      }
      if(U_FAILURE(*status)) {
          r = nullptr;
      }
  }

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

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

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

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

      resB = p;
  }
1055}

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

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

1066/*
1067U_CFUNC void ures_setResPath(UResourceBundle *resB, const char* toAdd) {
if(resB->fResPath == nullptr) {
  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);
1081}
1082*/
1083static void ures_appendResPath(UResourceBundle *resB, const char* toAdd, int32_t lenToAdd, UErrorCode *status) {
  int32_t resPathLenOrig = resB->fResPathLen;
  if(resB->fResPath == nullptr) {
      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 = static_cast<char*>(uprv_mallocuprv_malloc_77((resB->fResPathLen + 1) * sizeof(char)));
          /* Check that memory was allocated correctly. */
          if (resB->fResPath == nullptr) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          uprv_strcpy(resB->fResPath, resB->fResBuf):: strcpy(resB->fResPath, resB->fResBuf);
      } else {
          char* temp = static_cast<char*>(uprv_reallocuprv_realloc_77(resB->fResPath, (resB->fResPathLen + 1) * sizeof(char)));
          /* Check that memory was reallocated correctly. */
          if (temp == nullptr) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          resB->fResPath = temp;
      }
  }
  uprv_strcpy(resB->fResPath + resPathLenOrig, toAdd):: strcpy(resB->fResPath + resPathLenOrig, toAdd);
1111}

1113static void ures_freeResPath(UResourceBundle *resB) {
  if (resB->fResPath && resB->fResPath != resB->fResBuf) {
      uprv_freeuprv_free_77(resB->fResPath);
  }
  resB->fResPath = nullptr;
  resB->fResPathLen = 0;
1119}

1121static void
1122ures_closeBundle(UResourceBundle* resB, UBool freeBundleObj)
1123{
  if(resB != nullptr) {
      if(resB->fData != nullptr) {
          entryClose(resB->fData);
      }
      if(resB->fVersion != nullptr) {
          uprv_freeuprv_free_77(resB->fVersion);
      }
      ures_freeResPath(resB);

      if(ures_isStackObject(resB) == false && freeBundleObj) {
          uprv_freeuprv_free_77(resB);
      }
1136#if 0 /*U_DEBUG*/
      else {
          /* poison the data */
          uprv_memset(resB, -1, sizeof(UResourceBundle)):: memset(resB, -1, sizeof(UResourceBundle));
      }
1141#endif
  }
1143}

1145U_CAPIextern "C" void  U_EXPORT2
1146ures_closeures_close_77(UResourceBundle* resB)
1147{
  ures_closeBundle(resB, true);
1149}

1151namespace {

1153UResourceBundle *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);

1159// TODO: Try to refactor further, so that we output a dataEntry + Resource + (optionally) resPath,
1160// rather than a UResourceBundle.
1161// May need to entryIncrease() the resulting dataEntry.
1162UResourceBundle *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; }
26
←
Taking false branch→
  U_ASSERT(RES_GET_TYPE(r) == URES_ALIAS)(static_cast <bool> (((int32_t)((r)>>28UL)) == URES_ALIAS
) ? void (0) : __assert_fail ("((int32_t)((r)>>28UL)) == URES_ALIAS"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
27
←
Assuming the condition is true→
28
←
'?' condition is true→
  int32_t len = 0;
  const char16_t *alias = res_getAliasres_getAlias_77(&resData, r, &len);
  if(len <= 0) {
29
←
Assuming 'len' is > 0→
30
←
Taking false branch→
      // 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)) {
31
←
Taking false branch→
      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'/') {
32
←
Assuming the condition is false→
33
←
Taking false branch→
      // 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) {
34
←
Assuming the condition is true→
35
←
Taking true branch→
          *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) {
36
←
Taking false branch→
      // 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_77(path, locale, &intStatus));
      if(U_FAILURE(intStatus)) {
37
←
Taking false branch→
          // 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) {
38
←
Taking false branch→
      // 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_77(&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_77(&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_77(&dataEntry->fData, r, idx, &aKey);
          } else { /* array */
              r = res_getArrayItemres_getArrayItem_77(&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)) {
39
←
Taking false branch→
          return nullptr;
      }
      char *myPath = pathBuf.data();
      containerResPath = nullptr;
      // Now we have fallback following here.
      for(;;) {
40
←
Loop condition is true.  Entering loop body→
          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)) {
41
←
Assuming the condition is false→
              r = res_findResourceres_findResource_77(&(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, static_cast<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) {
42
←
Assuming 'r' is not equal to RES_BOGUS→
43
←
Taking true branch→
              break;
44
←
 Execution continues on line 363→
          }
          // 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) {
45
←
Taking false branch→
      mainRes.orphan();
  }
  ResourceTracer(resB).maybeTrace("getalias");
  return resB;
46
←
Returning without writing to 'resB->fData'→
1381}

1383// Recursive function, should be called only by itself, by its simpler wrapper,
1384// or by getAliasTargetAsResourceBundle().
1385UResourceBundle *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 == nullptr || U_FAILURE(*status)) {
      return resB;
  }
  if (validLocaleDataEntry == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return nullptr;
  }
  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 == nullptr) {
      resB = static_cast<UResourceBundle*>(uprv_mallocuprv_malloc_77(sizeof(UResourceBundle)));
      if (resB == nullptr) {
          *status = U_MEMORY_ALLOCATION_ERROR;
          return nullptr;
      }
      ures_setIsStackObject(resB, false);
      resB->fResPath = nullptr;
      resB->fResPathLen = 0;
  } else {
      if(resB->fData != nullptr) {
          entryClose(resB->fData);
      }
      if(resB->fVersion != nullptr) {
          uprv_freeuprv_free_77(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 = false;
  resB->fIsTopLevel = false;
  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 != nullptr) {
      ures_appendResPath(resB, key, static_cast<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_77(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 = nullptr;
  resB->fRes = r;
  resB->fSize = res_countArrayItemsres_countArrayItems_77(&resB->getResData(), resB->fRes);
  ResourceTracer(resB).trace("get");
  return resB;
1474}

1476UResourceBundle *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);
1484}

1486}  // namespace

1488UResourceBundle *ures_copyResbures_copyResb_77(UResourceBundle *r, const UResourceBundle *original, UErrorCode *status) {
  UBool isStackObject;
  if(U_FAILURE(*status) || r == original) {
      return r;
  }
  if(original != nullptr) {
      if(r == nullptr) {
          isStackObject = false;
          r = static_cast<UResourceBundle*>(uprv_mallocuprv_malloc_77(sizeof(UResourceBundle)));
          /* test for nullptr */
          if (r == nullptr) {
              *status = U_MEMORY_ALLOCATION_ERROR;
              return nullptr;
          }
      } else {
          isStackObject = ures_isStackObject(r);
          ures_closeBundle(r, false);
      }
      uprv_memcpy(r, original, sizeof(UResourceBundle))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (r != __null) ? void (0) : __assert_fail
 ("r != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (original !=
 __null) ? void (0) : __assert_fail ("original != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(r, original, sizeof(UResourceBundle
)); } while (false);
      r->fResPath = nullptr;
      r->fResPathLen = 0;
      if(original->fResPath) {
          ures_appendResPath(r, original->fResPath, original->fResPathLen, status);
      }
      ures_setIsStackObject(r, isStackObject);
      if(r->fData != nullptr) {
          entryIncrease(r->fData);
      }
  }
  return r;
1518}

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

1524U_CAPIextern "C" const char16_t* U_EXPORT2 ures_getStringures_getString_77(const UResourceBundle* resB, int32_t* len, UErrorCode* status) {
  const char16_t *s;
  if (status==nullptr || U_FAILURE(*status)) {
      return nullptr;
  }
  if(resB == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return nullptr;
  }
  s = res_getString({resB}, &resB->getResData(), resB->fRes, len);
  if (s == nullptr) {
      *status = U_RESOURCE_TYPE_MISMATCH;
  }
  return s;
1538}

1540static const char *
1541ures_toUTF8String(const char16_t *s16, int32_t length16,
                char *dest, int32_t *pLength,
                UBool forceCopy,
                UErrorCode *status) {
  int32_t capacity;

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

  if (length16 == 0) {
      /* empty string, return as read-only pointer */
      if (pLength != nullptr) {
          *pLength = 0;
      }
      if (forceCopy) {
          u_terminateCharsu_terminateChars_77(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_77(nullptr, 0, pLength, s16, length16, status);
      }
      if (!forceCopy && (length16 <= 0x2aaaaaaa)) {
          /*
           * We know the string will fit into dest because each char16_t 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_77(dest, capacity, pLength, s16, length16, status);
  }
1600}

1602U_CAPIextern "C" const char * U_EXPORT2
1603ures_getUTF8Stringures_getUTF8String_77(const UResourceBundle *resB,
                 char *dest, int32_t *pLength,
                 UBool forceCopy,
                 UErrorCode *status) {
  int32_t length16;
  const char16_t *s16 = ures_getStringures_getString_77(resB, &length16, status);
  return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
1610}

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

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

1646/* this function returns a signed integer */ 
1647/* it performs sign extension */
1648U_CAPIextern "C" int32_t U_EXPORT2 ures_getIntures_getInt_77(const UResourceBundle* resB, UErrorCode *status) {
if (status==nullptr || U_FAILURE(*status)) {
  return 0xffffffff;
}
if(resB == nullptr) {
  *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);
1661}

1663U_CAPIextern "C" uint32_t U_EXPORT2 ures_getUIntures_getUInt_77(const UResourceBundle* resB, UErrorCode *status) {
if (status==nullptr || U_FAILURE(*status)) {
  return 0xffffffff;
}
if(resB == nullptr) {
  *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);
1676}

1678U_CAPIextern "C" UResType U_EXPORT2 ures_getTypeures_getType_77(const UResourceBundle *resB) {
if(resB == nullptr) {
  return URES_NONE;
}
return res_getPublicTyperes_getPublicType_77(resB->fRes);
1683}

1685U_CAPIextern "C" const char * U_EXPORT2 ures_getKeyures_getKey_77(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 == nullptr) {
  return nullptr;
}
return(resB->fKey);
1699}

1701U_CAPIextern "C" int32_t U_EXPORT2 ures_getSizeures_getSize_77(const UResourceBundle *resB) {
if(resB == nullptr) {
  return 0;
}

return resB->fSize;
1707}

1709static const char16_t* 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 char16_t* result = nullptr;
  UResourceBundle *tempRes = ures_getByIndexures_getByIndex_77(resB, sIndex, nullptr, status);
  result = ures_getStringures_getString_77(tempRes, len, status);
  ures_closeures_close_77(tempRes);
  return result;
} else {
  return res_getString({resB, sIndex}, &resB->getResData(), r, len); 
}
1719}

1721U_CAPIextern "C" void U_EXPORT2 ures_resetIteratorures_resetIterator_77(UResourceBundle *resB){
if(resB == nullptr) {
  return;
}
resB->fIndex = -1;
1726}

1728U_CAPIextern "C" UBool U_EXPORT2 ures_hasNextures_hasNext_77(const UResourceBundle *resB) {
if(resB == nullptr) {
  return false;
}
return resB->fIndex < resB->fSize-1;
1733}

1735U_CAPIextern "C" const char16_t* U_EXPORT2 ures_getNextStringures_getNextString_77(UResourceBundle *resB, int32_t* len, const char ** key, UErrorCode *status) {
Resource r = RES_BOGUS0xffffffff;

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

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_77(&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_77(&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 nullptr;
  }
}

return nullptr;
1782}

1784U_CAPIextern "C" UResourceBundle* U_EXPORT2 ures_getNextResourceures_getNextResource_77(UResourceBundle *resB, UResourceBundle *fillIn, UErrorCode *status) {
  const char *key = nullptr;
  Resource r = RES_BOGUS0xffffffff;

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

  if(resB->fIndex == resB->fSize-1) {
    *status = U_INDEX_OUTOFBOUNDS_ERROR;
    /*return nullptr;*/
  } 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_77(fillIn, resB, status);
      case URES_TABLE:
      case URES_TABLE16:
      case URES_TABLE32:
          r = res_getTableItemByIndexres_getTableItemByIndex_77(&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_77(&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 nullptr;*/
          return fillIn;
      }
  }
  /*return nullptr;*/
  return fillIn;
1832}

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

  if (status==nullptr || U_FAILURE(*status)) {
      /*return nullptr;*/
      return fillIn;
  }
  if(resB == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      /*return nullptr;*/
      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_77(fillIn, resB, status);
      case URES_TABLE:
      case URES_TABLE16:
      case URES_TABLE32:
          r = res_getTableItemByIndexres_getTableItemByIndex_77(&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_77(&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 nullptr;*/
          return fillIn;
      }
  } else {
      *status = U_MISSING_RESOURCE_ERROR;
  }
  /*return nullptr;*/
  return fillIn;
1880}

1882U_CAPIextern "C" const char16_t* U_EXPORT2 ures_getStringByIndexures_getStringByIndex_77(const UResourceBundle *resB, int32_t indexS, int32_t* len, UErrorCode *status) {
  const char* key = nullptr;
  Resource r = RES_BOGUS0xffffffff;

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

  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_77(&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_77(&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 nullptr;
1930}

1932U_CAPIextern "C" const char * U_EXPORT2
1933ures_getUTF8StringByIndexures_getUTF8StringByIndex_77(const UResourceBundle *resB,
                        int32_t idx,
                        char *dest, int32_t *pLength,
                        UBool forceCopy,
                        UErrorCode *status) {
  int32_t length16;
  const char16_t *s16 = ures_getStringByIndexures_getStringByIndex_77(resB, idx, &length16, status);
  return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
1941}

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

1947U_CAPIextern "C" UResourceBundle* U_EXPORT2
1948ures_findResourceures_findResource_77(const char* path, UResourceBundle *fillIn, UErrorCode *status) 
1949{
UResourceBundle *first = nullptr; 
UResourceBundle *result = fillIn;
char *packageName = nullptr;
char *pathToResource = nullptr, *save = nullptr;
char *locale = nullptr, *localeEnd = nullptr;
int32_t length;

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

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

 (static_cast <bool> (pathToResource != __null) ? void
 (0) : __assert_fail ("pathToResource != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (
static_cast <bool> (path != __null) ? void (0) : __assert_fail
 ("path != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); 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 == nullptr) {
    *status = U_ILLEGAL_ARGUMENT_ERROR;
  } else {
    *pathToResource = 0;
    locale = pathToResource+1;
  }
}

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

first = ures_openures_open_77(packageName, locale, status);

if(U_SUCCESS(*status)) {
  if(localeEnd) {
    result = ures_findSubResourceures_findSubResource_77(first, localeEnd+1, fillIn, status);
  } else {
    result = ures_copyResbures_copyResb_77(fillIn, first, status);
  }
  ures_closeures_close_77(first);
}
uprv_freeuprv_free_77(save);
return result;
2000}

2002U_CAPIextern "C" UResourceBundle* U_EXPORT2
2003ures_findSubResourceures_findSubResource_77(const UResourceBundle *resB, char* path, UResourceBundle *fillIn, UErrorCode *status) 
2004{
Resource res = RES_BOGUS0xffffffff;
UResourceBundle *result = fillIn;
const char *key;

if(status == nullptr || 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_77(&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;
2028}
2029U_CAPIextern "C" const char16_t* U_EXPORT2
2030ures_getStringByKeyWithFallbackures_getStringByKeyWithFallback_77(const UResourceBundle *resB, 
                              const char* inKey, 
                              int32_t* len,
                              UErrorCode *status) {

  UResourceBundle stack;
  const char16_t* retVal = nullptr;
  ures_initStackObjectures_initStackObject_77(&stack);
  ures_getByKeyWithFallbackures_getByKeyWithFallback_77(resB, inKey, &stack, status);
  int32_t length;
  retVal = ures_getStringures_getString_77(&stack, &length, status);
  ures_closeures_close_77(&stack);
  if (U_FAILURE(*status)) {
      return nullptr;
  }
  if (length == 3 && retVal[0] == EMPTY_SET0x2205 && retVal[1] == EMPTY_SET0x2205 && retVal[2] == EMPTY_SET0x2205 ) {
      retVal = nullptr;
      length = 0;
      *status = U_MISSING_RESOURCE_ERROR;
  }
  if (len != nullptr) {
      *len = length;
  }
  return retVal;
2054}

2056/*
Like res_getTableItemByKey but accepts full paths like "NumberElements/latn/patternsShort".
2058*/  
2059static 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 = static_cast<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 != nullptr) {
    *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_77(pResData, resource, &t, &pathP);
  type = static_cast<UResType>(RES_GET_TYPE(resource)((int32_t)((resource)>>28UL)));
  pathPart = nextPathPart; 
}
if (*pathPart) {
  return RES_BOGUS0xffffffff;
}
return resource;
2085}

2087static 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);
  }
2158}

2160U_CAPIextern "C" UResourceBundle* U_EXPORT2
2161ures_getByKeyWithFallbackures_getByKeyWithFallback_77(const UResourceBundle *resB,
                        const char* inKey,
                        UResourceBundle *fillIn,
                        UErrorCode *status) {
  Resource res = RES_BOGUS0xffffffff, rootRes = RES_BOGUS0xffffffff;
  UResourceBundle *helper = nullptr;

  if (status==nullptr || U_FAILURE(*status)) {
      return fillIn;
  }
  if(resB == nullptr) {
      *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 = nullptr;
          const char* resPath = resB->fResPath;
          int32_t len = resB->fResPathLen;
          while(res == RES_BOGUS0xffffffff && (dataEntry->fParent != nullptr || !didRootOnce)) { /* Otherwise, we'll look in parents */
              if (dataEntry->fParent != nullptr) {
                  dataEntry = dataEntry->fParent;
              } else {
                  // We can't just stop when we get to a bundle whose fParent is nullptr.  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_77(helper);
                      return fillIn;
                  }
                  myPath = path.data();
                  key = inKey;
                  do {
                      res = res_findResourceres_findResource_77(&(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, nullptr, -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_77())==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_77(helper);
  return fillIn;
2272}

2274namespace {

2276void getAllItemsWithFallback(
      const UResourceBundle *bundle, ResourceDataValue &value,
      ResourceSink &sink, UErrorCode &errorCode) {
  if (U_FAILURE(errorCode)) { return; }
9
←
Taking false branch→
  // 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 != nullptr && U_SUCCESS(parentEntry->fBogus);
10
←
Assuming the condition is false→
  value.setResource(bundle->fRes, ResourceTracer(bundle));
  sink.put(bundle->fKey, value, !hasParent, errorCode);
11
←
Calling 'GetAllChildrenSink::put'→
  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 = true;
      parentRef.fRes = parentRef.getResData().rootRes;
      parentRef.fSize = res_countArrayItemsres_countArrayItems_77(&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 == nullptr || *bundle->fResPath == 0) {
          rb = parentBundle.getAlias();
      } else {
          rb = ures_getByKeyWithFallbackures_getByKeyWithFallback_77(parentBundle.getAlias(), bundle->fResPath,
                                         containerBundle.getAlias(), &pathErrorCode);
      }
      if (U_SUCCESS(pathErrorCode)) {
          getAllItemsWithFallback(rb, value, sink, errorCode);
      }
  }
2330}

2332struct 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; }
12
←
Taking false branch→
      for (int32_t i = 0; itemsTable.getKeyAndValue(i, key, value); ++i) {
13
←
Loop condition is true.  Entering loop body→
          if (value.getType() == URES_ALIAS) {
14
←
Assuming the condition is true→
15
←
Taking true branch→
              ResourceDataValue& rdv = static_cast<ResourceDataValue&>(value);
              StackUResourceBundle stackTempBundle;
16
←
Calling default constructor for 'StackUResourceBundle'→
24
←
Returning from default constructor for 'StackUResourceBundle'→
              UResourceBundle* aliasRB = getAliasTargetAsResourceBundle(rdv.getData(), rdv.getResource(), nullptr, -1,
25
←
Calling 'getAliasTargetAsResourceBundle'→
47
←
Returning from 'getAliasTargetAsResourceBundle'→
                                                                        rdv.getValidLocaleDataEntry(), nullptr, 0,
                                                                        stackTempBundle.getAlias(), &errorCode);
              if (U_SUCCESS(errorCode)) {
48
←
Taking true branch→
                  ResourceDataValue aliasedValue;
                  aliasedValue.setData(aliasRB->getResData());
49
←
Calling 'UResourceBundle::getResData'→
                  aliasedValue.setValidLocaleDataEntry(aliasRB->fValidLocaleDataEntry);
                  aliasedValue.setResource(aliasRB->fRes, ResourceTracer(aliasRB));
                  
                  if (aliasedValue.getType() != URES_TABLE) {
                      dest.put(key, aliasedValue, isRoot, errorCode);
                  } else {
                      // if the resource we're aliasing over to is a table, the sink might iterate over its contents.
                      // If it does, it'll get only the things defined in the actual alias target, not the things
                      // the target inherits from its parent resources.  So we walk the parent chain for the *alias target*,
                      // calling dest.put() for each of the parent tables we could be inheriting from.  This means
                      // that dest.put() has to iterate over the children of multiple tables to get all of the inherited
                      // resource values, but it already has to do that to handle normal vertical inheritance.
                      UResType aliasedValueType = URES_TABLE;
                      CharString tablePath;
                      tablePath.append(aliasRB->fResPath, errorCode);
                      const char* parentKey = key; // dest.put() changes the key
                      dest.put(parentKey, aliasedValue, isRoot, errorCode);
                      UResourceDataEntry* entry = aliasRB->fData;
                      Resource res = aliasRB->fRes;
                      while (aliasedValueType == URES_TABLE && entry->fParent != nullptr) {
                          CharString localPath;
                          localPath.copyFrom(tablePath, errorCode);
                          char* localPathAsCharPtr = localPath.data();
                          const char* childKey;
                          entry = entry->fParent;
                          res = entry->fData.rootRes;
                          Resource newRes = res_findResourceres_findResource_77(&entry->fData, res, &localPathAsCharPtr, &childKey);
                          if (newRes != RES_BOGUS0xffffffff) {
                              aliasedValue.setData(entry->fData);
                              // TODO: do I also need to call aliasedValue.setValueLocaleDataEntry() ?
                              aliasedValue.setResource(newRes, ResourceTracer(aliasRB)); // probably wrong to use aliasRB here
                              aliasedValueType = aliasedValue.getType();
                              if (aliasedValueType == URES_ALIAS) {
                                  // in a few rare cases, when we get to the root resource bundle, the resource in question
                                  // won't be an actual table, but will instead be an alias to a table.  That is, we have
                                  // two aliases in the inheritance path.  (For some locales, such as Zulu, we see this with
                                  // children of the "fields" resource: "day-narrow" aliases to "day-short", which aliases
                                  // to "day".)  When this happens, we need to make sure we follow all the aliases.
                                  ResourceDataValue& rdv2 = static_cast<ResourceDataValue&>(aliasedValue);
                                  aliasRB = getAliasTargetAsResourceBundle(rdv2.getData(), rdv2.getResource(), nullptr, -1,
                                                                           rdv2.getValidLocaleDataEntry(), nullptr, 0,
                                                                           stackTempBundle.getAlias(), &errorCode);
                                  tablePath.clear();
                                  tablePath.append(aliasRB->fResPath, errorCode);
                                  entry = aliasRB->fData;
                                  res = aliasRB->fRes;
                                  aliasedValue.setData(entry->fData);
                                  // TODO: do I also need to call aliasedValue.setValueLocaleDataEntry() ?
                                  aliasedValue.setResource(res, ResourceTracer(aliasRB)); // probably wrong to use aliasRB here
                                  aliasedValueType = aliasedValue.getType();
                              }
                              if (aliasedValueType == URES_TABLE) {
                                  dest.put(parentKey, aliasedValue, isRoot, errorCode);
                              } else {
                                  // once we've followed the alias, the resource we're looking at really should
                                  // be a table
                                  errorCode = U_INTERNAL_PROGRAM_ERROR;
                                  return;
                              }
                          }
                      }
                  }
              }
          } else {
              dest.put(key, value, isRoot, errorCode);
          }
          if (U_FAILURE(errorCode)) { return; }
      }
  }
2422};

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

2427U_CAPIextern "C" void U_EXPORT2
2428ures_getAllChildrenWithFallbackures_getAllChildrenWithFallback_77(const UResourceBundle *bundle, const char *path,
                              icu::ResourceSink &sink, UErrorCode &errorCode) {
  GetAllChildrenSink allChildrenSink(sink);
  ures_getAllItemsWithFallbackures_getAllItemsWithFallback_77(bundle, path, allChildrenSink, errorCode);
1
Calling 'ures_getAllItemsWithFallback_77'→
2432}

2434}  // namespace

2436// Requires a ResourceDataValue fill-in, so that we need not cast from a ResourceValue.
2437// Unfortunately, the caller must know which subclass to make and pass in.
2438// Alternatively, we could make it as polymorphic as in Java by
2439// returning a ResourceValue pointer (possibly wrapped into a LocalPointer)
2440// that the caller then owns.
2441//
2442// Also requires a UResourceBundle fill-in, so that the value's ResourceTracer
2443// can point to a non-local bundle.
2444// Without tracing, the child bundle could be a function-local object.
2445U_CAPIextern "C" void U_EXPORT2
2446ures_getValueWithFallbackures_getValueWithFallback_77(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_77(bundle, path, tempFillIn, &errorCode);
      if (U_FAILURE(errorCode)) {
          return;
      }
  }
  value.setData(rb->getResData());
  value.setValidLocaleDataEntry(rb->fValidLocaleDataEntry);
  value.setResource(rb->fRes, ResourceTracer(rb));
2467}

2469U_CAPIextern "C" void U_EXPORT2
2470ures_getAllItemsWithFallbackures_getAllItemsWithFallback_77(const UResourceBundle *bundle, const char *path,
                           icu::ResourceSink &sink, UErrorCode &errorCode) {
  if (U_FAILURE(errorCode)) { return; }
2
←
Taking false branch→
  if (path == nullptr) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  StackUResourceBundle stackBundle;
  const UResourceBundle *rb;
  if (*path == 0) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
      // empty path
      rb = bundle;
  } else {
      rb = ures_getByKeyWithFallbackures_getByKeyWithFallback_77(bundle, path, stackBundle.getAlias(), &errorCode);
      if (U_FAILURE(errorCode)) {
7
←
Taking false branch→
          return;
      }
  }
  // Get all table items with fallback.
  ResourceDataValue value;
  getAllItemsWithFallback(rb, value, sink, errorCode);
8
←
Calling 'getAllItemsWithFallback'→
2491}

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

  if (status==nullptr || U_FAILURE(*status)) {
      return fillIn;
  }
  if(resB == nullptr) {
      *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_77(&resB->getResData(), resB->fRes, &t, &key);
      if(res == RES_BOGUS0xffffffff) {
          key = inKey;
          if(resB->fHasFallback) {
              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);
      }
  } 
2527#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 == true) {
      /* 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;
      }
  }
2539#endif    
  else {
      *status = U_RESOURCE_TYPE_MISMATCH;
  }
  return fillIn;
2544}

2546U_CAPIextern "C" const char16_t* U_EXPORT2 ures_getStringByKeyures_getStringByKey_77(const UResourceBundle *resB, const char* inKey, int32_t* len, UErrorCode *status) {
  Resource res = RES_BOGUS0xffffffff;
  UResourceDataEntry *dataEntry = nullptr;
  const char* key = inKey;

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

  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_77(&resB->getResData(), resB->fRes, &t, &key);

      if(res == RES_BOGUS0xffffffff) {
          key = inKey;
          if(resB->fHasFallback) {
              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 char16_t* result = nullptr;
                      UResourceBundle *tempRes = ures_getByKeyures_getByKey_77(resB, inKey, nullptr, status);
                      result = ures_getStringures_getString_77(tempRes, len, status);
                      ures_closeures_close_77(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 char16_t* result = nullptr;
              UResourceBundle *tempRes = ures_getByKeyures_getByKey_77(resB, inKey, nullptr, status);
              result = ures_getStringures_getString_77(tempRes, len, status);
              ures_closeures_close_77(tempRes);
              return result;
            }
          default:
              *status = U_RESOURCE_TYPE_MISMATCH;
          }
      }
  } 
2609#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 == true) {
      /* 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;
      }
  } 
2622#endif    
  else {
      *status = U_RESOURCE_TYPE_MISMATCH;
  }
  return nullptr;
2627}

2629U_CAPIextern "C" const char * U_EXPORT2
2630ures_getUTF8StringByKeyures_getUTF8StringByKey_77(const UResourceBundle *resB,
                      const char *key,
                      char *dest, int32_t *pLength,
                      UBool forceCopy,
                      UErrorCode *status) {
  int32_t length16;
  const char16_t *s16 = ures_getStringByKeyures_getStringByKey_77(resB, key, &length16, status);
  return ures_toUTF8String(s16, length16, dest, pLength, forceCopy, status);
2638}

2640/* TODO: clean from here down */

2642/**
*  INTERNAL: Get the name of the first real locale (not placeholder) 
*  that has resource bundle data.
*/
2646U_CAPIextern "C" const char*  U_EXPORT2
2647ures_getLocaleInternalures_getLocaleInternal_77(const UResourceBundle* resourceBundle, UErrorCode* status)
2648{
  if (status==nullptr || U_FAILURE(*status)) {
      return nullptr;
  }
  if (!resourceBundle) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return nullptr;
  } else {
    return resourceBundle->fData->fName;
  }
2658}

2660U_CAPIextern "C" const char* U_EXPORT2 
2661ures_getLocaleures_getLocale_77(const UResourceBundle* resourceBundle, 
             UErrorCode* status)
2663{
return ures_getLocaleInternalures_getLocaleInternal_77(resourceBundle, status);
2665}


2668U_CAPIextern "C" const char* U_EXPORT2 
2669ures_getLocaleByTypeures_getLocaleByType_77(const UResourceBundle* resourceBundle, 
                   ULocDataLocaleType type, 
                   UErrorCode* status) {
  if (status==nullptr || U_FAILURE(*status)) {
      return nullptr;
  }
  if (!resourceBundle) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return nullptr;
  } 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 nullptr;
      }
  }
2690}

2692U_CFUNCextern "C" const char* ures_getNameures_getName_77(const UResourceBundle* resB) {
if(resB == nullptr) {
  return nullptr;
}

return resB->fData->fName;
2698}

2700#ifdef URES_DEBUG
2701U_CFUNCextern "C" const char* ures_getPath(const UResourceBundle* resB) {
if(resB == nullptr) {
  return nullptr;
}

return resB->fData->fPath;
2707}
2708#endif

2710static UResourceBundle*
2711ures_openWithType(UResourceBundle *r, const char* path, const char* localeID,
                UResOpenType openType, UErrorCode* status) {
  if(U_FAILURE(*status)) {
      return nullptr;
  }

  UResourceDataEntry *entry;
  if(openType != URES_OPEN_DIRECT) {
      if (localeID == nullptr) {
          localeID = uloc_getDefaultuloc_getDefault_77();
      }
      /* first "canonicalize" the locale ID */
      CharString canonLocaleID = ulocimp_getBaseNameulocimp_getBaseName_77(localeID, *status);
      if(U_FAILURE(*status)) {
          *status = U_ILLEGAL_ARGUMENT_ERROR;
          return nullptr;
      }
      entry = entryOpen(path, canonLocaleID.data(), openType, status);
  } else {
      entry = entryOpenDirect(path, localeID, status);
  }
  if(U_FAILURE(*status)) {
      return nullptr;
  }
  if(entry == nullptr) {
      *status = U_MISSING_RESOURCE_ERROR;
      return nullptr;
  }

  UBool isStackObject;
  if(r == nullptr) {
      r = static_cast<UResourceBundle*>(uprv_mallocuprv_malloc_77(sizeof(UResourceBundle)));
      if(r == nullptr) {
          entryClose(entry);
          *status = U_MEMORY_ALLOCATION_ERROR;
          return nullptr;
      }
      isStackObject = false;
  } else {  // fill-in
      isStackObject = ures_isStackObject(r);
      ures_closeBundle(r, false);
  }
  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 = true;
  r->fRes = r->getResData().rootRes;
  r->fSize = res_countArrayItemsres_countArrayItems_77(&r->getResData(), r->fRes);
  r->fIndex = -1;

  ResourceTracer(r).traceOpen();

  return r;
2766}

2768U_CAPIextern "C" UResourceBundle* U_EXPORT2
2769ures_openures_open_77(const char* path, const char* localeID, UErrorCode* status) {
  return ures_openWithType(nullptr, path, localeID, URES_OPEN_LOCALE_DEFAULT_ROOT, status);
2771}

2773U_CAPIextern "C" UResourceBundle* U_EXPORT2
2774ures_openNoDefaultures_openNoDefault_77(const char* path, const char* localeID, UErrorCode* status) {
  return ures_openWithType(nullptr, path, localeID, URES_OPEN_LOCALE_ROOT, status);
2776}

2778/**
*  Opens a resource bundle without "canonicalizing" the locale name. No fallback will be performed 
*  or sought. However, alias substitution will happen!
*/
2782U_CAPIextern "C" UResourceBundle*  U_EXPORT2
2783ures_openDirectures_openDirect_77(const char* path, const char* localeID, UErrorCode* status) {
  return ures_openWithType(nullptr, path, localeID, URES_OPEN_DIRECT, status);
2785}

2787/**
*  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.
*/
2794U_CAPIextern "C" void U_EXPORT2
2795ures_openFillInures_openFillIn_77(UResourceBundle *r, const char* path,
              const char* localeID, UErrorCode* status) {
  if(U_SUCCESS(*status) && r == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  ures_openWithType(r, path, localeID, URES_OPEN_LOCALE_DEFAULT_ROOT, status);
2802}

2804/**
* Same as ures_openDirect(), but uses the fill-in parameter and does not allocate a new bundle.
*/
2807U_CAPIextern "C" void U_EXPORT2
2808ures_openDirectFillInures_openDirectFillIn_77(UResourceBundle *r, const char* path, const char* localeID, UErrorCode* status) {
  if(U_SUCCESS(*status) && r == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  ures_openWithType(r, path, localeID, URES_OPEN_DIRECT, status);
2814}

2816/**
*  API: Counts members. For arrays and tables, returns number of resources.
*  For strings, returns 1.
*/
2820U_CAPIextern "C" int32_t  U_EXPORT2
2821ures_countArrayItemsures_countArrayItems_77(const UResourceBundle* resourceBundle,
                const char* resourceKey,
                UErrorCode* status)
2824{
  UResourceBundle resData;
  ures_initStackObjectures_initStackObject_77(&resData);
  if (status==nullptr || U_FAILURE(*status)) {
      return 0;
  }
  if(resourceBundle == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  ures_getByKeyures_getByKey_77(resourceBundle, resourceKey, &resData, status);
  
  if(resData.getResData().data != nullptr) {
      int32_t result = res_countArrayItemsres_countArrayItems_77(&resData.getResData(), resData.fRes);
      ures_closeures_close_77(&resData);
      return result;
  } else {
      *status = U_MISSING_RESOURCE_ERROR;
      ures_closeures_close_77(&resData);
      return 0;
  }
2845}

2847/**
* 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
*/
2857U_CAPIextern "C" const char* U_EXPORT2 
2858ures_getVersionNumberInternalures_getVersionNumberInternal_77(const UResourceBundle *resourceBundle)
2859{
  if (!resourceBundle) return nullptr;

  if(resourceBundle->fVersion == nullptr) {

      /* 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 char16_t* minor_version = ures_getStringByKeyures_getStringByKey_77(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_77(1 + len); 
      /* Check for null pointer. */
      if (((UResourceBundle *)resourceBundle)->fVersion == nullptr) {
          return nullptr;
      }
     
      if(minor_len > 0) {
          u_UCharsToCharsu_UCharsToChars_77(minor_version, resourceBundle->fVersion , minor_len);
          resourceBundle->fVersion[len] =  '\0';
      }
      else {
          uprv_strcpy(resourceBundle->fVersion, kDefaultMinorVersion):: strcpy(resourceBundle->fVersion, "0");
      }
  }

  return resourceBundle->fVersion;
2899}

2901U_CAPIextern "C" const char*  U_EXPORT2
2902ures_getVersionNumberures_getVersionNumber_77(const UResourceBundle*   resourceBundle)
2903{
  return ures_getVersionNumberInternalures_getVersionNumberInternal_77(resourceBundle);
2905}

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

  u_versionFromStringu_versionFromString_77(versionInfo, ures_getVersionNumberInternalures_getVersionNumberInternal_77(resB));
2911}

2913/** Tree support functions *******************************/
2914#define INDEX_LOCALE_NAME"res_index" "res_index"
2915#define INDEX_TAG"InstalledLocales"         "InstalledLocales"
2916#define DEFAULT_TAG"default"       "default"

2918#if defined(URES_TREE_DEBUG)
2919#include <stdio.h>
2920#endif

2922typedef struct ULocalesContext {
  UResourceBundle installed;
  UResourceBundle curr;
2925} ULocalesContext;

2927static void U_CALLCONV
2928ures_loc_closeLocales(UEnumeration *enumerator) {
  ULocalesContext* ctx = static_cast<ULocalesContext*>(enumerator->context);
  ures_closeures_close_77(&ctx->curr);
  ures_closeures_close_77(&ctx->installed);
  uprv_freeuprv_free_77(ctx);
  uprv_freeuprv_free_77(enumerator);
2934}

2936static int32_t U_CALLCONV
2937ures_loc_countLocales(UEnumeration *en, UErrorCode * /*status*/) {
  ULocalesContext* ctx = static_cast<ULocalesContext*>(en->context);
  return ures_getSizeures_getSize_77(&ctx->installed);
2940}

2942U_CDECL_BEGINextern "C" {


2945static const char * U_CALLCONV
2946ures_loc_nextLocale(UEnumeration* en,
                  int32_t* resultLength,
                  UErrorCode* status) {
  ULocalesContext *ctx = (ULocalesContext *)en->context;
  UResourceBundle *res = &(ctx->installed);
  UResourceBundle *k = nullptr;
  const char *result = nullptr;
  int32_t len = 0;
  if (ures_hasNextures_hasNext_77(res) && (k = ures_getNextResourceures_getNextResource_77(res, &ctx->curr, status)) != nullptr) {
      result = ures_getKeyures_getKey_77(k);
      len = (int32_t)uprv_strlen(result):: strlen(result);
  }
  if (resultLength) {
      *resultLength = len;
  }
  return result;
2962}

2964static void U_CALLCONV 
2965ures_loc_resetLocales(UEnumeration* en, 
                    UErrorCode* /*status*/) {
  UResourceBundle *res = &((ULocalesContext *)en->context)->installed;
  ures_resetIteratorures_resetIterator_77(res);
2969}

2971U_CDECL_END}

2973static const UEnumeration gLocalesEnum = {
  nullptr,
      nullptr,
      ures_loc_closeLocales,
      ures_loc_countLocales,
      uenum_unextDefaultuenum_unextDefault_77,
      ures_loc_nextLocale,
      ures_loc_resetLocales
2981};


2984U_CAPIextern "C" UEnumeration* U_EXPORT2
2985ures_openAvailableLocalesures_openAvailableLocales_77(const char *path, UErrorCode *status)
2986{
  UResourceBundle *idx = nullptr;
  UEnumeration *en = nullptr;
  ULocalesContext *myContext = nullptr;

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

 (static_cast <bool> (en != __null) ? void (0) : __assert_fail
 ("en != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (&gLocalesEnum
 != __null) ? void (0) : __assert_fail ("&gLocalesEnum != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(en, &gLocalesEnum, sizeof
(UEnumeration)); } while (false);

  ures_initStackObjectures_initStackObject_77(&myContext->installed);
  ures_initStackObjectures_initStackObject_77(&myContext->curr);
  idx = ures_openDirectures_openDirect_77(path, INDEX_LOCALE_NAME"res_index", status);
  ures_getByKeyures_getByKey_77(idx, INDEX_TAG"InstalledLocales", &myContext->installed, status);
  if(U_SUCCESS(*status)) {
3009#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_77(&myContext->installed));
3012#endif
      en->context = myContext;
  } else {
3015#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "%s open failed - %s\n", path, u_errorNameu_errorName_77(*status));
3017#endif
      ures_closeures_close_77(&myContext->installed);
      uprv_freeuprv_free_77(myContext);
      uprv_freeuprv_free_77(en);
      en = nullptr;
  }
  
  ures_closeures_close_77(idx);
  
  return en;
3027}

3029static UBool isLocaleInList(UEnumeration *locEnum, const char *locToSearch, UErrorCode *status) {
  const char *loc;
  while ((loc = uenum_nextuenum_next_77(locEnum, nullptr, status)) != nullptr) {
      if (uprv_strcmp(loc, locToSearch):: strcmp(loc, locToSearch) == 0) {
          return true;
      }
  }
  return false;
3037}

3039static void getParentForFunctionalEquivalent(const char*      localeID,
                                           UResourceBundle* res,
                                           UResourceBundle* bund1,
                                           CharString&      parent) {
  // Get parent.
  // First check for a parent from %%Parent resource (Note that in resource trees
  // such as collation, data may have different parents than in parentLocales).
  UErrorCode subStatus = U_ZERO_ERROR;
  parent.clear();
  if (res != nullptr) {
      ures_getByKeyures_getByKey_77(res, "%%Parent", bund1, &subStatus);
      if (U_SUCCESS(subStatus)) {
          int32_t length16;
          const char16_t* s16 = ures_getStringures_getString_77(bund1, &length16, &subStatus);
          parent.appendInvariantChars(s16, length16, subStatus);
      }
  }
  
  // If none there, use normal truncation parent
  if (U_FAILURE(subStatus) || parent.isEmpty()) {
      subStatus = U_ZERO_ERROR;
      parent = ulocimp_getParentulocimp_getParent_77(localeID, subStatus);
  }
3062}

3064U_CAPIextern "C" int32_t U_EXPORT2
3065ures_getFunctionalEquivalentures_getFunctionalEquivalent_77(char *result, int32_t resultCapacity,
                           const char *path, const char *resName, const char *keyword, const char *locid,
                           UBool *isAvailable, UBool omitDefault, UErrorCode *status)
3068{
  CharString defVal; /* default value for given locale */
  CharString defLoc; /* default value for given locale */
  CharString found;
  CharString parent;
  CharString full;
  UResourceBundle bund1, bund2;
  UResourceBundle *res = nullptr;
  UErrorCode subStatus = U_ZERO_ERROR;
  int32_t length = 0;
  if(U_FAILURE(*status)) return 0;
  CharString kwVal;
  if (keyword != nullptr && *keyword != '\0') {
      kwVal = ulocimp_getKeywordValueulocimp_getKeywordValue_77(locid, keyword, subStatus);
      if (kwVal == DEFAULT_TAG"default") {
          kwVal.clear();
      }
  }
  if (locid == nullptr) {
      locid = uloc_getDefaultuloc_getDefault_77();
  }
  CharString base = ulocimp_getBaseNameulocimp_getBaseName_77(locid, subStatus);
3090#if defined(URES_TREE_DEBUG)
  fprintf(stderrstderr, "getFunctionalEquivalent: \"%s\" [%s=%s] in %s - %s\n", 
          locid, keyword, kwVal.data(), base.data(), u_errorNameu_errorName_77(subStatus));
3093#endif
  ures_initStackObjectures_initStackObject_77(&bund1);
  ures_initStackObjectures_initStackObject_77(&bund2);

  parent.copyFrom(base, subStatus);
  found.copyFrom(base, subStatus);

  if(isAvailable) {
      UEnumeration *locEnum = ures_openAvailableLocalesures_openAvailableLocales_77(path, &subStatus);
      *isAvailable = true;
      if (U_SUCCESS(subStatus)) {
          *isAvailable = isLocaleInList(locEnum, parent.data(), &subStatus);
      }
      uenum_closeuenum_close_77(locEnum);
  }

  if(U_FAILURE(subStatus)) {
      *status = subStatus;
      return 0;
  }
  
  do {
      subStatus = U_ZERO_ERROR;
      res = ures_openures_open_77(path, parent.data(), &subStatus);
      if(((subStatus == U_USING_FALLBACK_WARNING) ||
          (subStatus == U_USING_DEFAULT_WARNING)) && isAvailable)
      {
          *isAvailable = false;
      }
      isAvailable = nullptr; /* only want to set this the first time around */
      
3124#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "%s;%s -> %s [%s]\n", path?path:"ICUDATA", parent.data(), u_errorNameu_errorName_77(subStatus), ures_getLocaleures_getLocale_77(res, &subStatus));
3126#endif
      if(U_FAILURE(subStatus)) {
          *status = subStatus;
      } else if(subStatus == U_ZERO_ERROR) {
          ures_getByKeyures_getByKey_77(res,resName,&bund1, &subStatus);
          if(subStatus == U_ZERO_ERROR) {
              const char16_t *defUstr;
              int32_t defLen;
              /* look for default item */
3135#if defined(URES_TREE_DEBUG)
              fprintf(stderrstderr, "%s;%s : loaded default -> %s\n",
                  path?path:"ICUDATA", parent.data(), u_errorNameu_errorName_77(subStatus));
3138#endif
              defUstr = ures_getStringByKeyures_getStringByKey_77(&bund1, DEFAULT_TAG"default", &defLen, &subStatus);
              if(U_SUCCESS(subStatus) && defLen) {
                  defVal.clear().appendInvariantChars(defUstr, defLen, subStatus);
3142#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "%s;%s -> default %s=%s,  %s\n", 
                      path?path:"ICUDATA", parent.data(), keyword, defVal.data(), u_errorNameu_errorName_77(subStatus));
3145#endif
                  defLoc.copyFrom(parent, subStatus);
                  if(kwVal.isEmpty()) {
                      kwVal.append(defVal, subStatus);
3149#if defined(URES_TREE_DEBUG)
                      fprintf(stderrstderr, "%s;%s -> kwVal =  %s\n", 
                          path?path:"ICUDATA", parent.data(), keyword, kwVal.data());
3152#endif
                  }
              }
          }
      }
      
      subStatus = U_ZERO_ERROR;

      if (res != nullptr) {
          found.clear().append(ures_getLocaleByTypeures_getLocaleByType_77(res, ULOC_VALID_LOCALE, &subStatus), subStatus);
      }

      if (found != parent) {
          parent.copyFrom(found, subStatus);
      } else {
          getParentForFunctionalEquivalent(found.data(),res,&bund1,parent);
      }
      ures_closeures_close_77(res);
  } while(defVal.isEmpty() && !found.isEmpty() && found != "root" && U_SUCCESS(*status));
  
  /* Now, see if we can find the kwVal collator.. start the search over.. */
  parent.copyFrom(base, subStatus);
  found.copyFrom(base, subStatus);

  do {
      res = ures_openures_open_77(path, parent.data(), &subStatus);
      if((subStatus == U_USING_FALLBACK_WARNING) && isAvailable) {
          *isAvailable = false;
      }
      isAvailable = nullptr; /* only want to set this the first time around */
      
3183#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "%s;%s -> %s (looking for %s)\n", 
          path?path:"ICUDATA", parent.data(), u_errorNameu_errorName_77(subStatus), kwVal.data());
3186#endif
      if(U_FAILURE(subStatus)) {
          *status = subStatus;
      } else if(subStatus == U_ZERO_ERROR) {
          ures_getByKeyures_getByKey_77(res,resName,&bund1, &subStatus);
3191#if defined(URES_TREE_DEBUG)
3192/**/ fprintf(stderrstderr,"@%d [%s] %s\n", __LINE__3192, resName, u_errorNameu_errorName_77(subStatus));
3193#endif
          if(subStatus == U_ZERO_ERROR) {
              ures_getByKeyures_getByKey_77(&bund1, kwVal.data(), &bund2, &subStatus);
3196#if defined(URES_TREE_DEBUG)
3197/**/ fprintf(stderrstderr,"@%d [%s] %s\n", __LINE__3197, kwVal.data(), u_errorNameu_errorName_77(subStatus));
3198#endif
              if(subStatus == U_ZERO_ERROR) {
3200#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "%s;%s -> full0 %s=%s,  %s\n", 
                      path?path:"ICUDATA", parent.data(), keyword, kwVal.data(), u_errorNameu_errorName_77(subStatus));
3203#endif
                  if (parent.isEmpty()) {
                      full.clear().append("root", subStatus);
                  } else {
                      full.copyFrom(parent, subStatus);
                  }
                      /* now, recalculate default kw if need be */
                      if(defLoc.length() > full.length()) {
                        const char16_t *defUstr;
                        int32_t defLen;
                        /* look for default item */
3214#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> recalculating Default0\n", 
                                  path?path:"ICUDATA", full.data());
3217#endif
                        defUstr = ures_getStringByKeyures_getStringByKey_77(&bund1, DEFAULT_TAG"default", &defLen, &subStatus);
                        if(U_SUCCESS(subStatus) && defLen) {
                          defVal.clear().appendInvariantChars(defUstr, defLen, subStatus);
3221#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> default0 %s=%s,  %s\n", 
                                  path?path:"ICUDATA", full.data(), keyword, defVal.data(), u_errorNameu_errorName_77(subStatus));
3224#endif
                          defLoc.copyFrom(full, subStatus);
                        }
                      } /* end of recalculate default KW */
3228#if defined(URES_TREE_DEBUG)
                      else {
                        fprintf(stderrstderr, "No trim0,  %s <= %s\n", defLoc.data(), full.data());
                      }
3232#endif
              } else {
3234#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "err=%s in %s looking for %s\n", 
                      u_errorNameu_errorName_77(subStatus), parent.data(), kwVal.data());
3237#endif
              }
          }
      }
      
      subStatus = U_ZERO_ERROR;
      UBool haveFound = false;
      // At least for collations which may be aliased, we need to use the VALID locale
      // as the parent instead of just truncating, as long as the VALID locale is not
      // root and has a different language than the parent. Use of the VALID locale
      // here is similar to the procedure used at the end of the previous do-while loop
      // for all resource types.
      if (res != nullptr && uprv_strcmp(resName, "collations"):: strcmp(resName, "collations") == 0) {
          const char *validLoc = ures_getLocaleByTypeures_getLocaleByType_77(res, ULOC_VALID_LOCALE, &subStatus);
          if (U_SUCCESS(subStatus) && validLoc != nullptr && validLoc[0] != 0 && uprv_strcmp(validLoc, "root"):: strcmp(validLoc, "root") != 0) {
              CharString validLang = ulocimp_getLanguageulocimp_getLanguage_77(validLoc, subStatus);
              CharString parentLang = ulocimp_getLanguageulocimp_getLanguage_77(parent.toStringPiece(), subStatus);
              if (U_SUCCESS(subStatus) && validLang != parentLang) {
                  // validLoc is not root and has a different language than parent, use it instead
                  found.clear().append(validLoc, subStatus);
                  haveFound = true;
              }
          }
          subStatus = U_ZERO_ERROR;
      }
      if (!haveFound) {
          found.copyFrom(parent, subStatus);
      }

      getParentForFunctionalEquivalent(found.data(),res,&bund1,parent);
      ures_closeures_close_77(res);
      subStatus = U_ZERO_ERROR;
  } while(full.isEmpty() && !found.isEmpty() && U_SUCCESS(*status));

  if(full.isEmpty() && kwVal != defVal) {
3272#if defined(URES_TREE_DEBUG)
      fprintf(stderrstderr, "Failed to locate kw %s - try default %s\n", kwVal.data(), defVal.data());
3274#endif
      kwVal.clear().append(defVal, subStatus);
      parent.copyFrom(base, subStatus);
      found.copyFrom(base, subStatus);

      do { /* search for 'default' named item */
          res = ures_openures_open_77(path, parent.data(), &subStatus);
          if((subStatus == U_USING_FALLBACK_WARNING) && isAvailable) {
              *isAvailable = false;
          }
          isAvailable = nullptr; /* only want to set this the first time around */
          
3286#if defined(URES_TREE_DEBUG)
          fprintf(stderrstderr, "%s;%s -> %s (looking for default %s)\n",
              path?path:"ICUDATA", parent.data(), u_errorNameu_errorName_77(subStatus), kwVal.data());
3289#endif
          if(U_FAILURE(subStatus)) {
              *status = subStatus;
          } else if(subStatus == U_ZERO_ERROR) {
              ures_getByKeyures_getByKey_77(res,resName,&bund1, &subStatus);
              if(subStatus == U_ZERO_ERROR) {
                  ures_getByKeyures_getByKey_77(&bund1, kwVal.data(), &bund2, &subStatus);
                  if(subStatus == U_ZERO_ERROR) {
3297#if defined(URES_TREE_DEBUG)
                      fprintf(stderrstderr, "%s;%s -> full1 %s=%s,  %s\n", path?path:"ICUDATA",
                          parent.data(), keyword, kwVal.data(), u_errorNameu_errorName_77(subStatus));
3300#endif
                      if (parent.isEmpty()) {
                          full.clear().append("root", subStatus);
                      } else {
                          full.copyFrom(parent, subStatus);
                      }
                      
                      /* now, recalculate default kw if need be */
                      if(defLoc.length() > full.length()) {
                        const char16_t *defUstr;
                        int32_t defLen;
                        /* look for default item */
3312#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> recalculating Default1\n", 
                                  path?path:"ICUDATA", full.data());
3315#endif
                        defUstr = ures_getStringByKeyures_getStringByKey_77(&bund1, DEFAULT_TAG"default", &defLen, &subStatus);
                        if(U_SUCCESS(subStatus) && defLen) {
                          defVal.clear().appendInvariantChars(defUstr, defLen, subStatus);
3319#if defined(URES_TREE_DEBUG)
                          fprintf(stderrstderr, "%s;%s -> default %s=%s,  %s\n", 
                                  path?path:"ICUDATA", full.data(), keyword, defVal.data(), u_errorNameu_errorName_77(subStatus));
3322#endif
                          defLoc.copyFrom(full, subStatus);
                        }
                      } /* end of recalculate default KW */
3326#if defined(URES_TREE_DEBUG)
                      else {
                        fprintf(stderrstderr, "No trim1,  %s <= %s\n", defLoc.data(), full.data());
                      }
3330#endif
                  }
              }
          }
          
          subStatus = U_ZERO_ERROR;
          found.copyFrom(parent, subStatus);
          getParentForFunctionalEquivalent(found.data(),res,&bund1,parent);
          ures_closeures_close_77(res);
          subStatus = U_ZERO_ERROR;
      } while(full.isEmpty() && !found.isEmpty() && U_SUCCESS(*status));
  }
  
  if(U_SUCCESS(*status)) {
      if(full.isEmpty()) {
3345#if defined(URES_TREE_DEBUG)
        fprintf(stderrstderr, "Still could not load keyword %s=%s\n", keyword, kwVal.data());
3347#endif
        *status = U_MISSING_RESOURCE_ERROR;
      } else if(omitDefault) {
3350#if defined(URES_TREE_DEBUG)
        fprintf(stderrstderr,"Trim? full=%s, defLoc=%s, found=%s\n", full.data(), defLoc.data(), found.data());
3352#endif        
        if(defLoc.length() <= full.length()) {
          /* found the keyword in a *child* of where the default tag was present. */
          if(kwVal == defVal) { /* if the requested kw is default, */
            /* and the default is in or in an ancestor of the current locale */
3357#if defined(URES_TREE_DEBUG)
            fprintf(stderrstderr, "Removing unneeded var %s=%s\n", keyword, kwVal.data());
3359#endif
            kwVal.clear();
          }
        }
      }
      found.copyFrom(full, subStatus);
      if(!kwVal.isEmpty()) {
          found
              .append("@", subStatus)
              .append(keyword, subStatus)
              .append("=", subStatus)
              .append(kwVal, subStatus);
      } else if(!omitDefault) {
          found
              .append("@", subStatus)
              .append(keyword, subStatus)
              .append("=", subStatus)
              .append(defVal, subStatus);
      }
  }
  /* we found the default locale - no need to repeat it.*/
  
  ures_closeures_close_77(&bund1);
  ures_closeures_close_77(&bund2);
  
  length = found.length();

  if(U_SUCCESS(*status)) {
      int32_t copyLength = uprv_minuprv_min_77(length, resultCapacity);
      if(copyLength>0) {
          found.extract(result, copyLength, subStatus);
      }
      if(length == 0) {
        *status = U_MISSING_RESOURCE_ERROR; 
      }
  } else {
      length = 0;
      result[0]=0;
  }
  return u_terminateCharsu_terminateChars_77(result, resultCapacity, length, status);
3399}

3401U_CAPIextern "C" UEnumeration* U_EXPORT2
3402ures_getKeywordValuesures_getKeywordValues_77(const char *path, const char *keyword, UErrorCode *status)
3403{
3404#define VALUES_BUF_SIZE2048 2048
3405#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 = nullptr;
  
  UResourceBundle    item;
  UResourceBundle    subItem;
  
  ures_initStackObjectures_initStackObject_77(&item);
  ures_initStackObjectures_initStackObject_77(&subItem);
  locs = ures_openAvailableLocalesures_openAvailableLocales_77(path, status);
  
  if(U_FAILURE(*status)) {
      ures_closeures_close_77(&item);
      ures_closeures_close_77(&subItem);
      return nullptr;
  }
  
  valuesBuf[0]=0;
  valuesBuf[1]=0;

  while ((locale = uenum_nextuenum_next_77(locs, &locLen, status)) != nullptr) {
      UResourceBundle   *bund = nullptr;
      UResourceBundle   *subPtr = nullptr;
      UErrorCode subStatus = U_ZERO_ERROR; /* don't fail if a bundle is unopenable */
      bund = ures_openures_open_77(path, locale, &subStatus);
      
3439#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_77(subStatus));
      }
3444#endif
      
      ures_getByKeyures_getByKey_77(bund, keyword, &item, &subStatus);
      
      if(!bund || U_FAILURE(subStatus)) {
3449#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_77(subStatus));
3452#endif
          ures_closeures_close_77(bund);
          bund = nullptr;
          continue;
      }

      while ((subPtr = ures_getNextResourceures_getNextResource_77(&item, &subItem, &subStatus)) != nullptr
          && U_SUCCESS(subStatus)) {
          const char *k;
          int32_t i;
          k = ures_getKeyures_getKey_77(subPtr);

3464#if defined(URES_TREE_DEBUG)
          /* fprintf(stderr, "%s | %s | %s | %s\n", path?path:"<ICUDATA>", keyword, locale, k); */
3466#endif
          if(k == nullptr || *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 = nullptr; /* found duplicate */
                  break;
              }
          }
          if(k != nullptr) {
              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;
3487#if defined(URES_TREE_DEBUG)
                  fprintf(stderrstderr, "%s | %s | %s | [%s]   (UNIQUE)\n",
                      path?path:"<ICUDATA>", keyword, locale, k);
3490#endif
                  valuesBuf[valuesIndex++] = 0; /* terminate */
              }
          }
      }
      ures_closeures_close_77(bund);
  }
  valuesBuf[valuesIndex++] = 0; /* terminate */
  
  ures_closeures_close_77(&item);
  ures_closeures_close_77(&subItem);
  uenum_closeuenum_close_77(locs);
3502#if defined(URES_TREE_DEBUG)
  fprintf(stderrstderr, "%s:  size %d, #%d\n", u_errorNameu_errorName_77(*status), 
      valuesIndex, valuesCount);
3505#endif
  return uloc_openKeywordListuloc_openKeywordList_77(valuesBuf, valuesIndex, status);
3507}
3508#if 0
3509/* This code isn't needed, and given the documentation warnings the implementation is suspect */
3510U_CAPIextern "C" UBool U_EXPORT2
3511ures_equal(const UResourceBundle* res1, const UResourceBundle* res2){
  if(res1==nullptr || res2==nullptr){
      return res1==res2; /* pointer comparison */
  }
  if(res1->fKey==nullptr||  res2->fKey==nullptr){
      return (res1->fKey==res2->fKey);
  }else{
      if(uprv_strcmp(res1->fKey, res2->fKey):: strcmp(res1->fKey, res2->fKey)!=0){
          return false;
      }
  }
  if(uprv_strcmp(res1->fData->fName, res2->fData->fName):: strcmp(res1->fData->fName, res2->fData->fName)!=0){
      return false;
  }
  if(res1->fData->fPath == nullptr||  res2->fData->fPath==nullptr){
      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 false;
      }
  }
  if(uprv_strcmp(res1->fData->fParent->fName, res2->fData->fParent->fName):: strcmp(res1->fData->fParent->fName, res2->fData
->fParent->fName)!=0){
      return false;
  }
  if(uprv_strcmp(res1->fData->fParent->fPath, res2->fData->fParent->fPath):: strcmp(res1->fData->fParent->fPath, res2->fData
->fParent->fPath)!=0){
      return false;
  }
  if(uprv_strncmp(res1->fResPath, res2->fResPath, res1->fResPathLen):: strncmp(res1->fResPath, res2->fResPath, res1->fResPathLen
)!=0){
      return false;
  }
  if(res1->fRes != res2->fRes){
      return false;
  }
  return true;
3545}
3546U_CAPIextern "C" UResourceBundle* U_EXPORT2
3547ures_clone(const UResourceBundle* res, UErrorCode* status){
  UResourceBundle* bundle = nullptr;
  UResourceBundle* ret = nullptr;
  if(U_FAILURE(*status) || res == nullptr){
      return nullptr;
  }
  bundle = ures_openures_open_77(res->fData->fPath, res->fData->fName, status);
  if(res->fResPath!=nullptr){
      ret = ures_findSubResourceures_findSubResource_77(bundle, res->fResPath, nullptr, status);
      ures_closeures_close_77(bundle);
  }else{
      ret = bundle;
  }
  return ret;
3561}
3562U_CAPIextern "C" const UResourceBundle* U_EXPORT2
3563ures_getParentBundle(const UResourceBundle* res){
  if(res==nullptr){
      return nullptr;
  }
  return res->fParentRes;
3568}
3569#endif

3571U_CAPIextern "C" void U_EXPORT2
3572ures_getVersionByKeyures_getVersionByKey_77(const UResourceBundle* res, const char *key, UVersionInfo ver, UErrorCode *status) {
const char16_t *str;
int32_t len;
str = ures_getStringByKeyures_getStringByKey_77(res, key, &len, status);
if(U_SUCCESS(*status)) {
  u_versionFromUStringu_versionFromUString_77(ver, str);
} 
3579}

3581/* eof */

←

/root/firefox-clang/intl/icu/source/common/uresimp.h

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4**********************************************************************
5*   Copyright (C) 2000-2016, International Business Machines
6*   Corporation and others.  All Rights Reserved.
7**********************************************************************
8*/

10#ifndef URESIMP_H
11#define URESIMP_H

13#include "unicode/ures.h"
14#include "unicode/utypes.h"

16#include "uresdata.h"

18#define kRootLocaleName"root"         "root"
19#define kPoolBundleName"pool"         "pool"

21/*
The default minor version and the version separator must be exactly one
character long.
24*/

26#define kDefaultMinorVersion"0"    "0"
27#define kVersionSeparator"."       "."
28#define kVersionTag"Version"             "Version"

30#define MAGIC119700503 19700503
31#define MAGIC219641227 19641227

33#define URES_MAX_ALIAS_LEVEL256 256

35#define EMPTY_SET0x2205 0x2205

37struct UResourceDataEntry;
38typedef struct UResourceDataEntry UResourceDataEntry;

40/*
* Note: If we wanted to make this structure smaller, then we could try
* to use one UResourceDataEntry pointer for fAlias and fPool, with a separate
* flag to distinguish whether this struct is for a real bundle with a pool,
* or for an alias entry for which we won't use the pool after loading.
*/
46struct UResourceDataEntry {
  char *fName; /* name of the locale for bundle - still to decide whether it is original or fallback */
  char *fPath; /* path to bundle - used for distinguishing between resources with the same name */
  UResourceDataEntry *fParent; /*next resource in fallback chain*/
  UResourceDataEntry *fAlias;
  UResourceDataEntry *fPool;
  ResourceData fData; /* data for low level access */
  char fNameBuffer[3]; /* A small buffer of free space for fName. The free space is due to struct padding. */
  uint32_t fCountExisting; /* how much is this resource used */
  UErrorCode fBogus;
  /* int32_t fHashKey;*/ /* for faster access in the hashtable */
57};

59#define RES_BUFSIZE64 64
60#define RES_PATH_SEPARATOR'/'   '/'
61#define RES_PATH_SEPARATOR_S"/"   "/"

63U_CAPIextern "C" void U_EXPORT2 ures_initStackObjectures_initStackObject_77(UResourceBundle* resB);

65#ifdef __cplusplus201703L

67struct UResourceBundle {
  const char *fKey; /*tag*/
  /**
   * The dataEntry for the actual locale in which this item lives.
   * Used for accessing the item's data.
   * Non-const pointer for reference counting via entryIncrease().
   */
  UResourceDataEntry *fData; /*for low-level access*/
  char *fVersion;
  /**
   * The dataEntry for the valid locale.
   * Used for /LOCALE/path alias resolution that starts back from the valid locale,
   * rather than from the actual locale of this item which might live in
   * an ancestor bundle.
   */
  UResourceDataEntry *fValidLocaleDataEntry;
  char *fResPath; /* full path to the resource: "zh_TW/CollationElements/Sequence" */
  char fResBuf[RES_BUFSIZE64];
  int32_t fResPathLen;
  Resource fRes;
  UBool fHasFallback;
  UBool fIsTopLevel;
  uint32_t fMagic1;   /* For determining if it's a stack object */
  uint32_t fMagic2;   /* For determining if it's a stack object */
  int32_t fIndex;
  int32_t fSize;

  inline const ResourceData &getResData() const { return fData->fData; }
50
←
Returning null reference
95};

97U_NAMESPACE_BEGINnamespace icu_77 {

99/**
* \class StackUResourceBundle
* "Smart pointer" like class, closes a UResourceBundle via ures_close().
*
* This code:
*
*   StackUResourceBundle bundle;
*   foo(bundle.getAlias());
*
* Is equivalent to this code:
*
*   UResourceBundle bundle;
*   ures_initStackObject(&bundle);
*   foo(&bundle);
*   ures_close(&bundle);
*
* @see LocalUResourceBundlePointer
* @internal
*/
118class U_COMMON_API StackUResourceBundle {
119public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) noexcept = delete;
  static void* U_EXPORT2 operator new[](size_t) noexcept = delete;
123#if U_HAVE_PLACEMENT_NEW1
  static void* U_EXPORT2 operator new(size_t, void*) noexcept = delete;
125#endif

  StackUResourceBundle();
  ~StackUResourceBundle();

  UResourceBundle* getAlias() { return &bundle; }

  UResourceBundle& ref() { return bundle; }
  const UResourceBundle& ref() const { return bundle; }

  StackUResourceBundle(const StackUResourceBundle&) = delete;
  StackUResourceBundle& operator=(const StackUResourceBundle&) = delete;

  StackUResourceBundle(StackUResourceBundle&&) = delete;
  StackUResourceBundle& operator=(StackUResourceBundle&&) = delete;

141private:
  UResourceBundle bundle;
143};

145U_NAMESPACE_END}

147#endif  /* __cplusplus */

149/**
* Opens a resource bundle for the locale;
* if there is not even a base language bundle, then loads the root bundle;
* never falls 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).
*/
157U_CAPIextern "C" UResourceBundle* U_EXPORT2
158ures_openNoDefaultures_openNoDefault_77(const char* path, const char* localeID, UErrorCode* status);

160/* Some getters used by the copy constructor */
161U_CFUNCextern "C" const char* ures_getNameures_getName_77(const UResourceBundle* resB);
162#ifdef URES_DEBUG
163U_CFUNCextern "C" const char* ures_getPath(const UResourceBundle* resB);
164/**
* If anything was in the RB cache, dump it to the screen.
* @return true if there was anything into the cache
*/
168U_CAPIextern "C" UBool U_EXPORT2 ures_dumpCacheContents(void);
169#endif

171/* Candidates for export */
172U_CFUNCextern "C" UResourceBundle *ures_copyResbures_copyResb_77(UResourceBundle *r, const UResourceBundle *original, UErrorCode *status);

174/**
* Returns a resource that can be located using the pathToResource argument. One needs optional package, locale
* and path inside the locale, for example: "/myData/en/zoneStrings/3". Keys and indexes are supported. Keys
* need to reference data in named structures, while indexes can reference both named and anonymous resources.
* Features a fill-in parameter. 
* 
* Note, this function does NOT have a syntax for specifying items within a tree.  May want to consider a
* syntax that delineates between package/tree and resource.  
*
* @param pathToResource    a path that will lead to the requested resource
* @param fillIn            if NULL a new UResourceBundle struct is allocated and must be deleted by the caller.
*                          Alternatively, you can supply a struct to be filled by this function.
* @param status            fills in the outgoing error code.
* @return                  a pointer to a UResourceBundle struct. If fill in param was NULL, caller must delete it
*/
189U_CAPIextern "C" UResourceBundle* U_EXPORT2
190ures_findResourceures_findResource_77(const char* pathToResource, 
                UResourceBundle *fillIn, UErrorCode *status); 

193/**
* Returns a sub resource that can be located using the pathToResource argument. One needs a path inside 
* the supplied resource, for example, if you have "en_US" resource bundle opened, you might ask for
* "zoneStrings/3". Keys and indexes are supported. Keys
* need to reference data in named structures, while indexes can reference both 
* named and anonymous resources.
* Features a fill-in parameter. 
*
* @param resourceBundle    a resource
* @param pathToResource    a path that will lead to the requested resource
* @param fillIn            if NULL a new UResourceBundle struct is allocated and must be deleted by the caller.
*                          Alternatively, you can supply a struct to be filled by this function.
* @param status            fills in the outgoing error code.
* @return                  a pointer to a UResourceBundle struct. If fill in param was NULL, caller must delete it
*/
208U_CAPIextern "C" UResourceBundle* U_EXPORT2
209ures_findSubResourceures_findSubResource_77(const UResourceBundle *resB, 
                   char* pathToResource, 
                   UResourceBundle *fillIn, UErrorCode *status);

213/**
* Returns a functionally equivalent locale (considering keywords) for the specified keyword.
* @param result fillin for the equivalent locale
* @param resultCapacity capacity of the fillin buffer
* @param path path to the tree, or NULL for ICU data
* @param resName top level resource. Example: "collations"
* @param keyword locale keyword. Example: "collation"
* @param locid The requested locale
* @param isAvailable If non-null, pointer to fillin parameter that indicates whether the 
* requested locale was available. The locale is defined as 'available' if it physically 
* exists within the specified tree.
* @param omitDefault if true, omit keyword and value if default. 'de_DE\@collation=standard' -> 'de_DE'
* @param status error code
* @return  the actual buffer size needed for the full locale.  If it's greater 
* than resultCapacity, the returned full name will be truncated and an error code will be returned.
*/
229U_CAPIextern "C" int32_t U_EXPORT2
230ures_getFunctionalEquivalentures_getFunctionalEquivalent_77(char *result, int32_t resultCapacity, 
                           const char *path, const char *resName, const char *keyword, const char *locid,
                           UBool *isAvailable, UBool omitDefault, UErrorCode *status);

234/**
* Given a tree path and keyword, return a string enumeration of all possible values for that keyword.
* @param path path to the tree, or NULL for ICU data
* @param keyword a particular keyword to consider, must match a top level resource name 
* within the tree.
* @param status error code
*/
241U_CAPIextern "C" UEnumeration* U_EXPORT2
242ures_getKeywordValuesures_getKeywordValues_77(const char *path, const char *keyword, UErrorCode *status);


245/**
* Get a resource with multi-level fallback. Normally only the top level resources will
* fallback to its parent. This performs fallback on subresources. For example, when a table
* is defined in a resource bundle and a parent resource bundle, normally no fallback occurs
* on the sub-resources because the table is defined in the current resource bundle, but this
* function can perform fallback on the sub-resources of the table.
* @param resB              a resource
* @param inKey             a key associated with the requested resource
* @param fillIn            if NULL a new UResourceBundle struct is allocated and must be deleted by the caller.
*                          Alternatively, you can supply a struct to be filled by this function.
* @param status: fills in the outgoing error code
*                could be <TT>U_MISSING_RESOURCE_ERROR</TT> if the key is not found
*                could be a non-failing error 
*                e.g.: <TT>U_USING_FALLBACK_WARNING</TT>,<TT>U_USING_DEFAULT_WARNING </TT>
* @return                  a pointer to a UResourceBundle struct. If fill in param was NULL, caller must delete it
*/
261U_CAPIextern "C" UResourceBundle* U_EXPORT2 
262ures_getByKeyWithFallbackures_getByKeyWithFallback_77(const UResourceBundle *resB, 
                        const char* inKey, 
                        UResourceBundle *fillIn, 
                        UErrorCode *status);

267/**
* Get a String with multi-level fallback. Normally only the top level resources will
* fallback to its parent. This performs fallback on subresources. For example, when a table
* is defined in a resource bundle and a parent resource bundle, normally no fallback occurs
* on the sub-resources because the table is defined in the current resource bundle, but this
* function can perform fallback on the sub-resources of the table.
* @param resB              a resource
* @param inKey             a key associated with the requested resource
* @param len               if not NULL, used to return the length of the string
* @param status: fills in the outgoing error code
*                could be <TT>U_MISSING_RESOURCE_ERROR</TT> if the key is not found
*                could be a non-failing error 
*                e.g.: <TT>U_USING_FALLBACK_WARNING</TT>,<TT>U_USING_DEFAULT_WARNING </TT>
* @return returns a pointer to a zero-terminated UChar array which lives in a
*         memory mapped/DLL file.
*/
283U_CAPIextern "C" const UChar* U_EXPORT2 
284ures_getStringByKeyWithFallbackures_getStringByKeyWithFallback_77(const UResourceBundle *resB, 
                        const char* inKey,  
                        int32_t* len,
                        UErrorCode *status);

289#ifdef __cplusplus201703L

291U_CAPIextern "C" void U_EXPORT2
292ures_getValueWithFallbackures_getValueWithFallback_77(const UResourceBundle *bundle, const char *path,
                        UResourceBundle *tempFillIn,
                        icu::ResourceDataValue &value, UErrorCode &errorCode);

296/**
* Locates the resource specified by `path` in the resource bundle specified by `bundle` (performing any
* necessary fallback and following any aliases) and calls the specified `sink`'s `put()` method with that
* resource.  Then walks the bundle's parent chain, calling `put()` on the sink for each item in the
* parent chain.
* @param bundle The bundle to search
* @param path The path of the desired resource
* @param sink A `ResourceSink` that gets called for each resource in the parent chain
* @param errorCode The error code
*/
306U_CAPIextern "C" void U_EXPORT2
307ures_getAllItemsWithFallbackures_getAllItemsWithFallback_77(const UResourceBundle *bundle, const char *path,
                           icu::ResourceSink &sink, UErrorCode &errorCode);

310/**
* Locates the resource specified by `path` in the resource bundle specified by `bundle` (performing any
* necessary fallback and following any aliases) and, if the resource is a table resource, iterates over its
* immediate child resources (again, following any aliases to get the individual resource values), and calls the specified
* `sink`'s `put()` method for each child resource (passing it that resource's key and either its actual value or,
* if that value is an alias, the value you get by following the alias).  Then walks back over the bundle's
* parent chain, similarly iterating over each parent table resource's child resources.
* Does not descend beyond one level of table children.
* @param bundle The bundle to search
* @param path The path of the desired resource
* @param sink A `ResourceSink` that gets called for each child resource of the specified resource (and each child
* of the resources in its parent chain).
* @param errorCode The error code.  This will be U_RESOURCE_TYPE_MISMATCH if the resource the caller
* is asking for isn't a table resource.
*/
325U_CAPIextern "C" void U_EXPORT2
326ures_getAllChildrenWithFallbackures_getAllChildrenWithFallback_77(const UResourceBundle *bundle, const char *path,
                              icu::ResourceSink &sink, UErrorCode &errorCode);

329#endif  /* __cplusplus */

331/**
* Get a version number by key
* @param resB bundle containing version number
* @param key the key for the version number
* @param ver fillin for the version number
* @param status error code
*/
338U_CAPIextern "C" void U_EXPORT2
339ures_getVersionByKeyures_getVersionByKey_77(const UResourceBundle *resB,
                   const char *key,
                   UVersionInfo ver,
                   UErrorCode *status);


345/**
* 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
*/
354U_CAPIextern "C" const char* U_EXPORT2 
355ures_getVersionNumberInternalures_getVersionNumberInternal_77(const UResourceBundle *resourceBundle);

357/**
* Return the name of the Locale associated with this ResourceBundle. This API allows
* you to query for the real locale of the resource. For example, if you requested 
* "en_US_CALIFORNIA" and only "en_US" bundle exists, "en_US" will be returned. 
* For subresources, the locale where this resource comes from will be returned.
* If fallback has occurred, getLocale will reflect this.
*
* This internal version avoids deprecated-warnings in ICU code.
*
* @param resourceBundle resource bundle in question
* @param status just for catching illegal arguments
* @return  A Locale name
*/
370U_CAPIextern "C" const char* U_EXPORT2 
371ures_getLocaleInternalures_getLocaleInternal_77(const UResourceBundle* resourceBundle, 
             UErrorCode* status);

374/**
* Same as ures_openDirect() but uses the fill-in parameter instead of allocating a new bundle.
* 
* @param r The existing UResourceBundle to fill in. If NULL then status will be
*          set to U_ILLEGAL_ARGUMENT_ERROR.
* @param packageName   The packageName and locale together point to an ICU udata object,
*                      as defined by <code> udata_open( packageName, "res", locale, err) </code>
*                      or equivalent.  Typically, packageName will refer to a (.dat) file, or to
*                      a package registered with udata_setAppData(). Using a full file or directory
*                      pathname for packageName is deprecated. If NULL, ICU data will be used.
* @param locale  specifies the locale for which we want to open the resource
*                if NULL, the default locale will be used. If strlen(locale) == 0
*                root locale will be used.
* @param status The error code.
* @see ures_openDirect
* @internal
*/
391U_CAPIextern "C" void U_EXPORT2
392ures_openDirectFillInures_openDirectFillIn_77(UResourceBundle *r,
                    const char *packageName,
                    const char *locale,
                    UErrorCode *status);

397#endif /*URESIMP_H*/