ICU 56 update step 1

source/i18n/rbt.cpp

 /*
 **********************************************************************
-*   Copyright (C) 1999-2013, International Business Machines
+*   Copyright (C) 1999-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *   Date        Name        Description
 *   11/17/99    aliu        Creation.
 **********************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_TRANSLITERATION
 
 #include "unicode/rep.h"
 #include "unicode/uniset.h"
 #include "rbt_pars.h"
 #include "rbt_data.h"
 #include "rbt_rule.h"
 #include "rbt.h"
+#include "mutex.h"
 #include "umutex.h"
 
 U_NAMESPACE_BEGIN
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedTransliterator)
 
 static UMutex transliteratorDataMutex = U_MUTEX_INITIALIZER;
 static Replaceable *gLockedText = NULL;
 
 void RuleBasedTransliterator::_construct(const UnicodeString& rules,
@@ skipping 206 matching lines @@
     // A Complication: compound transliterators can result in recursive entries to this
     //   function, sometimes with different "This" objects, always with the same text. 
     //   Double-locking must be prevented in these cases.
     //   
 
     // If the transliteration data is exclusively owned by this transliterator object,
     //   we don't need to do any locking.  No sharing between transliterators is possible,
     //   so no concurrent access from multiple threads is possible.
     UBool    lockedMutexAtThisLevel = FALSE;
     if (isDataOwned == FALSE) {
-        // Test whether this request is operating on the same text string as some
+        // Test whether this request is operating on the same text string as
         //   some other transliteration that is still in progress and holding the 
         //   transliteration mutex.  If so, do not lock the transliteration
         //    mutex again.
+        //
+        //  gLockedText variable is protected by the global ICU mutex.
+        //  Shared RBT data protected by transliteratorDataMutex.
+        //
         // TODO(andy): Need a better scheme for handling this.
         UBool needToLock;
-        umtx_lock(NULL);
-        needToLock = (&text != gLockedText);
-        umtx_unlock(NULL);
+        {
+            Mutex m;
+            needToLock = (&text != gLockedText);
+        }
         if (needToLock) {
-            umtx_lock(&transliteratorDataMutex);
+            umtx_lock(&transliteratorDataMutex);  // Contention, longish waits possible here.
+            Mutex m;
             gLockedText = &text;
             lockedMutexAtThisLevel = TRUE;
         }
     }
     
     // Check to make sure we don't dereference a null pointer.
     if (fData != NULL) {
             while (index.start < index.limit &&
                    loopCount <= loopLimit &&
                    fData->ruleSet.transliterate(text, index, isIncremental)) {
                 ++loopCount;
             }
     }
     if (lockedMutexAtThisLevel) {
-        gLockedText = NULL;
+        {
+            Mutex m;
+            gLockedText = NULL;
+        }
         umtx_unlock(&transliteratorDataMutex);
     }
 }
 
 UnicodeString& RuleBasedTransliterator::toRules(UnicodeString& rulesSource,
                                                 UBool escapeUnprintable) const {
     return fData->ruleSet.toRules(rulesSource, escapeUnprintable);
 }
 
 /**
  * Implement Transliterator framework
  */
 void RuleBasedTransliterator::handleGetSourceSet(UnicodeSet& result) const {
     fData->ruleSet.getSourceTargetSet(result, FALSE);
 }
 
 /**
  * Override Transliterator framework
  */
 UnicodeSet& RuleBasedTransliterator::getTargetSet(UnicodeSet& result) const {
     return fData->ruleSet.getSourceTargetSet(result, TRUE);
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_TRANSLITERATION */