The Tor Browser: intl/icu/source/i18n/tridpars.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/tridpars.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/tridpars.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
 **********************************************************************
 *   Copyright (c) 2002-2012, International Business Machines Corporation
 *   and others.  All Rights Reserved.
 **********************************************************************
 *   Date        Name        Description
 *   01/14/2002  aliu        Creation.
 **********************************************************************
 */
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_TRANSLITERATION
 #include "tridpars.h"
 #include "hash.h"
 #include "mutex.h"
 #include "ucln_in.h"
 #include "unicode/parsepos.h"
 #include "unicode/translit.h"
 #include "unicode/uchar.h"
 #include "unicode/uniset.h"
 #include "unicode/unistr.h"
 #include "unicode/utrans.h"
 #include "util.h"
 #include "uvector.h"
 U_NAMESPACE_BEGIN
 static const UChar ID_DELIM    = 0x003B; // ;
 static const UChar TARGET_SEP  = 0x002D; // -
 static const UChar VARIANT_SEP = 0x002F; // /
 static const UChar OPEN_REV    = 0x0028; // (
 static const UChar CLOSE_REV   = 0x0029; // )
 //static const UChar EMPTY[]     = {0}; // ""
 static const UChar ANY[]       = {65,110,121,0}; // "Any"
 static const UChar ANY_NULL[]  = {65,110,121,45,78,117,108,108,0}; // "Any-Null"
 static const int32_t FORWARD = UTRANS_FORWARD;
 static const int32_t REVERSE = UTRANS_REVERSE;
 static Hashtable* SPECIAL_INVERSES = NULL;
 /**
  * The mutex controlling access to SPECIAL_INVERSES
  */
 static UMutex LOCK = U_MUTEX_INITIALIZER;
 TransliteratorIDParser::Specs::Specs(const UnicodeString& s, const UnicodeString& t,
                                      const UnicodeString& v, UBool sawS,
                                      const UnicodeString& f) {
     source = s;
     target = t;
     variant = v;
     sawSource = sawS;
     filter = f;
 }
 TransliteratorIDParser::SingleID::SingleID(const UnicodeString& c, const UnicodeString& b,
                                            const UnicodeString& f) {
     canonID = c;
     basicID = b;
     filter = f;
 }
 TransliteratorIDParser::SingleID::SingleID(const UnicodeString& c, const UnicodeString& b) {
     canonID = c;
     basicID = b;
 }
 Transliterator* TransliteratorIDParser::SingleID::createInstance() {
     Transliterator* t;
     if (basicID.length() == 0) {
         t = createBasicInstance(UnicodeString(TRUE, ANY_NULL, 8), &canonID);
     } else {
         t = createBasicInstance(basicID, &canonID);
     }
     if (t != NULL) {
         if (filter.length() != 0) {
             UErrorCode ec = U_ZERO_ERROR;
             UnicodeSet *set = new UnicodeSet(filter, ec);
             if (U_FAILURE(ec)) {
                 delete set;
             } else {
                 t->adoptFilter(set);
             }
         }
     }
     return t;
 }
 /**
  * Parse a single ID, that is, an ID of the general form
  * "[f1] s1-t1/v1 ([f2] s2-t3/v2)", with the parenthesized element
  * optional, the filters optional, and the variants optional.
  * @param id the id to be parsed
  * @param pos INPUT-OUTPUT parameter.  On input, the position of
  * the first character to parse.  On output, the position after
  * the last character parsed.
  * @param dir the direction.  If the direction is REVERSE then the
  * SingleID is constructed for the reverse direction.
  * @return a SingleID object or NULL
  */
 TransliteratorIDParser::SingleID*
 TransliteratorIDParser::parseSingleID(const UnicodeString& id, int32_t& pos,
                                       int32_t dir, UErrorCode& status) {
     int32_t start = pos;
     // The ID will be of the form A, A(), A(B), or (B), where
     // A and B are filter IDs.
     Specs* specsA = NULL;
     Specs* specsB = NULL;
     UBool sawParen = FALSE;
     // On the first pass, look for (B) or ().  If this fails, then
     // on the second pass, look for A, A(B), or A().
     for (int32_t pass=1; pass<=2; ++pass) {
         if (pass == 2) {
             specsA = parseFilterID(id, pos, TRUE);
             if (specsA == NULL) {
                 pos = start;
                 return NULL;
             }
         }
         if (ICU_Utility::parseChar(id, pos, OPEN_REV)) {
             sawParen = TRUE;
             if (!ICU_Utility::parseChar(id, pos, CLOSE_REV)) {
                 specsB = parseFilterID(id, pos, TRUE);
                 // Must close with a ')'
                 if (specsB == NULL || !ICU_Utility::parseChar(id, pos, CLOSE_REV)) {
                     delete specsA;
                     pos = start;
                     return NULL;
                 }
             }
             break;
         }
     }
     // Assemble return results
     SingleID* single;
     if (sawParen) {
         if (dir == FORWARD) {
             SingleID* b = specsToID(specsB, FORWARD);
             single = specsToID(specsA, FORWARD);
             // Null pointers check
             if (b == NULL || single == NULL) {
             	delete b;
             	delete single;
             	status = U_MEMORY_ALLOCATION_ERROR;
             	return NULL;
             }
             single->canonID.append(OPEN_REV)
                 .append(b->canonID).append(CLOSE_REV);
             if (specsA != NULL) {
                 single->filter = specsA->filter;
             }
             delete b;
         } else {
             SingleID* a = specsToID(specsA, FORWARD);
             single = specsToID(specsB, FORWARD);
             // Check for null pointer.
             if (a == NULL || single == NULL) {
             	delete a;
             	delete single;
             	status = U_MEMORY_ALLOCATION_ERROR;
             	return NULL;
             }
             single->canonID.append(OPEN_REV)
                 .append(a->canonID).append(CLOSE_REV);
             if (specsB != NULL) {
                 single->filter = specsB->filter;
             }
             delete a;
         }
     } else {
         // assert(specsA != NULL);
         if (dir == FORWARD) {
             single = specsToID(specsA, FORWARD);
         } else {
             single = specsToSpecialInverse(*specsA, status);
             if (single == NULL) {
                 single = specsToID(specsA, REVERSE);
             }
         }
         // Check for NULL pointer
         if (single == NULL) {
         	status = U_MEMORY_ALLOCATION_ERROR;
         	return NULL;
         }
         single->filter = specsA->filter;
     }
     delete specsA;
     delete specsB;
     return single;
 }
 /**
  * Parse a filter ID, that is, an ID of the general form
  * "[f1] s1-t1/v1", with the filters optional, and the variants optional.
  * @param id the id to be parsed
  * @param pos INPUT-OUTPUT parameter.  On input, the position of
  * the first character to parse.  On output, the position after
  * the last character parsed.
  * @return a SingleID object or null if the parse fails
  */
 TransliteratorIDParser::SingleID*
 TransliteratorIDParser::parseFilterID(const UnicodeString& id, int32_t& pos) {
     int32_t start = pos;
     Specs* specs = parseFilterID(id, pos, TRUE);
     if (specs == NULL) {
         pos = start;
         return NULL;
     }
     // Assemble return results
     SingleID* single = specsToID(specs, FORWARD);
     if (single != NULL) {
         single->filter = specs->filter;
     }
     delete specs;
     return single;
 }
 /**
  * Parse a global filter of the form "[f]" or "([f])", depending
  * on 'withParens'.
  * @param id the pattern the parse
  * @param pos INPUT-OUTPUT parameter.  On input, the position of
  * the first character to parse.  On output, the position after
  * the last character parsed.
  * @param dir the direction.
  * @param withParens INPUT-OUTPUT parameter.  On entry, if
  * withParens is 0, then parens are disallowed.  If it is 1,
  * then parens are requires.  If it is -1, then parens are
  * optional, and the return result will be set to 0 or 1.
  * @param canonID OUTPUT parameter.  The pattern for the filter
  * added to the canonID, either at the end, if dir is FORWARD, or
  * at the start, if dir is REVERSE.  The pattern will be enclosed
  * in parentheses if appropriate, and will be suffixed with an
  * ID_DELIM character.  May be NULL.
  * @return a UnicodeSet object or NULL.  A non-NULL results
  * indicates a successful parse, regardless of whether the filter
  * applies to the given direction.  The caller should discard it
  * if withParens != (dir == REVERSE).
  */
 UnicodeSet* TransliteratorIDParser::parseGlobalFilter(const UnicodeString& id, int32_t& pos,
                                                       int32_t dir,
                                                       int32_t& withParens,
                                                       UnicodeString* canonID) {
     UnicodeSet* filter = NULL;
     int32_t start = pos;
     if (withParens == -1) {
         withParens = ICU_Utility::parseChar(id, pos, OPEN_REV) ? 1 : 0;
     } else if (withParens == 1) {
         if (!ICU_Utility::parseChar(id, pos, OPEN_REV)) {
             pos = start;
             return NULL;
         }
     }
     ICU_Utility::skipWhitespace(id, pos, TRUE);
     if (UnicodeSet::resemblesPattern(id, pos)) {
         ParsePosition ppos(pos);
         UErrorCode ec = U_ZERO_ERROR;
         filter = new UnicodeSet(id, ppos, USET_IGNORE_SPACE, NULL, ec);
         /* test for NULL */
         if (filter == 0) {
             pos = start;
             return 0;
         }
         if (U_FAILURE(ec)) {
             delete filter;
             pos = start;
             return NULL;
         }
         UnicodeString pattern;
         id.extractBetween(pos, ppos.getIndex(), pattern);
         pos = ppos.getIndex();
         if (withParens == 1 && !ICU_Utility::parseChar(id, pos, CLOSE_REV)) {
             pos = start;
             return NULL;
         }
         // In the forward direction, append the pattern to the
         // canonID.  In the reverse, insert it at zero, and invert
         // the presence of parens ("A" <-> "(A)").
         if (canonID != NULL) {
             if (dir == FORWARD) {
                 if (withParens == 1) {
                     pattern.insert(0, OPEN_REV);
                     pattern.append(CLOSE_REV);
                 }
                 canonID->append(pattern).append(ID_DELIM);
             } else {
                 if (withParens == 0) {
                     pattern.insert(0, OPEN_REV);
                     pattern.append(CLOSE_REV);
                 }
                 canonID->insert(0, pattern);
                 canonID->insert(pattern.length(), ID_DELIM);
             }
         }
     }
     return filter;
 }
 U_CDECL_BEGIN
 static void U_CALLCONV _deleteSingleID(void* obj) {
     delete (TransliteratorIDParser::SingleID*) obj;
 }
 static void U_CALLCONV _deleteTransliteratorTrIDPars(void* obj) {
     delete (Transliterator*) obj;
 }
 U_CDECL_END
 /**
  * Parse a compound ID, consisting of an optional forward global
  * filter, a separator, one or more single IDs delimited by
  * separators, an an optional reverse global filter.  The
  * separator is a semicolon.  The global filters are UnicodeSet
  * patterns.  The reverse global filter must be enclosed in
  * parentheses.
  * @param id the pattern the parse
  * @param dir the direction.
  * @param canonID OUTPUT parameter that receives the canonical ID,
  * consisting of canonical IDs for all elements, as returned by
  * parseSingleID(), separated by semicolons.  Previous contents
  * are discarded.
  * @param list OUTPUT parameter that receives a list of SingleID
  * objects representing the parsed IDs.  Previous contents are
  * discarded.
  * @param globalFilter OUTPUT parameter that receives a pointer to
  * a newly created global filter for this ID in this direction, or
  * NULL if there is none.
  * @return TRUE if the parse succeeds, that is, if the entire
  * id is consumed without syntax error.
  */
 UBool TransliteratorIDParser::parseCompoundID(const UnicodeString& id, int32_t dir,
                                               UnicodeString& canonID,
                                               UVector& list,
                                               UnicodeSet*& globalFilter) {
     UErrorCode ec = U_ZERO_ERROR;
     int32_t i;
     int32_t pos = 0;
     int32_t withParens = 1;
     list.removeAllElements();
     UnicodeSet* filter;
     globalFilter = NULL;
     canonID.truncate(0);
     // Parse leading global filter, if any
     withParens = 0; // parens disallowed
     filter = parseGlobalFilter(id, pos, dir, withParens, &canonID);
     if (filter != NULL) {
         if (!ICU_Utility::parseChar(id, pos, ID_DELIM)) {
             // Not a global filter; backup and resume
             canonID.truncate(0);
             pos = 0;
         }
         if (dir == FORWARD) {
             globalFilter = filter;
         } else {
             delete filter;
         }
         filter = NULL;
     }
     UBool sawDelimiter = TRUE;
     for (;;) {
         SingleID* single = parseSingleID(id, pos, dir, ec);
         if (single == NULL) {
             break;
         }
         if (dir == FORWARD) {
             list.addElement(single, ec);
         } else {
             list.insertElementAt(single, 0, ec);
         }
         if (U_FAILURE(ec)) {
             goto FAIL;
         }
         if (!ICU_Utility::parseChar(id, pos, ID_DELIM)) {
             sawDelimiter = FALSE;
             break;
         }
     }
     if (list.size() == 0) {
         goto FAIL;
     }
     // Construct canonical ID
     for (i=0; i<list.size(); ++i) {
         SingleID* single = (SingleID*) list.elementAt(i);
         canonID.append(single->canonID);
         if (i != (list.size()-1)) {
             canonID.append(ID_DELIM);
         }
     }
     // Parse trailing global filter, if any, and only if we saw
     // a trailing delimiter after the IDs.
     if (sawDelimiter) {
         withParens = 1; // parens required
         filter = parseGlobalFilter(id, pos, dir, withParens, &canonID);
         if (filter != NULL) {
             // Don't require trailing ';', but parse it if present
             ICU_Utility::parseChar(id, pos, ID_DELIM);
             if (dir == REVERSE) {
                 globalFilter = filter;
             } else {
                 delete filter;
             }
             filter = NULL;
         }
     }
     // Trailing unparsed text is a syntax error
     ICU_Utility::skipWhitespace(id, pos, TRUE);
     if (pos != id.length()) {
         goto FAIL;
     }
     return TRUE;
  FAIL:
     UObjectDeleter *save = list.setDeleter(_deleteSingleID);
     list.removeAllElements();
     list.setDeleter(save);
     delete globalFilter;
     globalFilter = NULL;
     return FALSE;
 }
 /**
  * Convert the elements of the 'list' vector, which are SingleID
  * objects, into actual Transliterator objects.  In the course of
  * this, some (or all) entries may be removed.  If all entries
  * are removed, the NULL transliterator will be added.
  *
  * Delete entries with empty basicIDs; these are generated by
  * elements like "(A)" in the forward direction, or "A()" in
  * the reverse.  THIS MAY RESULT IN AN EMPTY VECTOR.  Convert
  * SingleID entries to actual transliterators.
  *
  * @param list vector of SingleID objects.  On exit, vector
  * of one or more Transliterators.
  * @return new value of insertIndex.  The index will shift if
  * there are empty items, like "(Lower)", with indices less than
  * insertIndex.
  */
 void TransliteratorIDParser::instantiateList(UVector& list,
                                                 UErrorCode& ec) {
     UVector tlist(ec);
     if (U_FAILURE(ec)) {
         goto RETURN;
     }
     tlist.setDeleter(_deleteTransliteratorTrIDPars);
     Transliterator* t;
     int32_t i;
     for (i=0; i<=list.size(); ++i) { // [sic]: i<=list.size()
         // We run the loop too long by one, so we can
         // do an insert after the last element
         if (i==list.size()) {
             break;
         }
         SingleID* single = (SingleID*) list.elementAt(i);
         if (single->basicID.length() != 0) {
             t = single->createInstance();
             if (t == NULL) {
                 ec = U_INVALID_ID;
                 goto RETURN;
             }
             tlist.addElement(t, ec);
             if (U_FAILURE(ec)) {
                 delete t;
                 goto RETURN;
             }
         }
     }
     // An empty list is equivalent to a NULL transliterator.
     if (tlist.size() == 0) {
         t = createBasicInstance(UnicodeString(TRUE, ANY_NULL, 8), NULL);
         if (t == NULL) {
             // Should never happen
             ec = U_INTERNAL_TRANSLITERATOR_ERROR;
         }
         tlist.addElement(t, ec);
         if (U_FAILURE(ec)) {
             delete t;
         }
     }
  RETURN:
     UObjectDeleter *save = list.setDeleter(_deleteSingleID);
     list.removeAllElements();
     if (U_SUCCESS(ec)) {
         list.setDeleter(_deleteTransliteratorTrIDPars);
         while (tlist.size() > 0) {
             t = (Transliterator*) tlist.orphanElementAt(0);
             list.addElement(t, ec);
             if (U_FAILURE(ec)) {
                 delete t;
                 list.removeAllElements();
                 break;
             }
         }
     }
     list.setDeleter(save);
 }
 /**
  * Parse an ID into pieces.  Take IDs of the form T, T/V, S-T,
  * S-T/V, or S/V-T.  If the source is missing, return a source of
  * ANY.
  * @param id the id string, in any of several forms
  * @return an array of 4 strings: source, target, variant, and
  * isSourcePresent.  If the source is not present, ANY will be
  * given as the source, and isSourcePresent will be NULL.  Otherwise
  * isSourcePresent will be non-NULL.  The target may be empty if the
  * id is not well-formed.  The variant may be empty.
  */
 void TransliteratorIDParser::IDtoSTV(const UnicodeString& id,
                                      UnicodeString& source,
                                      UnicodeString& target,
                                      UnicodeString& variant,
                                      UBool& isSourcePresent) {
     source.setTo(ANY, 3);
     target.truncate(0);
     variant.truncate(0);
     int32_t sep = id.indexOf(TARGET_SEP);
     int32_t var = id.indexOf(VARIANT_SEP);
     if (var < 0) {
         var = id.length();
     }
     isSourcePresent = FALSE;
     if (sep < 0) {
         // Form: T/V or T (or /V)
         id.extractBetween(0, var, target);
         id.extractBetween(var, id.length(), variant);
     } else if (sep < var) {
         // Form: S-T/V or S-T (or -T/V or -T)
         if (sep > 0) {
             id.extractBetween(0, sep, source);
             isSourcePresent = TRUE;
         }
         id.extractBetween(++sep, var, target);
         id.extractBetween(var, id.length(), variant);
     } else {
         // Form: (S/V-T or /V-T)
         if (var > 0) {
             id.extractBetween(0, var, source);
             isSourcePresent = TRUE;
         }
         id.extractBetween(var, sep++, variant);
         id.extractBetween(sep, id.length(), target);
     }
     if (variant.length() > 0) {
         variant.remove(0, 1);
     }
 }
 /**
  * Given source, target, and variant strings, concatenate them into a
  * full ID.  If the source is empty, then "Any" will be used for the
  * source, so the ID will always be of the form s-t/v or s-t.
  */
 void TransliteratorIDParser::STVtoID(const UnicodeString& source,
                                      const UnicodeString& target,
                                      const UnicodeString& variant,
                                      UnicodeString& id) {
     id = source;
     if (id.length() == 0) {
         id.setTo(ANY, 3);
     }
     id.append(TARGET_SEP).append(target);
     if (variant.length() != 0) {
         id.append(VARIANT_SEP).append(variant);
     }
     // NUL-terminate the ID string for getTerminatedBuffer.
     // This prevents valgrind and Purify warnings.
     id.append((UChar)0);
     id.truncate(id.length()-1);
 }
 /**
  * Register two targets as being inverses of one another.  For
  * example, calling registerSpecialInverse("NFC", "NFD", TRUE) causes
  * Transliterator to form the following inverse relationships:
  *
  * <pre>NFC => NFD
  * Any-NFC => Any-NFD
  * NFD => NFC
  * Any-NFD => Any-NFC</pre>
  *
  * (Without the special inverse registration, the inverse of NFC
  * would be NFC-Any.)  Note that NFD is shorthand for Any-NFD, but
  * that the presence or absence of "Any-" is preserved.
  *
  * <p>The relationship is symmetrical; registering (a, b) is
  * equivalent to registering (b, a).
  *
  * <p>The relevant IDs must still be registered separately as
  * factories or classes.
  *
  * <p>Only the targets are specified.  Special inverses always
  * have the form Any-Target1 <=> Any-Target2.  The target should
  * have canonical casing (the casing desired to be produced when
  * an inverse is formed) and should contain no whitespace or other
  * extraneous characters.
  *
  * @param target the target against which to register the inverse
  * @param inverseTarget the inverse of target, that is
  * Any-target.getInverse() => Any-inverseTarget
  * @param bidirectional if TRUE, register the reverse relation
  * as well, that is, Any-inverseTarget.getInverse() => Any-target
  */
 void TransliteratorIDParser::registerSpecialInverse(const UnicodeString& target,
                                                     const UnicodeString& inverseTarget,
                                                     UBool bidirectional,
                                                     UErrorCode &status) {
     init(status);
     if (U_FAILURE(status)) {
         return;
     }
     // If target == inverseTarget then force bidirectional => FALSE
     if (bidirectional && 0==target.caseCompare(inverseTarget, U_FOLD_CASE_DEFAULT)) {
         bidirectional = FALSE;
     }
     Mutex lock(&LOCK);
     UnicodeString *tempus = new UnicodeString(inverseTarget);  // Used for null pointer check before usage.
     if (tempus == NULL) {
     	status = U_MEMORY_ALLOCATION_ERROR;
     	return;
     }
     SPECIAL_INVERSES->put(target, tempus, status);
     if (bidirectional) {
     	tempus = new UnicodeString(target);
     	if (tempus == NULL) {
     		status = U_MEMORY_ALLOCATION_ERROR;
     		return;
     	}
         SPECIAL_INVERSES->put(inverseTarget, tempus, status);
     }
 }
 //----------------------------------------------------------------
 // Private implementation
 //----------------------------------------------------------------
 /**
  * Parse an ID into component pieces.  Take IDs of the form T,
  * T/V, S-T, S-T/V, or S/V-T.  If the source is missing, return a
  * source of ANY.
  * @param id the id string, in any of several forms
  * @param pos INPUT-OUTPUT parameter.  On input, pos is the
  * offset of the first character to parse in id.  On output,
  * pos is the offset after the last parsed character.  If the
  * parse failed, pos will be unchanged.
  * @param allowFilter2 if TRUE, a UnicodeSet pattern is allowed
  * at any location between specs or delimiters, and is returned
  * as the fifth string in the array.
  * @return a Specs object, or NULL if the parse failed.  If
  * neither source nor target was seen in the parsed id, then the
  * parse fails.  If allowFilter is TRUE, then the parsed filter
  * pattern is returned in the Specs object, otherwise the returned
  * filter reference is NULL.  If the parse fails for any reason
  * NULL is returned.
  */
 TransliteratorIDParser::Specs*
 TransliteratorIDParser::parseFilterID(const UnicodeString& id, int32_t& pos,
                                       UBool allowFilter) {
     UnicodeString first;
     UnicodeString source;
     UnicodeString target;
     UnicodeString variant;
     UnicodeString filter;
     UChar delimiter = 0;
     int32_t specCount = 0;
     int32_t start = pos;
     // This loop parses one of the following things with each
     // pass: a filter, a delimiter character (either '-' or '/'),
     // or a spec (source, target, or variant).
     for (;;) {
         ICU_Utility::skipWhitespace(id, pos, TRUE);
         if (pos == id.length()) {
             break;
         }
         // Parse filters
         if (allowFilter && filter.length() == 0 &&
             UnicodeSet::resemblesPattern(id, pos)) {
             ParsePosition ppos(pos);
             UErrorCode ec = U_ZERO_ERROR;
             UnicodeSet set(id, ppos, USET_IGNORE_SPACE, NULL, ec);
             if (U_FAILURE(ec)) {
                 pos = start;
                 return NULL;
             }
             id.extractBetween(pos, ppos.getIndex(), filter);
             pos = ppos.getIndex();
             continue;
         }
         if (delimiter == 0) {
             UChar c = id.charAt(pos);
             if ((c == TARGET_SEP && target.length() == 0) ||
                 (c == VARIANT_SEP && variant.length() == 0)) {
                 delimiter = c;
                 ++pos;
                 continue;
             }
         }
         // We are about to try to parse a spec with no delimiter
         // when we can no longer do so (we can only do so at the
         // start); break.
         if (delimiter == 0 && specCount > 0) {
             break;
         }
         UnicodeString spec = ICU_Utility::parseUnicodeIdentifier(id, pos);
         if (spec.length() == 0) {
             // Note that if there was a trailing delimiter, we
             // consume it.  So Foo-, Foo/, Foo-Bar/, and Foo/Bar-
             // are legal.
             break;
         }
         switch (delimiter) {
         case 0:
             first = spec;
             break;
         case TARGET_SEP:
             target = spec;
             break;
         case VARIANT_SEP:
             variant = spec;
             break;
         }
         ++specCount;
         delimiter = 0;
     }
     // A spec with no prior character is either source or target,
     // depending on whether an explicit "-target" was seen.
     if (first.length() != 0) {
         if (target.length() == 0) {
             target = first;
         } else {
             source = first;
         }
     }
     // Must have either source or target
     if (source.length() == 0 && target.length() == 0) {
         pos = start;
         return NULL;
     }
     // Empty source or target defaults to ANY
     UBool sawSource = TRUE;
     if (source.length() == 0) {
         source.setTo(ANY, 3);
         sawSource = FALSE;
     }
     if (target.length() == 0) {
         target.setTo(ANY, 3);
     }
     return new Specs(source, target, variant, sawSource, filter);
 }
 /**
  * Givens a Spec object, convert it to a SingleID object.  The
  * Spec object is a more unprocessed parse result.  The SingleID
  * object contains information about canonical and basic IDs.
  * @return a SingleID; never returns NULL.  Returned object always
  * has 'filter' field of NULL.
  */
 TransliteratorIDParser::SingleID*
 TransliteratorIDParser::specsToID(const Specs* specs, int32_t dir) {
     UnicodeString canonID;
     UnicodeString basicID;
     UnicodeString basicPrefix;
     if (specs != NULL) {
         UnicodeString buf;
         if (dir == FORWARD) {
             if (specs->sawSource) {
                 buf.append(specs->source).append(TARGET_SEP);
             } else {
                 basicPrefix = specs->source;
                 basicPrefix.append(TARGET_SEP);
             }
             buf.append(specs->target);
         } else {
             buf.append(specs->target).append(TARGET_SEP).append(specs->source);
         }
         if (specs->variant.length() != 0) {
             buf.append(VARIANT_SEP).append(specs->variant);
         }
         basicID = basicPrefix;
         basicID.append(buf);
         if (specs->filter.length() != 0) {
             buf.insert(0, specs->filter);
         }
         canonID = buf;
     }
     return new SingleID(canonID, basicID);
 }
 /**
  * Given a Specs object, return a SingleID representing the
  * special inverse of that ID.  If there is no special inverse
  * then return NULL.
  * @return a SingleID or NULL.  Returned object always has
  * 'filter' field of NULL.
  */
 TransliteratorIDParser::SingleID*
 TransliteratorIDParser::specsToSpecialInverse(const Specs& specs, UErrorCode &status) {
     if (0!=specs.source.caseCompare(ANY, 3, U_FOLD_CASE_DEFAULT)) {
         return NULL;
     }
     init(status);
     UnicodeString* inverseTarget;
     umtx_lock(&LOCK);
     inverseTarget = (UnicodeString*) SPECIAL_INVERSES->get(specs.target);
     umtx_unlock(&LOCK);
     if (inverseTarget != NULL) {
         // If the original ID contained "Any-" then make the
         // special inverse "Any-Foo"; otherwise make it "Foo".
         // So "Any-NFC" => "Any-NFD" but "NFC" => "NFD".
         UnicodeString buf;
         if (specs.filter.length() != 0) {
             buf.append(specs.filter);
         }
         if (specs.sawSource) {
             buf.append(ANY, 3).append(TARGET_SEP);
         }
         buf.append(*inverseTarget);
         UnicodeString basicID(TRUE, ANY, 3);
         basicID.append(TARGET_SEP).append(*inverseTarget);
         if (specs.variant.length() != 0) {
             buf.append(VARIANT_SEP).append(specs.variant);
             basicID.append(VARIANT_SEP).append(specs.variant);
         }
         return new SingleID(buf, basicID);
     }
     return NULL;
 }
 /**
  * Glue method to get around access problems in C++.  This would
  * ideally be inline but we want to avoid a circular header
  * dependency.
  */
 Transliterator* TransliteratorIDParser::createBasicInstance(const UnicodeString& id, const UnicodeString* canonID) {
     return Transliterator::createBasicInstance(id, canonID);
 }
 /**
  * Initialize static memory.
  */
 void TransliteratorIDParser::init(UErrorCode &status) {
     if (SPECIAL_INVERSES != NULL) {
         return;
     }
     Hashtable* special_inverses = new Hashtable(TRUE, status);
     // Null pointer check
     if (special_inverses == NULL) {
     	status = U_MEMORY_ALLOCATION_ERROR;
     	return;
     }
     special_inverses->setValueDeleter(uprv_deleteUObject);
     umtx_lock(&LOCK);
     if (SPECIAL_INVERSES == NULL) {
         SPECIAL_INVERSES = special_inverses;
         special_inverses = NULL;
     }
     umtx_unlock(&LOCK);
     delete special_inverses; /*null instance*/
     ucln_i18n_registerCleanup(UCLN_I18N_TRANSLITERATOR, utrans_transliterator_cleanup);
 }
 /**
  * Free static memory.
  */
 void TransliteratorIDParser::cleanup() {
     if (SPECIAL_INVERSES) {
         delete SPECIAL_INVERSES;
         SPECIAL_INVERSES = NULL;
     }
 }
 U_NAMESPACE_END
 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
 //eof

The Tor Browser / annotate

intl/icu/source/i18n/tridpars.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/tridpars.cpp