Update ICU to 54.1 step 1

source/common/utext.cpp

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2005-2012, International Business Machines
+*   Copyright (C) 2005-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  utext.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2005apr12
 *   created by: Markus W. Scherer
@@ skipping 494 matching lines @@
         *status = U_NO_WRITE_PERMISSION;
         return;
     }
     ut->pFuncs->copy(ut, nativeStart, nativeLimit, destIndex, move, status);
 }
 
 
 
 U_CAPI UText * U_EXPORT2
 utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status) {
-    UText *result;
-    result = src->pFuncs->clone(dest, src, deep, status);
+    if (U_FAILURE(*status)) {
+        return dest;
+    }
+    UText *result = src->pFuncs->clone(dest, src, deep, status);
+    if (U_FAILURE(*status)) {
+        return result;
+    }
+    if (result == NULL) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+        return result;
+    }
     if (readOnly) {
         utext_freeze(result);
     }
     return result;
 }
 
 
 
 //------------------------------------------------------------------------------
 //
@@ skipping 268 matching lines @@
     //
     // Relocate any pointers in the target that refer to the UText itself
     //   to point to the cloned copy rather than the original source.
     //
     adjustPointer(dest, &dest->context, src);
     adjustPointer(dest, &dest->p, src);
     adjustPointer(dest, &dest->q, src);
     adjustPointer(dest, &dest->r, src);
     adjustPointer(dest, (const void **)&dest->chunkContents, src);
 
+    // The newly shallow-cloned UText does _not_ own the underlying storage for the text.
+    // (The source for the clone may or may not have owned the text.)
+
+    dest->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT);
+
     return dest;
 }
 
 
 U_CDECL_END
 
 
 
 //------------------------------------------------------------------------------
 //
@@ skipping 749 matching lines @@
     if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
         char *s = (char *)ut->context;
         uprv_free(s);
         ut->context = NULL;
     }
 }
 
 U_CDECL_END
 
 
-static const struct UTextFuncs utf8Funcs = 
+static const struct UTextFuncs utf8Funcs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
     utf8TextClone,
     utf8TextLength,
     utf8TextAccess,
     utf8TextExtract,
     NULL,                /* replace*/
     NULL,                /* copy   */
     utf8TextMapOffsetToNative,
@@ skipping 266 matching lines @@
             limit32--;
     }
 
     length=limit32-start32;
     if(length>destCapacity) {
         limit32 = start32 + destCapacity;
     }
     UnicodeString buffer(dest, 0, destCapacity); // writable alias
     rep->extractBetween(start32, limit32, buffer);
     repTextAccess(ut, limit32, TRUE);
-    
+
     return u_terminateUChars(dest, destCapacity, length, status);
 }
 
 static int32_t U_CALLCONV
 repTextReplace(UText *ut,
                int64_t start, int64_t limit,
                const UChar *src, int32_t length,
                UErrorCode *status) {
     Replaceable *rep=(Replaceable *)ut->context;
     int32_t oldLength;
@@ skipping 101 matching lines @@
     int32_t  nativeIterIndex = destIndex32 + limit32 - start32;
     if (move && destIndex32>start32) {
         // moved a block of text towards the end of the string.
         nativeIterIndex = destIndex32;
     }
 
     // Set position, reload chunk if needed.
     repTextAccess(ut, nativeIterIndex, TRUE);
 }
 
-static const struct UTextFuncs repFuncs = 
+static const struct UTextFuncs repFuncs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,           // Reserved alignment padding
     repTextClone,
     repTextLength,
     repTextAccess,
     repTextExtract,
-    repTextReplace,   
-    repTextCopy,   
+    repTextReplace,
+    repTextCopy,
     NULL,              // MapOffsetToNative,
     NULL,              // MapIndexToUTF16,
     repTextClose,
     NULL,              // spare 1
     NULL,              // spare 2
     NULL               // spare 3
 };
 
 
 U_CAPI UText * U_EXPORT2
@@ skipping 221 matching lines @@
     }
 
     // Iteration position to end of the newly inserted text.
     ut->chunkOffset = destIndex32+limit32-start32;
     if (move && destIndex32>start32) {
         ut->chunkOffset = destIndex32;
     }
 
 }
 
-static const struct UTextFuncs unistrFuncs = 
+static const struct UTextFuncs unistrFuncs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
     unistrTextClone,
     unistrTextLength,
     unistrTextAccess,
     unistrTextExtract,
-    unistrTextReplace,   
-    unistrTextCopy,   
+    unistrTextReplace,
+    unistrTextCopy,
     NULL,                // MapOffsetToNative,
     NULL,                // MapIndexToUTF16,
     unistrTextClose,
     NULL,                // spare 1
     NULL,                // spare 2
     NULL                 // spare 3
 };
 
 
 
@@ skipping 283 matching lines @@
 
     // Put iteration position at the point just following the extracted text
     ut->chunkOffset = uprv_min(strLength, start32 + destCapacity);
 
     // Add a terminating NUL if space in the buffer permits,
     // and set the error status as required.
     u_terminateUChars(dest, destCapacity, di, pErrorCode);
     return di;
 }
 
-static const struct UTextFuncs ucstrFuncs = 
+static const struct UTextFuncs ucstrFuncs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,           // Reserved alignment padding
     ucstrTextClone,
     ucstrTextLength,
     ucstrTextAccess,
     ucstrTextExtract,
     NULL,              // Replace
     NULL,              // Copy
     NULL,              // MapOffsetToNative,
@@ skipping 196 matching lines @@
         U_ASSERT(desti+len>0); /* to ensure desti+len never exceeds MAX_INT32, which must not happen logically */
         if (desti+len <= destCapacity) {
             U16_APPEND_UNSAFE(dest, desti, c);
             copyLimit = srci+len;
         } else {
             desti += len;
             *status = U_BUFFER_OVERFLOW_ERROR;
         }
         srci += len;
     }
-    
+
     charIterTextAccess(ut, copyLimit, TRUE);
 
     u_terminateUChars(dest, destCapacity, desti, status);
     return desti;
 }
 
-static const struct UTextFuncs charIterFuncs = 
+static const struct UTextFuncs charIterFuncs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
     charIterTextClone,
     charIterTextLength,
     charIterTextAccess,
     charIterTextExtract,
     NULL,                // Replace
     NULL,                // Copy
     NULL,                // MapOffsetToNative,
@@ skipping 39 matching lines @@
         //          zero without Access() thinking that the chunk is valid.
         ut->chunkContents        = (UChar *)ut->p;
         ut->chunkNativeStart     = -1;
         ut->chunkOffset          = 1;
         ut->chunkNativeLimit     = 0;
         ut->chunkLength          = 0;
         ut->nativeIndexingLimit  = ut->chunkOffset;  // enables native indexing
     }
     return ut;
 }
-
-
-