]> git.saurik.com Git - apple/icu.git/blobdiff - icuSources/common/utext.cpp
ICU-551.24.tar.gz
[apple/icu.git] / icuSources / common / utext.cpp
index 40266ffb8606edd27f08dffb561697569cab1360..6dc31a0485d70e89e753f217137dddc4cacd1578 100644 (file)
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
 /*
 *******************************************************************************
 *
-*   Copyright (C) 2005-2009, International Business Machines
+*   Copyright (C) 2005-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 #include "unicode/unistr.h"
 #include "unicode/chariter.h"
 #include "unicode/utext.h"
 #include "unicode/unistr.h"
 #include "unicode/chariter.h"
 #include "unicode/utext.h"
+#include "unicode/utf.h"
+#include "unicode/utf8.h"
+#include "unicode/utf16.h"
 #include "ustr_imp.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "uassert.h"
 #include "ustr_imp.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "uassert.h"
+#include "putilimp.h"
 
 U_NAMESPACE_USE
 
 
 U_NAMESPACE_USE
 
@@ -117,13 +121,13 @@ utext_setNativeIndex(UText *ut, int64_t index) {
     // Adjust the index position if it is in the middle of a surrogate pair.
     if (ut->chunkOffset<ut->chunkLength) {
         UChar c= ut->chunkContents[ut->chunkOffset];
     // Adjust the index position if it is in the middle of a surrogate pair.
     if (ut->chunkOffset<ut->chunkLength) {
         UChar c= ut->chunkContents[ut->chunkOffset];
-        if (UTF16_IS_TRAIL(c)) {
+        if (U16_IS_TRAIL(c)) {
             if (ut->chunkOffset==0) {
                 ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE);
             }
             if (ut->chunkOffset>0) {
                 UChar lead = ut->chunkContents[ut->chunkOffset-1];
             if (ut->chunkOffset==0) {
                 ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE);
             }
             if (ut->chunkOffset>0) {
                 UChar lead = ut->chunkContents[ut->chunkOffset-1];
-                if (UTF16_IS_LEAD(lead)) {
+                if (U16_IS_LEAD(lead)) {
                     ut->chunkOffset--;
                 }
             }
                     ut->chunkOffset--;
                 }
             }
@@ -512,8 +516,17 @@ utext_copy(UText *ut,
 
 U_CAPI UText * U_EXPORT2
 utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *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);
     }
     if (readOnly) {
         utext_freeze(result);
     }
@@ -800,7 +813,12 @@ shallowTextClone(UText * dest, const UText * src, UErrorCode * status) {
     adjustPointer(dest, &dest->p, src);
     adjustPointer(dest, &dest->q, src);
     adjustPointer(dest, &dest->r, src);
     adjustPointer(dest, &dest->p, src);
     adjustPointer(dest, &dest->q, src);
     adjustPointer(dest, &dest->r, src);
-       adjustPointer(dest, (const void **)&dest->chunkContents, 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;
 }
 
     return dest;
 }
@@ -932,7 +950,7 @@ utf8TextAccess(UText *ut, int64_t index, UBool forward) {
     if (ix>length) {
         if (length>=0) {
             ix=length;
     if (ix>length) {
         if (length>=0) {
             ix=length;
-        } else if (ix>ut->c) {
+        } else if (ix>=ut->c) {
             // Zero terminated string, and requested index is beyond
             //   the region that has already been scanned.
             //   Scan up to either the end of the string or to the
             // Zero terminated string, and requested index is beyond
             //   the region that has already been scanned.
             //   Scan up to either the end of the string or to the
@@ -1190,7 +1208,7 @@ fillForward:
         int32_t  destIx       = 0;
         int32_t  srcIx        = ix;
         UBool    seenNonAscii = FALSE;
         int32_t  destIx       = 0;
         int32_t  srcIx        = ix;
         UBool    seenNonAscii = FALSE;
-        UChar32   c;
+        UChar32  c = 0;
 
         // Fill the chunk buffer and mapping arrays.
         while (destIx<UTF8_TEXT_CHUNK_SIZE) {
 
         // Fill the chunk buffer and mapping arrays.
         while (destIx<UTF8_TEXT_CHUNK_SIZE) {
@@ -1198,9 +1216,9 @@ fillForward:
             if (c>0 && c<0x80) {
                 // Special case ASCII range for speed.
                 //   zero is excluded to simplify bounds checking.
             if (c>0 && c<0x80) {
                 // Special case ASCII range for speed.
                 //   zero is excluded to simplify bounds checking.
-                buf[destIx] = c;
-                mapToNative[destIx]    = srcIx - ix;
-                mapToUChars[srcIx-ix]  = destIx;
+                buf[destIx] = (UChar)c;
+                mapToNative[destIx]    = (uint8_t)(srcIx - ix);
+                mapToUChars[srcIx-ix]  = (uint8_t)destIx;
                 srcIx++;
                 destIx++;
             } else {
                 srcIx++;
                 destIx++;
             } else {
@@ -1213,23 +1231,19 @@ fillForward:
                 int32_t  cIx      = srcIx;
                 int32_t  dIx      = destIx;
                 int32_t  dIxSaved = destIx;
                 int32_t  cIx      = srcIx;
                 int32_t  dIx      = destIx;
                 int32_t  dIxSaved = destIx;
-                U8_NEXT(s8, srcIx, strLen, c);
+                U8_NEXT_OR_FFFD(s8, srcIx, strLen, c);
                 if (c==0 && nulTerminated) {
                     srcIx--;
                     break;
                 }
                 if (c==0 && nulTerminated) {
                     srcIx--;
                     break;
                 }
-                if (c<0) {
-                    // Illegal UTF-8.  Replace with sub character.
-                    c = 0x0fffd;
-                }
 
                 U16_APPEND_UNSAFE(buf, destIx, c);
                 do {
 
                 U16_APPEND_UNSAFE(buf, destIx, c);
                 do {
-                    mapToNative[dIx++] = cIx - ix;
+                    mapToNative[dIx++] = (uint8_t)(cIx - ix);
                 } while (dIx < destIx);
 
                 do {
                 } while (dIx < destIx);
 
                 do {
-                    mapToUChars[cIx++ - ix] = dIxSaved;
+                    mapToUChars[cIx++ - ix] = (uint8_t)dIxSaved;
                 } while (cIx < srcIx);
             }
             if (srcIx>=strLen) {
                 } while (cIx < srcIx);
             }
             if (srcIx>=strLen) {
@@ -1240,8 +1254,8 @@ fillForward:
 
         //  store Native <--> Chunk Map entries for the end of the buffer.
         //    There is no actual character here, but the index position is valid.
 
         //  store Native <--> Chunk Map entries for the end of the buffer.
         //    There is no actual character here, but the index position is valid.
-        mapToNative[destIx]     = srcIx - ix;
-        mapToUChars[srcIx - ix] = destIx;
+        mapToNative[destIx]     = (uint8_t)(srcIx - ix);
+        mapToUChars[srcIx - ix] = (uint8_t)destIx;
 
         //  fill in Buffer descriptor
         u8b->bufNativeStart     = ix;
 
         //  fill in Buffer descriptor
         u8b->bufNativeStart     = ix;
@@ -1307,8 +1321,8 @@ fillReverse:
         // Map to/from Native Indexes, fill in for the position at the end of
         //   the buffer.
         //
         // Map to/from Native Indexes, fill in for the position at the end of
         //   the buffer.
         //
-        mapToNative[destIx] = srcIx - toUCharsMapStart;
-        mapToUChars[srcIx - toUCharsMapStart] = destIx;
+        mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart);
+        mapToUChars[srcIx - toUCharsMapStart] = (uint8_t)destIx;
 
         // Fill the chunk buffer
         // Work backwards, filling from the end of the buffer towards the front.
 
         // Fill the chunk buffer
         // Work backwards, filling from the end of the buffer towards the front.
@@ -1321,39 +1335,35 @@ fillReverse:
             c = s8[srcIx];
             if (c<0x80) {
                 // Special case ASCII range for speed.
             c = s8[srcIx];
             if (c<0x80) {
                 // Special case ASCII range for speed.
-                buf[destIx] = c;
-                mapToUChars[srcIx - toUCharsMapStart] = destIx;
-                mapToNative[destIx] = srcIx - toUCharsMapStart;
+                buf[destIx] = (UChar)c;
+                mapToUChars[srcIx - toUCharsMapStart] = (uint8_t)destIx;
+                mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart);
             } else {
                 // General case, handle everything non-ASCII.
 
                 int32_t  sIx      = srcIx;  // ix of last byte of multi-byte u8 char
 
                 // Get the full character from the UTF8 string.
             } else {
                 // General case, handle everything non-ASCII.
 
                 int32_t  sIx      = srcIx;  // ix of last byte of multi-byte u8 char
 
                 // Get the full character from the UTF8 string.
-                //   use code derived from tbe macros in utf.8
+                //   use code derived from tbe macros in utf8.h
                 //   Leaves srcIx pointing at the first byte of the UTF-8 char.
                 //
                 //   Leaves srcIx pointing at the first byte of the UTF-8 char.
                 //
-                if (c<=0xbf) {
-                    c=utf8_prevCharSafeBody(s8, 0, &srcIx, c, -1);
-                    // leaves srcIx at first byte of the multi-byte char.
-                } else {
-                    c=0x0fffd;
-                }
+                c=utf8_prevCharSafeBody(s8, 0, &srcIx, c, -3);
+                // leaves srcIx at first byte of the multi-byte char.
 
                 // Store the character in UTF-16 buffer.
                 if (c<0x10000) {
 
                 // Store the character in UTF-16 buffer.
                 if (c<0x10000) {
-                    buf[destIx] = c;
-                    mapToNative[destIx] = srcIx - toUCharsMapStart;
+                    buf[destIx] = (UChar)c;
+                    mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart);
                 } else {
                     buf[destIx]         = U16_TRAIL(c);
                 } else {
                     buf[destIx]         = U16_TRAIL(c);
-                    mapToNative[destIx] = srcIx - toUCharsMapStart;
+                    mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart);
                     buf[--destIx]       = U16_LEAD(c);
                     buf[--destIx]       = U16_LEAD(c);
-                    mapToNative[destIx] = srcIx - toUCharsMapStart;
+                    mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart);
                 }
 
                 // Fill in the map from native indexes to UChars buf index.
                 do {
                 }
 
                 // Fill in the map from native indexes to UChars buf index.
                 do {
-                    mapToUChars[sIx-- - toUCharsMapStart] = destIx;
+                    mapToUChars[sIx-- - toUCharsMapStart] = (uint8_t)destIx;
                 } while (sIx >= srcIx);
 
                 // Set native indexing limit to be the current position.
                 } while (sIx >= srcIx);
 
                 // Set native indexing limit to be the current position.
@@ -1399,7 +1409,7 @@ utext_strFromUTF8(UChar *dest,
 {
 
     UChar *pDest = dest;
 {
 
     UChar *pDest = dest;
-    UChar *pDestLimit = dest+destCapacity;
+    UChar *pDestLimit = (dest!=NULL)?(dest+destCapacity):NULL;
     UChar32 ch=0;
     int32_t index = 0;
     int32_t reqLength = 0;
     UChar32 ch=0;
     int32_t index = 0;
     int32_t reqLength = 0;
@@ -1411,16 +1421,13 @@ utext_strFromUTF8(UChar *dest,
         if(ch <=0x7f){
             *pDest++=(UChar)ch;
         }else{
         if(ch <=0x7f){
             *pDest++=(UChar)ch;
         }else{
-            ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, -1);
-            if(ch<0){
-                ch = 0xfffd;
-            }
-            if(ch<=0xFFFF){
+            ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, -3);
+            if(U_IS_BMP(ch)){
                 *(pDest++)=(UChar)ch;
             }else{
                 *(pDest++)=(UChar)ch;
             }else{
-                *(pDest++)=UTF16_LEAD(ch);
+                *(pDest++)=U16_LEAD(ch);
                 if(pDest<pDestLimit){
                 if(pDest<pDestLimit){
-                    *(pDest++)=UTF16_TRAIL(ch);
+                    *(pDest++)=U16_TRAIL(ch);
                 }else{
                     reqLength++;
                     break;
                 }else{
                     reqLength++;
                     break;
@@ -1434,11 +1441,8 @@ utext_strFromUTF8(UChar *dest,
         if(ch <= 0x7f){
             reqLength++;
         }else{
         if(ch <= 0x7f){
             reqLength++;
         }else{
-            ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, -1);
-            if(ch<0){
-                ch = 0xfffd;
-            }
-            reqLength+=UTF_CHAR_LENGTH(ch);
+            ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, -3);
+            reqLength+=U16_LENGTH(ch);
         }
     }
 
         }
     }
 
@@ -1485,7 +1489,7 @@ utf8TextExtract(UText *ut,
     int i;
     if (start32 < ut->chunkNativeLimit) {
         for (i=0; i<3; i++) {
     int i;
     if (start32 < ut->chunkNativeLimit) {
         for (i=0; i<3; i++) {
-            if (U8_IS_LEAD(buf[start32]) || start32==0) {
+            if (U8_IS_SINGLE(buf[start32]) || U8_IS_LEAD(buf[start32]) || start32==0) {
                 break;
             }
             start32--;
                 break;
             }
             start32--;
@@ -1494,7 +1498,7 @@ utf8TextExtract(UText *ut,
 
     if (limit32 < ut->chunkNativeLimit) {
         for (i=0; i<3; i++) {
 
     if (limit32 < ut->chunkNativeLimit) {
         for (i=0; i<3; i++) {
-            if (U8_IS_LEAD(buf[limit32]) || limit32==0) {
+            if (U8_IS_SINGLE(buf[limit32]) || U8_IS_LEAD(buf[limit32]) || limit32==0) {
                 break;
             }
             limit32--;
                 break;
             }
             limit32--;
@@ -1506,6 +1510,7 @@ utf8TextExtract(UText *ut,
     utext_strFromUTF8(dest, destCapacity, &destLength,
                     (const char *)ut->context+start32, limit32-start32,
                     pErrorCode);
     utext_strFromUTF8(dest, destCapacity, &destLength,
                     (const char *)ut->context+start32, limit32-start32,
                     pErrorCode);
+    utf8TextAccess(ut, limit32, TRUE);
     return destLength;
 }
 
     return destLength;
 }
 
@@ -1584,7 +1589,7 @@ utf8TextClose(UText *ut) {
 U_CDECL_END
 
 
 U_CDECL_END
 
 
-static const struct UTextFuncs utf8Funcs = 
+static const struct UTextFuncs utf8Funcs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
@@ -1603,11 +1608,17 @@ static const struct UTextFuncs utf8Funcs =
 };
 
 
 };
 
 
+static const char gEmptyString[] = {0};
+
 U_CAPI UText * U_EXPORT2
 utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status) {
     if(U_FAILURE(*status)) {
         return NULL;
     }
 U_CAPI UText * U_EXPORT2
 utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status) {
     if(U_FAILURE(*status)) {
         return NULL;
     }
+    if(s==NULL && length==0) {
+        s = gEmptyString;
+    }
+
     if(s==NULL || length<-1 || length>INT32_MAX) {
         *status=U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     if(s==NULL || length<-1 || length>INT32_MAX) {
         *status=U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
@@ -1864,6 +1875,8 @@ repTextExtract(UText *ut,
     }
     UnicodeString buffer(dest, 0, destCapacity); // writable alias
     rep->extractBetween(start32, limit32, buffer);
     }
     UnicodeString buffer(dest, 0, destCapacity); // writable alias
     rep->extractBetween(start32, limit32, buffer);
+    repTextAccess(ut, limit32, TRUE);
+
     return u_terminateUChars(dest, destCapacity, length, status);
 }
 
     return u_terminateUChars(dest, destCapacity, length, status);
 }
 
@@ -1985,7 +1998,7 @@ repTextCopy(UText *ut,
     repTextAccess(ut, nativeIterIndex, TRUE);
 }
 
     repTextAccess(ut, nativeIterIndex, TRUE);
 }
 
-static const struct UTextFuncs repFuncs = 
+static const struct UTextFuncs repFuncs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,           // Reserved alignment padding
 {
     sizeof(UTextFuncs),
     0, 0, 0,           // Reserved alignment padding
@@ -1993,8 +2006,8 @@ static const struct UTextFuncs repFuncs =
     repTextLength,
     repTextAccess,
     repTextExtract,
     repTextLength,
     repTextAccess,
     repTextExtract,
-    repTextReplace,   
-    repTextCopy,   
+    repTextReplace,
+    repTextCopy,
     NULL,              // MapOffsetToNative,
     NULL,              // MapIndexToUTF16,
     repTextClose,
     NULL,              // MapOffsetToNative,
     NULL,              // MapIndexToUTF16,
     repTextClose,
@@ -2132,6 +2145,9 @@ unistrTextExtract(UText *t,
             trimmedLength=destCapacity;
         }
         us->extract(start32, trimmedLength, dest);
             trimmedLength=destCapacity;
         }
         us->extract(start32, trimmedLength, dest);
+        t->chunkOffset = start32+trimmedLength;
+    } else {
+        t->chunkOffset = start32;
     }
     u_terminateUChars(dest, destCapacity, length, pErrorCode);
     return length;
     }
     u_terminateUChars(dest, destCapacity, length, pErrorCode);
     return length;
@@ -2233,7 +2249,7 @@ unistrTextCopy(UText *ut,
 
 }
 
 
 }
 
-static const struct UTextFuncs unistrFuncs = 
+static const struct UTextFuncs unistrFuncs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
@@ -2241,8 +2257,8 @@ static const struct UTextFuncs unistrFuncs =
     unistrTextLength,
     unistrTextAccess,
     unistrTextExtract,
     unistrTextLength,
     unistrTextAccess,
     unistrTextExtract,
-    unistrTextReplace,   
-    unistrTextCopy,   
+    unistrTextReplace,
+    unistrTextCopy,
     NULL,                // MapOffsetToNative,
     NULL,                // MapIndexToUTF16,
     unistrTextClose,
     NULL,                // MapOffsetToNative,
     NULL,                // MapIndexToUTF16,
     unistrTextClose,
@@ -2258,20 +2274,9 @@ U_CDECL_END
 
 U_CAPI UText * U_EXPORT2
 utext_openUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) {
 
 U_CAPI UText * U_EXPORT2
 utext_openUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) {
-    // TODO:  use openConstUnicodeString, then add in the differences.
-    //
-    ut = utext_setup(ut, 0, status);
+    ut = utext_openConstUnicodeString(ut, s, status);
     if (U_SUCCESS(*status)) {
     if (U_SUCCESS(*status)) {
-        ut->pFuncs              = &unistrFuncs;
-        ut->context             = s;
-        ut->providerProperties  = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS)|
-                                  I32_FLAG(UTEXT_PROVIDER_WRITABLE);
-
-        ut->chunkContents       = s->getBuffer();
-        ut->chunkLength         = s->length();
-        ut->chunkNativeStart    = 0;
-        ut->chunkNativeLimit    = ut->chunkLength;
-        ut->nativeIndexingLimit = ut->chunkLength;
+        ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_WRITABLE);
     }
     return ut;
 }
     }
     return ut;
 }
@@ -2280,6 +2285,13 @@ utext_openUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) {
 
 U_CAPI UText * U_EXPORT2
 utext_openConstUnicodeString(UText *ut, const UnicodeString *s, UErrorCode *status) {
 
 U_CAPI UText * U_EXPORT2
 utext_openConstUnicodeString(UText *ut, const UnicodeString *s, UErrorCode *status) {
+    if (U_SUCCESS(*status) && s->isBogus()) {
+        // The UnicodeString is bogus, but we still need to detach the UText
+        //   from whatever it was hooked to before, if anything.
+        utext_openUChars(ut, NULL, 0, status);
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return ut;
+    }
     ut = utext_setup(ut, 0, status);
     //    note:  use the standard (writable) function table for UnicodeString.
     //           The flag settings disable writing, so having the functions in
     ut = utext_setup(ut, 0, status);
     //    note:  use the standard (writable) function table for UnicodeString.
     //           The flag settings disable writing, so having the functions in
@@ -2484,7 +2496,7 @@ ucstrTextExtract(UText *ut,
         return 0;
     }
 
         return 0;
     }
 
-    const UChar *s=(const UChar *)ut->context;
+    //const UChar *s=(const UChar *)ut->context;
     int32_t si, di;
 
     int32_t start32;
     int32_t si, di;
 
     int32_t start32;
@@ -2494,8 +2506,8 @@ ucstrTextExtract(UText *ut,
     //   Pins 'start' to the length of the string, if it came in out-of-bounds.
     //   Snaps 'start' to the beginning of a code point.
     ucstrTextAccess(ut, start, TRUE);
     //   Pins 'start' to the length of the string, if it came in out-of-bounds.
     //   Snaps 'start' to the beginning of a code point.
     ucstrTextAccess(ut, start, TRUE);
-    U_ASSERT(start <= INT32_MAX);
-    start32 = (int32_t)start;
+    const UChar *s=ut->chunkContents;
+    start32 = ut->chunkOffset;
 
     int32_t strLength=(int32_t)ut->a;
     if (strLength >= 0) {
 
     int32_t strLength=(int32_t)ut->a;
     if (strLength >= 0) {
@@ -2503,7 +2515,6 @@ ucstrTextExtract(UText *ut,
     } else {
         limit32 = pinIndex(limit, INT32_MAX);
     }
     } else {
         limit32 = pinIndex(limit, INT32_MAX);
     }
-
     di = 0;
     for (si=start32; si<limit32; si++) {
         if (strLength<0 && s[si]==0) {
     di = 0;
     for (si=start32; si<limit32; si++) {
         if (strLength<0 && s[si]==0) {
@@ -2515,6 +2526,7 @@ ucstrTextExtract(UText *ut,
             strLength               = si;
             break;
         }
             strLength               = si;
             break;
         }
+        U_ASSERT(di>=0); /* to ensure di never exceeds INT32_MAX, which must not happen logically */
         if (di<destCapacity) {
             // only store if there is space.
             dest[di] = s[si];
         if (di<destCapacity) {
             // only store if there is space.
             dest[di] = s[si];
@@ -2522,7 +2534,7 @@ ucstrTextExtract(UText *ut,
             if (strLength>=0) {
                 // We have filled the destination buffer, and the string length is known.
                 //  Cut the loop short.  There is no need to scan string termination.
             if (strLength>=0) {
                 // We have filled the destination buffer, and the string length is known.
                 //  Cut the loop short.  There is no need to scan string termination.
-                di = strLength;
+                di = limit32 - start32;
                 si = limit32;
                 break;
             }
                 si = limit32;
                 break;
             }
@@ -2542,7 +2554,7 @@ ucstrTextExtract(UText *ut,
     }
 
     // Put iteration position at the point just following the extracted text
     }
 
     // Put iteration position at the point just following the extracted text
-    ut->chunkOffset = si;
+    ut->chunkOffset = uprv_min(strLength, start32 + destCapacity);
 
     // Add a terminating NUL if space in the buffer permits,
     // and set the error status as required.
 
     // Add a terminating NUL if space in the buffer permits,
     // and set the error status as required.
@@ -2550,7 +2562,7 @@ ucstrTextExtract(UText *ut,
     return di;
 }
 
     return di;
 }
 
-static const struct UTextFuncs ucstrFuncs = 
+static const struct UTextFuncs ucstrFuncs =
 {
     sizeof(UTextFuncs),
     0, 0, 0,           // Reserved alignment padding
 {
     sizeof(UTextFuncs),
     0, 0, 0,           // Reserved alignment padding
@@ -2570,13 +2582,17 @@ static const struct UTextFuncs ucstrFuncs =
 
 U_CDECL_END
 
 
 U_CDECL_END
 
+static const UChar gEmptyUString[] = {0};
 
 U_CAPI UText * U_EXPORT2
 utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status) {
     if (U_FAILURE(*status)) {
         return NULL;
     }
 
 U_CAPI UText * U_EXPORT2
 utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status) {
     if (U_FAILURE(*status)) {
         return NULL;
     }
-    if (length < -1 || length>INT32_MAX) {
+    if(s==NULL && length==0) {
+        s = gEmptyUString;
+    }
+    if (s==NULL || length < -1 || length>INT32_MAX) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
@@ -2744,15 +2760,19 @@ charIterTextExtract(UText *ut,
     int32_t  limit32 = pinIndex(limit, length);
     int32_t  desti   = 0;
     int32_t  srci;
     int32_t  limit32 = pinIndex(limit, length);
     int32_t  desti   = 0;
     int32_t  srci;
+    int32_t  copyLimit;
 
     CharacterIterator *ci = (CharacterIterator *)ut->context;
     ci->setIndex32(start32);   // Moves ix to lead of surrogate pair, if needed.
     srci = ci->getIndex();
 
     CharacterIterator *ci = (CharacterIterator *)ut->context;
     ci->setIndex32(start32);   // Moves ix to lead of surrogate pair, if needed.
     srci = ci->getIndex();
+    copyLimit = srci;
     while (srci<limit32) {
         UChar32 c = ci->next32PostInc();
         int32_t  len = U16_LENGTH(c);
     while (srci<limit32) {
         UChar32 c = ci->next32PostInc();
         int32_t  len = U16_LENGTH(c);
+        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);
         if (desti+len <= destCapacity) {
             U16_APPEND_UNSAFE(dest, desti, c);
+            copyLimit = srci+len;
         } else {
             desti += len;
             *status = U_BUFFER_OVERFLOW_ERROR;
         } else {
             desti += len;
             *status = U_BUFFER_OVERFLOW_ERROR;
@@ -2760,11 +2780,13 @@ charIterTextExtract(UText *ut,
         srci += len;
     }
 
         srci += len;
     }
 
+    charIterTextAccess(ut, copyLimit, TRUE);
+
     u_terminateUChars(dest, destCapacity, desti, status);
     return desti;
 }
 
     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
 {
     sizeof(UTextFuncs),
     0, 0, 0,             // Reserved alignment padding
@@ -2824,6 +2846,3 @@ utext_openCharacterIterator(UText *ut, CharacterIterator *ci, UErrorCode *status
     }
     return ut;
 }
     }
     return ut;
 }
-
-
-