1/* 2********************************************************************** 3* Copyright (c) 2001-2010, International Business Machines 4* Corporation and others. All Rights Reserved. 5********************************************************************** 6* Date Name Description 7* 08/10/2001 aliu Creation. 8********************************************************************** 9*/ 10 11#include "unicode/utypes.h" 12 13#if !UCONFIG_NO_TRANSLITERATION 14 15#include "unicode/translit.h" 16#include "unicode/resbund.h" 17#include "unicode/uniset.h" 18#include "unicode/uscript.h" 19#include "rbt.h" 20#include "cpdtrans.h" 21#include "nultrans.h" 22#include "transreg.h" 23#include "rbt_data.h" 24#include "rbt_pars.h" 25#include "tridpars.h" 26#include "charstr.h" 27#include "uassert.h" 28#include "locutil.h" 29 30// Enable the following symbol to add debugging code that tracks the 31// allocation, deletion, and use of Entry objects. BoundsChecker has 32// reported dangling pointer errors with these objects, but I have 33// been unable to confirm them. I suspect BoundsChecker is getting 34// confused with pointers going into and coming out of a UHashtable, 35// despite the hinting code that is designed to help it. 36// #define DEBUG_MEM 37#ifdef DEBUG_MEM 38#include <stdio.h> 39#endif 40 41// UChar constants 42static const UChar LOCALE_SEP = 95; // '_' 43//static const UChar ID_SEP = 0x002D; /*-*/ 44//static const UChar VARIANT_SEP = 0x002F; // '/' 45 46// String constants 47static const UChar NO_VARIANT[] = { 0 }; // empty string 48static const UChar ANY[] = { 65, 110, 121, 0 }; // Any 49 50/** 51 * Resource bundle key for the RuleBasedTransliterator rule. 52 */ 53//static const char RB_RULE[] = "Rule"; 54 55U_NAMESPACE_BEGIN 56 57//------------------------------------------------------------------ 58// Alias 59//------------------------------------------------------------------ 60 61TransliteratorAlias::TransliteratorAlias(const UnicodeString& theAliasID, 62 const UnicodeSet* cpdFilter) : 63 ID(), 64 aliasesOrRules(theAliasID), 65 transes(0), 66 compoundFilter(cpdFilter), 67 direction(UTRANS_FORWARD), 68 type(TransliteratorAlias::SIMPLE) { 69} 70 71TransliteratorAlias::TransliteratorAlias(const UnicodeString& theID, 72 const UnicodeString& idBlocks, 73 UVector* adoptedTransliterators, 74 const UnicodeSet* cpdFilter) : 75 ID(theID), 76 aliasesOrRules(idBlocks), 77 transes(adoptedTransliterators), 78 compoundFilter(cpdFilter), 79 direction(UTRANS_FORWARD), 80 type(TransliteratorAlias::COMPOUND) { 81} 82 83TransliteratorAlias::TransliteratorAlias(const UnicodeString& theID, 84 const UnicodeString& rules, 85 UTransDirection dir) : 86 ID(theID), 87 aliasesOrRules(rules), 88 transes(0), 89 compoundFilter(0), 90 direction(dir), 91 type(TransliteratorAlias::RULES) { 92} 93 94TransliteratorAlias::~TransliteratorAlias() { 95 delete transes; 96} 97 98 99Transliterator* TransliteratorAlias::create(UParseError& pe, 100 UErrorCode& ec) { 101 if (U_FAILURE(ec)) { 102 return 0; 103 } 104 Transliterator *t = NULL; 105 switch (type) { 106 case SIMPLE: 107 t = Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec); 108 if(U_FAILURE(ec)){ 109 return 0; 110 } 111 if (compoundFilter != 0) 112 t->adoptFilter((UnicodeSet*)compoundFilter->clone()); 113 break; 114 case COMPOUND: 115 { 116 // the total number of transliterators in the compound is the total number of anonymous transliterators 117 // plus the total number of ID blocks-- we start by assuming the list begins and ends with an ID 118 // block and that each pair anonymous transliterators has an ID block between them. Then we go back 119 // to see whether there really are ID blocks at the beginning and end (by looking for U+FFFF, which 120 // marks the position where an anonymous transliterator goes) and adjust accordingly 121 int32_t anonymousRBTs = transes->size(); 122 int32_t transCount = anonymousRBTs * 2 + 1; 123 if (!aliasesOrRules.isEmpty() && aliasesOrRules[0] == (UChar)(0xffff)) 124 --transCount; 125 if (aliasesOrRules.length() >= 2 && aliasesOrRules[aliasesOrRules.length() - 1] == (UChar)(0xffff)) 126 --transCount; 127 UnicodeString noIDBlock((UChar)(0xffff)); 128 noIDBlock += ((UChar)(0xffff)); 129 int32_t pos = aliasesOrRules.indexOf(noIDBlock); 130 while (pos >= 0) { 131 --transCount; 132 pos = aliasesOrRules.indexOf(noIDBlock, pos + 1); 133 } 134 135 UVector transliterators(ec); 136 UnicodeString idBlock; 137 int32_t blockSeparatorPos = aliasesOrRules.indexOf((UChar)(0xffff)); 138 while (blockSeparatorPos >= 0) { 139 aliasesOrRules.extract(0, blockSeparatorPos, idBlock); 140 aliasesOrRules.remove(0, blockSeparatorPos + 1); 141 if (!idBlock.isEmpty()) 142 transliterators.addElement(Transliterator::createInstance(idBlock, UTRANS_FORWARD, pe, ec), ec); 143 if (!transes->isEmpty()) 144 transliterators.addElement(transes->orphanElementAt(0), ec); 145 blockSeparatorPos = aliasesOrRules.indexOf((UChar)(0xffff)); 146 } 147 if (!aliasesOrRules.isEmpty()) 148 transliterators.addElement(Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec), ec); 149 while (!transes->isEmpty()) 150 transliterators.addElement(transes->orphanElementAt(0), ec); 151 152 if (U_SUCCESS(ec)) { 153 t = new CompoundTransliterator(ID, transliterators, 154 (compoundFilter ? (UnicodeSet*)(compoundFilter->clone()) : 0), 155 anonymousRBTs, pe, ec); 156 if (t == 0) { 157 ec = U_MEMORY_ALLOCATION_ERROR; 158 return 0; 159 } 160 } else { 161 for (int32_t i = 0; i < transliterators.size(); i++) 162 delete (Transliterator*)(transliterators.elementAt(i)); 163 } 164 } 165 break; 166 case RULES: 167 U_ASSERT(FALSE); // don't call create() if isRuleBased() returns TRUE! 168 break; 169 } 170 return t; 171} 172 173UBool TransliteratorAlias::isRuleBased() const { 174 return type == RULES; 175} 176 177void TransliteratorAlias::parse(TransliteratorParser& parser, 178 UParseError& pe, UErrorCode& ec) const { 179 U_ASSERT(type == RULES); 180 if (U_FAILURE(ec)) { 181 return; 182 } 183 184 parser.parse(aliasesOrRules, direction, pe, ec); 185} 186 187//---------------------------------------------------------------------- 188// class TransliteratorSpec 189//---------------------------------------------------------------------- 190 191/** 192 * A TransliteratorSpec is a string specifying either a source or a target. In more 193 * general terms, it may also specify a variant, but we only use the 194 * Spec class for sources and targets. 195 * 196 * A Spec may be a locale or a script. If it is a locale, it has a 197 * fallback chain that goes xx_YY_ZZZ -> xx_YY -> xx -> ssss, where 198 * ssss is the script mapping of xx_YY_ZZZ. The Spec API methods 199 * hasFallback(), next(), and reset() iterate over this fallback 200 * sequence. 201 * 202 * The Spec class canonicalizes itself, so the locale is put into 203 * canonical form, or the script is transformed from an abbreviation 204 * to a full name. 205 */ 206class TransliteratorSpec : public UMemory { 207 public: 208 TransliteratorSpec(const UnicodeString& spec); 209 ~TransliteratorSpec(); 210 211 const UnicodeString& get() const; 212 UBool hasFallback() const; 213 const UnicodeString& next(); 214 void reset(); 215 216 UBool isLocale() const; 217 ResourceBundle& getBundle() const; 218 219 operator const UnicodeString&() const { return get(); } 220 const UnicodeString& getTop() const { return top; } 221 222 private: 223 void setupNext(); 224 225 UnicodeString top; 226 UnicodeString spec; 227 UnicodeString nextSpec; 228 UnicodeString scriptName; 229 UBool isSpecLocale; // TRUE if spec is a locale 230 UBool isNextLocale; // TRUE if nextSpec is a locale 231 ResourceBundle* res; 232 233 TransliteratorSpec(const TransliteratorSpec &other); // forbid copying of this class 234 TransliteratorSpec &operator=(const TransliteratorSpec &other); // forbid copying of this class 235}; 236 237TransliteratorSpec::TransliteratorSpec(const UnicodeString& theSpec) 238: top(theSpec), 239 res(0) 240{ 241 UErrorCode status = U_ZERO_ERROR; 242 Locale topLoc(""); 243 LocaleUtility::initLocaleFromName(theSpec, topLoc); 244 if (!topLoc.isBogus()) { 245 res = new ResourceBundle(U_ICUDATA_TRANSLIT, topLoc, status); 246 /* test for NULL */ 247 if (res == 0) { 248 return; 249 } 250 if (U_FAILURE(status) || status == U_USING_DEFAULT_WARNING) { 251 delete res; 252 res = 0; 253 } 254 } 255 256 // Canonicalize script name -or- do locale->script mapping 257 status = U_ZERO_ERROR; 258 static const int32_t capacity = 10; 259 UScriptCode script[capacity]={USCRIPT_INVALID_CODE}; 260 int32_t num = uscript_getCode(CharString().appendInvariantChars(theSpec, status).data(), 261 script, capacity, &status); 262 if (num > 0 && script[0] != USCRIPT_INVALID_CODE) { 263 scriptName = UnicodeString(uscript_getName(script[0]), -1, US_INV); 264 } 265 266 // Canonicalize top 267 if (res != 0) { 268 // Canonicalize locale name 269 UnicodeString locStr; 270 LocaleUtility::initNameFromLocale(topLoc, locStr); 271 if (!locStr.isBogus()) { 272 top = locStr; 273 } 274 } else if (scriptName.length() != 0) { 275 // We are a script; use canonical name 276 top = scriptName; 277 } 278 279 // assert(spec != top); 280 reset(); 281} 282 283TransliteratorSpec::~TransliteratorSpec() { 284 delete res; 285} 286 287UBool TransliteratorSpec::hasFallback() const { 288 return nextSpec.length() != 0; 289} 290 291void TransliteratorSpec::reset() { 292 if (spec != top) { 293 spec = top; 294 isSpecLocale = (res != 0); 295 setupNext(); 296 } 297} 298 299void TransliteratorSpec::setupNext() { 300 isNextLocale = FALSE; 301 if (isSpecLocale) { 302 nextSpec = spec; 303 int32_t i = nextSpec.lastIndexOf(LOCALE_SEP); 304 // If i == 0 then we have _FOO, so we fall through 305 // to the scriptName. 306 if (i > 0) { 307 nextSpec.truncate(i); 308 isNextLocale = TRUE; 309 } else { 310 nextSpec = scriptName; // scriptName may be empty 311 } 312 } else { 313 // spec is a script, so we are at the end 314 nextSpec.truncate(0); 315 } 316} 317 318// Protocol: 319// for(const UnicodeString& s(spec.get()); 320// spec.hasFallback(); s(spec.next())) { ... 321 322const UnicodeString& TransliteratorSpec::next() { 323 spec = nextSpec; 324 isSpecLocale = isNextLocale; 325 setupNext(); 326 return spec; 327} 328 329const UnicodeString& TransliteratorSpec::get() const { 330 return spec; 331} 332 333UBool TransliteratorSpec::isLocale() const { 334 return isSpecLocale; 335} 336 337ResourceBundle& TransliteratorSpec::getBundle() const { 338 return *res; 339} 340 341//---------------------------------------------------------------------- 342 343#ifdef DEBUG_MEM 344 345// Vector of Entry pointers currently in use 346static UVector* DEBUG_entries = NULL; 347 348static void DEBUG_setup() { 349 if (DEBUG_entries == NULL) { 350 UErrorCode ec = U_ZERO_ERROR; 351 DEBUG_entries = new UVector(ec); 352 } 353} 354 355// Caller must call DEBUG_setup first. Return index of given Entry, 356// if it is in use (not deleted yet), or -1 if not found. 357static int DEBUG_findEntry(TransliteratorEntry* e) { 358 for (int i=0; i<DEBUG_entries->size(); ++i) { 359 if (e == (TransliteratorEntry*) DEBUG_entries->elementAt(i)) { 360 return i; 361 } 362 } 363 return -1; 364} 365 366// Track object creation 367static void DEBUG_newEntry(TransliteratorEntry* e) { 368 DEBUG_setup(); 369 if (DEBUG_findEntry(e) >= 0) { 370 // This should really never happen unless the heap is broken 371 printf("ERROR DEBUG_newEntry duplicate new pointer %08X\n", e); 372 return; 373 } 374 UErrorCode ec = U_ZERO_ERROR; 375 DEBUG_entries->addElement(e, ec); 376} 377 378// Track object deletion 379static void DEBUG_delEntry(TransliteratorEntry* e) { 380 DEBUG_setup(); 381 int i = DEBUG_findEntry(e); 382 if (i < 0) { 383 printf("ERROR DEBUG_delEntry possible double deletion %08X\n", e); 384 return; 385 } 386 DEBUG_entries->removeElementAt(i); 387} 388 389// Track object usage 390static void DEBUG_useEntry(TransliteratorEntry* e) { 391 if (e == NULL) return; 392 DEBUG_setup(); 393 int i = DEBUG_findEntry(e); 394 if (i < 0) { 395 printf("ERROR DEBUG_useEntry possible dangling pointer %08X\n", e); 396 } 397} 398 399#else 400// If we're not debugging then make these macros into NOPs 401#define DEBUG_newEntry(x) 402#define DEBUG_delEntry(x) 403#define DEBUG_useEntry(x) 404#endif 405 406//---------------------------------------------------------------------- 407// class Entry 408//---------------------------------------------------------------------- 409 410/** 411 * The Entry object stores objects of different types and 412 * singleton objects as placeholders for rule-based transliterators to 413 * be built as needed. Instances of this struct can be placeholders, 414 * can represent prototype transliterators to be cloned, or can 415 * represent TransliteratorData objects. We don't support storing 416 * classes in the registry because we don't have the rtti infrastructure 417 * for it. We could easily add this if there is a need for it in the 418 * future. 419 */ 420class TransliteratorEntry : public UMemory { 421public: 422 enum Type { 423 RULES_FORWARD, 424 RULES_REVERSE, 425 LOCALE_RULES, 426 PROTOTYPE, 427 RBT_DATA, 428 COMPOUND_RBT, 429 ALIAS, 430 FACTORY, 431 NONE // Only used for uninitialized entries 432 } entryType; 433 // NOTE: stringArg cannot go inside the union because 434 // it has a copy constructor 435 UnicodeString stringArg; // For RULES_*, ALIAS, COMPOUND_RBT 436 int32_t intArg; // For COMPOUND_RBT, LOCALE_RULES 437 UnicodeSet* compoundFilter; // For COMPOUND_RBT 438 union { 439 Transliterator* prototype; // For PROTOTYPE 440 TransliterationRuleData* data; // For RBT_DATA 441 UVector* dataVector; // For COMPOUND_RBT 442 struct { 443 Transliterator::Factory function; 444 Transliterator::Token context; 445 } factory; // For FACTORY 446 } u; 447 TransliteratorEntry(); 448 ~TransliteratorEntry(); 449 void adoptPrototype(Transliterator* adopted); 450 void setFactory(Transliterator::Factory factory, 451 Transliterator::Token context); 452 453private: 454 455 TransliteratorEntry(const TransliteratorEntry &other); // forbid copying of this class 456 TransliteratorEntry &operator=(const TransliteratorEntry &other); // forbid copying of this class 457}; 458 459TransliteratorEntry::TransliteratorEntry() { 460 u.prototype = 0; 461 compoundFilter = NULL; 462 entryType = NONE; 463 DEBUG_newEntry(this); 464} 465 466TransliteratorEntry::~TransliteratorEntry() { 467 DEBUG_delEntry(this); 468 if (entryType == PROTOTYPE) { 469 delete u.prototype; 470 } else if (entryType == RBT_DATA) { 471 // The data object is shared between instances of RBT. The 472 // entry object owns it. It should only be deleted when the 473 // transliterator component is being cleaned up. Doing so 474 // invalidates any RBTs that the user has instantiated. 475 delete u.data; 476 } else if (entryType == COMPOUND_RBT) { 477 while (u.dataVector != NULL && !u.dataVector->isEmpty()) 478 delete (TransliterationRuleData*)u.dataVector->orphanElementAt(0); 479 delete u.dataVector; 480 } 481 delete compoundFilter; 482} 483 484void TransliteratorEntry::adoptPrototype(Transliterator* adopted) { 485 if (entryType == PROTOTYPE) { 486 delete u.prototype; 487 } 488 entryType = PROTOTYPE; 489 u.prototype = adopted; 490} 491 492void TransliteratorEntry::setFactory(Transliterator::Factory factory, 493 Transliterator::Token context) { 494 if (entryType == PROTOTYPE) { 495 delete u.prototype; 496 } 497 entryType = FACTORY; 498 u.factory.function = factory; 499 u.factory.context = context; 500} 501 502// UObjectDeleter for Hashtable::setValueDeleter 503U_CDECL_BEGIN 504static void U_CALLCONV 505deleteEntry(void* obj) { 506 delete (TransliteratorEntry*) obj; 507} 508U_CDECL_END 509 510//---------------------------------------------------------------------- 511// class TransliteratorRegistry: Basic public API 512//---------------------------------------------------------------------- 513 514TransliteratorRegistry::TransliteratorRegistry(UErrorCode& status) : 515 registry(TRUE, status), 516 specDAG(TRUE, status), 517 availableIDs(status) 518{ 519 registry.setValueDeleter(deleteEntry); 520 availableIDs.setDeleter(uhash_deleteUnicodeString); 521 availableIDs.setComparer(uhash_compareCaselessUnicodeString); 522 specDAG.setValueDeleter(uhash_deleteHashtable); 523} 524 525TransliteratorRegistry::~TransliteratorRegistry() { 526 // Through the magic of C++, everything cleans itself up 527} 528 529Transliterator* TransliteratorRegistry::get(const UnicodeString& ID, 530 TransliteratorAlias*& aliasReturn, 531 UErrorCode& status) { 532 U_ASSERT(aliasReturn == NULL); 533 TransliteratorEntry *entry = find(ID); 534 return (entry == 0) ? 0 535 : instantiateEntry(ID, entry, aliasReturn, status); 536} 537 538Transliterator* TransliteratorRegistry::reget(const UnicodeString& ID, 539 TransliteratorParser& parser, 540 TransliteratorAlias*& aliasReturn, 541 UErrorCode& status) { 542 U_ASSERT(aliasReturn == NULL); 543 TransliteratorEntry *entry = find(ID); 544 545 if (entry == 0) { 546 // We get to this point if there are two threads, one of which 547 // is instantiating an ID, and another of which is removing 548 // the same ID from the registry, and the timing is just right. 549 return 0; 550 } 551 552 // The usage model for the caller is that they will first call 553 // reg->get() inside the mutex, they'll get back an alias, they call 554 // alias->isRuleBased(), and if they get TRUE, they call alias->parse() 555 // outside the mutex, then reg->reget() inside the mutex again. A real 556 // mess, but it gets things working for ICU 3.0. [alan]. 557 558 // Note: It's possible that in between the caller calling 559 // alias->parse() and reg->reget(), that another thread will have 560 // called reg->reget(), and the entry will already have been fixed up. 561 // We have to detect this so we don't stomp over existing entry 562 // data members and potentially leak memory (u.data and compoundFilter). 563 564 if (entry->entryType == TransliteratorEntry::RULES_FORWARD || 565 entry->entryType == TransliteratorEntry::RULES_REVERSE || 566 entry->entryType == TransliteratorEntry::LOCALE_RULES) { 567 568 if (parser.idBlockVector.isEmpty() && parser.dataVector.isEmpty()) { 569 entry->u.data = 0; 570 entry->entryType = TransliteratorEntry::ALIAS; 571 entry->stringArg = UNICODE_STRING_SIMPLE("Any-NULL"); 572 } 573 else if (parser.idBlockVector.isEmpty() && parser.dataVector.size() == 1) { 574 entry->u.data = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0); 575 entry->entryType = TransliteratorEntry::RBT_DATA; 576 } 577 else if (parser.idBlockVector.size() == 1 && parser.dataVector.isEmpty()) { 578 entry->stringArg = *(UnicodeString*)(parser.idBlockVector.elementAt(0)); 579 entry->compoundFilter = parser.orphanCompoundFilter(); 580 entry->entryType = TransliteratorEntry::ALIAS; 581 } 582 else { 583 entry->entryType = TransliteratorEntry::COMPOUND_RBT; 584 entry->compoundFilter = parser.orphanCompoundFilter(); 585 entry->u.dataVector = new UVector(status); 586 entry->stringArg.remove(); 587 588 int32_t limit = parser.idBlockVector.size(); 589 if (parser.dataVector.size() > limit) 590 limit = parser.dataVector.size(); 591 592 for (int32_t i = 0; i < limit; i++) { 593 if (i < parser.idBlockVector.size()) { 594 UnicodeString* idBlock = (UnicodeString*)parser.idBlockVector.elementAt(i); 595 if (!idBlock->isEmpty()) 596 entry->stringArg += *idBlock; 597 } 598 if (!parser.dataVector.isEmpty()) { 599 TransliterationRuleData* data = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0); 600 entry->u.dataVector->addElement(data, status); 601 entry->stringArg += (UChar)0xffff; // use U+FFFF to mark position of RBTs in ID block 602 } 603 } 604 } 605 } 606 607 Transliterator *t = 608 instantiateEntry(ID, entry, aliasReturn, status); 609 return t; 610} 611 612void TransliteratorRegistry::put(Transliterator* adoptedProto, 613 UBool visible, 614 UErrorCode& ec) 615{ 616 TransliteratorEntry *entry = new TransliteratorEntry(); 617 if (entry == NULL) { 618 ec = U_MEMORY_ALLOCATION_ERROR; 619 return; 620 } 621 entry->adoptPrototype(adoptedProto); 622 registerEntry(adoptedProto->getID(), entry, visible); 623} 624 625void TransliteratorRegistry::put(const UnicodeString& ID, 626 Transliterator::Factory factory, 627 Transliterator::Token context, 628 UBool visible, 629 UErrorCode& ec) { 630 TransliteratorEntry *entry = new TransliteratorEntry(); 631 if (entry == NULL) { 632 ec = U_MEMORY_ALLOCATION_ERROR; 633 return; 634 } 635 entry->setFactory(factory, context); 636 registerEntry(ID, entry, visible); 637} 638 639void TransliteratorRegistry::put(const UnicodeString& ID, 640 const UnicodeString& resourceName, 641 UTransDirection dir, 642 UBool readonlyResourceAlias, 643 UBool visible, 644 UErrorCode& ec) { 645 TransliteratorEntry *entry = new TransliteratorEntry(); 646 if (entry == NULL) { 647 ec = U_MEMORY_ALLOCATION_ERROR; 648 return; 649 } 650 entry->entryType = (dir == UTRANS_FORWARD) ? TransliteratorEntry::RULES_FORWARD 651 : TransliteratorEntry::RULES_REVERSE; 652 if (readonlyResourceAlias) { 653 entry->stringArg.setTo(TRUE, resourceName.getBuffer(), -1); 654 } 655 else { 656 entry->stringArg = resourceName; 657 } 658 registerEntry(ID, entry, visible); 659} 660 661void TransliteratorRegistry::put(const UnicodeString& ID, 662 const UnicodeString& alias, 663 UBool readonlyAliasAlias, 664 UBool visible, 665 UErrorCode& /*ec*/) { 666 TransliteratorEntry *entry = new TransliteratorEntry(); 667 // Null pointer check 668 if (entry != NULL) { 669 entry->entryType = TransliteratorEntry::ALIAS; 670 if (readonlyAliasAlias) { 671 entry->stringArg.setTo(TRUE, alias.getBuffer(), -1); 672 } 673 else { 674 entry->stringArg = alias; 675 } 676 registerEntry(ID, entry, visible); 677 } 678} 679 680void TransliteratorRegistry::remove(const UnicodeString& ID) { 681 UnicodeString source, target, variant; 682 UBool sawSource; 683 TransliteratorIDParser::IDtoSTV(ID, source, target, variant, sawSource); 684 // Only need to do this if ID.indexOf('-') < 0 685 UnicodeString id; 686 TransliteratorIDParser::STVtoID(source, target, variant, id); 687 registry.remove(id); 688 removeSTV(source, target, variant); 689 availableIDs.removeElement((void*) &id); 690} 691 692//---------------------------------------------------------------------- 693// class TransliteratorRegistry: Public ID and spec management 694//---------------------------------------------------------------------- 695 696/** 697 * == OBSOLETE - remove in ICU 3.4 == 698 * Return the number of IDs currently registered with the system. 699 * To retrieve the actual IDs, call getAvailableID(i) with 700 * i from 0 to countAvailableIDs() - 1. 701 */ 702int32_t TransliteratorRegistry::countAvailableIDs(void) const { 703 return availableIDs.size(); 704} 705 706/** 707 * == OBSOLETE - remove in ICU 3.4 == 708 * Return the index-th available ID. index must be between 0 709 * and countAvailableIDs() - 1, inclusive. If index is out of 710 * range, the result of getAvailableID(0) is returned. 711 */ 712const UnicodeString& TransliteratorRegistry::getAvailableID(int32_t index) const { 713 if (index < 0 || index >= availableIDs.size()) { 714 index = 0; 715 } 716 return *(const UnicodeString*) availableIDs[index]; 717} 718 719StringEnumeration* TransliteratorRegistry::getAvailableIDs() const { 720 return new Enumeration(*this); 721} 722 723int32_t TransliteratorRegistry::countAvailableSources(void) const { 724 return specDAG.count(); 725} 726 727UnicodeString& TransliteratorRegistry::getAvailableSource(int32_t index, 728 UnicodeString& result) const { 729 int32_t pos = -1; 730 const UHashElement *e = 0; 731 while (index-- >= 0) { 732 e = specDAG.nextElement(pos); 733 if (e == 0) { 734 break; 735 } 736 } 737 if (e == 0) { 738 result.truncate(0); 739 } else { 740 result = *(UnicodeString*) e->key.pointer; 741 } 742 return result; 743} 744 745int32_t TransliteratorRegistry::countAvailableTargets(const UnicodeString& source) const { 746 Hashtable *targets = (Hashtable*) specDAG.get(source); 747 return (targets == 0) ? 0 : targets->count(); 748} 749 750UnicodeString& TransliteratorRegistry::getAvailableTarget(int32_t index, 751 const UnicodeString& source, 752 UnicodeString& result) const { 753 Hashtable *targets = (Hashtable*) specDAG.get(source); 754 if (targets == 0) { 755 result.truncate(0); // invalid source 756 return result; 757 } 758 int32_t pos = -1; 759 const UHashElement *e = 0; 760 while (index-- >= 0) { 761 e = targets->nextElement(pos); 762 if (e == 0) { 763 break; 764 } 765 } 766 if (e == 0) { 767 result.truncate(0); // invalid index 768 } else { 769 result = *(UnicodeString*) e->key.pointer; 770 } 771 return result; 772} 773 774int32_t TransliteratorRegistry::countAvailableVariants(const UnicodeString& source, 775 const UnicodeString& target) const { 776 Hashtable *targets = (Hashtable*) specDAG.get(source); 777 if (targets == 0) { 778 return 0; 779 } 780 UVector *variants = (UVector*) targets->get(target); 781 // variants may be 0 if the source/target are invalid 782 return (variants == 0) ? 0 : variants->size(); 783} 784 785UnicodeString& TransliteratorRegistry::getAvailableVariant(int32_t index, 786 const UnicodeString& source, 787 const UnicodeString& target, 788 UnicodeString& result) const { 789 Hashtable *targets = (Hashtable*) specDAG.get(source); 790 if (targets == 0) { 791 result.truncate(0); // invalid source 792 return result; 793 } 794 UVector *variants = (UVector*) targets->get(target); 795 if (variants == 0) { 796 result.truncate(0); // invalid target 797 return result; 798 } 799 UnicodeString *v = (UnicodeString*) variants->elementAt(index); 800 if (v == 0) { 801 result.truncate(0); // invalid index 802 } else { 803 result = *v; 804 } 805 return result; 806} 807 808//---------------------------------------------------------------------- 809// class TransliteratorRegistry::Enumeration 810//---------------------------------------------------------------------- 811 812TransliteratorRegistry::Enumeration::Enumeration(const TransliteratorRegistry& _reg) : 813 index(0), reg(_reg) { 814} 815 816TransliteratorRegistry::Enumeration::~Enumeration() { 817} 818 819int32_t TransliteratorRegistry::Enumeration::count(UErrorCode& /*status*/) const { 820 return reg.availableIDs.size(); 821} 822 823const UnicodeString* TransliteratorRegistry::Enumeration::snext(UErrorCode& status) { 824 // This is sloppy but safe -- if we get out of sync with the underlying 825 // registry, we will still return legal strings, but they might not 826 // correspond to the snapshot at construction time. So there could be 827 // duplicate IDs or omitted IDs if insertions or deletions occur in one 828 // thread while another is iterating. To be more rigorous, add a timestamp, 829 // which is incremented with any modification, and validate this iterator 830 // against the timestamp at construction time. This probably isn't worth 831 // doing as long as there is some possibility of removing this code in favor 832 // of some new code based on Doug's service framework. 833 if (U_FAILURE(status)) { 834 return NULL; 835 } 836 int32_t n = reg.availableIDs.size(); 837 if (index > n) { 838 status = U_ENUM_OUT_OF_SYNC_ERROR; 839 } 840 // index == n is okay -- this means we've reached the end 841 if (index < n) { 842 // Copy the string! This avoids lifetime problems. 843 unistr = *(const UnicodeString*)reg.availableIDs[index++]; 844 return &unistr; 845 } else { 846 return NULL; 847 } 848} 849 850void TransliteratorRegistry::Enumeration::reset(UErrorCode& /*status*/) { 851 index = 0; 852} 853 854UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TransliteratorRegistry::Enumeration) 855 856//---------------------------------------------------------------------- 857// class TransliteratorRegistry: internal 858//---------------------------------------------------------------------- 859 860/** 861 * Convenience method. Calls 6-arg registerEntry(). 862 */ 863void TransliteratorRegistry::registerEntry(const UnicodeString& source, 864 const UnicodeString& target, 865 const UnicodeString& variant, 866 TransliteratorEntry* adopted, 867 UBool visible) { 868 UnicodeString ID; 869 UnicodeString s(source); 870 if (s.length() == 0) { 871 s = ANY; 872 } 873 TransliteratorIDParser::STVtoID(source, target, variant, ID); 874 registerEntry(ID, s, target, variant, adopted, visible); 875} 876 877/** 878 * Convenience method. Calls 6-arg registerEntry(). 879 */ 880void TransliteratorRegistry::registerEntry(const UnicodeString& ID, 881 TransliteratorEntry* adopted, 882 UBool visible) { 883 UnicodeString source, target, variant; 884 UBool sawSource; 885 TransliteratorIDParser::IDtoSTV(ID, source, target, variant, sawSource); 886 // Only need to do this if ID.indexOf('-') < 0 887 UnicodeString id; 888 TransliteratorIDParser::STVtoID(source, target, variant, id); 889 registerEntry(id, source, target, variant, adopted, visible); 890} 891 892/** 893 * Register an entry object (adopted) with the given ID, source, 894 * target, and variant strings. 895 */ 896void TransliteratorRegistry::registerEntry(const UnicodeString& ID, 897 const UnicodeString& source, 898 const UnicodeString& target, 899 const UnicodeString& variant, 900 TransliteratorEntry* adopted, 901 UBool visible) { 902 UErrorCode status = U_ZERO_ERROR; 903 registry.put(ID, adopted, status); 904 if (visible) { 905 registerSTV(source, target, variant); 906 if (!availableIDs.contains((void*) &ID)) { 907 UnicodeString *newID = (UnicodeString *)ID.clone(); 908 // Check to make sure newID was created. 909 if (newID != NULL) { 910 // NUL-terminate the ID string 911 newID->getTerminatedBuffer(); 912 availableIDs.addElement(newID, status); 913 } 914 } 915 } else { 916 removeSTV(source, target, variant); 917 availableIDs.removeElement((void*) &ID); 918 } 919} 920 921/** 922 * Register a source-target/variant in the specDAG. Variant may be 923 * empty, but source and target must not be. If variant is empty then 924 * the special variant NO_VARIANT is stored in slot zero of the 925 * UVector of variants. 926 */ 927void TransliteratorRegistry::registerSTV(const UnicodeString& source, 928 const UnicodeString& target, 929 const UnicodeString& variant) { 930 // assert(source.length() > 0); 931 // assert(target.length() > 0); 932 UErrorCode status = U_ZERO_ERROR; 933 Hashtable *targets = (Hashtable*) specDAG.get(source); 934 if (targets == 0) { 935 targets = new Hashtable(TRUE, status); 936 if (U_FAILURE(status) || targets == 0) { 937 return; 938 } 939 targets->setValueDeleter(uhash_deleteUObject); 940 specDAG.put(source, targets, status); 941 } 942 UVector *variants = (UVector*) targets->get(target); 943 if (variants == 0) { 944 variants = new UVector(uhash_deleteUnicodeString, 945 uhash_compareCaselessUnicodeString, status); 946 if (variants == 0) { 947 return; 948 } 949 targets->put(target, variants, status); 950 } 951 // assert(NO_VARIANT == ""); 952 // We add the variant string. If it is the special "no variant" 953 // string, that is, the empty string, we add it at position zero. 954 if (!variants->contains((void*) &variant)) { 955 UnicodeString *tempus; // Used for null pointer check. 956 if (variant.length() > 0) { 957 tempus = new UnicodeString(variant); 958 if (tempus != NULL) { 959 variants->addElement(tempus, status); 960 } 961 } else { 962 tempus = new UnicodeString(NO_VARIANT) ; 963 if (tempus != NULL) { 964 variants->insertElementAt(tempus, 0, status); 965 } 966 } 967 } 968} 969 970/** 971 * Remove a source-target/variant from the specDAG. 972 */ 973void TransliteratorRegistry::removeSTV(const UnicodeString& source, 974 const UnicodeString& target, 975 const UnicodeString& variant) { 976 // assert(source.length() > 0); 977 // assert(target.length() > 0); 978// UErrorCode status = U_ZERO_ERROR; 979 Hashtable *targets = (Hashtable*) specDAG.get(source); 980 if (targets == 0) { 981 return; // should never happen for valid s-t/v 982 } 983 UVector *variants = (UVector*) targets->get(target); 984 if (variants == 0) { 985 return; // should never happen for valid s-t/v 986 } 987 variants->removeElement((void*) &variant); 988 if (variants->size() == 0) { 989 targets->remove(target); // should delete variants 990 if (targets->count() == 0) { 991 specDAG.remove(source); // should delete targets 992 } 993 } 994} 995 996/** 997 * Attempt to find a source-target/variant in the dynamic registry 998 * store. Return 0 on failure. 999 * 1000 * Caller does NOT own returned object. 1001 */ 1002TransliteratorEntry* TransliteratorRegistry::findInDynamicStore(const TransliteratorSpec& src, 1003 const TransliteratorSpec& trg, 1004 const UnicodeString& variant) const { 1005 UnicodeString ID; 1006 TransliteratorIDParser::STVtoID(src, trg, variant, ID); 1007 TransliteratorEntry *e = (TransliteratorEntry*) registry.get(ID); 1008 DEBUG_useEntry(e); 1009 return e; 1010} 1011 1012/** 1013 * Attempt to find a source-target/variant in the static locale 1014 * resource store. Do not perform fallback. Return 0 on failure. 1015 * 1016 * On success, create a new entry object, register it in the dynamic 1017 * store, and return a pointer to it, but do not make it public -- 1018 * just because someone requested something, we do not expand the 1019 * available ID list (or spec DAG). 1020 * 1021 * Caller does NOT own returned object. 1022 */ 1023TransliteratorEntry* TransliteratorRegistry::findInStaticStore(const TransliteratorSpec& src, 1024 const TransliteratorSpec& trg, 1025 const UnicodeString& variant) { 1026 TransliteratorEntry* entry = 0; 1027 if (src.isLocale()) { 1028 entry = findInBundle(src, trg, variant, UTRANS_FORWARD); 1029 } else if (trg.isLocale()) { 1030 entry = findInBundle(trg, src, variant, UTRANS_REVERSE); 1031 } 1032 1033 // If we found an entry, store it in the Hashtable for next 1034 // time. 1035 if (entry != 0) { 1036 registerEntry(src.getTop(), trg.getTop(), variant, entry, FALSE); 1037 } 1038 1039 return entry; 1040} 1041 1042// As of 2.0, resource bundle keys cannot contain '_' 1043static const UChar TRANSLITERATE_TO[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,84,111,0}; // "TransliterateTo" 1044 1045static const UChar TRANSLITERATE_FROM[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,70,114,111,109,0}; // "TransliterateFrom" 1046 1047static const UChar TRANSLITERATE[] = {84,114,97,110,115,108,105,116,101,114,97,116,101,0}; // "Transliterate" 1048 1049/** 1050 * Attempt to find an entry in a single resource bundle. This is 1051 * a one-sided lookup. findInStaticStore() performs up to two such 1052 * lookups, one for the source, and one for the target. 1053 * 1054 * Do not perform fallback. Return 0 on failure. 1055 * 1056 * On success, create a new Entry object, populate it, and return it. 1057 * The caller owns the returned object. 1058 */ 1059TransliteratorEntry* TransliteratorRegistry::findInBundle(const TransliteratorSpec& specToOpen, 1060 const TransliteratorSpec& specToFind, 1061 const UnicodeString& variant, 1062 UTransDirection direction) 1063{ 1064 UnicodeString utag; 1065 UnicodeString resStr; 1066 int32_t pass; 1067 1068 for (pass=0; pass<2; ++pass) { 1069 utag.truncate(0); 1070 // First try either TransliteratorTo_xxx or 1071 // TransliterateFrom_xxx, then try the bidirectional 1072 // Transliterate_xxx. This precedence order is arbitrary 1073 // but must be consistent and documented. 1074 if (pass == 0) { 1075 utag.append(direction == UTRANS_FORWARD ? 1076 TRANSLITERATE_TO : TRANSLITERATE_FROM); 1077 } else { 1078 utag.append(TRANSLITERATE); 1079 } 1080 UnicodeString s(specToFind.get()); 1081 utag.append(s.toUpper("")); 1082 UErrorCode status = U_ZERO_ERROR; 1083 ResourceBundle subres(specToOpen.getBundle().get( 1084 CharString().appendInvariantChars(utag, status).data(), status)); 1085 if (U_FAILURE(status) || status == U_USING_DEFAULT_WARNING) { 1086 continue; 1087 } 1088 1089 s.truncate(0); 1090 if (specToOpen.get() != LocaleUtility::initNameFromLocale(subres.getLocale(), s)) { 1091 continue; 1092 } 1093 1094 if (variant.length() != 0) { 1095 status = U_ZERO_ERROR; 1096 resStr = subres.getStringEx( 1097 CharString().appendInvariantChars(variant, status).data(), status); 1098 if (U_SUCCESS(status)) { 1099 // Exit loop successfully 1100 break; 1101 } 1102 } else { 1103 // Variant is empty, which means match the first variant listed. 1104 status = U_ZERO_ERROR; 1105 resStr = subres.getStringEx(1, status); 1106 if (U_SUCCESS(status)) { 1107 // Exit loop successfully 1108 break; 1109 } 1110 } 1111 } 1112 1113 if (pass==2) { 1114 // Failed 1115 return NULL; 1116 } 1117 1118 // We have succeeded in loading a string from the locale 1119 // resources. Create a new registry entry to hold it and return it. 1120 TransliteratorEntry *entry = new TransliteratorEntry(); 1121 if (entry != 0) { 1122 // The direction is always forward for the 1123 // TransliterateTo_xxx and TransliterateFrom_xxx 1124 // items; those are unidirectional forward rules. 1125 // For the bidirectional Transliterate_xxx items, 1126 // the direction is the value passed in to this 1127 // function. 1128 int32_t dir = (pass == 0) ? UTRANS_FORWARD : direction; 1129 entry->entryType = TransliteratorEntry::LOCALE_RULES; 1130 entry->stringArg = resStr; 1131 entry->intArg = dir; 1132 } 1133 1134 return entry; 1135} 1136 1137/** 1138 * Convenience method. Calls 3-arg find(). 1139 */ 1140TransliteratorEntry* TransliteratorRegistry::find(const UnicodeString& ID) { 1141 UnicodeString source, target, variant; 1142 UBool sawSource; 1143 TransliteratorIDParser::IDtoSTV(ID, source, target, variant, sawSource); 1144 return find(source, target, variant); 1145} 1146 1147/** 1148 * Top-level find method. Attempt to find a source-target/variant in 1149 * either the dynamic or the static (locale resource) store. Perform 1150 * fallback. 1151 * 1152 * Lookup sequence for ss_SS_SSS-tt_TT_TTT/v: 1153 * 1154 * ss_SS_SSS-tt_TT_TTT/v -- in hashtable 1155 * ss_SS_SSS-tt_TT_TTT/v -- in ss_SS_SSS (no fallback) 1156 * 1157 * repeat with t = tt_TT_TTT, tt_TT, tt, and tscript 1158 * 1159 * ss_SS_SSS-t/ * 1160 * ss_SS-t/ * 1161 * ss-t/ * 1162 * sscript-t/ * 1163 * 1164 * Here * matches the first variant listed. 1165 * 1166 * Caller does NOT own returned object. Return 0 on failure. 1167 */ 1168TransliteratorEntry* TransliteratorRegistry::find(UnicodeString& source, 1169 UnicodeString& target, 1170 UnicodeString& variant) { 1171 1172 TransliteratorSpec src(source); 1173 TransliteratorSpec trg(target); 1174 TransliteratorEntry* entry; 1175 1176 // Seek exact match in hashtable. Temporary fix for ICU 4.6. 1177 // TODO: The general logic for finding a matching transliterator needs to be reviewed. 1178 // ICU ticket #8089 1179 UnicodeString ID; 1180 TransliteratorIDParser::STVtoID(source, target, variant, ID); 1181 entry = (TransliteratorEntry*) registry.get(ID); 1182 if (entry != 0) { 1183 // std::string ss; 1184 // std::cout << ID.toUTF8String(ss) << std::endl; 1185 return entry; 1186 } 1187 1188 if (variant.length() != 0) { 1189 1190 // Seek exact match in hashtable 1191 entry = findInDynamicStore(src, trg, variant); 1192 if (entry != 0) { 1193 return entry; 1194 } 1195 1196 // Seek exact match in locale resources 1197 entry = findInStaticStore(src, trg, variant); 1198 if (entry != 0) { 1199 return entry; 1200 } 1201 } 1202 1203 for (;;) { 1204 src.reset(); 1205 for (;;) { 1206 // Seek match in hashtable 1207 entry = findInDynamicStore(src, trg, NO_VARIANT); 1208 if (entry != 0) { 1209 return entry; 1210 } 1211 1212 // Seek match in locale resources 1213 entry = findInStaticStore(src, trg, NO_VARIANT); 1214 if (entry != 0) { 1215 return entry; 1216 } 1217 if (!src.hasFallback()) { 1218 break; 1219 } 1220 src.next(); 1221 } 1222 if (!trg.hasFallback()) { 1223 break; 1224 } 1225 trg.next(); 1226 } 1227 1228 return 0; 1229} 1230 1231/** 1232 * Given an Entry object, instantiate it. Caller owns result. Return 1233 * 0 on failure. 1234 * 1235 * Return a non-empty aliasReturn value if the ID points to an alias. 1236 * We cannot instantiate it ourselves because the alias may contain 1237 * filters or compounds, which we do not understand. Caller should 1238 * make aliasReturn empty before calling. 1239 * 1240 * The entry object is assumed to reside in the dynamic store. It may be 1241 * modified. 1242 */ 1243Transliterator* TransliteratorRegistry::instantiateEntry(const UnicodeString& ID, 1244 TransliteratorEntry *entry, 1245 TransliteratorAlias* &aliasReturn, 1246 UErrorCode& status) { 1247 Transliterator *t = 0; 1248 U_ASSERT(aliasReturn == 0); 1249 1250 switch (entry->entryType) { 1251 case TransliteratorEntry::RBT_DATA: 1252 t = new RuleBasedTransliterator(ID, entry->u.data); 1253 if (t == 0) { 1254 status = U_MEMORY_ALLOCATION_ERROR; 1255 } 1256 return t; 1257 case TransliteratorEntry::PROTOTYPE: 1258 t = entry->u.prototype->clone(); 1259 if (t == 0) { 1260 status = U_MEMORY_ALLOCATION_ERROR; 1261 } 1262 return t; 1263 case TransliteratorEntry::ALIAS: 1264 aliasReturn = new TransliteratorAlias(entry->stringArg, entry->compoundFilter); 1265 if (aliasReturn == 0) { 1266 status = U_MEMORY_ALLOCATION_ERROR; 1267 } 1268 return 0; 1269 case TransliteratorEntry::FACTORY: 1270 t = entry->u.factory.function(ID, entry->u.factory.context); 1271 if (t == 0) { 1272 status = U_MEMORY_ALLOCATION_ERROR; 1273 } 1274 return t; 1275 case TransliteratorEntry::COMPOUND_RBT: 1276 { 1277 UVector* rbts = new UVector(entry->u.dataVector->size(), status); 1278 // Check for null pointer 1279 if (rbts == NULL) { 1280 status = U_MEMORY_ALLOCATION_ERROR; 1281 return NULL; 1282 } 1283 int32_t passNumber = 1; 1284 for (int32_t i = 0; U_SUCCESS(status) && i < entry->u.dataVector->size(); i++) { 1285 Transliterator* t = new RuleBasedTransliterator(UnicodeString(CompoundTransliterator::PASS_STRING) + (passNumber++), 1286 (TransliterationRuleData*)(entry->u.dataVector->elementAt(i)), FALSE); 1287 if (t == 0) 1288 status = U_MEMORY_ALLOCATION_ERROR; 1289 else 1290 rbts->addElement(t, status); 1291 } 1292 if (U_FAILURE(status)) { 1293 delete rbts; 1294 return 0; 1295 } 1296 aliasReturn = new TransliteratorAlias(ID, entry->stringArg, rbts, entry->compoundFilter); 1297 } 1298 if (aliasReturn == 0) { 1299 status = U_MEMORY_ALLOCATION_ERROR; 1300 } 1301 return 0; 1302 case TransliteratorEntry::LOCALE_RULES: 1303 aliasReturn = new TransliteratorAlias(ID, entry->stringArg, 1304 (UTransDirection) entry->intArg); 1305 if (aliasReturn == 0) { 1306 status = U_MEMORY_ALLOCATION_ERROR; 1307 } 1308 return 0; 1309 case TransliteratorEntry::RULES_FORWARD: 1310 case TransliteratorEntry::RULES_REVERSE: 1311 // Process the rule data into a TransliteratorRuleData object, 1312 // and possibly also into an ::id header and/or footer. Then 1313 // we modify the registry with the parsed data and retry. 1314 { 1315 TransliteratorParser parser(status); 1316 1317 // We use the file name, taken from another resource bundle 1318 // 2-d array at static init time, as a locale language. We're 1319 // just using the locale mechanism to map through to a file 1320 // name; this in no way represents an actual locale. 1321 //CharString ch(entry->stringArg); 1322 //UResourceBundle *bundle = ures_openDirect(0, ch, &status); 1323 UnicodeString rules = entry->stringArg; 1324 //ures_close(bundle); 1325 1326 //if (U_FAILURE(status)) { 1327 // We have a failure of some kind. Remove the ID from the 1328 // registry so we don't keep trying. NOTE: This will throw off 1329 // anyone who is, at the moment, trying to iterate over the 1330 // available IDs. That's acceptable since we should never 1331 // really get here except under installation, configuration, 1332 // or unrecoverable run time memory failures. 1333 // remove(ID); 1334 //} else { 1335 1336 // If the status indicates a failure, then we don't have any 1337 // rules -- there is probably an installation error. The list 1338 // in the root locale should correspond to all the installed 1339 // transliterators; if it lists something that's not 1340 // installed, we'll get an error from ResourceBundle. 1341 aliasReturn = new TransliteratorAlias(ID, rules, 1342 ((entry->entryType == TransliteratorEntry::RULES_REVERSE) ? 1343 UTRANS_REVERSE : UTRANS_FORWARD)); 1344 if (aliasReturn == 0) { 1345 status = U_MEMORY_ALLOCATION_ERROR; 1346 } 1347 //} 1348 } 1349 return 0; 1350 default: 1351 U_ASSERT(FALSE); // can't get here 1352 return 0; 1353 } 1354} 1355U_NAMESPACE_END 1356 1357#endif /* #if !UCONFIG_NO_TRANSLITERATION */ 1358 1359//eof 1360