summaryrefslogtreecommitdiffstats
path: root/intl/icu/source/i18n/transreg.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--intl/icu/source/i18n/transreg.cpp1406
1 files changed, 1406 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/transreg.cpp b/intl/icu/source/i18n/transreg.cpp
new file mode 100644
index 0000000000..46c68eb74d
--- /dev/null
+++ b/intl/icu/source/i18n/transreg.cpp
@@ -0,0 +1,1406 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+**********************************************************************
+* Copyright (c) 2001-2014, International Business Machines
+* Corporation and others. All Rights Reserved.
+**********************************************************************
+* Date Name Description
+* 08/10/2001 aliu Creation.
+**********************************************************************
+*/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_TRANSLITERATION
+
+#include "unicode/translit.h"
+#include "unicode/resbund.h"
+#include "unicode/uniset.h"
+#include "unicode/uscript.h"
+#include "rbt.h"
+#include "cpdtrans.h"
+#include "nultrans.h"
+#include "transreg.h"
+#include "rbt_data.h"
+#include "rbt_pars.h"
+#include "tridpars.h"
+#include "charstr.h"
+#include "uassert.h"
+#include "locutil.h"
+
+// Enable the following symbol to add debugging code that tracks the
+// allocation, deletion, and use of Entry objects. BoundsChecker has
+// reported dangling pointer errors with these objects, but I have
+// been unable to confirm them. I suspect BoundsChecker is getting
+// confused with pointers going into and coming out of a UHashtable,
+// despite the hinting code that is designed to help it.
+// #define DEBUG_MEM
+#ifdef DEBUG_MEM
+#include <stdio.h>
+#endif
+
+// char16_t constants
+static const char16_t LOCALE_SEP = 95; // '_'
+//static const char16_t ID_SEP = 0x002D; /*-*/
+//static const char16_t VARIANT_SEP = 0x002F; // '/'
+
+// String constants
+static const char16_t ANY[] = { 0x41, 0x6E, 0x79, 0 }; // Any
+static const char16_t LAT[] = { 0x4C, 0x61, 0x74, 0 }; // Lat
+
+// empty string
+#define NO_VARIANT UnicodeString()
+
+// initial estimate for specDAG size
+// ICU 60 Transliterator::countAvailableSources()
+#define SPECDAG_INIT_SIZE 149
+
+// initial estimate for number of variant names
+#define VARIANT_LIST_INIT_SIZE 11
+#define VARIANT_LIST_MAX_SIZE 31
+
+// initial estimate for availableIDs count (default estimate is 8 => multiple reallocs)
+// ICU 60 Transliterator::countAvailableIDs()
+#define AVAILABLE_IDS_INIT_SIZE 641
+
+// initial estimate for number of targets for source "Any", "Lat"
+// ICU 60 Transliterator::countAvailableTargets("Any")/("Latn")
+#define ANY_TARGETS_INIT_SIZE 125
+#define LAT_TARGETS_INIT_SIZE 23
+
+/**
+ * Resource bundle key for the RuleBasedTransliterator rule.
+ */
+//static const char RB_RULE[] = "Rule";
+
+U_NAMESPACE_BEGIN
+
+//------------------------------------------------------------------
+// Alias
+//------------------------------------------------------------------
+
+TransliteratorAlias::TransliteratorAlias(const UnicodeString& theAliasID,
+ const UnicodeSet* cpdFilter) :
+ ID(),
+ aliasesOrRules(theAliasID),
+ transes(0),
+ compoundFilter(cpdFilter),
+ direction(UTRANS_FORWARD),
+ type(TransliteratorAlias::SIMPLE) {
+}
+
+TransliteratorAlias::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) {
+}
+
+TransliteratorAlias::TransliteratorAlias(const UnicodeString& theID,
+ const UnicodeString& rules,
+ UTransDirection dir) :
+ ID(theID),
+ aliasesOrRules(rules),
+ transes(0),
+ compoundFilter(0),
+ direction(dir),
+ type(TransliteratorAlias::RULES) {
+}
+
+TransliteratorAlias::~TransliteratorAlias() {
+ delete transes;
+}
+
+
+Transliterator* TransliteratorAlias::create(UParseError& pe,
+ UErrorCode& ec) {
+ if (U_FAILURE(ec)) {
+ return 0;
+ }
+ Transliterator *t = nullptr;
+ 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();
+ UnicodeString noIDBlock((char16_t)(0xffff));
+ noIDBlock += ((char16_t)(0xffff));
+ int32_t pos = aliasesOrRules.indexOf(noIDBlock);
+ while (pos >= 0) {
+ pos = aliasesOrRules.indexOf(noIDBlock, pos + 1);
+ }
+
+ UVector transliterators(uprv_deleteUObject, nullptr, ec);
+ UnicodeString idBlock;
+ int32_t blockSeparatorPos = aliasesOrRules.indexOf((char16_t)(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((char16_t)(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_EXIT; // don't call create() if isRuleBased() returns true!
+ }
+ return t;
+}
+
+UBool TransliteratorAlias::isRuleBased() const {
+ return type == RULES;
+}
+
+void TransliteratorAlias::parse(TransliteratorParser& parser,
+ UParseError& pe, UErrorCode& ec) const {
+ U_ASSERT(type == RULES);
+ if (U_FAILURE(ec)) {
+ return;
+ }
+
+ parser.parse(aliasesOrRules, direction, pe, ec);
+}
+
+//----------------------------------------------------------------------
+// class TransliteratorSpec
+//----------------------------------------------------------------------
+
+/**
+ * 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.
+ */
+class 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
+};
+
+TransliteratorSpec::TransliteratorSpec(const UnicodeString& theSpec)
+: top(theSpec),
+ res(0)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ Locale topLoc("");
+ LocaleUtility::initLocaleFromName(theSpec, topLoc);
+ if (!topLoc.isBogus()) {
+ res = new ResourceBundle(U_ICUDATA_TRANSLIT, topLoc, status);
+ /* test for nullptr */
+ 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_getCode(CharString().appendInvariantChars(theSpec, status).data(),
+ script, capacity, &status);
+ if (num > 0 && script[0] != USCRIPT_INVALID_CODE) {
+ scriptName = UnicodeString(uscript_getName(script[0]), -1, US_INV);
+ }
+
+ // Canonicalize top
+ if (res != 0) {
+ // Canonicalize locale name
+ UnicodeString locStr;
+ LocaleUtility::initNameFromLocale(topLoc, locStr);
+ if (!locStr.isBogus()) {
+ top = locStr;
+ }
+ } else if (scriptName.length() != 0) {
+ // We are a script; use canonical name
+ top = scriptName;
+ }
+
+ // assert(spec != top);
+ reset();
+}
+
+TransliteratorSpec::~TransliteratorSpec() {
+ delete res;
+}
+
+UBool TransliteratorSpec::hasFallback() const {
+ return nextSpec.length() != 0;
+}
+
+void TransliteratorSpec::reset() {
+ if (spec != top) {
+ spec = top;
+ isSpecLocale = (res != 0);
+ setupNext();
+ }
+}
+
+void TransliteratorSpec::setupNext() {
+ isNextLocale = false;
+ 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 = true;
+ } else {
+ nextSpec = scriptName; // scriptName may be empty
+ }
+ } else {
+ // spec is a script, so we are at the end
+ nextSpec.truncate(0);
+ }
+}
+
+// Protocol:
+// for(const UnicodeString& s(spec.get());
+// spec.hasFallback(); s(spec.next())) { ...
+
+const UnicodeString& TransliteratorSpec::next() {
+ spec = nextSpec;
+ isSpecLocale = isNextLocale;
+ setupNext();
+ return spec;
+}
+
+const UnicodeString& TransliteratorSpec::get() const {
+ return spec;
+}
+
+UBool TransliteratorSpec::isLocale() const {
+ return isSpecLocale;
+}
+
+ResourceBundle& TransliteratorSpec::getBundle() const {
+ return *res;
+}
+
+//----------------------------------------------------------------------
+
+#ifdef DEBUG_MEM
+
+// Vector of Entry pointers currently in use
+static UVector* DEBUG_entries = nullptr;
+
+static void DEBUG_setup() {
+ if (DEBUG_entries == nullptr) {
+ UErrorCode ec = U_ZERO_ERROR;
+ DEBUG_entries = new UVector(ec);
+ }
+}
+
+// Caller must call DEBUG_setup first. Return index of given Entry,
+// if it is in use (not deleted yet), or -1 if not found.
+static 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;
+}
+
+// Track object creation
+static 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);
+}
+
+// Track object deletion
+static 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);
+}
+
+// Track object usage
+static void DEBUG_useEntry(TransliteratorEntry* e) {
+ if (e == nullptr) return;
+ DEBUG_setup();
+ int i = DEBUG_findEntry(e);
+ if (i < 0) {
+ printf("ERROR DEBUG_useEntry possible dangling pointer %08X\n", e);
+ }
+}
+
+#else
+// If we're not debugging then make these macros into NOPs
+#define DEBUG_newEntry(x)
+#define DEBUG_delEntry(x)
+#define DEBUG_useEntry(x)
+#endif
+
+//----------------------------------------------------------------------
+// class Entry
+//----------------------------------------------------------------------
+
+/**
+ * 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.
+ */
+class TransliteratorEntry : public UMemory {
+public:
+ 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);
+
+private:
+
+ TransliteratorEntry(const TransliteratorEntry &other); // forbid copying of this class
+ TransliteratorEntry &operator=(const TransliteratorEntry &other); // forbid copying of this class
+};
+
+TransliteratorEntry::TransliteratorEntry() {
+ u.prototype = 0;
+ compoundFilter = nullptr;
+ entryType = NONE;
+ DEBUG_newEntry(this);
+}
+
+TransliteratorEntry::~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 != nullptr && !u.dataVector->isEmpty())
+ delete (TransliterationRuleData*)u.dataVector->orphanElementAt(0);
+ delete u.dataVector;
+ }
+ delete compoundFilter;
+}
+
+void TransliteratorEntry::adoptPrototype(Transliterator* adopted) {
+ if (entryType == PROTOTYPE) {
+ delete u.prototype;
+ }
+ entryType = PROTOTYPE;
+ u.prototype = adopted;
+}
+
+void TransliteratorEntry::setFactory(Transliterator::Factory factory,
+ Transliterator::Token context) {
+ if (entryType == PROTOTYPE) {
+ delete u.prototype;
+ }
+ entryType = FACTORY;
+ u.factory.function = factory;
+ u.factory.context = context;
+}
+
+// UObjectDeleter for Hashtable::setValueDeleter
+U_CDECL_BEGIN
+static void U_CALLCONV
+deleteEntry(void* obj) {
+ delete (TransliteratorEntry*) obj;
+}
+U_CDECL_END
+
+//----------------------------------------------------------------------
+// class TransliteratorRegistry: Basic public API
+//----------------------------------------------------------------------
+
+TransliteratorRegistry::TransliteratorRegistry(UErrorCode& status) :
+ registry(true, status),
+ specDAG(true, SPECDAG_INIT_SIZE, status),
+ variantList(VARIANT_LIST_INIT_SIZE, status),
+ availableIDs(AVAILABLE_IDS_INIT_SIZE, status)
+{
+ registry.setValueDeleter(deleteEntry);
+ variantList.setDeleter(uprv_deleteUObject);
+ variantList.setComparer(uhash_compareCaselessUnicodeString);
+ UnicodeString *emptyString = new UnicodeString();
+ if (emptyString != nullptr) {
+ variantList.adoptElement(emptyString, status);
+ }
+ availableIDs.setDeleter(uprv_deleteUObject);
+ availableIDs.setComparer(uhash_compareCaselessUnicodeString);
+ specDAG.setValueDeleter(uhash_deleteHashtable);
+}
+
+TransliteratorRegistry::~TransliteratorRegistry() {
+ // Through the magic of C++, everything cleans itself up
+}
+
+Transliterator* TransliteratorRegistry::get(const UnicodeString& ID,
+ TransliteratorAlias*& aliasReturn,
+ UErrorCode& status) {
+ U_ASSERT(aliasReturn == nullptr);
+ TransliteratorEntry *entry = find(ID);
+ return (entry == 0) ? 0
+ : instantiateEntry(ID, entry, aliasReturn, status);
+}
+
+Transliterator* TransliteratorRegistry::reget(const UnicodeString& ID,
+ TransliteratorParser& parser,
+ TransliteratorAlias*& aliasReturn,
+ UErrorCode& status) {
+ U_ASSERT(aliasReturn == nullptr);
+ TransliteratorEntry *entry = find(ID);
+
+ 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-nullptr");
+ }
+ 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 += (char16_t)0xffff; // use U+FFFF to mark position of RBTs in ID block
+ }
+ }
+ }
+ }
+
+ Transliterator *t =
+ instantiateEntry(ID, entry, aliasReturn, status);
+ return t;
+}
+
+void TransliteratorRegistry::put(Transliterator* adoptedProto,
+ UBool visible,
+ UErrorCode& ec)
+{
+ TransliteratorEntry *entry = new TransliteratorEntry();
+ if (entry == nullptr) {
+ ec = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ entry->adoptPrototype(adoptedProto);
+ registerEntry(adoptedProto->getID(), entry, visible);
+}
+
+void TransliteratorRegistry::put(const UnicodeString& ID,
+ Transliterator::Factory factory,
+ Transliterator::Token context,
+ UBool visible,
+ UErrorCode& ec) {
+ TransliteratorEntry *entry = new TransliteratorEntry();
+ if (entry == nullptr) {
+ ec = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ entry->setFactory(factory, context);
+ registerEntry(ID, entry, visible);
+}
+
+void TransliteratorRegistry::put(const UnicodeString& ID,
+ const UnicodeString& resourceName,
+ UTransDirection dir,
+ UBool readonlyResourceAlias,
+ UBool visible,
+ UErrorCode& ec) {
+ TransliteratorEntry *entry = new TransliteratorEntry();
+ if (entry == nullptr) {
+ ec = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ entry->entryType = (dir == UTRANS_FORWARD) ? TransliteratorEntry::RULES_FORWARD
+ : TransliteratorEntry::RULES_REVERSE;
+ if (readonlyResourceAlias) {
+ entry->stringArg.setTo(true, resourceName.getBuffer(), -1);
+ }
+ else {
+ entry->stringArg = resourceName;
+ }
+ registerEntry(ID, entry, visible);
+}
+
+void TransliteratorRegistry::put(const UnicodeString& ID,
+ const UnicodeString& alias,
+ UBool readonlyAliasAlias,
+ UBool visible,
+ UErrorCode& /*ec*/) {
+ TransliteratorEntry *entry = new TransliteratorEntry();
+ // Null pointer check
+ if (entry != nullptr) {
+ entry->entryType = TransliteratorEntry::ALIAS;
+ if (readonlyAliasAlias) {
+ entry->stringArg.setTo(true, alias.getBuffer(), -1);
+ }
+ else {
+ entry->stringArg = alias;
+ }
+ registerEntry(ID, entry, visible);
+ }
+}
+
+void 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);
+}
+
+//----------------------------------------------------------------------
+// class TransliteratorRegistry: Public ID and spec management
+//----------------------------------------------------------------------
+
+/**
+ * == 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.
+ */
+int32_t TransliteratorRegistry::countAvailableIDs() const {
+ return availableIDs.size();
+}
+
+/**
+ * == 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.
+ */
+const UnicodeString& TransliteratorRegistry::getAvailableID(int32_t index) const {
+ if (index < 0 || index >= availableIDs.size()) {
+ index = 0;
+ }
+ return *(const UnicodeString*) availableIDs[index];
+}
+
+StringEnumeration* TransliteratorRegistry::getAvailableIDs() const {
+ return new Enumeration(*this);
+}
+
+int32_t TransliteratorRegistry::countAvailableSources() const {
+ return specDAG.count();
+}
+
+UnicodeString& TransliteratorRegistry::getAvailableSource(int32_t index,
+ UnicodeString& result) const {
+ int32_t pos = UHASH_FIRST;
+ 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;
+}
+
+int32_t TransliteratorRegistry::countAvailableTargets(const UnicodeString& source) const {
+ Hashtable *targets = (Hashtable*) specDAG.get(source);
+ return (targets == 0) ? 0 : targets->count();
+}
+
+UnicodeString& 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;
+ 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;
+}
+
+int32_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;
+}
+
+UnicodeString& 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 != nullptr) {
+ result = *v;
+ return result;
+ }
+ break;
+ }
+ varCount++;
+ }
+ varMask >>= 1;
+ varListIndex++;
+ }
+ result.truncate(0); // invalid target or index
+ return result;
+}
+
+//----------------------------------------------------------------------
+// class TransliteratorRegistry::Enumeration
+//----------------------------------------------------------------------
+
+TransliteratorRegistry::Enumeration::Enumeration(const TransliteratorRegistry& _reg) :
+ index(0), reg(_reg) {
+}
+
+TransliteratorRegistry::Enumeration::~Enumeration() {
+}
+
+int32_t TransliteratorRegistry::Enumeration::count(UErrorCode& /*status*/) const {
+ return reg.availableIDs.size();
+}
+
+const 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 nullptr;
+ }
+ 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 nullptr;
+ }
+}
+
+void TransliteratorRegistry::Enumeration::reset(UErrorCode& /*status*/) {
+ index = 0;
+}
+
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TransliteratorRegistry::Enumeration)
+
+//----------------------------------------------------------------------
+// class TransliteratorRegistry: internal
+//----------------------------------------------------------------------
+
+/**
+ * Convenience method. Calls 6-arg registerEntry().
+ */
+void 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(true, ANY, 3);
+ }
+ TransliteratorIDParser::STVtoID(source, target, variant, ID);
+ registerEntry(ID, s, target, variant, adopted, visible);
+}
+
+/**
+ * Convenience method. Calls 6-arg registerEntry().
+ */
+void 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);
+}
+
+/**
+ * Register an entry object (adopted) with the given ID, source,
+ * target, and variant strings.
+ */
+void 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 != nullptr) {
+ // NUL-terminate the ID string
+ newID->getTerminatedBuffer();
+ availableIDs.adoptElement(newID, status);
+ }
+ }
+ } else {
+ removeSTV(source, target, variant);
+ availableIDs.removeElement((void*) &ID);
+ }
+}
+
+/**
+ * Register a source-target/variant in the specDAG. Variant may be
+ * empty, but source and target must not be.
+ */
+void 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_SIZE;
+ } else if (source.compare(LAT,3) == 0) {
+ size = LAT_TARGETS_INIT_SIZE;
+ }
+ targets = new Hashtable(true, size, status);
+ if (U_FAILURE(status) || targets == nullptr) {
+ return;
+ }
+ specDAG.put(source, targets, status);
+ }
+ int32_t variantListIndex = variantList.indexOf((void*) &variant, 0);
+ if (variantListIndex < 0) {
+ if (variantList.size() >= VARIANT_LIST_MAX_SIZE) {
+ // can't handle any more variants
+ return;
+ }
+ UnicodeString *variantEntry = new UnicodeString(variant);
+ if (variantEntry != nullptr) {
+ 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);
+}
+
+/**
+ * Remove a source-target/variant from the specDAG.
+ */
+void 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 == nullptr) {
+ 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
+ }
+ }
+}
+
+/**
+ * Attempt to find a source-target/variant in the dynamic registry
+ * store. Return 0 on failure.
+ *
+ * Caller does NOT own returned object.
+ */
+TransliteratorEntry* 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;
+}
+
+/**
+ * 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.
+ */
+TransliteratorEntry* TransliteratorRegistry::findInStaticStore(const TransliteratorSpec& src,
+ const TransliteratorSpec& trg,
+ const UnicodeString& variant) {
+ TransliteratorEntry* entry = 0;
+ if (src.isLocale()) {
+ entry = findInBundle(src, trg, variant, UTRANS_FORWARD);
+ } 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, false);
+ }
+
+ return entry;
+}
+
+// As of 2.0, resource bundle keys cannot contain '_'
+static const char16_t TRANSLITERATE_TO[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,84,111,0}; // "TransliterateTo"
+
+static const char16_t TRANSLITERATE_FROM[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,70,114,111,109,0}; // "TransliterateFrom"
+
+static const char16_t TRANSLITERATE[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,0}; // "Transliterate"
+
+/**
+ * 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.
+ */
+TransliteratorEntry* TransliteratorRegistry::findInBundle(const TransliteratorSpec& specToOpen,
+ const TransliteratorSpec& specToFind,
+ const UnicodeString& variant,
+ UTransDirection direction)
+{
+ UnicodeString utag;
+ UnicodeString resStr;
+ int32_t pass;
+
+ for (pass=0; pass<2; ++pass) {
+ 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 (pass == 0) {
+ utag.append(direction == UTRANS_FORWARD ?
+ 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(
+ 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 nullptr;
+ }
+
+ // 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;
+}
+
+/**
+ * Convenience method. Calls 3-arg find().
+ */
+TransliteratorEntry* TransliteratorRegistry::find(const UnicodeString& ID) {
+ UnicodeString source, target, variant;
+ UBool sawSource;
+ TransliteratorIDParser::IDtoSTV(ID, source, target, variant, sawSource);
+ return find(source, target, variant);
+}
+
+/**
+ * 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.
+ */
+TransliteratorEntry* TransliteratorRegistry::find(UnicodeString& source,
+ UnicodeString& target,
+ UnicodeString& variant) {
+
+ TransliteratorSpec src(source);
+ 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) {
+ // std::string ss;
+ // std::cout << ID.toUTF8String(ss) << std::endl;
+ return entry;
+ }
+
+ if (variant.length() != 0) {
+
+ // Seek exact match in hashtable
+ entry = findInDynamicStore(src, trg, variant);
+ if (entry != 0) {
+ return entry;
+ }
+
+ // Seek exact match in locale resources
+ entry = findInStaticStore(src, trg, variant);
+ if (entry != 0) {
+ return entry;
+ }
+ }
+
+ for (;;) {
+ src.reset();
+ for (;;) {
+ // Seek match in hashtable
+ entry = findInDynamicStore(src, trg, NO_VARIANT);
+ if (entry != 0) {
+ return entry;
+ }
+
+ // Seek match in locale resources
+ entry = findInStaticStore(src, trg, NO_VARIANT);
+ if (entry != 0) {
+ return entry;
+ }
+ if (!src.hasFallback()) {
+ break;
+ }
+ src.next();
+ }
+ if (!trg.hasFallback()) {
+ break;
+ }
+ trg.next();
+ }
+
+ return 0;
+}
+
+/**
+ * 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.
+ */
+Transliterator* TransliteratorRegistry::instantiateEntry(const UnicodeString& ID,
+ TransliteratorEntry *entry,
+ TransliteratorAlias* &aliasReturn,
+ UErrorCode& status) {
+ Transliterator *t = 0;
+ U_ASSERT(aliasReturn == 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_deleteUObject, nullptr, entry->u.dataVector->size(), status);
+ // Check for null pointer
+ if (rbts == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return nullptr;
+ }
+ 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)), false);
+ 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_EXIT; // can't get here
+ }
+}
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_TRANSLITERATION */
+
+//eof
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-24 11:21:47 +0000