The Tor Browser / file revision

 /*

 **********************************************************************

 *   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