Update ICU to 54.1 step 1

source/i18n/tridpars.cpp

 /*
 **********************************************************************
-*   Copyright (c) 2002-2012, International Business Machines Corporation
+*   Copyright (c) 2002-2014, 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 "transreg.h"
+#include "uassert.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;
+static UInitOnce gSpecialInversesInitOnce = U_INITONCE_INITIALIZER;
 
 /**
  * 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;
@@ skipping 583 matching lines @@
  * @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);
+    umtx_initOnce(gSpecialInversesInitOnce, 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);
@@ skipping 186 matching lines @@
  * 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);
+    umtx_initOnce(gSpecialInversesInitOnce, init, status);
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
 
     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".
@@ skipping 22 matching lines @@
 /**
  * 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.
+ * Initialize static memory. Called through umtx_initOnce only.
  */
 void TransliteratorIDParser::init(UErrorCode &status) {
-    if (SPECIAL_INVERSES != NULL) {
-        return;
-    }
+    U_ASSERT(SPECIAL_INVERSES == NULL);
+    ucln_i18n_registerCleanup(UCLN_I18N_TRANSLITERATOR, utrans_transliterator_cleanup);
 
-    Hashtable* special_inverses = new Hashtable(TRUE, status);
-    // Null pointer check
-    if (special_inverses == NULL) {
+    SPECIAL_INVERSES = new Hashtable(TRUE, status);
+    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);
+    SPECIAL_INVERSES->setValueDeleter(uprv_deleteUObject);
 }
 
 /**
  * Free static memory.
  */
 void TransliteratorIDParser::cleanup() {
     if (SPECIAL_INVERSES) {
         delete SPECIAL_INVERSES;
         SPECIAL_INVERSES = NULL;
     }
+    gSpecialInversesInitOnce.reset();
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
 
 //eof