Update ICU to 54.1 step 1

source/i18n/anytrans.cpp

 /*
 *****************************************************************
-* Copyright (c) 2002-2011, International Business Machines Corporation
+* Copyright (c) 2002-2014, International Business Machines Corporation
 * and others.  All Rights Reserved.
 *****************************************************************
 * Date        Name        Description
 * 06/06/2002  aliu        Creation.
 *****************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_TRANSLITERATION
 
 #include "unicode/uobject.h"
 #include "unicode/uscript.h"
+
+#include "anytrans.h"
+#include "hash.h"
+#include "mutex.h"
 #include "nultrans.h"
-#include "anytrans.h"
+#include "putilimp.h"
+#include "tridpars.h"
+#include "uinvchar.h"
 #include "uvector.h"
-#include "tridpars.h"
-#include "hash.h"
-#include "putilimp.h"
-#include "uinvchar.h"
 
 //------------------------------------------------------------
 // Constants
 
 static const UChar TARGET_SEP = 45; // '-'
 static const UChar VARIANT_SEP = 47; // '/'
 static const UChar ANY[] = {65,110,121,0}; // "Any"
 static const UChar NULL_ID[] = {78,117,108,108,0}; // "Null"
 static const UChar LATIN_PIVOT[] = {45,76,97,116,105,110,59,76,97,116,105,110,45,0}; // "-Latin;Latin-"
 
 //------------------------------------------------------------
 
 U_CDECL_BEGIN
 /**
  * Deleter function for Transliterator*.
  */
 static void U_CALLCONV
 _deleteTransliterator(void *obj) {
-    delete (icu::Transliterator*) obj;    
+    delete (icu::Transliterator*) obj;
 }
 U_CDECL_END
 
 //------------------------------------------------------------
 
 U_NAMESPACE_BEGIN
 
 //------------------------------------------------------------
 // ScriptRunIterator
 
@@ skipping 25 matching lines @@
 
     /**
      * The start of the run, inclusive, valid after next() returns.
      */
     int32_t start;
 
     /**
      * The end of the run, exclusive, valid after next() returns.
      */
     int32_t limit;
-    
+
     /**
      * Constructs a run iterator over the given text from start
      * (inclusive) to limit (exclusive).
      */
     ScriptRunIterator(const Replaceable& text, int32_t start, int32_t limit);
 
     /**
      * Returns TRUE if there are any more runs.  TRUE is always
      * returned at least once.  Upon return, the caller should
      * examine scriptCode, start, and limit.
@@ skipping 74 matching lines @@
 // AnyTransliterator
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AnyTransliterator)
 
 AnyTransliterator::AnyTransliterator(const UnicodeString& id,
                                      const UnicodeString& theTarget,
                                      const UnicodeString& theVariant,
                                      UScriptCode theTargetScript,
                                      UErrorCode& ec) :
     Transliterator(id, NULL),
-    targetScript(theTargetScript) 
+    targetScript(theTargetScript)
 {
     cache = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &ec);
     if (U_FAILURE(ec)) {
         return;
     }
     uhash_setValueDeleter(cache, _deleteTransliterator);
 
     target = theTarget;
     if (theVariant.length() > 0) {
         target.append(VARIANT_SEP).append(theVariant);
@@ skipping 38 matching lines @@
 
     ScriptRunIterator it(text, pos.contextStart, pos.contextLimit);
 
     while (it.next()) {
         // Ignore runs in the ante context
         if (it.limit <= allStart) continue;
 
         // Try to instantiate transliterator from it.scriptCode to
         // our target or target/variant
         Transliterator* t = getTransliterator(it.scriptCode);
-       
+
         if (t == NULL) {
             // We have no transliterator.  Do nothing, but keep
             // pos.start up to date.
             pos.start = it.limit;
             continue;
         }
 
         // If the run end is before the transliteration limit, do
         // a non-incremental transliteration.  Otherwise do an
         // incremental one.
         UBool incremental = isIncremental && (it.limit >= allLimit);
-        
+
         pos.start = uprv_max(allStart, it.start);
         pos.limit = uprv_min(allLimit, it.limit);
         int32_t limit = pos.limit;
         t->filteredTransliterate(text, pos, incremental);
         int32_t delta = pos.limit - limit;
         allLimit += delta;
         it.adjustLimit(delta);
 
         // We're done if we enter the post context
         if (it.limit >= allLimit) break;
     }
 
     // Restore limit.  pos.start is fine where the last transliterator
     // left it, or at the end of the last run.
     pos.limit = allLimit;
 }
 
 Transliterator* AnyTransliterator::getTransliterator(UScriptCode source) const {
 
     if (source == targetScript || source == USCRIPT_INVALID_CODE) {
         return NULL;
     }
 
-    Transliterator* t = (Transliterator*) uhash_iget(cache, (int32_t) source);
+    Transliterator* t = NULL;
+    {
+        Mutex m(NULL);
+        t = (Transliterator*) uhash_iget(cache, (int32_t) source);
+    }
     if (t == NULL) {
         UErrorCode ec = U_ZERO_ERROR;
         UnicodeString sourceName(uscript_getName(source), -1, US_INV);
         UnicodeString id(sourceName);
         id.append(TARGET_SEP).append(target);
-        
+
         t = Transliterator::createInstance(id, UTRANS_FORWARD, ec);
         if (U_FAILURE(ec) || t == NULL) {
             delete t;
-            
+
             // Try to pivot around Latin, our most common script
             id = sourceName;
             id.append(LATIN_PIVOT, -1).append(target);
             t = Transliterator::createInstance(id, UTRANS_FORWARD, ec);
             if (U_FAILURE(ec) || t == NULL) {
                 delete t;
                 t = NULL;
             }
         }
 
         if (t != NULL) {
-            uhash_iput(cache, (int32_t) source, t, &ec);
+            Transliterator *rt = NULL;
+            {
+                Mutex m(NULL);
+                rt = static_cast<Transliterator *> (uhash_iget(cache, (int32_t) source));
+                if (rt == NULL) {
+                    // Common case, no race to cache this new transliterator.
+                    uhash_iput(cache, (int32_t) source, t, &ec);
+                } else {
+                    // Race case, some other thread beat us to caching this transliterator.
+                    Transliterator *temp = rt;
+                    rt = t;    // Our newly created transliterator that lost the race & now needs deleting.
+                    t  = temp; // The transliterator from the cache that we will return.
+                }
+            }
+            delete rt;    // will be non-null only in case of races.
         }
     }
-
     return t;
 }
 
 /**
  * Return the script code for a given name, or -1 if not found.
  */
 static UScriptCode scriptNameToCode(const UnicodeString& name) {
     char buf[128];
     UScriptCode code;
     UErrorCode ec = U_ZERO_ERROR;
     int32_t nameLen = name.length();
     UBool isInvariant = uprv_isInvariantUString(name.getBuffer(), nameLen);
-    
+
     if (isInvariant) {
         name.extract(0, nameLen, buf, (int32_t)sizeof(buf), US_INV);
         buf[127] = 0;   // Make sure that we NULL terminate the string.
     }
     if (!isInvariant || uscript_getCode(buf, &code, 1, &ec) != 1 || U_FAILURE(ec))
     {
         code = USCRIPT_INVALID_CODE;
     }
     return code;
 }
@@ skipping 18 matching lines @@
 
         int32_t targetCount = Transliterator::_countAvailableTargets(source);
         for (int32_t t=0; t<targetCount; ++t) {
             UnicodeString target;
             Transliterator::_getAvailableTarget(t, source, target);
 
             // Only process each target once
             if (seen.geti(target) != 0) continue;
             ec = U_ZERO_ERROR;
             seen.puti(target, 1, ec);
-            
+
             // Get the script code for the target.  If not a script, ignore.
             UScriptCode targetScript = scriptNameToCode(target);
             if (targetScript == USCRIPT_INVALID_CODE) continue;
 
             int32_t variantCount = Transliterator::_countAvailableVariants(source, target);
             // assert(variantCount >= 1);
             for (int32_t v=0; v<variantCount; ++v) {
                 UnicodeString variant;
                 Transliterator::_getAvailableVariant(v, source, target, variant);
-                
+
                 UnicodeString id;
                 TransliteratorIDParser::STVtoID(UnicodeString(TRUE, ANY, 3), target, variant, id);
                 ec = U_ZERO_ERROR;
                 AnyTransliterator* t = new AnyTransliterator(id, target, variant,
                                                              targetScript, ec);
                 if (U_FAILURE(ec)) {
                     delete t;
                 } else {
                     Transliterator::_registerInstance(t);
                     Transliterator::_registerSpecialInverse(target, UnicodeString(TRUE, NULL_ID, 4), FALSE);
                 }
             }
         }
     }
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
 
 //eof