source/i18n/translit.cpp

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4  **********************************************************************
   5  *   Copyright (C) 1999-2016, International Business Machines
   6  *   Corporation and others.  All Rights Reserved.
   7  **********************************************************************
   8  *   Date        Name        Description
   9  *   11/17/99    aliu        Creation.
  10  **********************************************************************
  11  */
  12
  13 #include "utypeinfo.h"  // for 'typeid' to work
  14
  15 #include "unicode/utypes.h"
  16
  17 #if !UCONFIG_NO_TRANSLITERATION
  18
  19 #include "unicode/putil.h"
  20 #include "unicode/translit.h"
  21 #include "unicode/locid.h"
  22 #include "unicode/msgfmt.h"
  23 #include "unicode/rep.h"
  24 #include "unicode/resbund.h"
  25 #include "unicode/unifilt.h"
  26 #include "unicode/uniset.h"
  27 #include "unicode/uscript.h"
  28 #include "unicode/strenum.h"
  29 #include "unicode/utf16.h"
  30 #include "cpdtrans.h"
  31 #include "nultrans.h"
  32 #include "rbt_data.h"
  33 #include "rbt_pars.h"
  34 #include "rbt.h"
  35 #include "transreg.h"
  36 #include "name2uni.h"
  37 #include "nortrans.h"
  38 #include "remtrans.h"
  39 #include "titletrn.h"
  40 #include "tolowtrn.h"
  41 #include "toupptrn.h"
  42 #include "uni2name.h"
  43 #include "brktrans.h"
  44 #include "esctrn.h"
  45 #include "unesctrn.h"
  46 #include "tridpars.h"
  47 #include "anytrans.h"
  48 #include "util.h"
  49 #include "hash.h"
  50 #include "mutex.h"
  51 #include "ucln_in.h"
  52 #include "uassert.h"
  53 #include "cmemory.h"
  54 #include "cstring.h"
  55 #include "uinvchar.h"
  56
  57 static const UChar TARGET_SEP  = 0x002D; /*-*/
  58 static const UChar ID_DELIM    = 0x003B; /*;*/
  59 static const UChar VARIANT_SEP = 0x002F; // '/'
  60
  61 /**
  62  * Prefix for resource bundle key for the display name for a
  63  * transliterator.  The ID is appended to this to form the key.
  64  * The resource bundle value should be a String.
  65  */
  66 static const char RB_DISPLAY_NAME_PREFIX[] = "%Translit%%";
  67
  68 /**
  69  * Prefix for resource bundle key for the display name for a
  70  * transliterator SCRIPT.  The ID is appended to this to form the key.
  71  * The resource bundle value should be a String.
  72  */
  73 static const char RB_SCRIPT_DISPLAY_NAME_PREFIX[] = "%Translit%";
  74
  75 /**
  76  * Resource bundle key for display name pattern.
  77  * The resource bundle value should be a String forming a
  78  * MessageFormat pattern, e.g.:
  79  * "{0,choice,0#|1#{1} Transliterator|2#{1} to {2} Transliterator}".
  80  */
  81 static const char RB_DISPLAY_NAME_PATTERN[] = "TransliteratorNamePattern";
  82
  83 /**
  84  * Resource bundle key for the list of RuleBasedTransliterator IDs.
  85  * The resource bundle value should be a String[] with each element
  86  * being a valid ID.  The ID will be appended to RB_RULE_BASED_PREFIX
  87  * to obtain the class name in which the RB_RULE key will be sought.
  88  */
  89 static const char RB_RULE_BASED_IDS[] = "RuleBasedTransliteratorIDs";
  90
  91 /**
  92  * The mutex controlling access to registry object.
  93  */
  94 static UMutex registryMutex = U_MUTEX_INITIALIZER;
  95
  96 /**
  97  * System transliterator registry; non-null when initialized.
  98  */
  99 static icu::TransliteratorRegistry* registry = 0;
 100
 101 // Macro to check/initialize the registry. ONLY USE WITHIN
 102 // MUTEX. Avoids function call when registry is initialized.
 103 #define HAVE_REGISTRY(status) (registry!=0 || initializeRegistry(status))
 104
 105 U_NAMESPACE_BEGIN
 106
 107 UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(Transliterator)
 108
 109 /**
 110  * Return TRUE if the given UTransPosition is valid for text of
 111  * the given length.
 112  */
 113 static inline UBool positionIsValid(UTransPosition& index, int32_t len) {
 114     return !(index.contextStart < 0 ||
 115              index.start < index.contextStart ||
 116              index.limit < index.start ||
 117              index.contextLimit < index.limit ||
 118              len < index.contextLimit);
 119 }
 120
 121 /**
 122  * Default constructor.
 123  * @param theID the string identifier for this transliterator
 124  * @param theFilter the filter.  Any character for which
 125  * <tt>filter.contains()</tt> returns <tt>FALSE</tt> will not be
 126  * altered by this transliterator.  If <tt>filter</tt> is
 127  * <tt>null</tt> then no filtering is applied.
 128  */
 129 Transliterator::Transliterator(const UnicodeString& theID,
 130                                UnicodeFilter* adoptedFilter) :
 131     UObject(), ID(theID), filter(adoptedFilter),
 132     maximumContextLength(0)
 133 {
 134     // NUL-terminate the ID string, which is a non-aliased copy.
 135     ID.append((UChar)0);
 136     ID.truncate(ID.length()-1);
 137 }
 138
 139 /**
 140  * Destructor.
 141  */
 142 Transliterator::~Transliterator() {
 143     if (filter) {
 144         delete filter;
 145     }
 146 }
 147
 148 /**
 149  * Copy constructor.
 150  */
 151 Transliterator::Transliterator(const Transliterator& other) :
 152     UObject(other), ID(other.ID), filter(0),
 153     maximumContextLength(other.maximumContextLength)
 154 {
 155     // NUL-terminate the ID string, which is a non-aliased copy.
 156     ID.append((UChar)0);
 157     ID.truncate(ID.length()-1);
 158
 159     if (other.filter != 0) {
 160         // We own the filter, so we must have our own copy
 161         filter = (UnicodeFilter*) other.filter->clone();
 162     }
 163 }
 164
 165 Transliterator* Transliterator::clone() const {
 166     return NULL;
 167 }
 168
 169 /**
 170  * Assignment operator.
 171  */
 172 Transliterator& Transliterator::operator=(const Transliterator& other) {
 173     ID = other.ID;
 174     // NUL-terminate the ID string
 175     ID.getTerminatedBuffer();
 176
 177     maximumContextLength = other.maximumContextLength;
 178     adoptFilter((other.filter == 0) ? 0 : (UnicodeFilter*) other.filter->clone());
 179     return *this;
 180 }
 181
 182 /**
 183  * Transliterates a segment of a string.  <code>Transliterator</code> API.
 184  * @param text the string to be transliterated
 185  * @param start the beginning index, inclusive; <code>0 <= start
 186  * <= limit</code>.
 187  * @param limit the ending index, exclusive; <code>start <= limit
 188  * <= text.length()</code>.
 189  * @return the new limit index, or -1
 190  */
 191 int32_t Transliterator::transliterate(Replaceable& text,
 192                                       int32_t start, int32_t limit) const {
 193     if (start < 0 ||
 194         limit < start ||
 195         text.length() < limit) {
 196         return -1;
 197     }
 198
 199     UTransPosition offsets;
 200     offsets.contextStart= start;
 201     offsets.contextLimit = limit;
 202     offsets.start = start;
 203     offsets.limit = limit;
 204     filteredTransliterate(text, offsets, FALSE, TRUE);
 205     return offsets.limit;
 206 }
 207
 208 /**
 209  * Transliterates an entire string in place. Convenience method.
 210  * @param text the string to be transliterated
 211  */
 212 void Transliterator::transliterate(Replaceable& text) const {
 213     transliterate(text, 0, text.length());
 214 }
 215
 216 /**
 217  * Transliterates the portion of the text buffer that can be
 218  * transliterated unambiguosly after new text has been inserted,
 219  * typically as a result of a keyboard event.  The new text in
 220  * <code>insertion</code> will be inserted into <code>text</code>
 221  * at <code>index.contextLimit</code>, advancing
 222  * <code>index.contextLimit</code> by <code>insertion.length()</code>.
 223  * Then the transliterator will try to transliterate characters of
 224  * <code>text</code> between <code>index.start</code> and
 225  * <code>index.contextLimit</code>.  Characters before
 226  * <code>index.start</code> will not be changed.
 227  *
 228  * <p>Upon return, values in <code>index</code> will be updated.
 229  * <code>index.contextStart</code> will be advanced to the first
 230  * character that future calls to this method will read.
 231  * <code>index.start</code> and <code>index.contextLimit</code> will
 232  * be adjusted to delimit the range of text that future calls to
 233  * this method may change.
 234  *
 235  * <p>Typical usage of this method begins with an initial call
 236  * with <code>index.contextStart</code> and <code>index.contextLimit</code>
 237  * set to indicate the portion of <code>text</code> to be
 238  * transliterated, and <code>index.start == index.contextStart</code>.
 239  * Thereafter, <code>index</code> can be used without
 240  * modification in future calls, provided that all changes to
 241  * <code>text</code> are made via this method.
 242  *
 243  * <p>This method assumes that future calls may be made that will
 244  * insert new text into the buffer.  As a result, it only performs
 245  * unambiguous transliterations.  After the last call to this
 246  * method, there may be untransliterated text that is waiting for
 247  * more input to resolve an ambiguity.  In order to perform these
 248  * pending transliterations, clients should call {@link
 249  * #finishKeyboardTransliteration} after the last call to this
 250  * method has been made.
 251  *
 252  * @param text the buffer holding transliterated and untransliterated text
 253  * @param index an array of three integers.
 254  *
 255  * <ul><li><code>index.contextStart</code>: the beginning index,
 256  * inclusive; <code>0 <= index.contextStart <= index.contextLimit</code>.
 257  *
 258  * <li><code>index.contextLimit</code>: the ending index, exclusive;
 259  * <code>index.contextStart <= index.contextLimit <= text.length()</code>.
 260  * <code>insertion</code> is inserted at
 261  * <code>index.contextLimit</code>.
 262  *
 263  * <li><code>index.start</code>: the next character to be
 264  * considered for transliteration; <code>index.contextStart <=
 265  * index.start <= index.contextLimit</code>.  Characters before
 266  * <code>index.start</code> will not be changed by future calls
 267  * to this method.</ul>
 268  *
 269  * @param insertion text to be inserted and possibly
 270  * transliterated into the translation buffer at
 271  * <code>index.contextLimit</code>.  If <code>null</code> then no text
 272  * is inserted.
 273  * @see #START
 274  * @see #LIMIT
 275  * @see #CURSOR
 276  * @see #handleTransliterate
 277  * @exception IllegalArgumentException if <code>index</code>
 278  * is invalid
 279  */
 280 void Transliterator::transliterate(Replaceable& text,
 281                                    UTransPosition& index,
 282                                    const UnicodeString& insertion,
 283                                    UErrorCode &status) const {
 284     _transliterate(text, index, &insertion, status);
 285 }
 286
 287 /**
 288  * Transliterates the portion of the text buffer that can be
 289  * transliterated unambiguosly after a new character has been
 290  * inserted, typically as a result of a keyboard event.  This is a
 291  * convenience method; see {@link
 292  * #transliterate(Replaceable, int[], String)} for details.
 293  * @param text the buffer holding transliterated and
 294  * untransliterated text
 295  * @param index an array of three integers.  See {@link
 296  * #transliterate(Replaceable, int[], String)}.
 297  * @param insertion text to be inserted and possibly
 298  * transliterated into the translation buffer at
 299  * <code>index.contextLimit</code>.
 300  * @see #transliterate(Replaceable, int[], String)
 301  */
 302 void Transliterator::transliterate(Replaceable& text,
 303                                    UTransPosition& index,
 304                                    UChar32 insertion,
 305                                    UErrorCode& status) const {
 306     UnicodeString str(insertion);
 307     _transliterate(text, index, &str, status);
 308 }
 309
 310 /**
 311  * Transliterates the portion of the text buffer that can be
 312  * transliterated unambiguosly.  This is a convenience method; see
 313  * {@link #transliterate(Replaceable, int[], String)} for
 314  * details.
 315  * @param text the buffer holding transliterated and
 316  * untransliterated text
 317  * @param index an array of three integers.  See {@link
 318  * #transliterate(Replaceable, int[], String)}.
 319  * @see #transliterate(Replaceable, int[], String)
 320  */
 321 void Transliterator::transliterate(Replaceable& text,
 322                                    UTransPosition& index,
 323                                    UErrorCode& status) const {
 324     _transliterate(text, index, 0, status);
 325 }
 326
 327 /**
 328  * Finishes any pending transliterations that were waiting for
 329  * more characters.  Clients should call this method as the last
 330  * call after a sequence of one or more calls to
 331  * <code>transliterate()</code>.
 332  * @param text the buffer holding transliterated and
 333  * untransliterated text.
 334  * @param index the array of indices previously passed to {@link
 335  * #transliterate}
 336  */
 337 void Transliterator::finishTransliteration(Replaceable& text,
 338                                            UTransPosition& index) const {
 339     if (!positionIsValid(index, text.length())) {
 340         return;
 341     }
 342
 343     filteredTransliterate(text, index, FALSE, TRUE);
 344 }
 345
 346 /**
 347  * This internal method does keyboard transliteration.  If the
 348  * 'insertion' is non-null then we append it to 'text' before
 349  * proceeding.  This method calls through to the pure virtual
 350  * framework method handleTransliterate() to do the actual
 351  * work.
 352  */
 353 void Transliterator::_transliterate(Replaceable& text,
 354                                     UTransPosition& index,
 355                                     const UnicodeString* insertion,
 356                                     UErrorCode &status) const {
 357     if (U_FAILURE(status)) {
 358         return;
 359     }
 360
 361     if (!positionIsValid(index, text.length())) {
 362         status = U_ILLEGAL_ARGUMENT_ERROR;
 363         return;
 364     }
 365
 366 //    int32_t originalStart = index.contextStart;
 367     if (insertion != 0) {
 368         text.handleReplaceBetween(index.limit, index.limit, *insertion);
 369         index.limit += insertion->length();
 370         index.contextLimit += insertion->length();
 371     }
 372
 373     if (index.limit > 0 &&
 374         U16_IS_LEAD(text.charAt(index.limit - 1))) {
 375         // Oops, there is a dangling lead surrogate in the buffer.
 376         // This will break most transliterators, since they will
 377         // assume it is part of a pair.  Don't transliterate until
 378         // more text comes in.
 379         return;
 380     }
 381
 382     filteredTransliterate(text, index, TRUE, TRUE);
 383
 384 #if 0
 385     // TODO
 386     // I CAN'T DO what I'm attempting below now that the Kleene star
 387     // operator is supported.  For example, in the rule
 388
 389     //   ([:Lu:]+) { x } > $1;
 390
 391     // what is the maximum context length?  getMaximumContextLength()
 392     // will return 1, but this is just the length of the ante context
 393     // part of the pattern string -- 1 character, which is a standin
 394     // for a Quantifier, which contains a StringMatcher, which
 395     // contains a UnicodeSet.
 396
 397     // There is a complicated way to make this work again, and that's
 398     // to add a "maximum left context" protocol into the
 399     // UnicodeMatcher hierarchy.  At present I'm not convinced this is
 400     // worth it.
 401
 402     // ---
 403
 404     // The purpose of the code below is to keep the context small
 405     // while doing incremental transliteration.  When part of the left
 406     // context (between contextStart and start) is no longer needed,
 407     // we try to advance contextStart past that portion.  We use the
 408     // maximum context length to do so.
 409     int32_t newCS = index.start;
 410     int32_t n = getMaximumContextLength();
 411     while (newCS > originalStart && n-- > 0) {
 412         --newCS;
 413         newCS -= U16_LENGTH(text.char32At(newCS)) - 1;
 414     }
 415     index.contextStart = uprv_max(newCS, originalStart);
 416 #endif
 417 }
 418
 419 /**
 420  * This method breaks up the input text into runs of unfiltered
 421  * characters.  It passes each such run to
 422  * <subclass>.handleTransliterate().  Subclasses that can handle the
 423  * filter logic more efficiently themselves may override this method.
 424  *
 425  * All transliteration calls in this class go through this method.
 426  */
 427 void Transliterator::filteredTransliterate(Replaceable& text,
 428                                            UTransPosition& index,
 429                                            UBool incremental,
 430                                            UBool rollback) const {
 431     // Short circuit path for transliterators with no filter in
 432     // non-incremental mode.
 433     if (filter == 0 && !rollback) {
 434         handleTransliterate(text, index, incremental);
 435         return;
 436     }
 437
 438     //----------------------------------------------------------------------
 439     // This method processes text in two groupings:
 440     //
 441     // RUNS -- A run is a contiguous group of characters which are contained
 442     // in the filter for this transliterator (filter.contains(ch) == TRUE).
 443     // Text outside of runs may appear as context but it is not modified.
 444     // The start and limit Position values are narrowed to each run.
 445     //
 446     // PASSES (incremental only) -- To make incremental mode work correctly,
 447     // each run is broken up into n passes, where n is the length (in code
 448     // points) of the run.  Each pass contains the first n characters.  If a
 449     // pass is completely transliterated, it is committed, and further passes
 450     // include characters after the committed text.  If a pass is blocked,
 451     // and does not transliterate completely, then this method rolls back
 452     // the changes made during the pass, extends the pass by one code point,
 453     // and tries again.
 454     //----------------------------------------------------------------------
 455
 456     // globalLimit is the limit value for the entire operation.  We
 457     // set index.limit to the end of each unfiltered run before
 458     // calling handleTransliterate(), so we need to maintain the real
 459     // value of index.limit here.  After each transliteration, we
 460     // update globalLimit for insertions or deletions that have
 461     // happened.
 462     int32_t globalLimit = index.limit;
 463
 464     // If there is a non-null filter, then break the input text up.  Say the
 465     // input text has the form:
 466     //   xxxabcxxdefxx
 467     // where 'x' represents a filtered character (filter.contains('x') ==
 468     // false).  Then we break this up into:
 469     //   xxxabc xxdef xx
 470     // Each pass through the loop consumes a run of filtered
 471     // characters (which are ignored) and a subsequent run of
 472     // unfiltered characters (which are transliterated).
 473
 474     for (;;) {
 475
 476         if (filter != NULL) {
 477             // Narrow the range to be transliterated to the first segment
 478             // of unfiltered characters at or after index.start.
 479
 480             // Advance past filtered chars
 481             UChar32 c;
 482             while (index.start < globalLimit &&
 483                    !filter->contains(c=text.char32At(index.start))) {
 484                 index.start += U16_LENGTH(c);
 485             }
 486
 487             // Find the end of this run of unfiltered chars
 488             index.limit = index.start;
 489             while (index.limit < globalLimit &&
 490                    filter->contains(c=text.char32At(index.limit))) {
 491                 index.limit += U16_LENGTH(c);
 492             }
 493         }
 494
 495         // Check to see if the unfiltered run is empty.  This only
 496         // happens at the end of the string when all the remaining
 497         // characters are filtered.
 498         if (index.limit == index.start) {
 499             // assert(index.start == globalLimit);
 500             break;
 501         }
 502
 503         // Is this run incremental?  If there is additional
 504         // filtered text (if limit < globalLimit) then we pass in
 505         // an incremental value of FALSE to force the subclass to
 506         // complete the transliteration for this run.
 507         UBool isIncrementalRun =
 508             (index.limit < globalLimit ? FALSE : incremental);
 509
 510         int32_t delta;
 511
 512         // Implement rollback.  To understand the need for rollback,
 513         // consider the following transliterator:
 514         //
 515         //  "t" is "a > A;"
 516         //  "u" is "A > b;"
 517         //  "v" is a compound of "t; NFD; u" with a filter [:Ll:]
 518         //
 519         // Now apply "c" to the input text "a".  The result is "b".  But if
 520         // the transliteration is done incrementally, then the NFD holds
 521         // things up after "t" has already transformed "a" to "A".  When
 522         // finishTransliterate() is called, "A" is _not_ processed because
 523         // it gets excluded by the [:Ll:] filter, and the end result is "A"
 524         // -- incorrect.  The problem is that the filter is applied to a
 525         // partially-transliterated result, when we only want it to apply to
 526         // input text.  Although this example hinges on a compound
 527         // transliterator containing NFD and a specific filter, it can
 528         // actually happen with any transliterator which may do a partial
 529         // transformation in incremental mode into characters outside its
 530         // filter.
 531         //
 532         // To handle this, when in incremental mode we supply characters to
 533         // handleTransliterate() in several passes.  Each pass adds one more
 534         // input character to the input text.  That is, for input "ABCD", we
 535         // first try "A", then "AB", then "ABC", and finally "ABCD".  If at
 536         // any point we block (upon return, start < limit) then we roll
 537         // back.  If at any point we complete the run (upon return start ==
 538         // limit) then we commit that run.
 539
 540         if (rollback && isIncrementalRun) {
 541
 542             int32_t runStart = index.start;
 543             int32_t runLimit = index.limit;
 544             int32_t runLength =  runLimit - runStart;
 545
 546             // Make a rollback copy at the end of the string
 547             int32_t rollbackOrigin = text.length();
 548             text.copy(runStart, runLimit, rollbackOrigin);
 549
 550             // Variables reflecting the commitment of completely
 551             // transliterated text.  passStart is the runStart, advanced
 552             // past committed text.  rollbackStart is the rollbackOrigin,
 553             // advanced past rollback text that corresponds to committed
 554             // text.
 555             int32_t passStart = runStart;
 556             int32_t rollbackStart = rollbackOrigin;
 557
 558             // The limit for each pass; we advance by one code point with
 559             // each iteration.
 560             int32_t passLimit = index.start;
 561
 562             // Total length, in 16-bit code units, of uncommitted text.
 563             // This is the length to be rolled back.
 564             int32_t uncommittedLength = 0;
 565
 566             // Total delta (change in length) for all passes
 567             int32_t totalDelta = 0;
 568
 569             // PASS MAIN LOOP -- Start with a single character, and extend
 570             // the text by one character at a time.  Roll back partial
 571             // transliterations and commit complete transliterations.
 572             for (;;) {
 573                 // Length of additional code point, either one or two
 574                 int32_t charLength = U16_LENGTH(text.char32At(passLimit));
 575                 passLimit += charLength;
 576                 if (passLimit > runLimit) {
 577                     break;
 578                 }
 579                 uncommittedLength += charLength;
 580
 581                 index.limit = passLimit;
 582
 583                 // Delegate to subclass for actual transliteration.  Upon
 584                 // return, start will be updated to point after the
 585                 // transliterated text, and limit and contextLimit will be
 586                 // adjusted for length changes.
 587                 handleTransliterate(text, index, TRUE);
 588
 589                 delta = index.limit - passLimit; // change in length
 590
 591                 // We failed to completely transliterate this pass.
 592                 // Roll back the text.  Indices remain unchanged; reset
 593                 // them where necessary.
 594                 if (index.start != index.limit) {
 595                     // Find the rollbackStart, adjusted for length changes
 596                     // and the deletion of partially transliterated text.
 597                     int32_t rs = rollbackStart + delta - (index.limit - passStart);
 598
 599                     // Delete the partially transliterated text
 600                     text.handleReplaceBetween(passStart, index.limit, UnicodeString());
 601
 602                     // Copy the rollback text back
 603                     text.copy(rs, rs + uncommittedLength, passStart);
 604
 605                     // Restore indices to their original values
 606                     index.start = passStart;
 607                     index.limit = passLimit;
 608                     index.contextLimit -= delta;
 609                 }
 610
 611                 // We did completely transliterate this pass.  Update the
 612                 // commit indices to record how far we got.  Adjust indices
 613                 // for length change.
 614                 else {
 615                     // Move the pass indices past the committed text.
 616                     passStart = passLimit = index.start;
 617
 618                     // Adjust the rollbackStart for length changes and move
 619                     // it past the committed text.  All characters we've
 620                     // processed to this point are committed now, so zero
 621                     // out the uncommittedLength.
 622                     rollbackStart += delta + uncommittedLength;
 623                     uncommittedLength = 0;
 624
 625                     // Adjust indices for length changes.
 626                     runLimit += delta;
 627                     totalDelta += delta;
 628                 }
 629             }
 630
 631             // Adjust overall limit and rollbackOrigin for insertions and
 632             // deletions.  Don't need to worry about contextLimit because
 633             // handleTransliterate() maintains that.
 634             rollbackOrigin += totalDelta;
 635             globalLimit += totalDelta;
 636
 637             // Delete the rollback copy
 638             text.handleReplaceBetween(rollbackOrigin, rollbackOrigin + runLength, UnicodeString());
 639
 640             // Move start past committed text
 641             index.start = passStart;
 642         }
 643
 644         else {
 645             // Delegate to subclass for actual transliteration.
 646             int32_t limit = index.limit;
 647             handleTransliterate(text, index, isIncrementalRun);
 648             delta = index.limit - limit; // change in length
 649
 650             // In a properly written transliterator, start == limit after
 651             // handleTransliterate() returns when incremental is false.
 652             // Catch cases where the subclass doesn't do this, and throw
 653             // an exception.  (Just pinning start to limit is a bad idea,
 654             // because what's probably happening is that the subclass
 655             // isn't transliterating all the way to the end, and it should
 656             // in non-incremental mode.)
 657             if (!incremental && index.start != index.limit) {
 658                 // We can't throw an exception, so just fudge things
 659                 index.start = index.limit;
 660             }
 661
 662             // Adjust overall limit for insertions/deletions.  Don't need
 663             // to worry about contextLimit because handleTransliterate()
 664             // maintains that.
 665             globalLimit += delta;
 666         }
 667
 668         if (filter == NULL || isIncrementalRun) {
 669             break;
 670         }
 671
 672         // If we did completely transliterate this
 673         // run, then repeat with the next unfiltered run.
 674     }
 675
 676     // Start is valid where it is.  Limit needs to be put back where
 677     // it was, modulo adjustments for deletions/insertions.
 678     index.limit = globalLimit;
 679 }
 680
 681 void Transliterator::filteredTransliterate(Replaceable& text,
 682                                            UTransPosition& index,
 683                                            UBool incremental) const {
 684     filteredTransliterate(text, index, incremental, FALSE);
 685 }
 686
 687 /**
 688  * Method for subclasses to use to set the maximum context length.
 689  * @see #getMaximumContextLength
 690  */
 691 void Transliterator::setMaximumContextLength(int32_t maxContextLength) {
 692     maximumContextLength = maxContextLength;
 693 }
 694
 695 /**
 696  * Returns a programmatic identifier for this transliterator.
 697  * If this identifier is passed to <code>getInstance()</code>, it
 698  * will return this object, if it has been registered.
 699  * @see #registerInstance
 700  * @see #getAvailableIDs
 701  */
 702 const UnicodeString& Transliterator::getID(void) const {
 703     return ID;
 704 }
 705
 706 /**
 707  * Returns a name for this transliterator that is appropriate for
 708  * display to the user in the default locale.  See {@link
 709  * #getDisplayName(Locale)} for details.
 710  */
 711 UnicodeString& U_EXPORT2 Transliterator::getDisplayName(const UnicodeString& ID,
 712                                               UnicodeString& result) {
 713     return getDisplayName(ID, Locale::getDefault(), result);
 714 }
 715
 716 /**
 717  * Returns a name for this transliterator that is appropriate for
 718  * display to the user in the given locale.  This name is taken
 719  * from the locale resource data in the standard manner of the
 720  * <code>java.text</code> package.
 721  *
 722  * <p>If no localized names exist in the system resource bundles,
 723  * a name is synthesized using a localized
 724  * <code>MessageFormat</code> pattern from the resource data.  The
 725  * arguments to this pattern are an integer followed by one or two
 726  * strings.  The integer is the number of strings, either 1 or 2.
 727  * The strings are formed by splitting the ID for this
 728  * transliterator at the first TARGET_SEP.  If there is no TARGET_SEP, then the
 729  * entire ID forms the only string.
 730  * @param inLocale the Locale in which the display name should be
 731  * localized.
 732  * @see java.text.MessageFormat
 733  */
 734 UnicodeString& U_EXPORT2 Transliterator::getDisplayName(const UnicodeString& id,
 735                                               const Locale& inLocale,
 736                                               UnicodeString& result) {
 737     UErrorCode status = U_ZERO_ERROR;
 738
 739     ResourceBundle bundle(U_ICUDATA_TRANSLIT, inLocale, status);
 740
 741     // Suspend checking status until later...
 742
 743     result.truncate(0);
 744
 745     // Normalize the ID
 746     UnicodeString source, target, variant;
 747     UBool sawSource;
 748     TransliteratorIDParser::IDtoSTV(id, source, target, variant, sawSource);
 749     if (target.length() < 1) {
 750         // No target; malformed id
 751         return result;
 752     }
 753     if (variant.length() > 0) { // Change "Foo" to "/Foo"
 754         variant.insert(0, VARIANT_SEP);
 755     }
 756     UnicodeString ID(source);
 757     ID.append(TARGET_SEP).append(target).append(variant);
 758
 759     // build the char* key
 760     if (uprv_isInvariantUString(ID.getBuffer(), ID.length())) {
 761         char key[200];
 762         uprv_strcpy(key, RB_DISPLAY_NAME_PREFIX);
 763         int32_t length=(int32_t)uprv_strlen(RB_DISPLAY_NAME_PREFIX);
 764         ID.extract(0, (int32_t)(sizeof(key)-length), key+length, (int32_t)(sizeof(key)-length), US_INV);
 765
 766         // Try to retrieve a UnicodeString from the bundle.
 767         UnicodeString resString = bundle.getStringEx(key, status);
 768
 769         if (U_SUCCESS(status) && resString.length() != 0) {
 770             return result = resString; // [sic] assign & return
 771         }
 772
 773 #if !UCONFIG_NO_FORMATTING
 774         // We have failed to get a name from the locale data.  This is
 775         // typical, since most transliterators will not have localized
 776         // name data.  The next step is to retrieve the MessageFormat
 777         // pattern from the locale data and to use it to synthesize the
 778         // name from the ID.
 779
 780         status = U_ZERO_ERROR;
 781         resString = bundle.getStringEx(RB_DISPLAY_NAME_PATTERN, status);
 782
 783         if (U_SUCCESS(status) && resString.length() != 0) {
 784             MessageFormat msg(resString, inLocale, status);
 785             // Suspend checking status until later...
 786
 787             // We pass either 2 or 3 Formattable objects to msg.
 788             Formattable args[3];
 789             int32_t nargs;
 790             args[0].setLong(2); // # of args to follow
 791             args[1].setString(source);
 792             args[2].setString(target);
 793             nargs = 3;
 794
 795             // Use display names for the scripts, if they exist
 796             UnicodeString s;
 797             length=(int32_t)uprv_strlen(RB_SCRIPT_DISPLAY_NAME_PREFIX);
 798             for (int j=1; j<=2; ++j) {
 799                 status = U_ZERO_ERROR;
 800                 uprv_strcpy(key, RB_SCRIPT_DISPLAY_NAME_PREFIX);
 801                 args[j].getString(s);
 802                 if (uprv_isInvariantUString(s.getBuffer(), s.length())) {
 803                     s.extract(0, sizeof(key)-length-1, key+length, (int32_t)sizeof(key)-length-1, US_INV);
 804
 805                     resString = bundle.getStringEx(key, status);
 806
 807                     if (U_SUCCESS(status)) {
 808                         args[j] = resString;
 809                     }
 810                 }
 811             }
 812
 813             status = U_ZERO_ERROR;
 814             FieldPosition pos; // ignored by msg
 815             msg.format(args, nargs, result, pos, status);
 816             if (U_SUCCESS(status)) {
 817                 result.append(variant);
 818                 return result;
 819             }
 820         }
 821 #endif
 822     }
 823
 824     // We should not reach this point unless there is something
 825     // wrong with the build or the RB_DISPLAY_NAME_PATTERN has
 826     // been deleted from the root RB_LOCALE_ELEMENTS resource.
 827     result = ID;
 828     return result;
 829 }
 830
 831 /**
 832  * Returns the filter used by this transliterator, or <tt>null</tt>
 833  * if this transliterator uses no filter.  Caller musn't delete
 834  * the result!
 835  */
 836 const UnicodeFilter* Transliterator::getFilter(void) const {
 837     return filter;
 838 }
 839
 840 /**
 841  * Returns the filter used by this transliterator, or
 842  * <tt>NULL</tt> if this transliterator uses no filter.  The
 843  * caller must eventually delete the result.  After this call,
 844  * this transliterator's filter is set to <tt>NULL</tt>.
 845  */
 846 UnicodeFilter* Transliterator::orphanFilter(void) {
 847     UnicodeFilter *result = filter;
 848     filter = NULL;
 849     return result;
 850 }
 851
 852 /**
 853  * Changes the filter used by this transliterator.  If the filter
 854  * is set to <tt>null</tt> then no filtering will occur.
 855  *
 856  * <p>Callers must take care if a transliterator is in use by
 857  * multiple threads.  The filter should not be changed by one
 858  * thread while another thread may be transliterating.
 859  */
 860 void Transliterator::adoptFilter(UnicodeFilter* filterToAdopt) {
 861     delete filter;
 862     filter = filterToAdopt;
 863 }
 864
 865 /**
 866  * Returns this transliterator's inverse.  See the class
 867  * documentation for details.  This implementation simply inverts
 868  * the two entities in the ID and attempts to retrieve the
 869  * resulting transliterator.  That is, if <code>getID()</code>
 870  * returns "A-B", then this method will return the result of
 871  * <code>getInstance("B-A")</code>, or <code>null</code> if that
 872  * call fails.
 873  *
 874  * <p>This method does not take filtering into account.  The
 875  * returned transliterator will have no filter.
 876  *
 877  * <p>Subclasses with knowledge of their inverse may wish to
 878  * override this method.
 879  *
 880  * @return a transliterator that is an inverse, not necessarily
 881  * exact, of this transliterator, or <code>null</code> if no such
 882  * transliterator is registered.
 883  * @see #registerInstance
 884  */
 885 Transliterator* Transliterator::createInverse(UErrorCode& status) const {
 886     UParseError parseError;
 887     return Transliterator::createInstance(ID, UTRANS_REVERSE,parseError,status);
 888 }
 889
 890 Transliterator* U_EXPORT2
 891 Transliterator::createInstance(const UnicodeString& ID,
 892                                 UTransDirection dir,
 893                                 UErrorCode& status)
 894 {
 895     UParseError parseError;
 896     return createInstance(ID, dir, parseError, status);
 897 }
 898
 899 /**
 900  * Returns a <code>Transliterator</code> object given its ID.
 901  * The ID must be either a system transliterator ID or a ID registered
 902  * using <code>registerInstance()</code>.
 903  *
 904  * @param ID a valid ID, as enumerated by <code>getAvailableIDs()</code>
 905  * @return A <code>Transliterator</code> object with the given ID
 906  * @see #registerInstance
 907  * @see #getAvailableIDs
 908  * @see #getID
 909  */
 910 Transliterator* U_EXPORT2
 911 Transliterator::createInstance(const UnicodeString& ID,
 912                                 UTransDirection dir,
 913                                 UParseError& parseError,
 914                                 UErrorCode& status)
 915 {
 916     if (U_FAILURE(status)) {
 917         return 0;
 918     }
 919
 920     UnicodeString canonID;
 921     UVector list(status);
 922     if (U_FAILURE(status)) {
 923         return NULL;
 924     }
 925
 926     UnicodeSet* globalFilter;
 927     // TODO add code for parseError...currently unused, but
 928     // later may be used by parsing code...
 929     if (!TransliteratorIDParser::parseCompoundID(ID, dir, canonID, list, globalFilter)) {
 930         status = U_INVALID_ID;
 931         return NULL;
 932     }
 933
 934     TransliteratorIDParser::instantiateList(list, status);
 935     if (U_FAILURE(status)) {
 936         return NULL;
 937     }
 938
 939     U_ASSERT(list.size() > 0);
 940     Transliterator* t = NULL;
 941
 942     if (list.size() > 1 || canonID.indexOf(ID_DELIM) >= 0) {
 943         // [NOTE: If it's a compoundID, we instantiate a CompoundTransliterator even if it only
 944         // has one child transliterator.  This is so that toRules() will return the right thing
 945         // (without any inactive ID), but our main ID still comes out correct.  That is, if we
 946         // instantiate "(Lower);Latin-Greek;", we want the rules to come out as "::Latin-Greek;"
 947         // even though the ID is "(Lower);Latin-Greek;".
 948         t = new CompoundTransliterator(list, parseError, status);
 949     }
 950     else {
 951         t = (Transliterator*)list.elementAt(0);
 952     }
 953     // Check null pointer
 954     if (t != NULL) {
 955         t->setID(canonID);
 956         if (globalFilter != NULL) {
 957             t->adoptFilter(globalFilter);
 958         }
 959     }
 960     else if (U_SUCCESS(status)) {
 961         status = U_MEMORY_ALLOCATION_ERROR;
 962     }
 963     return t;
 964 }
 965
 966 /**
 967  * Create a transliterator from a basic ID.  This is an ID
 968  * containing only the forward direction source, target, and
 969  * variant.
 970  * @param id a basic ID of the form S-T or S-T/V.
 971  * @return a newly created Transliterator or null if the ID is
 972  * invalid.
 973  */
 974 Transliterator* Transliterator::createBasicInstance(const UnicodeString& id,
 975                                                     const UnicodeString* canon) {
 976     UParseError pe;
 977     UErrorCode ec = U_ZERO_ERROR;
 978     TransliteratorAlias* alias = 0;
 979     Transliterator* t = 0;
 980
 981     umtx_lock(&registryMutex);
 982     if (HAVE_REGISTRY(ec)) {
 983         t = registry->get(id, alias, ec);
 984     }
 985     umtx_unlock(&registryMutex);
 986
 987     if (U_FAILURE(ec)) {
 988         delete t;
 989         delete alias;
 990         return 0;
 991     }
 992
 993     // We may have not gotten a transliterator:  Because we can't
 994     // instantiate a transliterator from inside TransliteratorRegistry::
 995     // get() (that would deadlock), we sometimes pass back an alias.  This
 996     // contains the data we need to finish the instantiation outside the
 997     // registry mutex.  The alias may, in turn, generate another alias, so
 998     // we handle aliases in a loop.  The max times through the loop is two.
 999     // [alan]
1000     while (alias != 0) {
1001         U_ASSERT(t==0);
1002         // Rule-based aliases are handled with TransliteratorAlias::
1003         // parse(), followed by TransliteratorRegistry::reget().
1004         // Other aliases are handled with TransliteratorAlias::create().
1005         if (alias->isRuleBased()) {
1006             // Step 1. parse
1007             TransliteratorParser parser(ec);
1008             alias->parse(parser, pe, ec);
1009             delete alias;
1010             alias = 0;
1011
1012             // Step 2. reget
1013             umtx_lock(&registryMutex);
1014             if (HAVE_REGISTRY(ec)) {
1015                 t = registry->reget(id, parser, alias, ec);
1016             }
1017             umtx_unlock(&registryMutex);
1018
1019             // Step 3. Loop back around!
1020         } else {
1021             t = alias->create(pe, ec);
1022             delete alias;
1023             alias = 0;
1024             break;
1025         }
1026         if (U_FAILURE(ec)) {
1027             delete t;
1028             delete alias;
1029             t = NULL;
1030             break;
1031         }
1032     }
1033
1034     if (t != NULL && canon != NULL) {
1035         t->setID(*canon);
1036     }
1037
1038     return t;
1039 }
1040
1041 /**
1042  * Returns a <code>Transliterator</code> object constructed from
1043  * the given rule string.  This will be a RuleBasedTransliterator,
1044  * if the rule string contains only rules, or a
1045  * CompoundTransliterator, if it contains ID blocks, or a
1046  * NullTransliterator, if it contains ID blocks which parse as
1047  * empty for the given direction.
1048  */
1049 Transliterator* U_EXPORT2
1050 Transliterator::createFromRules(const UnicodeString& ID,
1051                                 const UnicodeString& rules,
1052                                 UTransDirection dir,
1053                                 UParseError& parseError,
1054                                 UErrorCode& status)
1055 {
1056     Transliterator* t = NULL;
1057
1058     TransliteratorParser parser(status);
1059     parser.parse(rules, dir, parseError, status);
1060
1061     if (U_FAILURE(status)) {
1062         return 0;
1063     }
1064
1065     // NOTE: The logic here matches that in TransliteratorRegistry.
1066     if (parser.idBlockVector.size() == 0 && parser.dataVector.size() == 0) {
1067         t = new NullTransliterator();
1068     }
1069     else if (parser.idBlockVector.size() == 0 && parser.dataVector.size() == 1) {
1070         t = new RuleBasedTransliterator(ID, (TransliterationRuleData*)parser.dataVector.orphanElementAt(0), TRUE);
1071     }
1072     else if (parser.idBlockVector.size() == 1 && parser.dataVector.size() == 0) {
1073         // idBlock, no data -- this is an alias.  The ID has
1074         // been munged from reverse into forward mode, if
1075         // necessary, so instantiate the ID in the forward
1076         // direction.
1077         if (parser.compoundFilter != NULL) {
1078             UnicodeString filterPattern;
1079             parser.compoundFilter->toPattern(filterPattern, FALSE);
1080             t = createInstance(filterPattern + UnicodeString(ID_DELIM)
1081                     + *((UnicodeString*)parser.idBlockVector.elementAt(0)), UTRANS_FORWARD, parseError, status);
1082         }
1083         else
1084             t = createInstance(*((UnicodeString*)parser.idBlockVector.elementAt(0)), UTRANS_FORWARD, parseError, status);
1085
1086
1087         if (t != NULL) {
1088             t->setID(ID);
1089         }
1090     }
1091     else {
1092         UVector transliterators(status);
1093         int32_t passNumber = 1;
1094
1095         int32_t limit = parser.idBlockVector.size();
1096         if (parser.dataVector.size() > limit)
1097             limit = parser.dataVector.size();
1098
1099         for (int32_t i = 0; i < limit; i++) {
1100             if (i < parser.idBlockVector.size()) {
1101                 UnicodeString* idBlock = (UnicodeString*)parser.idBlockVector.elementAt(i);
1102                 if (!idBlock->isEmpty()) {
1103                     Transliterator* temp = createInstance(*idBlock, UTRANS_FORWARD, parseError, status);
1104                     if (temp != NULL && typeid(*temp) != typeid(NullTransliterator))
1105                         transliterators.addElement(temp, status);
1106                     else
1107                         delete temp;
1108                 }
1109             }
1110             if (!parser.dataVector.isEmpty()) {
1111                 TransliterationRuleData* data = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0);
1112                 // TODO: Should passNumber be turned into a decimal-string representation (1 -> "1")?
1113                 RuleBasedTransliterator* temprbt = new RuleBasedTransliterator(UnicodeString(CompoundTransliterator::PASS_STRING) + UnicodeString(passNumber++),
1114                         data, TRUE);
1115                 // Check if NULL before adding it to transliterators to avoid future usage of NULL pointer.
1116                 if (temprbt == NULL) {
1117                         status = U_MEMORY_ALLOCATION_ERROR;
1118                         return t;
1119                 }
1120                 transliterators.addElement(temprbt, status);
1121             }
1122         }
1123
1124         t = new CompoundTransliterator(transliterators, passNumber - 1, parseError, status);
1125         // Null pointer check
1126         if (t != NULL) {
1127             t->setID(ID);
1128             t->adoptFilter(parser.orphanCompoundFilter());
1129         }
1130     }
1131     if (U_SUCCESS(status) && t == NULL) {
1132         status = U_MEMORY_ALLOCATION_ERROR;
1133     }
1134     return t;
1135 }
1136
1137 UnicodeString& Transliterator::toRules(UnicodeString& rulesSource,
1138                                        UBool escapeUnprintable) const {
1139     // The base class implementation of toRules munges the ID into
1140     // the correct format.  That is: foo => ::foo
1141     if (escapeUnprintable) {
1142         rulesSource.truncate(0);
1143         UnicodeString id = getID();
1144         for (int32_t i=0; i<id.length();) {
1145             UChar32 c = id.char32At(i);
1146             if (!ICU_Utility::escapeUnprintable(rulesSource, c)) {
1147                 rulesSource.append(c);
1148             }
1149             i += U16_LENGTH(c);
1150         }
1151     } else {
1152         rulesSource = getID();
1153     }
1154     // KEEP in sync with rbt_pars
1155     rulesSource.insert(0, UNICODE_STRING_SIMPLE("::"));
1156     rulesSource.append(ID_DELIM);
1157     return rulesSource;
1158 }
1159
1160 int32_t Transliterator::countElements() const {
1161     const CompoundTransliterator* ct = dynamic_cast<const CompoundTransliterator*>(this);
1162     return ct != NULL ? ct->getCount() : 0;
1163 }
1164
1165 const Transliterator& Transliterator::getElement(int32_t index, UErrorCode& ec) const {
1166     if (U_FAILURE(ec)) {
1167         return *this;
1168     }
1169     const CompoundTransliterator* cpd = dynamic_cast<const CompoundTransliterator*>(this);
1170     int32_t n = (cpd == NULL) ? 1 : cpd->getCount();
1171     if (index < 0 || index >= n) {
1172         ec = U_INDEX_OUTOFBOUNDS_ERROR;
1173         return *this;
1174     } else {
1175         return (n == 1) ? *this : cpd->getTransliterator(index);
1176     }
1177 }
1178
1179 UnicodeSet& Transliterator::getSourceSet(UnicodeSet& result) const {
1180     handleGetSourceSet(result);
1181     if (filter != NULL) {
1182         UnicodeSet* filterSet = dynamic_cast<UnicodeSet*>(filter);
1183         UBool deleteFilterSet = FALSE;
1184         // Most, but not all filters will be UnicodeSets.  Optimize for
1185         // the high-runner case.
1186         if (filterSet == NULL) {
1187             filterSet = new UnicodeSet();
1188             // Check null pointer
1189             if (filterSet == NULL) {
1190                 return result;
1191             }
1192             deleteFilterSet = TRUE;
1193             filter->addMatchSetTo(*filterSet);
1194         }
1195         result.retainAll(*filterSet);
1196         if (deleteFilterSet) {
1197             delete filterSet;
1198         }
1199     }
1200     return result;
1201 }
1202
1203 void Transliterator::handleGetSourceSet(UnicodeSet& result) const {
1204     result.clear();
1205 }
1206
1207 UnicodeSet& Transliterator::getTargetSet(UnicodeSet& result) const {
1208     return result.clear();
1209 }
1210
1211 // For public consumption
1212 void U_EXPORT2 Transliterator::registerFactory(const UnicodeString& id,
1213                                      Transliterator::Factory factory,
1214                                      Transliterator::Token context) {
1215     Mutex lock(&registryMutex);
1216     UErrorCode ec = U_ZERO_ERROR;
1217     if (HAVE_REGISTRY(ec)) {
1218         _registerFactory(id, factory, context);
1219     }
1220 }
1221
1222 // To be called only by Transliterator subclasses that are called
1223 // to register themselves by initializeRegistry().
1224 void Transliterator::_registerFactory(const UnicodeString& id,
1225                                       Transliterator::Factory factory,
1226                                       Transliterator::Token context) {
1227     UErrorCode ec = U_ZERO_ERROR;
1228     registry->put(id, factory, context, TRUE, ec);
1229 }
1230
1231 // To be called only by Transliterator subclasses that are called
1232 // to register themselves by initializeRegistry().
1233 void Transliterator::_registerSpecialInverse(const UnicodeString& target,
1234                                              const UnicodeString& inverseTarget,
1235                                              UBool bidirectional) {
1236     UErrorCode status = U_ZERO_ERROR;
1237     TransliteratorIDParser::registerSpecialInverse(target, inverseTarget, bidirectional, status);
1238 }
1239
1240 /**
1241  * Registers a instance <tt>obj</tt> of a subclass of
1242  * <code>Transliterator</code> with the system.  This object must
1243  * implement the <tt>clone()</tt> method.  When
1244  * <tt>getInstance()</tt> is called with an ID string that is
1245  * equal to <tt>obj.getID()</tt>, then <tt>obj.clone()</tt> is
1246  * returned.
1247  *
1248  * @param obj an instance of subclass of
1249  * <code>Transliterator</code> that defines <tt>clone()</tt>
1250  * @see #getInstance
1251  * @see #unregister
1252  */
1253 void U_EXPORT2 Transliterator::registerInstance(Transliterator* adoptedPrototype) {
1254     Mutex lock(&registryMutex);
1255     UErrorCode ec = U_ZERO_ERROR;
1256     if (HAVE_REGISTRY(ec)) {
1257         _registerInstance(adoptedPrototype);
1258     }
1259 }
1260
1261 void Transliterator::_registerInstance(Transliterator* adoptedPrototype) {
1262     UErrorCode ec = U_ZERO_ERROR;
1263     registry->put(adoptedPrototype, TRUE, ec);
1264 }
1265
1266 void U_EXPORT2 Transliterator::registerAlias(const UnicodeString& aliasID,
1267                                              const UnicodeString& realID) {
1268     Mutex lock(&registryMutex);
1269     UErrorCode ec = U_ZERO_ERROR;
1270     if (HAVE_REGISTRY(ec)) {
1271         _registerAlias(aliasID, realID);
1272     }
1273 }
1274
1275 void Transliterator::_registerAlias(const UnicodeString& aliasID,
1276                                     const UnicodeString& realID) {
1277     UErrorCode ec = U_ZERO_ERROR;
1278     registry->put(aliasID, realID, FALSE, TRUE, ec);
1279 }
1280
1281 /**
1282  * Unregisters a transliterator or class.  This may be either
1283  * a system transliterator or a user transliterator or class.
1284  *
1285  * @param ID the ID of the transliterator or class
1286  * @see #registerInstance
1287
1288  */
1289 void U_EXPORT2 Transliterator::unregister(const UnicodeString& ID) {
1290     Mutex lock(&registryMutex);
1291     UErrorCode ec = U_ZERO_ERROR;
1292     if (HAVE_REGISTRY(ec)) {
1293         registry->remove(ID);
1294     }
1295 }
1296
1297 /**
1298  * == OBSOLETE - remove in ICU 3.4 ==
1299  * Return the number of IDs currently registered with the system.
1300  * To retrieve the actual IDs, call getAvailableID(i) with
1301  * i from 0 to countAvailableIDs() - 1.
1302  */
1303 int32_t U_EXPORT2 Transliterator::countAvailableIDs(void) {
1304     int32_t retVal = 0;
1305     Mutex lock(&registryMutex);
1306     UErrorCode ec = U_ZERO_ERROR;
1307     if (HAVE_REGISTRY(ec)) {
1308         retVal = registry->countAvailableIDs();
1309     }
1310     return retVal;
1311 }
1312
1313 /**
1314  * == OBSOLETE - remove in ICU 3.4 ==
1315  * Return the index-th available ID.  index must be between 0
1316  * and countAvailableIDs() - 1, inclusive.  If index is out of
1317  * range, the result of getAvailableID(0) is returned.
1318  */
1319 const UnicodeString& U_EXPORT2 Transliterator::getAvailableID(int32_t index) {
1320     const UnicodeString* result = NULL;
1321     umtx_lock(&registryMutex);
1322     UErrorCode ec = U_ZERO_ERROR;
1323     if (HAVE_REGISTRY(ec)) {
1324         result = &registry->getAvailableID(index);
1325     }
1326     umtx_unlock(&registryMutex);
1327     U_ASSERT(result != NULL); // fail if no registry
1328     return *result;
1329 }
1330
1331 StringEnumeration* U_EXPORT2 Transliterator::getAvailableIDs(UErrorCode& ec) {
1332     if (U_FAILURE(ec)) return NULL;
1333     StringEnumeration* result = NULL;
1334     umtx_lock(&registryMutex);
1335     if (HAVE_REGISTRY(ec)) {
1336         result = registry->getAvailableIDs();
1337     }
1338     umtx_unlock(&registryMutex);
1339     if (result == NULL) {
1340         ec = U_INTERNAL_TRANSLITERATOR_ERROR;
1341     }
1342     return result;
1343 }
1344
1345 int32_t U_EXPORT2 Transliterator::countAvailableSources(void) {
1346     Mutex lock(&registryMutex);
1347     UErrorCode ec = U_ZERO_ERROR;
1348     return HAVE_REGISTRY(ec) ? _countAvailableSources() : 0;
1349 }
1350
1351 UnicodeString& U_EXPORT2 Transliterator::getAvailableSource(int32_t index,
1352                                                   UnicodeString& result) {
1353     Mutex lock(&registryMutex);
1354     UErrorCode ec = U_ZERO_ERROR;
1355     if (HAVE_REGISTRY(ec)) {
1356         _getAvailableSource(index, result);
1357     }
1358     return result;
1359 }
1360
1361 int32_t U_EXPORT2 Transliterator::countAvailableTargets(const UnicodeString& source) {
1362     Mutex lock(&registryMutex);
1363     UErrorCode ec = U_ZERO_ERROR;
1364     return HAVE_REGISTRY(ec) ? _countAvailableTargets(source) : 0;
1365 }
1366
1367 UnicodeString& U_EXPORT2 Transliterator::getAvailableTarget(int32_t index,
1368                                                   const UnicodeString& source,
1369                                                   UnicodeString& result) {
1370     Mutex lock(&registryMutex);
1371     UErrorCode ec = U_ZERO_ERROR;
1372     if (HAVE_REGISTRY(ec)) {
1373         _getAvailableTarget(index, source, result);
1374     }
1375     return result;
1376 }
1377
1378 int32_t U_EXPORT2 Transliterator::countAvailableVariants(const UnicodeString& source,
1379                                                const UnicodeString& target) {
1380     Mutex lock(&registryMutex);
1381     UErrorCode ec = U_ZERO_ERROR;
1382     return HAVE_REGISTRY(ec) ? _countAvailableVariants(source, target) : 0;
1383 }
1384
1385 UnicodeString& U_EXPORT2 Transliterator::getAvailableVariant(int32_t index,
1386                                                    const UnicodeString& source,
1387                                                    const UnicodeString& target,
1388                                                    UnicodeString& result) {
1389     Mutex lock(&registryMutex);
1390     UErrorCode ec = U_ZERO_ERROR;
1391     if (HAVE_REGISTRY(ec)) {
1392         _getAvailableVariant(index, source, target, result);
1393     }
1394     return result;
1395 }
1396
1397 int32_t Transliterator::_countAvailableSources(void) {
1398     return registry->countAvailableSources();
1399 }
1400
1401 UnicodeString& Transliterator::_getAvailableSource(int32_t index,
1402                                                   UnicodeString& result) {
1403     return registry->getAvailableSource(index, result);
1404 }
1405
1406 int32_t Transliterator::_countAvailableTargets(const UnicodeString& source) {
1407     return registry->countAvailableTargets(source);
1408 }
1409
1410 UnicodeString& Transliterator::_getAvailableTarget(int32_t index,
1411                                                   const UnicodeString& source,
1412                                                   UnicodeString& result) {
1413     return registry->getAvailableTarget(index, source, result);
1414 }
1415
1416 int32_t Transliterator::_countAvailableVariants(const UnicodeString& source,
1417                                                const UnicodeString& target) {
1418     return registry->countAvailableVariants(source, target);
1419 }
1420
1421 UnicodeString& Transliterator::_getAvailableVariant(int32_t index,
1422                                                    const UnicodeString& source,
1423                                                    const UnicodeString& target,
1424                                                    UnicodeString& result) {
1425     return registry->getAvailableVariant(index, source, target, result);
1426 }
1427
1428 #ifdef U_USE_DEPRECATED_TRANSLITERATOR_API
1429
1430 /**
1431  * Method for subclasses to use to obtain a character in the given
1432  * string, with filtering.
1433  * @deprecated the new architecture provides filtering at the top
1434  * level.  This method will be removed Dec 31 2001.
1435  */
1436 UChar Transliterator::filteredCharAt(const Replaceable& text, int32_t i) const {
1437     UChar c;
1438     const UnicodeFilter* localFilter = getFilter();
1439     return (localFilter == 0) ? text.charAt(i) :
1440         (localFilter->contains(c = text.charAt(i)) ? c : (UChar)0xFFFE);
1441 }
1442
1443 #endif
1444
1445 /**
1446  * If the registry is initialized, return TRUE.  If not, initialize it
1447  * and return TRUE.  If the registry cannot be initialized, return
1448  * FALSE (rare).
1449  *
1450  * IMPORTANT: Upon entry, registryMutex must be LOCKED.  The entire
1451  * initialization is done with the lock held.  There is NO REASON to
1452  * unlock, since no other thread that is waiting on the registryMutex
1453  * cannot itself proceed until the registry is initialized.
1454  */
1455 UBool Transliterator::initializeRegistry(UErrorCode &status) {
1456     if (registry != 0) {
1457         return TRUE;
1458     }
1459
1460     registry = new TransliteratorRegistry(status);
1461     if (registry == 0 || U_FAILURE(status)) {
1462         delete registry;
1463         registry = 0;
1464         return FALSE; // can't create registry, no recovery
1465     }
1466
1467     /* The following code parses the index table located in
1468      * icu/data/translit/root.txt.  The index is an n x 4 table
1469      * that follows this format:
1470      *  <id>{
1471      *      file{
1472      *          resource{"<resource>"}
1473      *          direction{"<direction>"}
1474      *      }
1475      *  }
1476      *  <id>{
1477      *      internal{
1478      *          resource{"<resource>"}
1479      *          direction{"<direction"}
1480      *       }
1481      *  }
1482      *  <id>{
1483      *      alias{"<getInstanceArg"}
1484      *  }
1485      * <id> is the ID of the system transliterator being defined.  These
1486      * are public IDs enumerated by Transliterator.getAvailableIDs(),
1487      * unless the second field is "internal".
1488      *
1489      * <resource> is a ResourceReader resource name.  Currently these refer
1490      * to file names under com/ibm/text/resources.  This string is passed
1491      * directly to ResourceReader, together with <encoding>.
1492      *
1493      * <direction> is either "FORWARD" or "REVERSE".
1494      *
1495      * <getInstanceArg> is a string to be passed directly to
1496      * Transliterator.getInstance().  The returned Transliterator object
1497      * then has its ID changed to <id> and is returned.
1498      *
1499      * The extra blank field on "alias" lines is to make the array square.
1500      */
1501     //static const char translit_index[] = "translit_index";
1502
1503     UResourceBundle *bundle, *transIDs, *colBund;
1504     bundle = ures_open(U_ICUDATA_TRANSLIT, NULL/*open default locale*/, &status);
1505     transIDs = ures_getByKey(bundle, RB_RULE_BASED_IDS, 0, &status);
1506     const UnicodeString T_PART = UNICODE_STRING_SIMPLE("-t-");
1507
1508     int32_t row, maxRows;
1509     if (U_SUCCESS(status)) {
1510         maxRows = ures_getSize(transIDs);
1511         for (row = 0; row < maxRows; row++) {
1512             colBund = ures_getByIndex(transIDs, row, 0, &status);
1513             if (U_SUCCESS(status)) {
1514                 UnicodeString id(ures_getKey(colBund), -1, US_INV);
1515                 if(id.indexOf(T_PART) != -1) {
1516                     ures_close(colBund);
1517                     continue;
1518                 }
1519                 UResourceBundle* res = ures_getNextResource(colBund, NULL, &status);
1520                 const char* typeStr = ures_getKey(res);
1521                 UChar type;
1522                 u_charsToUChars(typeStr, &type, 1);
1523
1524                 if (U_SUCCESS(status)) {
1525                     int32_t len = 0;
1526                     const UChar *resString;
1527                     switch (type) {
1528                     case 0x66: // 'f'
1529                     case 0x69: // 'i'
1530                         // 'file' or 'internal';
1531                         // row[2]=resource, row[3]=direction
1532                         {
1533
1534                             resString = ures_getStringByKey(res, "resource", &len, &status);
1535                             UBool visible = (type == 0x0066 /*f*/);
1536                             UTransDirection dir =
1537                                 (ures_getUnicodeStringByKey(res, "direction", &status).charAt(0) ==
1538                                  0x0046 /*F*/) ?
1539                                 UTRANS_FORWARD : UTRANS_REVERSE;
1540                             registry->put(id, UnicodeString(TRUE, resString, len), dir, TRUE, visible, status);
1541                         }
1542                         break;
1543                     case 0x61: // 'a'
1544                         // 'alias'; row[2]=createInstance argument
1545                         resString = ures_getString(res, &len, &status);
1546                         registry->put(id, UnicodeString(TRUE, resString, len), TRUE, TRUE, status);
1547                         break;
1548                     }
1549                 }
1550                 ures_close(res);
1551             }
1552             ures_close(colBund);
1553         }
1554     }
1555
1556     ures_close(transIDs);
1557     ures_close(bundle);
1558
1559     // Manually add prototypes that the system knows about to the
1560     // cache.  This is how new non-rule-based transliterators are
1561     // added to the system.
1562
1563     // This is to allow for null pointer check
1564     NullTransliterator* tempNullTranslit = new NullTransliterator();
1565     LowercaseTransliterator* tempLowercaseTranslit = new LowercaseTransliterator();
1566     UppercaseTransliterator* tempUppercaseTranslit = new UppercaseTransliterator();
1567     TitlecaseTransliterator* tempTitlecaseTranslit = new TitlecaseTransliterator();
1568     UnicodeNameTransliterator* tempUnicodeTranslit = new UnicodeNameTransliterator();
1569     NameUnicodeTransliterator* tempNameUnicodeTranslit = new NameUnicodeTransliterator();
1570 #if !UCONFIG_NO_BREAK_ITERATION
1571      // TODO: could or should these transliterators be referenced polymorphically once constructed?
1572      BreakTransliterator* tempBreakTranslit         = new BreakTransliterator();
1573 #endif
1574     // Check for null pointers
1575     if (tempNullTranslit == NULL || tempLowercaseTranslit == NULL || tempUppercaseTranslit == NULL ||
1576         tempTitlecaseTranslit == NULL || tempUnicodeTranslit == NULL ||
1577 #if !UCONFIG_NO_BREAK_ITERATION
1578         tempBreakTranslit == NULL ||
1579 #endif
1580         tempNameUnicodeTranslit == NULL )
1581     {
1582         delete tempNullTranslit;
1583         delete tempLowercaseTranslit;
1584         delete tempUppercaseTranslit;
1585         delete tempTitlecaseTranslit;
1586         delete tempUnicodeTranslit;
1587         delete tempNameUnicodeTranslit;
1588 #if !UCONFIG_NO_BREAK_ITERATION
1589         delete tempBreakTranslit;
1590 #endif
1591         // Since there was an error, remove registry
1592         delete registry;
1593         registry = NULL;
1594
1595         status = U_MEMORY_ALLOCATION_ERROR;
1596         return 0;
1597     }
1598
1599     registry->put(tempNullTranslit, TRUE, status);
1600     registry->put(tempLowercaseTranslit, TRUE, status);
1601     registry->put(tempUppercaseTranslit, TRUE, status);
1602     registry->put(tempTitlecaseTranslit, TRUE, status);
1603     registry->put(tempUnicodeTranslit, TRUE, status);
1604     registry->put(tempNameUnicodeTranslit, TRUE, status);
1605 #if !UCONFIG_NO_BREAK_ITERATION
1606     registry->put(tempBreakTranslit, FALSE, status);   // FALSE means invisible.
1607 #endif
1608
1609     RemoveTransliterator::registerIDs(); // Must be within mutex
1610     EscapeTransliterator::registerIDs();
1611     UnescapeTransliterator::registerIDs();
1612     NormalizationTransliterator::registerIDs();
1613     AnyTransliterator::registerIDs();
1614
1615     _registerSpecialInverse(UNICODE_STRING_SIMPLE("Null"),
1616                             UNICODE_STRING_SIMPLE("Null"), FALSE);
1617     _registerSpecialInverse(UNICODE_STRING_SIMPLE("Upper"),
1618                             UNICODE_STRING_SIMPLE("Lower"), TRUE);
1619     _registerSpecialInverse(UNICODE_STRING_SIMPLE("Title"),
1620                             UNICODE_STRING_SIMPLE("Lower"), FALSE);
1621
1622     ucln_i18n_registerCleanup(UCLN_I18N_TRANSLITERATOR, utrans_transliterator_cleanup);
1623
1624     return TRUE;
1625 }
1626
1627 U_NAMESPACE_END
1628
1629 // Defined in transreg.h:
1630
1631 /**
1632  * Release all static memory held by transliterator.  This will
1633  * necessarily invalidate any rule-based transliterators held by the
1634  * user, because RBTs hold pointers to common data objects.
1635  */
1636 U_CFUNC UBool utrans_transliterator_cleanup(void) {
1637     U_NAMESPACE_USE
1638     TransliteratorIDParser::cleanup();
1639     if (registry) {
1640         delete registry;
1641         registry = NULL;
1642     }
1643     return TRUE;
1644 }
1645
1646 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
1647
1648 //eof