ICU 56 update step 1

source/common/brkeng.cpp

 /*
  ************************************************************************************
- * Copyright (C) 2006-2014, International Business Machines Corporation
+ * Copyright (C) 2006-2015, International Business Machines Corporation
  * and others. All Rights Reserved.
  ************************************************************************************
  */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_BREAK_ITERATION
 
 #include "brkeng.h"
 #include "dictbe.h"
 #include "unicode/uchar.h"
 #include "unicode/uniset.h"
 #include "unicode/chariter.h"
 #include "unicode/ures.h"
 #include "unicode/udata.h"
 #include "unicode/putil.h"
 #include "unicode/ustring.h"
 #include "unicode/uscript.h"
 #include "unicode/ucharstrie.h"
 #include "unicode/bytestrie.h"
 #include "charstr.h"
 #include "dictionarydata.h"
+#include "mutex.h"
 #include "uvector.h"
 #include "umutex.h"
 #include "uresimp.h"
 #include "ubrkimpl.h"
 
 U_NAMESPACE_BEGIN
 
 /*
  ******************************************************************
  */
@@ skipping 95 matching lines @@
 }
 
 U_NAMESPACE_END
 U_CDECL_BEGIN
 static void U_CALLCONV _deleteEngine(void *obj) {
     delete (const icu::LanguageBreakEngine *) obj;
 }
 U_CDECL_END
 U_NAMESPACE_BEGIN
 
+static UMutex gBreakEngineMutex = U_MUTEX_INITIALIZER;
+
 const LanguageBreakEngine *
 ICULanguageBreakFactory::getEngineFor(UChar32 c, int32_t breakType) {
-    UBool       needsInit;
-    int32_t     i;
     const LanguageBreakEngine *lbe = NULL;
     UErrorCode  status = U_ZERO_ERROR;
 
-    // TODO: The global mutex should not be used.
-    // The global mutex should only be used for short periods.
-    // A ICULanguageBreakFactory specific mutex should be used.
-    umtx_lock(NULL);
-    needsInit = (UBool)(fEngines == NULL);
-    if (!needsInit) {
-        i = fEngines->size();
+    Mutex m(&gBreakEngineMutex);
+
+    if (fEngines == NULL) {
+        UStack  *engines = new UStack(_deleteEngine, NULL, status);
+        if (U_FAILURE(status) || engines == NULL) {
+            // Note: no way to return error code to caller.
+            delete engines;
+            return NULL;
+        }
+        fEngines = engines;
+    } else {
+        int32_t i = fEngines->size();
         while (--i >= 0) {
             lbe = (const LanguageBreakEngine *)(fEngines->elementAt(i));
             if (lbe != NULL && lbe->handles(c, breakType)) {
-                break;
+                return lbe;
             }
-            lbe = NULL;
-        }
-    }
-    umtx_unlock(NULL);
-    
-    if (lbe != NULL) {
-        return lbe;
-    }
-    
-    if (needsInit) {
-        UStack  *engines = new UStack(_deleteEngine, NULL, status);
-        if (U_SUCCESS(status) && engines == NULL) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-        }
-        else if (U_FAILURE(status)) {
-            delete engines;
-            engines = NULL;
-        }
-        else {
-            umtx_lock(NULL);
-            if (fEngines == NULL) {
-                fEngines = engines;
-                engines = NULL;
-            }
-            umtx_unlock(NULL);
-            delete engines;
         }
     }
     
-    if (fEngines == NULL) {
-        return NULL;
+    // We didn't find an engine. Create one.
+    lbe = loadEngineFor(c, breakType);
+    if (lbe != NULL) {
+        fEngines->push((void *)lbe, status);
     }
-
-    // We didn't find an engine the first time through, or there was no
-    // stack. Create an engine.
-    const LanguageBreakEngine *newlbe = loadEngineFor(c, breakType);
-    
-    // Now get the lock, and see if someone else has created it in the
-    // meantime
-    umtx_lock(NULL);
-    i = fEngines->size();
-    while (--i >= 0) {
-        lbe = (const LanguageBreakEngine *)(fEngines->elementAt(i));
-        if (lbe != NULL && lbe->handles(c, breakType)) {
-            break;
-        }
-        lbe = NULL;
-    }
-    if (lbe == NULL && newlbe != NULL) {
-        fEngines->push((void *)newlbe, status);
-        lbe = newlbe;
-        newlbe = NULL;
-    }
-    umtx_unlock(NULL);
-    
-    delete newlbe;
-
     return lbe;
 }
 
 const LanguageBreakEngine *
 ICULanguageBreakFactory::loadEngineFor(UChar32 c, int32_t breakType) {
     UErrorCode status = U_ZERO_ERROR;
     UScriptCode code = uscript_getScript(c, &status);
     if (U_SUCCESS(status)) {
         DictionaryMatcher *m = loadDictionaryMatcherFor(code, breakType);
         if (m != NULL) {
@@ skipping 107 matching lines @@
         // returning NULL here will cause us to fail to find a dictionary break engine, as expected
         status = U_ZERO_ERROR;
         return NULL;
     }
     return NULL;
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */