1299 lines
44 KiB
C++
1299 lines
44 KiB
C++
/*
|
|
**********************************************************************
|
|
* Copyright (c) 2001-2006, 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 (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 Spec
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* A Spec 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 Spec : public UMemory {
|
|
public:
|
|
Spec(const UnicodeString& spec);
|
|
~Spec();
|
|
|
|
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;
|
|
|
|
Spec(const Spec &other); // forbid copying of this class
|
|
Spec &operator=(const Spec &other); // forbid copying of this class
|
|
};
|
|
|
|
Spec::Spec(const UnicodeString& theSpec)
|
|
: top(theSpec),
|
|
res(0)
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
CharString topch(theSpec);
|
|
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(topch,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();
|
|
}
|
|
|
|
Spec::~Spec() {
|
|
delete res;
|
|
}
|
|
|
|
UBool Spec::hasFallback() const {
|
|
return nextSpec.length() != 0;
|
|
}
|
|
|
|
void Spec::reset() {
|
|
if (spec != top) {
|
|
spec = top;
|
|
isSpecLocale = (res != 0);
|
|
setupNext();
|
|
}
|
|
}
|
|
|
|
void Spec::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& Spec::next() {
|
|
spec = nextSpec;
|
|
isSpecLocale = isNextLocale;
|
|
setupNext();
|
|
return spec;
|
|
}
|
|
|
|
const UnicodeString& Spec::get() const {
|
|
return spec;
|
|
}
|
|
|
|
UBool Spec::isLocale() const {
|
|
return isSpecLocale;
|
|
}
|
|
|
|
ResourceBundle& Spec::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(Entry* e) {
|
|
for (int i=0; i<DEBUG_entries->size(); ++i) {
|
|
if (e == (Entry*) DEBUG_entries->elementAt(i)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Track object creation
|
|
static void DEBUG_newEntry(Entry* 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(Entry* 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(Entry* 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 Entry : 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;
|
|
Entry();
|
|
~Entry();
|
|
void adoptPrototype(Transliterator* adopted);
|
|
void setFactory(Transliterator::Factory factory,
|
|
Transliterator::Token context);
|
|
|
|
private:
|
|
|
|
Entry(const Entry &other); // forbid copying of this class
|
|
Entry &operator=(const Entry &other); // forbid copying of this class
|
|
};
|
|
|
|
Entry::Entry() {
|
|
u.prototype = 0;
|
|
compoundFilter = NULL;
|
|
entryType = NONE;
|
|
DEBUG_newEntry(this);
|
|
}
|
|
|
|
Entry::~Entry() {
|
|
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 Entry::adoptPrototype(Transliterator* adopted) {
|
|
if (entryType == PROTOTYPE) {
|
|
delete u.prototype;
|
|
}
|
|
entryType = PROTOTYPE;
|
|
u.prototype = adopted;
|
|
}
|
|
|
|
void Entry::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 (Entry*) 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);
|
|
Entry *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);
|
|
Entry *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 == Entry::RULES_FORWARD ||
|
|
entry->entryType == Entry::RULES_REVERSE ||
|
|
entry->entryType == Entry::LOCALE_RULES) {
|
|
|
|
if (parser.idBlockVector->isEmpty() && parser.dataVector->isEmpty()) {
|
|
entry->u.data = 0;
|
|
entry->entryType = Entry::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 = Entry::RBT_DATA;
|
|
}
|
|
else if (parser.idBlockVector->size() == 1 && parser.dataVector->isEmpty()) {
|
|
entry->stringArg = *(UnicodeString*)(parser.idBlockVector->elementAt(0));
|
|
entry->compoundFilter = parser.orphanCompoundFilter();
|
|
entry->entryType = Entry::ALIAS;
|
|
}
|
|
else {
|
|
entry->entryType = Entry::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) {
|
|
Entry *entry = new Entry();
|
|
entry->adoptPrototype(adoptedProto);
|
|
registerEntry(adoptedProto->getID(), entry, visible);
|
|
}
|
|
|
|
void TransliteratorRegistry::put(const UnicodeString& ID,
|
|
Transliterator::Factory factory,
|
|
Transliterator::Token context,
|
|
UBool visible) {
|
|
Entry *entry = new Entry();
|
|
entry->setFactory(factory, context);
|
|
registerEntry(ID, entry, visible);
|
|
}
|
|
|
|
void TransliteratorRegistry::put(const UnicodeString& ID,
|
|
const UnicodeString& resourceName,
|
|
UTransDirection dir,
|
|
UBool visible) {
|
|
Entry *entry = new Entry();
|
|
entry->entryType = (dir == UTRANS_FORWARD) ? Entry::RULES_FORWARD
|
|
: Entry::RULES_REVERSE;
|
|
entry->stringArg = resourceName;
|
|
registerEntry(ID, entry, visible);
|
|
}
|
|
|
|
void TransliteratorRegistry::put(const UnicodeString& ID,
|
|
const UnicodeString& alias,
|
|
UBool visible) {
|
|
Entry *entry = new Entry();
|
|
entry->entryType = Entry::ALIAS;
|
|
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,
|
|
Entry* 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,
|
|
Entry* 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,
|
|
Entry* 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();
|
|
// 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_deleteUVector);
|
|
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)) {
|
|
if (variant.length() > 0) {
|
|
variants->addElement(new UnicodeString(variant), status);
|
|
} else {
|
|
variants->insertElementAt(new UnicodeString(NO_VARIANT), 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.
|
|
*/
|
|
Entry* TransliteratorRegistry::findInDynamicStore(const Spec& src,
|
|
const Spec& trg,
|
|
const UnicodeString& variant) const {
|
|
UnicodeString ID;
|
|
TransliteratorIDParser::STVtoID(src, trg, variant, ID);
|
|
Entry *e = (Entry*) 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.
|
|
*/
|
|
Entry* TransliteratorRegistry::findInStaticStore(const Spec& src,
|
|
const Spec& trg,
|
|
const UnicodeString& variant) {
|
|
Entry* 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.
|
|
*/
|
|
Entry* TransliteratorRegistry::findInBundle(const Spec& specToOpen,
|
|
const Spec& 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(""));
|
|
CharString tag(utag);
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
ResourceBundle subres(specToOpen.getBundle().get(tag, 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) {
|
|
CharString var(variant);
|
|
status = U_ZERO_ERROR;
|
|
resStr = subres.getStringEx(var, 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.
|
|
Entry *entry = new Entry();
|
|
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 = Entry::LOCALE_RULES;
|
|
entry->stringArg = resStr;
|
|
entry->intArg = dir;
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
/**
|
|
* Convenience method. Calls 3-arg find().
|
|
*/
|
|
Entry* 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.
|
|
*/
|
|
Entry* TransliteratorRegistry::find(UnicodeString& source,
|
|
UnicodeString& target,
|
|
UnicodeString& variant) {
|
|
|
|
Spec src(source);
|
|
Spec trg(target);
|
|
Entry* 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,
|
|
Entry *entry,
|
|
TransliteratorAlias* &aliasReturn,
|
|
UErrorCode& status) {
|
|
Transliterator *t = 0;
|
|
U_ASSERT(aliasReturn == 0);
|
|
|
|
switch (entry->entryType) {
|
|
case Entry::RBT_DATA:
|
|
t = new RuleBasedTransliterator(ID, entry->u.data);
|
|
if (t == 0) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return t;
|
|
case Entry::PROTOTYPE:
|
|
t = entry->u.prototype->clone();
|
|
if (t == 0) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return t;
|
|
case Entry::ALIAS:
|
|
aliasReturn = new TransliteratorAlias(entry->stringArg, entry->compoundFilter);
|
|
if (aliasReturn == 0) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return 0;
|
|
case Entry::FACTORY:
|
|
t = entry->u.factory.function(ID, entry->u.factory.context);
|
|
if (t == 0) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return t;
|
|
case Entry::COMPOUND_RBT:
|
|
{
|
|
UVector* rbts = new UVector(status);
|
|
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))
|
|
return 0;
|
|
aliasReturn = new TransliteratorAlias(ID, entry->stringArg, rbts, entry->compoundFilter);
|
|
}
|
|
if (aliasReturn == 0) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return 0;
|
|
case Entry::LOCALE_RULES:
|
|
aliasReturn = new TransliteratorAlias(ID, entry->stringArg,
|
|
(UTransDirection) entry->intArg);
|
|
if (aliasReturn == 0) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return 0;
|
|
case Entry::RULES_FORWARD:
|
|
case Entry::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;
|
|
|
|
// 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 == Entry::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
|