Index: icu46/source/i18n/transreg.cpp |
=================================================================== |
--- icu46/source/i18n/transreg.cpp (revision 0) |
+++ icu46/source/i18n/transreg.cpp (revision 0) |
@@ -0,0 +1,1359 @@ |
+/* |
+********************************************************************** |
+* Copyright (c) 2001-2010, 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 |
+ |
+// UChar constants |
+static const UChar LOCALE_SEP = 95; // '_' |
+//static const UChar ID_SEP = 0x002D; /*-*/ |
+//static const UChar VARIANT_SEP = 0x002F; // '/' |
+ |
+// String constants |
+static const UChar NO_VARIANT[] = { 0 }; // empty string |
+static const UChar ANY[] = { 65, 110, 121, 0 }; // Any |
+ |
+/** |
+ * 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 = NULL; |
+ switch (type) { |
+ case SIMPLE: |
+ t = Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec); |
+ if(U_FAILURE(ec)){ |
+ return 0; |
+ } |
+ if (compoundFilter != 0) |
+ t->adoptFilter((UnicodeSet*)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(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.addElement(Transliterator::createInstance(idBlock, UTRANS_FORWARD, pe, ec), ec); |
+ if (!transes->isEmpty()) |
+ transliterators.addElement(transes->orphanElementAt(0), ec); |
+ blockSeparatorPos = aliasesOrRules.indexOf((UChar)(0xffff)); |
+ } |
+ if (!aliasesOrRules.isEmpty()) |
+ transliterators.addElement(Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec), ec); |
+ while (!transes->isEmpty()) |
+ transliterators.addElement(transes->orphanElementAt(0), ec); |
+ |
+ if (U_SUCCESS(ec)) { |
+ t = new CompoundTransliterator(ID, transliterators, |
+ (compoundFilter ? (UnicodeSet*)(compoundFilter->clone()) : 0), |
+ 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: |
+ U_ASSERT(FALSE); // don't call create() if isRuleBased() returns TRUE! |
+ break; |
+ } |
+ 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 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_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 = NULL; |
+ |
+static void DEBUG_setup() { |
+ if (DEBUG_entries == NULL) { |
+ 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 == NULL) 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 = NULL; |
+ 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 != NULL && !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, status), |
+ availableIDs(status) |
+{ |
+ registry.setValueDeleter(deleteEntry); |
+ availableIDs.setDeleter(uhash_deleteUnicodeString); |
+ 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 == NULL); |
+ 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 == NULL); |
+ 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-NULL"); |
+ } |
+ 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); |
+ 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); |
+ entry->stringArg += (UChar)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 == NULL) { |
+ 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 == NULL) { |
+ 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 == NULL) { |
+ 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 != NULL) { |
+ 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(void) 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(void) const { |
+ return specDAG.count(); |
+} |
+ |
+UnicodeString& TransliteratorRegistry::getAvailableSource(int32_t index, |
+ UnicodeString& result) const { |
+ int32_t pos = -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; |
+} |
+ |
+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 = -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; |
+} |
+ |
+int32_t TransliteratorRegistry::countAvailableVariants(const UnicodeString& source, |
+ const UnicodeString& target) const { |
+ Hashtable *targets = (Hashtable*) specDAG.get(source); |
+ if (targets == 0) { |
+ return 0; |
+ } |
+ UVector *variants = (UVector*) targets->get(target); |
+ // variants may be 0 if the source/target are invalid |
+ return (variants == 0) ? 0 : variants->size(); |
+} |
+ |
+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; |
+ } |
+ UVector *variants = (UVector*) targets->get(target); |
+ if (variants == 0) { |
+ result.truncate(0); // invalid target |
+ return result; |
+ } |
+ UnicodeString *v = (UnicodeString*) variants->elementAt(index); |
+ if (v == 0) { |
+ result.truncate(0); // invalid index |
+ } else { |
+ result = *v; |
+ } |
+ 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 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; |
+ } |
+} |
+ |
+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 = ANY; |
+ } |
+ 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 = (UnicodeString *)ID.clone(); |
+ // Check to make sure newID was created. |
+ if (newID != NULL) { |
+ // NUL-terminate the ID string |
+ newID->getTerminatedBuffer(); |
+ availableIDs.addElement(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. If variant is empty then |
+ * the special variant NO_VARIANT is stored in slot zero of the |
+ * UVector of variants. |
+ */ |
+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) { |
+ targets = new Hashtable(TRUE, status); |
+ if (U_FAILURE(status) || targets == 0) { |
+ return; |
+ } |
+ targets->setValueDeleter(uhash_deleteUObject); |
+ specDAG.put(source, targets, status); |
+ } |
+ UVector *variants = (UVector*) targets->get(target); |
+ if (variants == 0) { |
+ variants = new UVector(uhash_deleteUnicodeString, |
+ uhash_compareCaselessUnicodeString, status); |
+ if (variants == 0) { |
+ return; |
+ } |
+ targets->put(target, variants, status); |
+ } |
+ // assert(NO_VARIANT == ""); |
+ // We add the variant string. If it is the special "no variant" |
+ // string, that is, the empty string, we add it at position zero. |
+ if (!variants->contains((void*) &variant)) { |
+ UnicodeString *tempus; // Used for null pointer check. |
+ if (variant.length() > 0) { |
+ tempus = new UnicodeString(variant); |
+ if (tempus != NULL) { |
+ variants->addElement(tempus, status); |
+ } |
+ } else { |
+ tempus = new UnicodeString(NO_VARIANT) ; |
+ if (tempus != NULL) { |
+ variants->insertElementAt(tempus, 0, 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 == 0) { |
+ return; // should never happen for valid s-t/v |
+ } |
+ UVector *variants = (UVector*) targets->get(target); |
+ if (variants == 0) { |
+ return; // should never happen for valid s-t/v |
+ } |
+ variants->removeElement((void*) &variant); |
+ if (variants->size() == 0) { |
+ 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 UChar TRANSLITERATE_TO[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,84,111,0}; // "TransliterateTo" |
+ |
+static const UChar TRANSLITERATE_FROM[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,70,114,111,109,0}; // "TransliterateFrom" |
+ |
+static const UChar 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); |
+ } else { |
+ utag.append(TRANSLITERATE); |
+ } |
+ 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 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; |
+} |
+ |
+/** |
+ * 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(entry->u.dataVector->size(), status); |
+ // Check for null pointer |
+ if (rbts == NULL) { |
+ status = U_MEMORY_ALLOCATION_ERROR; |
+ return NULL; |
+ } |
+ int32_t passNumber = 1; |
+ for (int32_t i = 0; U_SUCCESS(status) && i < entry->u.dataVector->size(); i++) { |
+ Transliterator* t = new RuleBasedTransliterator(UnicodeString(CompoundTransliterator::PASS_STRING) + (passNumber++), |
+ (TransliterationRuleData*)(entry->u.dataVector->elementAt(i)), FALSE); |
+ if (t == 0) |
+ status = U_MEMORY_ALLOCATION_ERROR; |
+ else |
+ rbts->addElement(t, status); |
+ } |
+ if (U_FAILURE(status)) { |
+ delete rbts; |
+ return 0; |
+ } |
+ 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: |
+ U_ASSERT(FALSE); // can't get here |
+ return 0; |
+ } |
+} |
+U_NAMESPACE_END |
+ |
+#endif /* #if !UCONFIG_NO_TRANSLITERATION */ |
+ |
+//eof |
Property changes on: icu46/source/i18n/transreg.cpp |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |