../deps/icu-small/source/i18n/transreg.cpp

Bug Summary

File:	out/../deps/icu-small/source/i18n/transreg.cpp
Warning:	line 360, column 5 Returning null reference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name transreg.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_I18N_IMPLEMENTATION=1 -D U_IO_IMPLEMENTATION=1 -D U_TOOLUTIL_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/tools/toolutil -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/i18n/transreg.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) 2001-2014, International Business Machines
6*   Corporation and others.  All Rights Reserved.
7**********************************************************************
8*   Date        Name        Description
9*   08/10/2001  aliu        Creation.
10**********************************************************************
11*/

13#include "unicode/utypes.h"

15#if !UCONFIG_NO_TRANSLITERATION0

17#include "unicode/translit.h"
18#include "unicode/resbund.h"
19#include "unicode/uniset.h"
20#include "unicode/uscript.h"
21#include "rbt.h"
22#include "cpdtrans.h"
23#include "nultrans.h"
24#include "transreg.h"
25#include "rbt_data.h"
26#include "rbt_pars.h"
27#include "tridpars.h"
28#include "charstr.h"
29#include "uassert.h"
30#include "locutil.h"

32// Enable the following symbol to add debugging code that tracks the
33// allocation, deletion, and use of Entry objects.  BoundsChecker has
34// reported dangling pointer errors with these objects, but I have
35// been unable to confirm them.  I suspect BoundsChecker is getting
36// confused with pointers going into and coming out of a UHashtable,
37// despite the hinting code that is designed to help it.
38// #define DEBUG_MEM
39#ifdef DEBUG_MEM
40#include <stdio.h>
41#endif

43// UChar constants
44static const UChar LOCALE_SEP  = 95; // '_'
45//static const UChar ID_SEP      = 0x002D; /*-*/
46//static const UChar VARIANT_SEP = 0x002F; // '/'

48// String constants
49static const UChar ANY[] = { 0x41, 0x6E, 0x79, 0 }; // Any
50static const UChar LAT[] = { 0x4C, 0x61, 0x74, 0 }; // Lat

52// empty string
53#define NO_VARIANTUnicodeString() UnicodeString()

55// initial estimate for specDAG size
56// ICU 60 Transliterator::countAvailableSources()
57#define SPECDAG_INIT_SIZE149 149

59// initial estimate for number of variant names
60#define VARIANT_LIST_INIT_SIZE11 11
61#define VARIANT_LIST_MAX_SIZE31 31

63// initial estimate for availableIDs count (default estimate is 8 => multiple reallocs)
64// ICU 60 Transliterator::countAvailableIDs()
65#define AVAILABLE_IDS_INIT_SIZE641 641

67// initial estimate for number of targets for source "Any", "Lat"
68// ICU 60 Transliterator::countAvailableTargets("Any")/("Latn")
69#define ANY_TARGETS_INIT_SIZE125 125
70#define LAT_TARGETS_INIT_SIZE23 23

72/**
* Resource bundle key for the RuleBasedTransliterator rule.
*/
75//static const char RB_RULE[] = "Rule";

77U_NAMESPACE_BEGINnamespace icu_71 {

79//------------------------------------------------------------------
80// Alias
81//------------------------------------------------------------------

83TransliteratorAlias::TransliteratorAlias(const UnicodeString& theAliasID,
                                       const UnicodeSet* cpdFilter) :
  ID(),
  aliasesOrRules(theAliasID),
  transes(0),
  compoundFilter(cpdFilter),
  direction(UTRANS_FORWARD),
  type(TransliteratorAlias::SIMPLE) {
91}

93TransliteratorAlias::TransliteratorAlias(const UnicodeString& theID,
                                       const UnicodeString& idBlocks,
                                       UVector* adoptedTransliterators,
                                       const UnicodeSet* cpdFilter) :
  ID(theID),
  aliasesOrRules(idBlocks),
  transes(adoptedTransliterators),
  compoundFilter(cpdFilter),
  direction(UTRANS_FORWARD),
  type(TransliteratorAlias::COMPOUND) {
103}

105TransliteratorAlias::TransliteratorAlias(const UnicodeString& theID,
                                       const UnicodeString& rules,
                                       UTransDirection dir) :
  ID(theID),
  aliasesOrRules(rules),
  transes(0),
  compoundFilter(0),
  direction(dir),
  type(TransliteratorAlias::RULES) {
114}

116TransliteratorAlias::~TransliteratorAlias() {
  delete transes;
118}


121Transliterator* TransliteratorAlias::create(UParseError& pe,
                                          UErrorCode& ec) {
  if (U_FAILURE(ec)) {
      return 0;
  }
  Transliterator *t = NULL__null;
  switch (type) {
  case SIMPLE:
      t = Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec);
      if(U_FAILURE(ec)){
          return 0;
      }
      if (compoundFilter != 0)
          t->adoptFilter(compoundFilter->clone());
      break;
  case COMPOUND:
      {
          // the total number of transliterators in the compound is the total number of anonymous transliterators
          // plus the total number of ID blocks-- we start by assuming the list begins and ends with an ID
          // block and that each pair anonymous transliterators has an ID block between them.  Then we go back
          // to see whether there really are ID blocks at the beginning and end (by looking for U+FFFF, which
          // marks the position where an anonymous transliterator goes) and adjust accordingly
          int32_t anonymousRBTs = transes->size();
          int32_t transCount = anonymousRBTs * 2 + 1;
          if (!aliasesOrRules.isEmpty() && aliasesOrRules[0] == (UChar)(0xffff))
              --transCount;
          if (aliasesOrRules.length() >= 2 && aliasesOrRules[aliasesOrRules.length() - 1] == (UChar)(0xffff))
              --transCount;
          UnicodeString noIDBlock((UChar)(0xffff));
          noIDBlock += ((UChar)(0xffff));
          int32_t pos = aliasesOrRules.indexOf(noIDBlock);
          while (pos >= 0) {
              --transCount;
              pos = aliasesOrRules.indexOf(noIDBlock, pos + 1);
          }

          UVector transliterators(uprv_deleteUObjectuprv_deleteUObject_71, nullptr, ec);
          UnicodeString idBlock;
          int32_t blockSeparatorPos = aliasesOrRules.indexOf((UChar)(0xffff));
          while (blockSeparatorPos >= 0) {
              aliasesOrRules.extract(0, blockSeparatorPos, idBlock);
              aliasesOrRules.remove(0, blockSeparatorPos + 1);
              if (!idBlock.isEmpty())
                  transliterators.adoptElement(Transliterator::createInstance(idBlock, UTRANS_FORWARD, pe, ec), ec);
              if (!transes->isEmpty())
                  transliterators.adoptElement(transes->orphanElementAt(0), ec);
              blockSeparatorPos = aliasesOrRules.indexOf((UChar)(0xffff));
          }
          if (!aliasesOrRules.isEmpty())
              transliterators.adoptElement(Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec), ec);
          while (!transes->isEmpty())
              transliterators.adoptElement(transes->orphanElementAt(0), ec);
          transliterators.setDeleter(nullptr);

          if (U_SUCCESS(ec)) {
              t = new CompoundTransliterator(ID, transliterators,
                      (compoundFilter ? compoundFilter->clone() : nullptr),
                      anonymousRBTs, pe, ec);
              if (t == 0) {
                  ec = U_MEMORY_ALLOCATION_ERROR;
                  return 0;
              }
          } else {
              for (int32_t i = 0; i < transliterators.size(); i++)
                  delete (Transliterator*)(transliterators.elementAt(i));
          }
      }
      break;
  case RULES:
      UPRV_UNREACHABLE_EXITabort(); // don't call create() if isRuleBased() returns TRUE!
  }
  return t;
193}

195UBool TransliteratorAlias::isRuleBased() const {
  return type == RULES;
197}

199void TransliteratorAlias::parse(TransliteratorParser& parser,
                              UParseError& pe, UErrorCode& ec) const {
  U_ASSERT(type == RULES)(void)0;
  if (U_FAILURE(ec)) {
      return;
  }

  parser.parse(aliasesOrRules, direction, pe, ec);
207}

209//----------------------------------------------------------------------
210// class TransliteratorSpec
211//----------------------------------------------------------------------

213/**
* A TransliteratorSpec is a string specifying either a source or a target.  In more
* general terms, it may also specify a variant, but we only use the
* Spec class for sources and targets.
*
* A Spec may be a locale or a script.  If it is a locale, it has a
* fallback chain that goes xx_YY_ZZZ -> xx_YY -> xx -> ssss, where
* ssss is the script mapping of xx_YY_ZZZ.  The Spec API methods
* hasFallback(), next(), and reset() iterate over this fallback
* sequence.
*
* The Spec class canonicalizes itself, so the locale is put into
* canonical form, or the script is transformed from an abbreviation
* to a full name.
*/
228class TransliteratorSpec : public UMemory {
public:
  TransliteratorSpec(const UnicodeString& spec);
  ~TransliteratorSpec();

  const UnicodeString& get() const;
  UBool hasFallback() const;
  const UnicodeString& next();
  void reset();

  UBool isLocale() const;
  ResourceBundle& getBundle() const;

  operator const UnicodeString&() const { return get(); }
  const UnicodeString& getTop() const { return top; }

private:
  void setupNext();

  UnicodeString top;
  UnicodeString spec;
  UnicodeString nextSpec;
  UnicodeString scriptName;
  UBool isSpecLocale; // TRUE if spec is a locale
  UBool isNextLocale; // TRUE if nextSpec is a locale
  ResourceBundle* res;

  TransliteratorSpec(const TransliteratorSpec &other); // forbid copying of this class
  TransliteratorSpec &operator=(const TransliteratorSpec &other); // forbid copying of this class
257};

259TransliteratorSpec::TransliteratorSpec(const UnicodeString& theSpec)
top(theSpec),
res(0)
4
←
Null pointer value stored to 'src.res'→
262{
  UErrorCode status = U_ZERO_ERROR;
  Locale topLoc("");
  LocaleUtility::initLocaleFromName(theSpec, topLoc);
  if (!topLoc.isBogus()) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
      res = new ResourceBundle(U_ICUDATA_TRANSLIT"icudt" "71" "l" "-" "translit", topLoc, status);
      /* test for NULL */
      if (res == 0) {
          return;
      }
      if (U_FAILURE(status) || status == U_USING_DEFAULT_WARNING) {
          delete res;
          res = 0;
      }
  }

  // Canonicalize script name -or- do locale->script mapping
  status = U_ZERO_ERROR;
  static const int32_t capacity = 10;
  UScriptCode script[capacity]={USCRIPT_INVALID_CODE};
  int32_t num = uscript_getCodeuscript_getCode_71(CharString().appendInvariantChars(theSpec, status).data(),
                                script, capacity, &status);
  if (num > 0 && script[0] != USCRIPT_INVALID_CODE) {
7
←
Assuming 'num' is <= 0→
      scriptName = UnicodeString(uscript_getNameuscript_getName_71(script[0]), -1, US_INVicu::UnicodeString::kInvariant);
  }

  // Canonicalize top
  if (res7.1
Field 'res' is equal to null
 != 0) {
8
←
Taking false branch→
      // Canonicalize locale name
      UnicodeString locStr;
      LocaleUtility::initNameFromLocale(topLoc, locStr);
      if (!locStr.isBogus()) {
          top = locStr;
      }
  } else if (scriptName.length() != 0) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
      // We are a script; use canonical name
      top = scriptName;
  }

  // assert(spec != top);
  reset();
303}

305TransliteratorSpec::~TransliteratorSpec() {
  delete res;
307}

309UBool TransliteratorSpec::hasFallback() const {
  return nextSpec.length() != 0;
311}

313void TransliteratorSpec::reset() {
  if (spec != top) {
      spec = top;
      isSpecLocale = (res != 0);
      setupNext();
  }
319}

321void TransliteratorSpec::setupNext() {
  isNextLocale = FALSE0;
  if (isSpecLocale) {
      nextSpec = spec;
      int32_t i = nextSpec.lastIndexOf(LOCALE_SEP);
      // If i == 0 then we have _FOO, so we fall through
      // to the scriptName.
      if (i > 0) {
          nextSpec.truncate(i);
          isNextLocale = TRUE1;
      } else {
          nextSpec = scriptName; // scriptName may be empty
      }
  } else {
      // spec is a script, so we are at the end
      nextSpec.truncate(0);
  }
338}

340// Protocol:
341// for(const UnicodeString& s(spec.get());
342//     spec.hasFallback(); s(spec.next())) { ...

344const UnicodeString& TransliteratorSpec::next() {
  spec = nextSpec;
  isSpecLocale = isNextLocale;
  setupNext();
  return spec;
349}

351const UnicodeString& TransliteratorSpec::get() const {
  return spec;
353}

355UBool TransliteratorSpec::isLocale() const {
  return isSpecLocale;
357}

359ResourceBundle& TransliteratorSpec::getBundle() const {
  return *res;
26
←
Returning null reference
361}

363//----------------------------------------------------------------------

365#ifdef DEBUG_MEM

367// Vector of Entry pointers currently in use
368static UVector* DEBUG_entries = NULL__null;

370static void DEBUG_setup() {
  if (DEBUG_entries == NULL__null) {
      UErrorCode ec = U_ZERO_ERROR;
      DEBUG_entries = new UVector(ec);
  }
375}

377// Caller must call DEBUG_setup first.  Return index of given Entry,
378// if it is in use (not deleted yet), or -1 if not found.
379static int DEBUG_findEntry(TransliteratorEntry* e) {
  for (int i=0; i<DEBUG_entries->size(); ++i) {
      if (e == (TransliteratorEntry*) DEBUG_entries->elementAt(i)) {
          return i;
      }
  }
  return -1;
386}

388// Track object creation
389static void DEBUG_newEntry(TransliteratorEntry* e) {
  DEBUG_setup();
  if (DEBUG_findEntry(e) >= 0) {
      // This should really never happen unless the heap is broken
      printf("ERROR DEBUG_newEntry duplicate new pointer %08X\n", e);
      return;
  }
  UErrorCode ec = U_ZERO_ERROR;
  DEBUG_entries->addElement(e, ec);
398}

400// Track object deletion
401static void DEBUG_delEntry(TransliteratorEntry* e) {
  DEBUG_setup();
  int i = DEBUG_findEntry(e);
  if (i < 0) {
      printf("ERROR DEBUG_delEntry possible double deletion %08X\n", e);
      return;
  }
  DEBUG_entries->removeElementAt(i);
409}

411// Track object usage
412static void DEBUG_useEntry(TransliteratorEntry* e) {
  if (e == NULL__null) return;
  DEBUG_setup();
  int i = DEBUG_findEntry(e);
  if (i < 0) {
      printf("ERROR DEBUG_useEntry possible dangling pointer %08X\n", e);
  }
419}

421#else
422// If we're not debugging then make these macros into NOPs
423#define DEBUG_newEntry(x)
424#define DEBUG_delEntry(x)
425#define DEBUG_useEntry(x)
426#endif

428//----------------------------------------------------------------------
429// class Entry
430//----------------------------------------------------------------------

432/**
* The Entry object stores objects of different types and
* singleton objects as placeholders for rule-based transliterators to
* be built as needed.  Instances of this struct can be placeholders,
* can represent prototype transliterators to be cloned, or can
* represent TransliteratorData objects.  We don't support storing
* classes in the registry because we don't have the rtti infrastructure
* for it.  We could easily add this if there is a need for it in the
* future.
*/
442class TransliteratorEntry : public UMemory {
443public:
  enum Type {
      RULES_FORWARD,
      RULES_REVERSE,
      LOCALE_RULES,
      PROTOTYPE,
      RBT_DATA,
      COMPOUND_RBT,
      ALIAS,
      FACTORY,
      NONE // Only used for uninitialized entries
  } entryType;
  // NOTE: stringArg cannot go inside the union because
  // it has a copy constructor
  UnicodeString stringArg; // For RULES_*, ALIAS, COMPOUND_RBT
  int32_t intArg; // For COMPOUND_RBT, LOCALE_RULES
  UnicodeSet* compoundFilter; // For COMPOUND_RBT
  union {
      Transliterator* prototype; // For PROTOTYPE
      TransliterationRuleData* data; // For RBT_DATA
      UVector* dataVector;    // For COMPOUND_RBT
      struct {
          Transliterator::Factory function;
          Transliterator::Token   context;
      } factory; // For FACTORY
  } u;
  TransliteratorEntry();
  ~TransliteratorEntry();
  void adoptPrototype(Transliterator* adopted);
  void setFactory(Transliterator::Factory factory,
                  Transliterator::Token context);

475private:

  TransliteratorEntry(const TransliteratorEntry &other); // forbid copying of this class
  TransliteratorEntry &operator=(const TransliteratorEntry &other); // forbid copying of this class
479};

481TransliteratorEntry::TransliteratorEntry() {
  u.prototype = 0;
  compoundFilter = NULL__null;
  entryType = NONE;
  DEBUG_newEntry(this);
486}

488TransliteratorEntry::~TransliteratorEntry() {
  DEBUG_delEntry(this);
  if (entryType == PROTOTYPE) {
      delete u.prototype;
  } else if (entryType == RBT_DATA) {
      // The data object is shared between instances of RBT.  The
      // entry object owns it.  It should only be deleted when the
      // transliterator component is being cleaned up.  Doing so
      // invalidates any RBTs that the user has instantiated.
      delete u.data;
  } else if (entryType == COMPOUND_RBT) {
      while (u.dataVector != NULL__null && !u.dataVector->isEmpty())
          delete (TransliterationRuleData*)u.dataVector->orphanElementAt(0);
      delete u.dataVector;
  }
  delete compoundFilter;
504}

506void TransliteratorEntry::adoptPrototype(Transliterator* adopted) {
  if (entryType == PROTOTYPE) {
      delete u.prototype;
  }
  entryType = PROTOTYPE;
  u.prototype = adopted;
512}

514void TransliteratorEntry::setFactory(Transliterator::Factory factory,
                     Transliterator::Token context) {
  if (entryType == PROTOTYPE) {
      delete u.prototype;
  }
  entryType = FACTORY;
  u.factory.function = factory;
  u.factory.context = context;
522}

524// UObjectDeleter for Hashtable::setValueDeleter
525U_CDECL_BEGINextern "C" {
526static void U_CALLCONV
527deleteEntry(void* obj) {
  delete (TransliteratorEntry*) obj;
529}
530U_CDECL_END}

532//----------------------------------------------------------------------
533// class TransliteratorRegistry: Basic public API
534//----------------------------------------------------------------------

536TransliteratorRegistry::TransliteratorRegistry(UErrorCode& status) :
  registry(TRUE1, status),
  specDAG(TRUE1, SPECDAG_INIT_SIZE149, status),
  variantList(VARIANT_LIST_INIT_SIZE11, status),
  availableIDs(AVAILABLE_IDS_INIT_SIZE641, status)
541{
  registry.setValueDeleter(deleteEntry);
  variantList.setDeleter(uprv_deleteUObjectuprv_deleteUObject_71);
  variantList.setComparer(uhash_compareCaselessUnicodeStringuhash_compareCaselessUnicodeString_71);
  UnicodeString *emptyString = new UnicodeString();
  if (emptyString != NULL__null) {
      variantList.adoptElement(emptyString, status);
  }
  availableIDs.setDeleter(uprv_deleteUObjectuprv_deleteUObject_71);
  availableIDs.setComparer(uhash_compareCaselessUnicodeStringuhash_compareCaselessUnicodeString_71);
  specDAG.setValueDeleter(uhash_deleteHashtableuhash_deleteHashtable_71);
552}

554TransliteratorRegistry::~TransliteratorRegistry() {
  // Through the magic of C++, everything cleans itself up
556}

558Transliterator* TransliteratorRegistry::get(const UnicodeString& ID,
                                          TransliteratorAlias*& aliasReturn,
                                          UErrorCode& status) {
  U_ASSERT(aliasReturn == NULL)(void)0;
  TransliteratorEntry *entry = find(ID);
  return (entry == 0) ? 0
      : instantiateEntry(ID, entry, aliasReturn, status);
565}

567Transliterator* TransliteratorRegistry::reget(const UnicodeString& ID,
                                            TransliteratorParser& parser,
                                            TransliteratorAlias*& aliasReturn,
                                            UErrorCode& status) {
  U_ASSERT(aliasReturn == NULL)(void)0;
  TransliteratorEntry *entry = find(ID);
1
Calling 'TransliteratorRegistry::find'→

  if (entry == 0) {
      // We get to this point if there are two threads, one of which
      // is instantiating an ID, and another of which is removing
      // the same ID from the registry, and the timing is just right.
      return 0;
  }

  // The usage model for the caller is that they will first call
  // reg->get() inside the mutex, they'll get back an alias, they call
  // alias->isRuleBased(), and if they get TRUE, they call alias->parse()
  // outside the mutex, then reg->reget() inside the mutex again.  A real
  // mess, but it gets things working for ICU 3.0. [alan].

  // Note: It's possible that in between the caller calling
  // alias->parse() and reg->reget(), that another thread will have
  // called reg->reget(), and the entry will already have been fixed up.
  // We have to detect this so we don't stomp over existing entry
  // data members and potentially leak memory (u.data and compoundFilter).

  if (entry->entryType == TransliteratorEntry::RULES_FORWARD ||
      entry->entryType == TransliteratorEntry::RULES_REVERSE ||
      entry->entryType == TransliteratorEntry::LOCALE_RULES) {
      
      if (parser.idBlockVector.isEmpty() && parser.dataVector.isEmpty()) {
          entry->u.data = 0;
          entry->entryType = TransliteratorEntry::ALIAS;
          entry->stringArg = UNICODE_STRING_SIMPLE("Any-NULL")icu::UnicodeString(true, u"Any-NULL", -1);
      }
      else if (parser.idBlockVector.isEmpty() && parser.dataVector.size() == 1) {
          entry->u.data = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0);
          entry->entryType = TransliteratorEntry::RBT_DATA;
      }
      else if (parser.idBlockVector.size() == 1 && parser.dataVector.isEmpty()) {
          entry->stringArg = *(UnicodeString*)(parser.idBlockVector.elementAt(0));
          entry->compoundFilter = parser.orphanCompoundFilter();
          entry->entryType = TransliteratorEntry::ALIAS;
      }
      else {
          entry->entryType = TransliteratorEntry::COMPOUND_RBT;
          entry->compoundFilter = parser.orphanCompoundFilter();
          entry->u.dataVector = new UVector(status);
          // TODO ICU-21701: missing check for nullptr and failed status.
          //       Unclear how best to bail out.
          entry->stringArg.remove();

          int32_t limit = parser.idBlockVector.size();
          if (parser.dataVector.size() > limit)
              limit = parser.dataVector.size();

          for (int32_t i = 0; i < limit; i++) {
              if (i < parser.idBlockVector.size()) {
                  UnicodeString* idBlock = (UnicodeString*)parser.idBlockVector.elementAt(i);
                  if (!idBlock->isEmpty())
                      entry->stringArg += *idBlock;
              }
              if (!parser.dataVector.isEmpty()) {
                  TransliterationRuleData* data = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0);
                  entry->u.dataVector->addElement(data, status);
                  if (U_FAILURE(status)) {
                      delete data;
                  }
                  entry->stringArg += (UChar)0xffff;  // use U+FFFF to mark position of RBTs in ID block
              }
          }
      }
  }

  Transliterator *t =
      instantiateEntry(ID, entry, aliasReturn, status);
  return t;
644}

646void TransliteratorRegistry::put(Transliterator* adoptedProto,
                               UBool visible,
                               UErrorCode& ec)
649{
  TransliteratorEntry *entry = new TransliteratorEntry();
  if (entry == NULL__null) {
      ec = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  entry->adoptPrototype(adoptedProto);
  registerEntry(adoptedProto->getID(), entry, visible);
657}

659void TransliteratorRegistry::put(const UnicodeString& ID,
                               Transliterator::Factory factory,
                               Transliterator::Token context,
                               UBool visible,
                               UErrorCode& ec) {
  TransliteratorEntry *entry = new TransliteratorEntry();
  if (entry == NULL__null) {
      ec = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  entry->setFactory(factory, context);
  registerEntry(ID, entry, visible);
671}

673void TransliteratorRegistry::put(const UnicodeString& ID,
                               const UnicodeString& resourceName,
                               UTransDirection dir,
                               UBool readonlyResourceAlias,
                               UBool visible,
                               UErrorCode& ec) {
  TransliteratorEntry *entry = new TransliteratorEntry();
  if (entry == NULL__null) {
      ec = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  entry->entryType = (dir == UTRANS_FORWARD) ? TransliteratorEntry::RULES_FORWARD
      : TransliteratorEntry::RULES_REVERSE;
  if (readonlyResourceAlias) {
      entry->stringArg.setTo(TRUE1, resourceName.getBuffer(), -1);
  }
  else {
      entry->stringArg = resourceName;
  }
  registerEntry(ID, entry, visible);
693}

695void TransliteratorRegistry::put(const UnicodeString& ID,
                               const UnicodeString& alias,
                               UBool readonlyAliasAlias,
                               UBool visible,
                               UErrorCode& /*ec*/) {
  TransliteratorEntry *entry = new TransliteratorEntry();
  // Null pointer check
  if (entry != NULL__null) {
      entry->entryType = TransliteratorEntry::ALIAS;
      if (readonlyAliasAlias) {
          entry->stringArg.setTo(TRUE1, alias.getBuffer(), -1);
      }
      else {
          entry->stringArg = alias;
      }
      registerEntry(ID, entry, visible);
  }
712}

714void TransliteratorRegistry::remove(const UnicodeString& ID) {
  UnicodeString source, target, variant;
  UBool sawSource;
  TransliteratorIDParser::IDtoSTV(ID, source, target, variant, sawSource);
  // Only need to do this if ID.indexOf('-') < 0
  UnicodeString id;
  TransliteratorIDParser::STVtoID(source, target, variant, id);
  registry.remove(id);
  removeSTV(source, target, variant);
  availableIDs.removeElement((void*) &id);
724}

726//----------------------------------------------------------------------
727// class TransliteratorRegistry: Public ID and spec management
728//----------------------------------------------------------------------

730/**
* == OBSOLETE - remove in ICU 3.4 ==
* Return the number of IDs currently registered with the system.
* To retrieve the actual IDs, call getAvailableID(i) with
* i from 0 to countAvailableIDs() - 1.
*/
736int32_t TransliteratorRegistry::countAvailableIDs(void) const {
  return availableIDs.size();
738}

740/**
* == OBSOLETE - remove in ICU 3.4 ==
* Return the index-th available ID.  index must be between 0
* and countAvailableIDs() - 1, inclusive.  If index is out of
* range, the result of getAvailableID(0) is returned.
*/
746const UnicodeString& TransliteratorRegistry::getAvailableID(int32_t index) const {
  if (index < 0 || index >= availableIDs.size()) {
      index = 0;
  }
  return *(const UnicodeString*) availableIDs[index];
751}

753StringEnumeration* TransliteratorRegistry::getAvailableIDs() const {
  return new Enumeration(*this);
755}

757int32_t TransliteratorRegistry::countAvailableSources(void) const {
  return specDAG.count();
759}

761UnicodeString& TransliteratorRegistry::getAvailableSource(int32_t index,
                                                        UnicodeString& result) const {
  int32_t pos = UHASH_FIRST(-1);
  const UHashElement *e = 0;
  while (index-- >= 0) {
      e = specDAG.nextElement(pos);
      if (e == 0) {
          break;
      }
  }
  if (e == 0) {
      result.truncate(0);
  } else {
      result = *(UnicodeString*) e->key.pointer;
  }
  return result;
777}

779int32_t TransliteratorRegistry::countAvailableTargets(const UnicodeString& source) const {
  Hashtable *targets = (Hashtable*) specDAG.get(source);
  return (targets == 0) ? 0 : targets->count();
782}

784UnicodeString& TransliteratorRegistry::getAvailableTarget(int32_t index,
                                                        const UnicodeString& source,
                                                        UnicodeString& result) const {
  Hashtable *targets = (Hashtable*) specDAG.get(source);
  if (targets == 0) {
      result.truncate(0); // invalid source
      return result;
  }
  int32_t pos = UHASH_FIRST(-1);
  const UHashElement *e = 0;
  while (index-- >= 0) {
      e = targets->nextElement(pos);
      if (e == 0) {
          break;
      }
  }
  if (e == 0) {
      result.truncate(0); // invalid index
  } else {
      result = *(UnicodeString*) e->key.pointer;
  }
  return result;
806}

808int32_t TransliteratorRegistry::countAvailableVariants(const UnicodeString& source,
                                                     const UnicodeString& target) const {
  Hashtable *targets = (Hashtable*) specDAG.get(source);
  if (targets == 0) {
      return 0;
  }
  uint32_t varMask = targets->geti(target);
  int32_t varCount = 0;
  while (varMask > 0) {
      if (varMask & 1) {
          varCount++;
      }
      varMask >>= 1;
  }
  return varCount;
823}

825UnicodeString& TransliteratorRegistry::getAvailableVariant(int32_t index,
                                                         const UnicodeString& source,
                                                         const UnicodeString& target,
                                                         UnicodeString& result) const {
  Hashtable *targets = (Hashtable*) specDAG.get(source);
  if (targets == 0) {
      result.truncate(0); // invalid source
      return result;
  }
  uint32_t varMask = targets->geti(target);
  int32_t varCount = 0;
  int32_t varListIndex = 0;
  while (varMask > 0) {
      if (varMask & 1) {
          if (varCount == index) {
              UnicodeString *v = (UnicodeString*) variantList.elementAt(varListIndex);
              if (v != NULL__null) {
                  result = *v;
                  return result;
              }
              break;
          }
          varCount++;
      }
      varMask >>= 1;
      varListIndex++;
  }
  result.truncate(0); // invalid target or index
  return result;
854}

856//----------------------------------------------------------------------
857// class TransliteratorRegistry::Enumeration
858//----------------------------------------------------------------------

860TransliteratorRegistry::Enumeration::Enumeration(const TransliteratorRegistry& _reg) :
  index(0), reg(_reg) {
862}

864TransliteratorRegistry::Enumeration::~Enumeration() {
865}

867int32_t TransliteratorRegistry::Enumeration::count(UErrorCode& /*status*/) const {
  return reg.availableIDs.size();
869}

871const UnicodeString* TransliteratorRegistry::Enumeration::snext(UErrorCode& status) {
  // This is sloppy but safe -- if we get out of sync with the underlying
  // registry, we will still return legal strings, but they might not
  // correspond to the snapshot at construction time.  So there could be
  // duplicate IDs or omitted IDs if insertions or deletions occur in one
  // thread while another is iterating.  To be more rigorous, add a timestamp,
  // which is incremented with any modification, and validate this iterator
  // against the timestamp at construction time.  This probably isn't worth
  // doing as long as there is some possibility of removing this code in favor
  // of some new code based on Doug's service framework.
  if (U_FAILURE(status)) {
      return NULL__null;
  }
  int32_t n = reg.availableIDs.size();
  if (index > n) {
      status = U_ENUM_OUT_OF_SYNC_ERROR;
  }
  // index == n is okay -- this means we've reached the end
  if (index < n) {
      // Copy the string! This avoids lifetime problems.
      unistr = *(const UnicodeString*)reg.availableIDs[index++];
      return &unistr;
  } else {
      return NULL__null;
  }
896}

898void TransliteratorRegistry::Enumeration::reset(UErrorCode& /*status*/) {
  index = 0;
900}

902UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TransliteratorRegistry::Enumeration)UClassID TransliteratorRegistry::Enumeration::getStaticClassID
() { static char classID = 0; return (UClassID)&classID; }
 UClassID TransliteratorRegistry::Enumeration::getDynamicClassID
() const { return TransliteratorRegistry::Enumeration::getStaticClassID
(); }

904//----------------------------------------------------------------------
905// class TransliteratorRegistry: internal
906//----------------------------------------------------------------------

908/**
* Convenience method.  Calls 6-arg registerEntry().
*/
911void TransliteratorRegistry::registerEntry(const UnicodeString& source,
                                         const UnicodeString& target,
                                         const UnicodeString& variant,
                                         TransliteratorEntry* adopted,
                                         UBool visible) {
  UnicodeString ID;
  UnicodeString s(source);
  if (s.length() == 0) {
      s.setTo(TRUE1, ANY, 3);
  }
  TransliteratorIDParser::STVtoID(source, target, variant, ID);
  registerEntry(ID, s, target, variant, adopted, visible);
923}

925/**
* Convenience method.  Calls 6-arg registerEntry().
*/
928void TransliteratorRegistry::registerEntry(const UnicodeString& ID,
                                         TransliteratorEntry* adopted,
                                         UBool visible) {
  UnicodeString source, target, variant;
  UBool sawSource;
  TransliteratorIDParser::IDtoSTV(ID, source, target, variant, sawSource);
  // Only need to do this if ID.indexOf('-') < 0
  UnicodeString id;
  TransliteratorIDParser::STVtoID(source, target, variant, id);
  registerEntry(id, source, target, variant, adopted, visible);
938}

940/**
* Register an entry object (adopted) with the given ID, source,
* target, and variant strings.
*/
944void TransliteratorRegistry::registerEntry(const UnicodeString& ID,
                                         const UnicodeString& source,
                                         const UnicodeString& target,
                                         const UnicodeString& variant,
                                         TransliteratorEntry* adopted,
                                         UBool visible) {
  UErrorCode status = U_ZERO_ERROR;
  registry.put(ID, adopted, status);
  if (visible) {
      registerSTV(source, target, variant);
      if (!availableIDs.contains((void*) &ID)) {
          UnicodeString *newID = ID.clone();
          // Check to make sure newID was created.
          if (newID != NULL__null) {
              // NUL-terminate the ID string
              newID->getTerminatedBuffer();
              availableIDs.adoptElement(newID, status);
          }
      }
  } else {
      removeSTV(source, target, variant);
      availableIDs.removeElement((void*) &ID);
  }
967}

969/**
* Register a source-target/variant in the specDAG.  Variant may be
* empty, but source and target must not be.
*/
973void TransliteratorRegistry::registerSTV(const UnicodeString& source,
                                       const UnicodeString& target,
                                       const UnicodeString& variant) {
  // assert(source.length() > 0);
  // assert(target.length() > 0);
  UErrorCode status = U_ZERO_ERROR;
  Hashtable *targets = (Hashtable*) specDAG.get(source);
  if (targets == 0) {
      int32_t size = 3;
      if (source.compare(ANY,3) == 0) {
          size = ANY_TARGETS_INIT_SIZE125;
      } else if (source.compare(LAT,3) == 0) {
          size = LAT_TARGETS_INIT_SIZE23;
      }
      targets = new Hashtable(TRUE1, size, status);
      if (U_FAILURE(status) || targets == NULL__null) {
          return;
      }
      specDAG.put(source, targets, status);
  }
  int32_t variantListIndex = variantList.indexOf((void*) &variant, 0);
  if (variantListIndex < 0) {
      if (variantList.size() >= VARIANT_LIST_MAX_SIZE31) {
          // can't handle any more variants
          return;
      }
      UnicodeString *variantEntry = new UnicodeString(variant);
      if (variantEntry != NULL__null) {
          variantList.adoptElement(variantEntry, status);
          if (U_SUCCESS(status)) {
              variantListIndex = variantList.size() - 1;
          }
      }
      if (variantListIndex < 0) {
          return;
      }
  }
  uint32_t addMask = 1 << variantListIndex;
  uint32_t varMask = targets->geti(target);
  targets->puti(target, varMask | addMask, status);
1013}

1015/**
* Remove a source-target/variant from the specDAG.
*/
1018void TransliteratorRegistry::removeSTV(const UnicodeString& source,
                                     const UnicodeString& target,
                                     const UnicodeString& variant) {
  // assert(source.length() > 0);
  // assert(target.length() > 0);
  UErrorCode status = U_ZERO_ERROR;
  Hashtable *targets = (Hashtable*) specDAG.get(source);
  if (targets == NULL__null) {
      return; // should never happen for valid s-t/v
  }
  uint32_t varMask = targets->geti(target);
  if (varMask == 0) {
      return; // should never happen for valid s-t/v
  }
  int32_t variantListIndex = variantList.indexOf((void*) &variant, 0);
  if (variantListIndex < 0) {
      return; // should never happen for valid s-t/v
  }
  int32_t remMask = 1 << variantListIndex;
  varMask &= (~remMask);
  if (varMask != 0) {
      targets->puti(target, varMask, status);
  } else {
      targets->remove(target); // should delete variants
      if (targets->count() == 0) {
          specDAG.remove(source); // should delete targets
      }
  }
1046}

1048/**
* Attempt to find a source-target/variant in the dynamic registry
* store.  Return 0 on failure.
*
* Caller does NOT own returned object.
*/
1054TransliteratorEntry* TransliteratorRegistry::findInDynamicStore(const TransliteratorSpec& src,
                                                const TransliteratorSpec& trg,
                                                const UnicodeString& variant) const {
  UnicodeString ID;
  TransliteratorIDParser::STVtoID(src, trg, variant, ID);
  TransliteratorEntry *e = (TransliteratorEntry*) registry.get(ID);
  DEBUG_useEntry(e);
  return e;
1062}

1064/**
* Attempt to find a source-target/variant in the static locale
* resource store.  Do not perform fallback.  Return 0 on failure.
*
* On success, create a new entry object, register it in the dynamic
* store, and return a pointer to it, but do not make it public --
* just because someone requested something, we do not expand the
* available ID list (or spec DAG).
*
* Caller does NOT own returned object.
*/
1075TransliteratorEntry* TransliteratorRegistry::findInStaticStore(const TransliteratorSpec& src,
                                               const TransliteratorSpec& trg,
                                               const UnicodeString& variant) {
  TransliteratorEntry* entry = 0;
  if (src.isLocale()) {
19
←
Assuming the condition is true→
20
←
Taking true branch→
      entry = findInBundle(src, trg, variant, UTRANS_FORWARD);
21
←
Calling 'TransliteratorRegistry::findInBundle'→
  } else if (trg.isLocale()) {
      entry = findInBundle(trg, src, variant, UTRANS_REVERSE);
  }

  // If we found an entry, store it in the Hashtable for next
  // time.
  if (entry != 0) {
      registerEntry(src.getTop(), trg.getTop(), variant, entry, FALSE0);
  }

  return entry;
1092}

1094// As of 2.0, resource bundle keys cannot contain '_'
1095static const UChar TRANSLITERATE_TO[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,84,111,0}; // "TransliterateTo"

1097static const UChar TRANSLITERATE_FROM[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,70,114,111,109,0}; // "TransliterateFrom"

1099static const UChar TRANSLITERATE[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,0}; // "Transliterate"

1101/**
* Attempt to find an entry in a single resource bundle.  This is
* a one-sided lookup.  findInStaticStore() performs up to two such
* lookups, one for the source, and one for the target.
*
* Do not perform fallback.  Return 0 on failure.
*
* On success, create a new Entry object, populate it, and return it.
* The caller owns the returned object.
*/
1111TransliteratorEntry* TransliteratorRegistry::findInBundle(const TransliteratorSpec& specToOpen,
                                          const TransliteratorSpec& specToFind,
                                          const UnicodeString& variant,
                                          UTransDirection direction)
1115{
  UnicodeString utag;
  UnicodeString resStr;
  int32_t pass;

  for (pass=0; pass<2; ++pass) {
22
←
Loop condition is true.  Entering loop body→
      utag.truncate(0);
      // First try either TransliteratorTo_xxx or
      // TransliterateFrom_xxx, then try the bidirectional
      // Transliterate_xxx.  This precedence order is arbitrary
      // but must be consistent and documented.
      if (pass22.1
'pass' is equal to 0
 == 0) {
23
←
Taking true branch→
          utag.append(direction23.1
'direction' is equal to UTRANS_FORWARD
 == UTRANS_FORWARD ?
24
←
'?' condition is true→
                      TRANSLITERATE_TO : TRANSLITERATE_FROM, -1);
      } else {
          utag.append(TRANSLITERATE, -1);
      }
      UnicodeString s(specToFind.get());
      utag.append(s.toUpper(""));
      UErrorCode status = U_ZERO_ERROR;
      ResourceBundle subres(specToOpen.getBundle().get(
25
←
Calling 'TransliteratorSpec::getBundle'→
          CharString().appendInvariantChars(utag, status).data(), status));
      if (U_FAILURE(status) || status == U_USING_DEFAULT_WARNING) {
          continue;
      }

      s.truncate(0);
      if (specToOpen.get() != LocaleUtility::initNameFromLocale(subres.getLocale(), s)) {
          continue;
      }

      if (variant.length() != 0) {
          status = U_ZERO_ERROR;
          resStr = subres.getStringEx(
              CharString().appendInvariantChars(variant, status).data(), status);
          if (U_SUCCESS(status)) {
              // Exit loop successfully
              break;
          }
      } else {
          // Variant is empty, which means match the first variant listed.
          status = U_ZERO_ERROR;
          resStr = subres.getStringEx(1, status);
          if (U_SUCCESS(status)) {
              // Exit loop successfully
              break;
          }
      }
  }

  if (pass==2) {
      // Failed
      return NULL__null;
  }

  // We have succeeded in loading a string from the locale
  // resources.  Create a new registry entry to hold it and return it.
  TransliteratorEntry *entry = new TransliteratorEntry();
  if (entry != 0) {
      // The direction is always forward for the
      // TransliterateTo_xxx and TransliterateFrom_xxx
      // items; those are unidirectional forward rules.
      // For the bidirectional Transliterate_xxx items,
      // the direction is the value passed in to this
      // function.
      int32_t dir = (pass == 0) ? UTRANS_FORWARD : direction;
      entry->entryType = TransliteratorEntry::LOCALE_RULES;
      entry->stringArg = resStr;
      entry->intArg = dir;
  }

  return entry;
1187}

1189/**
* Convenience method.  Calls 3-arg find().
*/
1192TransliteratorEntry* TransliteratorRegistry::find(const UnicodeString& ID) {
  UnicodeString source, target, variant;
  UBool sawSource;
  TransliteratorIDParser::IDtoSTV(ID, source, target, variant, sawSource);
  return find(source, target, variant);
2
←
Calling 'TransliteratorRegistry::find'→
1197}

1199/**
* Top-level find method.  Attempt to find a source-target/variant in
* either the dynamic or the static (locale resource) store.  Perform
* fallback.
* 
* Lookup sequence for ss_SS_SSS-tt_TT_TTT/v:
*
*   ss_SS_SSS-tt_TT_TTT/v -- in hashtable
*   ss_SS_SSS-tt_TT_TTT/v -- in ss_SS_SSS (no fallback)
* 
*     repeat with t = tt_TT_TTT, tt_TT, tt, and tscript
*
*     ss_SS_SSS-t/ *
*     ss_SS-t/ *
*     ss-t/ *
*     sscript-t/ *
*
* Here * matches the first variant listed.
*
* Caller does NOT own returned object.  Return 0 on failure.
*/
1220TransliteratorEntry* TransliteratorRegistry::find(UnicodeString& source,
                                  UnicodeString& target,
                                  UnicodeString& variant) {
  
  TransliteratorSpec src(source);
3
←
Calling constructor for 'TransliteratorSpec'→
11
←
Returning from constructor for 'TransliteratorSpec'→
  TransliteratorSpec trg(target);
  TransliteratorEntry* entry;

  // Seek exact match in hashtable.  Temporary fix for ICU 4.6.
  // TODO: The general logic for finding a matching transliterator needs to be reviewed.
  // ICU ticket #8089
  UnicodeString ID;
  TransliteratorIDParser::STVtoID(source, target, variant, ID);
  entry = (TransliteratorEntry*) registry.get(ID);
  if (entry != 0) {
12
←
Assuming 'entry' is equal to null→
13
←
Taking false branch→
      // std::string ss;
      // std::cout << ID.toUTF8String(ss) << std::endl;
      return entry;
  }

  if (variant.length() != 0) {
14
←
Assuming the condition is true→
15
←
Taking true branch→
      
      // Seek exact match in hashtable
      entry = findInDynamicStore(src, trg, variant);
      if (entry != 0) {
16
←
Assuming 'entry' is equal to null→
17
←
Taking false branch→
          return entry;
      }
      
      // Seek exact match in locale resources
      entry = findInStaticStore(src, trg, variant);
18
←
Calling 'TransliteratorRegistry::findInStaticStore'→
      if (entry != 0) {
          return entry;
      }
  }

  for (;;) {
      src.reset();
      for (;;) {
          // Seek match in hashtable
          entry = findInDynamicStore(src, trg, NO_VARIANTUnicodeString());
          if (entry != 0) {
              return entry;
          }
          
          // Seek match in locale resources
          entry = findInStaticStore(src, trg, NO_VARIANTUnicodeString());
          if (entry != 0) {
              return entry;
          }
          if (!src.hasFallback()) {
              break;
          }
          src.next();
      }
      if (!trg.hasFallback()) {
          break;
      }
      trg.next();
  }

  return 0;
1281}

1283/**
* Given an Entry object, instantiate it.  Caller owns result.  Return
* 0 on failure.
*
* Return a non-empty aliasReturn value if the ID points to an alias.
* We cannot instantiate it ourselves because the alias may contain
* filters or compounds, which we do not understand.  Caller should
* make aliasReturn empty before calling.
*
* The entry object is assumed to reside in the dynamic store.  It may be
* modified.
*/
1295Transliterator* TransliteratorRegistry::instantiateEntry(const UnicodeString& ID,
                                                       TransliteratorEntry *entry,
                                                       TransliteratorAlias* &aliasReturn,
                                                       UErrorCode& status) {
  Transliterator *t = 0;
  U_ASSERT(aliasReturn == 0)(void)0;

  switch (entry->entryType) {
  case TransliteratorEntry::RBT_DATA:
      t = new RuleBasedTransliterator(ID, entry->u.data);
      if (t == 0) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return t;
  case TransliteratorEntry::PROTOTYPE:
      t = entry->u.prototype->clone();
      if (t == 0) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return t;
  case TransliteratorEntry::ALIAS:
      aliasReturn = new TransliteratorAlias(entry->stringArg, entry->compoundFilter);
      if (aliasReturn == 0) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return 0;
  case TransliteratorEntry::FACTORY:
      t = entry->u.factory.function(ID, entry->u.factory.context);
      if (t == 0) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return t;
  case TransliteratorEntry::COMPOUND_RBT:
      {
          UVector* rbts = new UVector(uprv_deleteUObjectuprv_deleteUObject_71, nullptr, entry->u.dataVector->size(), status);
          // Check for null pointer
          if (rbts == NULL__null) {
              status = U_MEMORY_ALLOCATION_ERROR;
              return NULL__null;
          }
          int32_t passNumber = 1;
          for (int32_t i = 0; U_SUCCESS(status) && i < entry->u.dataVector->size(); i++) {
              // TODO: Should passNumber be turned into a decimal-string representation (1 -> "1")?
              Transliterator* tl = new RuleBasedTransliterator(UnicodeString(CompoundTransliterator::PASS_STRING) + UnicodeString(passNumber++),
                  (TransliterationRuleData*)(entry->u.dataVector->elementAt(i)), FALSE0);
              if (tl == 0)
                  status = U_MEMORY_ALLOCATION_ERROR;
              else
                  rbts->adoptElement(tl, status);
          }
          if (U_FAILURE(status)) {
              delete rbts;
              return 0;
          }
          rbts->setDeleter(nullptr);
          aliasReturn = new TransliteratorAlias(ID, entry->stringArg, rbts, entry->compoundFilter);
      }
      if (aliasReturn == 0) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return 0;
  case TransliteratorEntry::LOCALE_RULES:
      aliasReturn = new TransliteratorAlias(ID, entry->stringArg,
                                            (UTransDirection) entry->intArg);
      if (aliasReturn == 0) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return 0;
  case TransliteratorEntry::RULES_FORWARD:
  case TransliteratorEntry::RULES_REVERSE:
      // Process the rule data into a TransliteratorRuleData object,
      // and possibly also into an ::id header and/or footer.  Then
      // we modify the registry with the parsed data and retry.
      {
          TransliteratorParser parser(status);
          
          // We use the file name, taken from another resource bundle
          // 2-d array at static init time, as a locale language.  We're
          // just using the locale mechanism to map through to a file
          // name; this in no way represents an actual locale.
          //CharString ch(entry->stringArg);
          //UResourceBundle *bundle = ures_openDirect(0, ch, &status);
          UnicodeString rules = entry->stringArg;
          //ures_close(bundle);
          
          //if (U_FAILURE(status)) {
              // We have a failure of some kind.  Remove the ID from the
              // registry so we don't keep trying.  NOTE: This will throw off
              // anyone who is, at the moment, trying to iterate over the
              // available IDs.  That's acceptable since we should never
              // really get here except under installation, configuration,
              // or unrecoverable run time memory failures.
          //    remove(ID);
          //} else {
              
              // If the status indicates a failure, then we don't have any
              // rules -- there is probably an installation error.  The list
              // in the root locale should correspond to all the installed
              // transliterators; if it lists something that's not
              // installed, we'll get an error from ResourceBundle.
              aliasReturn = new TransliteratorAlias(ID, rules,
                  ((entry->entryType == TransliteratorEntry::RULES_REVERSE) ?
                   UTRANS_REVERSE : UTRANS_FORWARD));
              if (aliasReturn == 0) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              }
          //}
      }
      return 0;
  default:
      UPRV_UNREACHABLE_EXITabort(); // can't get here
  }
1407}
1408U_NAMESPACE_END}

1410#endif /* #if !UCONFIG_NO_TRANSLITERATION */

1412//eof