ICU-551.24.tar.gz

[apple/icu.git] / icuSources / common / unistr.cpp

diff --git a/icuSources/common/unistr.cpp b/icuSources/common/unistr.cpp
index 52fddf322146a96b1d345fb277d175f4a5442e7c..9997aa7b57ba7e1b2eb78717acfe20a9166501c6 100644 (file)
--- a/icuSources/common/unistr.cpp
+++ b/icuSources/common/unistr.cpp
@@ -1,7 +1,7 @@
 /*
 ******************************************************************************
 /*
 ******************************************************************************

-* Copyright (C) 1999-2008, International Business Machines Corporation and   *
-* others. All Rights Reserved.                                               *
+* Copyright (C) 1999-2014, International Business Machines Corporation and
+* others. All Rights Reserved.

 ******************************************************************************
 *
 * File unistr.cpp
 ******************************************************************************
 *
 * File unistr.cpp


@@ -19,23 +19,23 @@
 */
 
 #include "unicode/utypes.h"
 */
 
 #include "unicode/utypes.h"

+#include "unicode/appendable.h"

 #include "unicode/putil.h"
 #include "cstring.h"
 #include "cmemory.h"
 #include "unicode/ustring.h"
 #include "unicode/unistr.h"
 #include "unicode/putil.h"
 #include "cstring.h"
 #include "cmemory.h"
 #include "unicode/ustring.h"
 #include "unicode/unistr.h"

-#include "uhash.h"
+#include "unicode/utf.h"
+#include "unicode/utf16.h"
+#include "uelement.h"

 #include "ustr_imp.h"
 #include "umutex.h"
 #include "ustr_imp.h"
 #include "umutex.h"

+#include "uassert.h"

 
 #if 0
 
 
 #if 0
 

-#if U_IOSTREAM_SOURCE >= 199711

 #include <iostream>
 using namespace std;
 #include <iostream>
 using namespace std;

-#elif U_IOSTREAM_SOURCE >= 198506
-#include <iostream.h>
-#endif

 
 //DEBUGGING
 void
 
 //DEBUGGING
 void


@@ -90,7 +90,7 @@ us_arrayCopy(const UChar *src, int32_t srcStart,
 U_CDECL_BEGIN
 static UChar U_CALLCONV
 UnicodeString_charAt(int32_t offset, void *context) {
 U_CDECL_BEGIN
 static UChar U_CALLCONV
 UnicodeString_charAt(int32_t offset, void *context) {

-    return ((U_NAMESPACE_QUALIFIER UnicodeString*) context)->charAt(offset);
+    return ((icu::UnicodeString*) context)->charAt(offset);

 }
 U_CDECL_END
 
 }
 U_CDECL_END
 


@@ -100,7 +100,7 @@ U_NAMESPACE_BEGIN
    due to how AIX works with multiple definitions of virtual functions.
 */
 Replaceable::~Replaceable() {}
    due to how AIX works with multiple definitions of virtual functions.
 */
 Replaceable::~Replaceable() {}

-Replaceable::Replaceable() {}
+

 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeString)
 
 UnicodeString U_EXPORT2
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeString)
 
 UnicodeString U_EXPORT2


@@ -117,27 +117,23 @@ operator+ (const UnicodeString &s1, const UnicodeString &s2) {
 //========================================
 
 void
 //========================================
 
 void

-UnicodeString::addRef()
-{  umtx_atomic_inc((int32_t *)fUnion.fFields.fArray - 1);}
+UnicodeString::addRef() {
+  umtx_atomic_inc((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
+}

 
 int32_t
 
 int32_t

-UnicodeString::removeRef()
-{ return umtx_atomic_dec((int32_t *)fUnion.fFields.fArray - 1);}
+UnicodeString::removeRef() {
+  return umtx_atomic_dec((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
+}

 
 int32_t
 
 int32_t

-UnicodeString::refCount() const 
-{ 
-    umtx_lock(NULL);
-    // Note: without the lock to force a memory barrier, we might see a very
-    //       stale value on some multi-processor systems.
-    int32_t  count = *((int32_t *)fUnion.fFields.fArray - 1);
-    umtx_unlock(NULL);
-    return count;
- }
+UnicodeString::refCount() const {
+  return umtx_loadAcquire(*((u_atomic_int32_t *)fUnion.fFields.fArray - 1));
+}

 
 void
 UnicodeString::releaseArray() {
 
 void
 UnicodeString::releaseArray() {

-  if((fFlags & kRefCounted) && removeRef() == 0) {
+  if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) {

     uprv_free((int32_t *)fUnion.fFields.fArray - 1);
   }
 }
     uprv_free((int32_t *)fUnion.fFields.fArray - 1);
   }
 }


@@ -147,21 +143,17 @@ UnicodeString::releaseArray() {
 //========================================
 // Constructors
 //========================================
 //========================================
 // Constructors
 //========================================

-UnicodeString::UnicodeString()
-  : fShortLength(0),
-    fFlags(kShortString)
-{}
-
-UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count)
-  : fShortLength(0),
-    fFlags(0)
-{
+
+// The default constructor is inline in unistr.h.
+
+UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count) {
+  fUnion.fFields.fLengthAndFlags = 0;

   if(count <= 0 || (uint32_t)c > 0x10ffff) {
     // just allocate and do not do anything else
     allocate(capacity);
   } else {
     // count > 0, allocate and fill the new string with count c's
   if(count <= 0 || (uint32_t)c > 0x10ffff) {
     // just allocate and do not do anything else
     allocate(capacity);
   } else {
     // count > 0, allocate and fill the new string with count c's

-    int32_t unitCount = UTF_CHAR_LENGTH(c), length = count * unitCount;
+    int32_t unitCount = U16_LENGTH(c), length = count * unitCount;

     if(capacity < length) {
       capacity = length;
     }
     if(capacity < length) {
       capacity = length;
     }


@@ -177,8 +169,8 @@ UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count)
         }
       } else {
         // get the code units for c
         }
       } else {
         // get the code units for c

-        UChar units[UTF_MAX_CHAR_LENGTH];
-        UTF_APPEND_CHAR_UNSAFE(units, i, c);
+        UChar units[U16_MAX_LENGTH];
+        U16_APPEND_UNSAFE(units, i, c);

 
         // now it must be i==unitCount
         i = 0;
 
         // now it must be i==unitCount
         i = 0;


@@ -197,44 +189,38 @@ UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count)
   }
 }
 
   }
 }
 

-UnicodeString::UnicodeString(UChar ch)
-  : fShortLength(1),
-    fFlags(kShortString)
-{
-  fUnion.fStackBuffer[0] = ch;
+UnicodeString::UnicodeString(UChar ch) {
+  fUnion.fFields.fLengthAndFlags = kLength1 | kShortString;
+  fUnion.fStackFields.fBuffer[0] = ch;

 }
 
 }
 

-UnicodeString::UnicodeString(UChar32 ch)
-  : fShortLength(0),
-    fFlags(kShortString)
-{
+UnicodeString::UnicodeString(UChar32 ch) {
+  fUnion.fFields.fLengthAndFlags = kShortString;

   int32_t i = 0;
   UBool isError = FALSE;
   int32_t i = 0;
   UBool isError = FALSE;

-  U16_APPEND(fUnion.fStackBuffer, i, US_STACKBUF_SIZE, ch, isError);
-  fShortLength = (int8_t)i;
+  U16_APPEND(fUnion.fStackFields.fBuffer, i, US_STACKBUF_SIZE, ch, isError);
+  // We test isError so that the compiler does not complain that we don't.
+  // If isError then i==0 which is what we want anyway.
+  if(!isError) {
+    setShortLength(i);
+  }

 }
 
 }
 

-UnicodeString::UnicodeString(const UChar *text)
-  : fShortLength(0),
-    fFlags(kShortString)
-{
+UnicodeString::UnicodeString(const UChar *text) {
+  fUnion.fFields.fLengthAndFlags = kShortString;

   doReplace(0, 0, text, 0, -1);
 }
 
 UnicodeString::UnicodeString(const UChar *text,
   doReplace(0, 0, text, 0, -1);
 }
 
 UnicodeString::UnicodeString(const UChar *text,

-                             int32_t textLength)
-  : fShortLength(0),
-    fFlags(kShortString)
-{
+                             int32_t textLength) {
+  fUnion.fFields.fLengthAndFlags = kShortString;

   doReplace(0, 0, text, 0, textLength);
 }
 
 UnicodeString::UnicodeString(UBool isTerminated,
                              const UChar *text,
   doReplace(0, 0, text, 0, textLength);
 }
 
 UnicodeString::UnicodeString(UBool isTerminated,
                              const UChar *text,

-                             int32_t textLength)
-  : fShortLength(0),
-    fFlags(kReadonlyAlias)
-{
+                             int32_t textLength) {
+  fUnion.fFields.fLengthAndFlags = kReadonlyAlias;

   if(text == NULL) {
     // treat as an empty string, do not alias
     setToEmpty();
   if(text == NULL) {
     // treat as an empty string, do not alias
     setToEmpty();


@@ -254,10 +240,8 @@ UnicodeString::UnicodeString(UBool isTerminated,
 
 UnicodeString::UnicodeString(UChar *buff,
                              int32_t buffLength,
 
 UnicodeString::UnicodeString(UChar *buff,
                              int32_t buffLength,

-                             int32_t buffCapacity)
-  : fShortLength(0),
-    fFlags(kWritableAlias)
-{
+                             int32_t buffCapacity) {
+  fUnion.fFields.fLengthAndFlags = kWritableAlias;

   if(buff == NULL) {
     // treat as an empty string, do not alias
     setToEmpty();
   if(buff == NULL) {
     // treat as an empty string, do not alias
     setToEmpty();


@@ -276,10 +260,8 @@ UnicodeString::UnicodeString(UChar *buff,
   }
 }
 
   }
 }
 

-UnicodeString::UnicodeString(const char *src, int32_t length, EInvariant)
-  : fShortLength(0),
-    fFlags(kShortString)
-{
+UnicodeString::UnicodeString(const char *src, int32_t length, EInvariant) {
+  fUnion.fFields.fLengthAndFlags = kShortString;

   if(src==NULL) {
     // treat as an empty string
   } else {
   if(src==NULL) {
     // treat as an empty string
   } else {


@@ -295,30 +277,45 @@ UnicodeString::UnicodeString(const char *src, int32_t length, EInvariant)
   }
 }
 
   }
 }
 

-UnicodeString::UnicodeString(const UnicodeString& that)
-  : Replaceable(),
-    fShortLength(0),
-    fFlags(kShortString)
-{
+#if U_CHARSET_IS_UTF8
+
+UnicodeString::UnicodeString(const char *codepageData) {
+  fUnion.fFields.fLengthAndFlags = kShortString;
+  if(codepageData != 0) {
+    setToUTF8(codepageData);
+  }
+}
+
+UnicodeString::UnicodeString(const char *codepageData, int32_t dataLength) {
+  fUnion.fFields.fLengthAndFlags = kShortString;
+  // if there's nothing to convert, do nothing
+  if(codepageData == 0 || dataLength == 0 || dataLength < -1) {
+    return;
+  }
+  if(dataLength == -1) {
+    dataLength = (int32_t)uprv_strlen(codepageData);
+  }
+  setToUTF8(StringPiece(codepageData, dataLength));
+}
+
+// else see unistr_cnv.cpp
+#endif
+
+UnicodeString::UnicodeString(const UnicodeString& that) {
+  fUnion.fFields.fLengthAndFlags = kShortString;

   copyFrom(that);
 }
 
 UnicodeString::UnicodeString(const UnicodeString& that,
   copyFrom(that);
 }
 
 UnicodeString::UnicodeString(const UnicodeString& that,

-                             int32_t srcStart)
-  : Replaceable(),
-    fShortLength(0),
-    fFlags(kShortString)
-{
+                             int32_t srcStart) {
+  fUnion.fFields.fLengthAndFlags = kShortString;

   setTo(that, srcStart);
 }
 
 UnicodeString::UnicodeString(const UnicodeString& that,
                              int32_t srcStart,
   setTo(that, srcStart);
 }
 
 UnicodeString::UnicodeString(const UnicodeString& that,
                              int32_t srcStart,

-                             int32_t srcLength)
-  : Replaceable(),
-    fShortLength(0),
-    fFlags(kShortString)
-{
+                             int32_t srcLength) {
+  fUnion.fFields.fLengthAndFlags = kShortString;

   setTo(that, srcStart, srcLength);
 }
 
   setTo(that, srcStart, srcLength);
 }
 


@@ -341,12 +338,13 @@ UnicodeString::clone() const {
 UBool
 UnicodeString::allocate(int32_t capacity) {
   if(capacity <= US_STACKBUF_SIZE) {
 UBool
 UnicodeString::allocate(int32_t capacity) {
   if(capacity <= US_STACKBUF_SIZE) {

-    fFlags = kShortString;
+    fUnion.fFields.fLengthAndFlags = kShortString;

   } else {
     // count bytes for the refCounter and the string capacity, and
     // round up to a multiple of 16; then divide by 4 and allocate int32_t's
     // to be safely aligned for the refCount
   } else {
     // count bytes for the refCounter and the string capacity, and
     // round up to a multiple of 16; then divide by 4 and allocate int32_t's
     // to be safely aligned for the refCount

-    int32_t words = (int32_t)(((sizeof(int32_t) + capacity * U_SIZEOF_UCHAR + 15) & ~15) >> 2);
+    // the +1 is for the NUL terminator, to avoid reallocation in getTerminatedBuffer()
+    int32_t words = (int32_t)(((sizeof(int32_t) + (capacity + 1) * U_SIZEOF_UCHAR + 15) & ~15) >> 2);

     int32_t *array = (int32_t*) uprv_malloc( sizeof(int32_t) * words );
     if(array != 0) {
       // set initial refCount and point behind the refCount
     int32_t *array = (int32_t*) uprv_malloc( sizeof(int32_t) * words );
     if(array != 0) {
       // set initial refCount and point behind the refCount


@@ -355,12 +353,11 @@ UnicodeString::allocate(int32_t capacity) {
       // have fArray point to the first UChar
       fUnion.fFields.fArray = (UChar *)array;
       fUnion.fFields.fCapacity = (int32_t)((words - 1) * (sizeof(int32_t) / U_SIZEOF_UCHAR));
       // have fArray point to the first UChar
       fUnion.fFields.fArray = (UChar *)array;
       fUnion.fFields.fCapacity = (int32_t)((words - 1) * (sizeof(int32_t) / U_SIZEOF_UCHAR));

-      fFlags = kLongString;
+      fUnion.fFields.fLengthAndFlags = kLongString;

     } else {
     } else {

-      fShortLength = 0;
+      fUnion.fFields.fLengthAndFlags = kIsBogus;

       fUnion.fFields.fArray = 0;
       fUnion.fFields.fCapacity = 0;
       fUnion.fFields.fArray = 0;
       fUnion.fFields.fCapacity = 0;

-      fFlags = kIsBogus;

       return FALSE;
     }
   }
       return FALSE;
     }
   }


@@ -375,6 +372,47 @@ UnicodeString::~UnicodeString()
   releaseArray();
 }
 
   releaseArray();
 }
 

+//========================================
+// Factory methods
+//========================================
+
+UnicodeString UnicodeString::fromUTF8(const StringPiece &utf8) {
+  UnicodeString result;
+  result.setToUTF8(utf8);
+  return result;
+}
+
+UnicodeString UnicodeString::fromUTF32(const UChar32 *utf32, int32_t length) {
+  UnicodeString result;
+  int32_t capacity;
+  // Most UTF-32 strings will be BMP-only and result in a same-length
+  // UTF-16 string. We overestimate the capacity just slightly,
+  // just in case there are a few supplementary characters.
+  if(length <= US_STACKBUF_SIZE) {
+    capacity = US_STACKBUF_SIZE;
+  } else {
+    capacity = length + (length >> 4) + 4;
+  }
+  do {
+    UChar *utf16 = result.getBuffer(capacity);
+    int32_t length16;
+    UErrorCode errorCode = U_ZERO_ERROR;
+    u_strFromUTF32WithSub(utf16, result.getCapacity(), &length16,
+        utf32, length,
+        0xfffd,  // Substitution character.
+        NULL,    // Don't care about number of substitutions.
+        &errorCode);
+    result.releaseBuffer(length16);
+    if(errorCode == U_BUFFER_OVERFLOW_ERROR) {
+      capacity = length16 + 1;  // +1 for the terminating NUL.
+      continue;
+    } else if(U_FAILURE(errorCode)) {
+      result.setToBogus();
+    }
+    break;
+  } while(TRUE);
+  return result;
+}

 
 //========================================
 // Assignment
 
 //========================================
 // Assignment


@@ -393,12 +431,12 @@ UnicodeString::fastCopyFrom(const UnicodeString &src) {
 UnicodeString &
 UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) {
   // if assigning to ourselves, do nothing
 UnicodeString &
 UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) {
   // if assigning to ourselves, do nothing

-  if(this == 0 || this == &src) {
+  if(this == &src) {

     return *this;
   }
 
   // is the right side bogus?
     return *this;
   }
 
   // is the right side bogus?

-  if(&src == 0 || src.isBogus()) {
+  if(src.isBogus()) {

     setToBogus();
     return *this;
   }
     setToBogus();
     return *this;
   }


@@ -412,25 +450,24 @@ UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) {
     return *this;
   }
 
     return *this;
   }
 

-  // we always copy the length
-  int32_t srcLength = src.length();
-  setLength(srcLength);
-

   // fLength>0 and not an "open" src.getBuffer(minCapacity)
   // fLength>0 and not an "open" src.getBuffer(minCapacity)

-  switch(src.fFlags) {
+  fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags;
+  switch(src.fUnion.fFields.fLengthAndFlags & kAllStorageFlags) {

   case kShortString:
     // short string using the stack buffer, do the same
   case kShortString:
     // short string using the stack buffer, do the same

-    fFlags = kShortString;
-    uprv_memcpy(fUnion.fStackBuffer, src.fUnion.fStackBuffer, fShortLength * U_SIZEOF_UCHAR);
+    uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer,
+                getShortLength() * U_SIZEOF_UCHAR);

     break;
   case kLongString:
     // src uses a refCounted string buffer, use that buffer with refCount
     break;
   case kLongString:
     // src uses a refCounted string buffer, use that buffer with refCount

-    // src is const, use a cast - we don't really change it
+    // src is const, use a cast - we don't actually change it

     ((UnicodeString &)src).addRef();
     // copy all fields, share the reference-counted buffer
     fUnion.fFields.fArray = src.fUnion.fFields.fArray;
     fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;
     ((UnicodeString &)src).addRef();
     // copy all fields, share the reference-counted buffer
     fUnion.fFields.fArray = src.fUnion.fFields.fArray;
     fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;

-    fFlags = src.fFlags;
+    if(!hasShortLength()) {
+      fUnion.fFields.fLength = src.fUnion.fFields.fLength;
+    }

     break;
   case kReadonlyAlias:
     if(fastCopy) {
     break;
   case kReadonlyAlias:
     if(fastCopy) {


@@ -438,25 +475,29 @@ UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) {
       // -> maintain the readonly alias as such
       fUnion.fFields.fArray = src.fUnion.fFields.fArray;
       fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;
       // -> maintain the readonly alias as such
       fUnion.fFields.fArray = src.fUnion.fFields.fArray;
       fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;

-      fFlags = src.fFlags;
+      if(!hasShortLength()) {
+        fUnion.fFields.fLength = src.fUnion.fFields.fLength;
+      }

       break;
     }
     // else if(!fastCopy) fall through to case kWritableAlias
     // -> allocate a new buffer and copy the contents
       break;
     }
     // else if(!fastCopy) fall through to case kWritableAlias
     // -> allocate a new buffer and copy the contents

-  case kWritableAlias:
+  case kWritableAlias: {

     // src is a writable alias; we make a copy of that instead
     // src is a writable alias; we make a copy of that instead

+    int32_t srcLength = src.length();

     if(allocate(srcLength)) {
       uprv_memcpy(getArrayStart(), src.getArrayStart(), srcLength * U_SIZEOF_UCHAR);
     if(allocate(srcLength)) {
       uprv_memcpy(getArrayStart(), src.getArrayStart(), srcLength * U_SIZEOF_UCHAR);

+      setLength(srcLength);

       break;
     }
     // if there is not enough memory, then fall through to setting to bogus
       break;
     }
     // if there is not enough memory, then fall through to setting to bogus

+  }

   default:
     // if src is bogus, set ourselves to bogus
   default:
     // if src is bogus, set ourselves to bogus

-    // do not call setToBogus() here because fArray and fFlags are not consistent here
-    fShortLength = 0;
+    // do not call setToBogus() here because fArray and flags are not consistent here
+    fUnion.fFields.fLengthAndFlags = kIsBogus;

     fUnion.fFields.fArray = 0;
     fUnion.fFields.fCapacity = 0;
     fUnion.fFields.fArray = 0;
     fUnion.fFields.fCapacity = 0;

-    fFlags = kIsBogus;

     break;
   }
 
     break;
   }
 


@@ -498,6 +539,13 @@ UChar32 UnicodeString::unescapeAt(int32_t &offset) const {
 //========================================
 // Read-only implementation
 //========================================
 //========================================
 // Read-only implementation
 //========================================

+UBool
+UnicodeString::doEquals(const UnicodeString &text, int32_t len) const {
+  // Requires: this & text not bogus and have same lengths.
+  // Byte-wise comparison works for equality regardless of endianness.
+  return uprv_memcmp(getArrayStart(), text.getArrayStart(), len * U_SIZEOF_UCHAR) == 0;
+}
+

 int8_t
 UnicodeString::doCompare( int32_t start,
               int32_t length,
 int8_t
 UnicodeString::doCompare( int32_t start,
               int32_t length,


@@ -506,7 +554,6 @@ UnicodeString::doCompare( int32_t start,
               int32_t srcLength) const
 {
   // compare illegal string values
               int32_t srcLength) const
 {
   // compare illegal string values

-  // treat const UChar *srcChars==NULL as an empty string

   if(isBogus()) {
     return -1;
   }
   if(isBogus()) {
     return -1;
   }


@@ -515,7 +562,8 @@ UnicodeString::doCompare( int32_t start,
   pinIndices(start, length);
 
   if(srcChars == NULL) {
   pinIndices(start, length);
 
   if(srcChars == NULL) {

-    srcStart = srcLength = 0;
+    // treat const UChar *srcChars==NULL as an empty string
+    return length == 0 ? 0 : 1;

   }
 
   // get the correct pointer
   }
 
   // get the correct pointer


@@ -597,7 +645,7 @@ UnicodeString::doCompareCodePointOrder(int32_t start,
     srcStart = srcLength = 0;
   }
 
     srcStart = srcLength = 0;
   }
 

-  int32_t diff = uprv_strCompare(getArrayStart() + start, length, srcChars + srcStart, srcLength, FALSE, TRUE);
+  int32_t diff = uprv_strCompare(getArrayStart() + start, length, (srcChars!=NULL)?(srcChars + srcStart):NULL, srcLength, FALSE, TRUE);

   /* translate the 32-bit result into an 8-bit one */
   if(diff!=0) {
     return (int8_t)(diff >> 15 | 1);
   /* translate the 32-bit result into an 8-bit one */
   if(diff!=0) {
     return (int8_t)(diff >> 15 | 1);


@@ -621,6 +669,43 @@ UnicodeString::getChar32At(int32_t offset) const {
   return char32At(offset);
 }
 
   return char32At(offset);
 }
 

+UChar32
+UnicodeString::char32At(int32_t offset) const
+{
+  int32_t len = length();
+  if((uint32_t)offset < (uint32_t)len) {
+    const UChar *array = getArrayStart();
+    UChar32 c;
+    U16_GET(array, 0, offset, len, c);
+    return c;
+  } else {
+    return kInvalidUChar;
+  }
+}
+
+int32_t
+UnicodeString::getChar32Start(int32_t offset) const {
+  if((uint32_t)offset < (uint32_t)length()) {
+    const UChar *array = getArrayStart();
+    U16_SET_CP_START(array, 0, offset);
+    return offset;
+  } else {
+    return 0;
+  }
+}
+
+int32_t
+UnicodeString::getChar32Limit(int32_t offset) const {
+  int32_t len = length();
+  if((uint32_t)offset < (uint32_t)len) {
+    const UChar *array = getArrayStart();
+    U16_SET_CP_LIMIT(array, 0, offset, len);
+    return offset;
+  } else {
+    return len;
+  }
+}
+

 int32_t
 UnicodeString::countChar32(int32_t start, int32_t length) const {
   pinIndices(start, length);
 int32_t
 UnicodeString::countChar32(int32_t start, int32_t length) const {
   pinIndices(start, length);


@@ -647,9 +732,9 @@ UnicodeString::moveIndex32(int32_t index, int32_t delta) const {
 
   const UChar *array = getArrayStart();
   if(delta>0) {
 
   const UChar *array = getArrayStart();
   if(delta>0) {

-    UTF_FWD_N(array, index, len, delta);
+    U16_FWD_N(array, index, len, delta);

   } else {
   } else {

-    UTF_BACK_N(array, 0, index, -delta);
+    U16_BACK_N(array, 0, index, -delta);

   }
 
   return index;
   }
 
   return index;


@@ -712,6 +797,46 @@ UnicodeString::extract(int32_t start,
   return u_terminateChars(target, targetCapacity, length, &status);
 }
 
   return u_terminateChars(target, targetCapacity, length, &status);
 }
 

+UnicodeString
+UnicodeString::tempSubString(int32_t start, int32_t len) const {
+  pinIndices(start, len);
+  const UChar *array = getBuffer();  // not getArrayStart() to check kIsBogus & kOpenGetBuffer
+  if(array==NULL) {
+    array=fUnion.fStackFields.fBuffer;  // anything not NULL because that would make an empty string
+    len=-2;  // bogus result string
+  }
+  return UnicodeString(FALSE, array + start, len);
+}
+
+int32_t
+UnicodeString::toUTF8(int32_t start, int32_t len,
+                      char *target, int32_t capacity) const {
+  pinIndices(start, len);
+  int32_t length8;
+  UErrorCode errorCode = U_ZERO_ERROR;
+  u_strToUTF8WithSub(target, capacity, &length8,
+                     getBuffer() + start, len,
+                     0xFFFD,  // Standard substitution character.
+                     NULL,    // Don't care about number of substitutions.
+                     &errorCode);
+  return length8;
+}
+
+#if U_CHARSET_IS_UTF8
+
+int32_t
+UnicodeString::extract(int32_t start, int32_t len,
+                       char *target, uint32_t dstSize) const {
+  // if the arguments are illegal, then do nothing
+  if(/*dstSize < 0 || */(dstSize > 0 && target == 0)) {
+    return 0;
+  }
+  return toUTF8(start, len, target, dstSize <= 0x7fffffff ? (int32_t)dstSize : 0x7fffffff);
+}
+
+// else see unistr_cnv.cpp
+#endif
+

 void 
 UnicodeString::extractBetween(int32_t start,
                   int32_t limit,
 void 
 UnicodeString::extractBetween(int32_t start,
                   int32_t limit,


@@ -721,6 +846,66 @@ UnicodeString::extractBetween(int32_t start,
   doExtract(start, limit - start, target);
 }
 
   doExtract(start, limit - start, target);
 }
 

+// When converting from UTF-16 to UTF-8, the result will have at most 3 times
+// as many bytes as the source has UChars.
+// The "worst cases" are writing systems like Indic, Thai and CJK with
+// 3:1 bytes:UChars.
+void
+UnicodeString::toUTF8(ByteSink &sink) const {
+  int32_t length16 = length();
+  if(length16 != 0) {
+    char stackBuffer[1024];
+    int32_t capacity = (int32_t)sizeof(stackBuffer);
+    UBool utf8IsOwned = FALSE;
+    char *utf8 = sink.GetAppendBuffer(length16 < capacity ? length16 : capacity,
+                                      3*length16,
+                                      stackBuffer, capacity,
+                                      &capacity);
+    int32_t length8 = 0;
+    UErrorCode errorCode = U_ZERO_ERROR;
+    u_strToUTF8WithSub(utf8, capacity, &length8,
+                       getBuffer(), length16,
+                       0xFFFD,  // Standard substitution character.
+                       NULL,    // Don't care about number of substitutions.
+                       &errorCode);
+    if(errorCode == U_BUFFER_OVERFLOW_ERROR) {
+      utf8 = (char *)uprv_malloc(length8);
+      if(utf8 != NULL) {
+        utf8IsOwned = TRUE;
+        errorCode = U_ZERO_ERROR;
+        u_strToUTF8WithSub(utf8, length8, &length8,
+                           getBuffer(), length16,
+                           0xFFFD,  // Standard substitution character.
+                           NULL,    // Don't care about number of substitutions.
+                           &errorCode);
+      } else {
+        errorCode = U_MEMORY_ALLOCATION_ERROR;
+      }
+    }
+    if(U_SUCCESS(errorCode)) {
+      sink.Append(utf8, length8);
+      sink.Flush();
+    }
+    if(utf8IsOwned) {
+      uprv_free(utf8);
+    }
+  }
+}
+
+int32_t
+UnicodeString::toUTF32(UChar32 *utf32, int32_t capacity, UErrorCode &errorCode) const {
+  int32_t length32=0;
+  if(U_SUCCESS(errorCode)) {
+    // getBuffer() and u_strToUTF32WithSub() check for illegal arguments.
+    u_strToUTF32WithSub(utf32, capacity, &length32,
+        getBuffer(), length(),
+        0xfffd,  // Substitution character.
+        NULL,    // Don't care about number of substitutions.
+        &errorCode);
+  }
+  return length32;
+}
+

 int32_t 
 UnicodeString::indexOf(const UChar *srcChars,
                int32_t srcStart,
 int32_t 
 UnicodeString::indexOf(const UChar *srcChars,
                int32_t srcStart,


@@ -901,27 +1086,64 @@ UnicodeString::setToBogus()
 {
   releaseArray();
 
 {
   releaseArray();
 

-  fShortLength = 0;
+  fUnion.fFields.fLengthAndFlags = kIsBogus;

   fUnion.fFields.fArray = 0;
   fUnion.fFields.fCapacity = 0;
   fUnion.fFields.fArray = 0;
   fUnion.fFields.fCapacity = 0;

-  fFlags = kIsBogus;

 }
 
 // turn a bogus string into an empty one
 void
 UnicodeString::unBogus() {
 }
 
 // turn a bogus string into an empty one
 void
 UnicodeString::unBogus() {

-  if(fFlags & kIsBogus) {
+  if(fUnion.fFields.fLengthAndFlags & kIsBogus) {

     setToEmpty();
   }
 }
 
     setToEmpty();
   }
 }
 

+const UChar *
+UnicodeString::getTerminatedBuffer() {
+  if(!isWritable()) {
+    return 0;
+  }
+  UChar *array = getArrayStart();
+  int32_t len = length();
+  if(len < getCapacity()) {
+    if(fUnion.fFields.fLengthAndFlags & kBufferIsReadonly) {
+      // If len<capacity on a read-only alias, then array[len] is
+      // either the original NUL (if constructed with (TRUE, s, length))
+      // or one of the original string contents characters (if later truncated),
+      // therefore we can assume that array[len] is initialized memory.
+      if(array[len] == 0) {
+        return array;
+      }
+    } else if(((fUnion.fFields.fLengthAndFlags & kRefCounted) == 0 || refCount() == 1)) {
+      // kRefCounted: Do not write the NUL if the buffer is shared.
+      // That is mostly safe, except when the length of one copy was modified
+      // without copy-on-write, e.g., via truncate(newLength) or remove(void).
+      // Then the NUL would be written into the middle of another copy's string.
+
+      // Otherwise, the buffer is fully writable and it is anyway safe to write the NUL.
+      // Do not test if there is a NUL already because it might be uninitialized memory.
+      // (That would be safe, but tools like valgrind & Purify would complain.)
+      array[len] = 0;
+      return array;
+    }
+  }
+  if(cloneArrayIfNeeded(len+1)) {
+    array = getArrayStart();
+    array[len] = 0;
+    return array;
+  } else {
+    return NULL;
+  }
+}
+

 // setTo() analogous to the readonly-aliasing constructor with the same signature
 UnicodeString &
 UnicodeString::setTo(UBool isTerminated,
                      const UChar *text,
                      int32_t textLength)
 {
 // setTo() analogous to the readonly-aliasing constructor with the same signature
 UnicodeString &
 UnicodeString::setTo(UBool isTerminated,
                      const UChar *text,
                      int32_t textLength)
 {

-  if(fFlags & kOpenGetBuffer) {
+  if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {

     // do not modify a string that has an "open" getBuffer(minCapacity)
     return *this;
   }
     // do not modify a string that has an "open" getBuffer(minCapacity)
     return *this;
   }


@@ -947,9 +1169,8 @@ UnicodeString::setTo(UBool isTerminated,
     // text is terminated, or else it would have failed the above test
     textLength = u_strlen(text);
   }
     // text is terminated, or else it would have failed the above test
     textLength = u_strlen(text);
   }

+  fUnion.fFields.fLengthAndFlags = kReadonlyAlias;

   setArray((UChar *)text, textLength, isTerminated ? textLength + 1 : textLength);
   setArray((UChar *)text, textLength, isTerminated ? textLength + 1 : textLength);

-
-  fFlags = kReadonlyAlias;

   return *this;
 }
 
   return *this;
 }
 


@@ -958,7 +1179,7 @@ UnicodeString &
 UnicodeString::setTo(UChar *buffer,
                      int32_t buffLength,
                      int32_t buffCapacity) {
 UnicodeString::setTo(UChar *buffer,
                      int32_t buffLength,
                      int32_t buffCapacity) {

-  if(fFlags & kOpenGetBuffer) {
+  if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {

     // do not modify a string that has an "open" getBuffer(minCapacity)
     return *this;
   }
     // do not modify a string that has an "open" getBuffer(minCapacity)
     return *this;
   }


@@ -984,8 +1205,33 @@ UnicodeString::setTo(UChar *buffer,
 
   releaseArray();
 
 
   releaseArray();
 

+  fUnion.fFields.fLengthAndFlags = kWritableAlias;

   setArray(buffer, buffLength, buffCapacity);
   setArray(buffer, buffLength, buffCapacity);

-  fFlags = kWritableAlias;
+  return *this;
+}
+
+UnicodeString &UnicodeString::setToUTF8(const StringPiece &utf8) {
+  unBogus();
+  int32_t length = utf8.length();
+  int32_t capacity;
+  // The UTF-16 string will be at most as long as the UTF-8 string.
+  if(length <= US_STACKBUF_SIZE) {
+    capacity = US_STACKBUF_SIZE;
+  } else {
+    capacity = length + 1;  // +1 for the terminating NUL.
+  }
+  UChar *utf16 = getBuffer(capacity);
+  int32_t length16;
+  UErrorCode errorCode = U_ZERO_ERROR;
+  u_strFromUTF8WithSub(utf16, getCapacity(), &length16,
+      utf8.data(), length,
+      0xfffd,  // Substitution character.
+      NULL,    // Don't care about number of substitutions.
+      &errorCode);
+  releaseBuffer(length16);
+  if(U_FAILURE(errorCode)) {
+    setToBogus();
+  }

   return *this;
 }
 
   return *this;
 }
 


@@ -1006,6 +1252,31 @@ UnicodeString::setCharAt(int32_t offset,
   return *this;
 }
 
   return *this;
 }
 

+UnicodeString&
+UnicodeString::replace(int32_t start,
+               int32_t _length,
+               UChar32 srcChar) {
+  UChar buffer[U16_MAX_LENGTH];
+  int32_t count = 0;
+  UBool isError = FALSE;
+  U16_APPEND(buffer, count, U16_MAX_LENGTH, srcChar, isError);
+  // We test isError so that the compiler does not complain that we don't.
+  // If isError (srcChar is not a valid code point) then count==0 which means
+  // we remove the source segment rather than replacing it with srcChar.
+  return doReplace(start, _length, buffer, 0, isError ? 0 : count);
+}
+
+UnicodeString&
+UnicodeString::append(UChar32 srcChar) {
+  UChar buffer[U16_MAX_LENGTH];
+  int32_t _length = 0;
+  UBool isError = FALSE;
+  U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError);
+  // We test isError so that the compiler does not complain that we don't.
+  // If isError then _length==0 which turns the doReplace() into a no-op anyway.
+  return isError ? *this : doReplace(length(), 0, buffer, 0, _length);
+}
+

 UnicodeString&
 UnicodeString::doReplace( int32_t start,
               int32_t length,
 UnicodeString&
 UnicodeString::doReplace( int32_t start,
               int32_t length,


@@ -1037,6 +1308,28 @@ UnicodeString::doReplace(int32_t start,
     return *this;
   }
 
     return *this;
   }
 

+  int32_t oldLength = this->length();
+
+  // optimize (read-only alias).remove(0, start) and .remove(start, end)
+  if((fUnion.fFields.fLengthAndFlags&kBufferIsReadonly) && srcLength == 0) {
+    if(start == 0) {
+      // remove prefix by adjusting the array pointer
+      pinIndex(length);
+      fUnion.fFields.fArray += length;
+      fUnion.fFields.fCapacity -= length;
+      setLength(oldLength - length);
+      return *this;
+    } else {
+      pinIndex(start);
+      if(length >= (oldLength - start)) {
+        // remove suffix by reducing the length (like truncate())
+        setLength(start);
+        fUnion.fFields.fCapacity = start;  // not NUL-terminated any more
+        return *this;
+      }
+    }
+  }
+

   if(srcChars == 0) {
     srcStart = srcLength = 0;
   } else if(srcLength < 0) {
   if(srcChars == 0) {
     srcStart = srcLength = 0;
   } else if(srcLength < 0) {


@@ -1044,17 +1337,28 @@ UnicodeString::doReplace(int32_t start,
     srcLength = u_strlen(srcChars + srcStart);
   }
 
     srcLength = u_strlen(srcChars + srcStart);
   }
 

-  int32_t oldLength = this->length();
-

   // calculate the size of the string after the replace
   // calculate the size of the string after the replace

-  int32_t newSize;
+  int32_t newLength;

 
   // optimize append() onto a large-enough, owned string
   if(start >= oldLength) {
 
   // optimize append() onto a large-enough, owned string
   if(start >= oldLength) {

-    newSize = oldLength + srcLength;
-    if(newSize <= getCapacity() && isBufferWritable()) {
-      us_arrayCopy(srcChars, srcStart, getArrayStart(), oldLength, srcLength);
-      setLength(newSize);
+    if(srcLength == 0) {
+      return *this;
+    }
+    newLength = oldLength + srcLength;
+    if(newLength <= getCapacity() && isBufferWritable()) {
+      UChar *oldArray = getArrayStart();
+      // Do not copy characters when
+      //   UChar *buffer=str.getAppendBuffer(...);
+      // is followed by
+      //   str.append(buffer, length);
+      // or
+      //   str.appendString(buffer, length)
+      // or similar.
+      if(srcChars + srcStart != oldArray + start || start > oldLength) {
+        us_arrayCopy(srcChars, srcStart, oldArray, oldLength, srcLength);
+      }
+      setLength(newLength);

       return *this;
     } else {
       // pin the indices to legal values
       return *this;
     } else {
       // pin the indices to legal values


@@ -1065,17 +1369,17 @@ UnicodeString::doReplace(int32_t start,
     // pin the indices to legal values
     pinIndices(start, length);
 
     // pin the indices to legal values
     pinIndices(start, length);
 

-    newSize = oldLength - length + srcLength;
+    newLength = oldLength - length + srcLength;

   }
 
   // the following may change fArray but will not copy the current contents;
   // therefore we need to keep the current fArray
   UChar oldStackBuffer[US_STACKBUF_SIZE];
   UChar *oldArray;
   }
 
   // the following may change fArray but will not copy the current contents;
   // therefore we need to keep the current fArray
   UChar oldStackBuffer[US_STACKBUF_SIZE];
   UChar *oldArray;

-  if((fFlags&kUsingStackBuffer) && (newSize > US_STACKBUF_SIZE)) {
+  if((fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) && (newLength > US_STACKBUF_SIZE)) {

     // copy the stack buffer contents because it will be overwritten with
     // fUnion.fFields values
     // copy the stack buffer contents because it will be overwritten with
     // fUnion.fFields values

-    u_memcpy(oldStackBuffer, fUnion.fStackBuffer, oldLength);
+    u_memcpy(oldStackBuffer, fUnion.fStackFields.fBuffer, oldLength);

     oldArray = oldStackBuffer;
   } else {
     oldArray = getArrayStart();
     oldArray = oldStackBuffer;
   } else {
     oldArray = getArrayStart();


@@ -1083,7 +1387,7 @@ UnicodeString::doReplace(int32_t start,
 
   // clone our array and allocate a bigger array if needed
   int32_t *bufferToDelete = 0;
 
   // clone our array and allocate a bigger array if needed
   int32_t *bufferToDelete = 0;

-  if(!cloneArrayIfNeeded(newSize, newSize + (newSize >> 2) + kGrowSize,
+  if(!cloneArrayIfNeeded(newLength, newLength + (newLength >> 2) + kGrowSize,

                          FALSE, &bufferToDelete)
   ) {
     return *this;
                          FALSE, &bufferToDelete)
   ) {
     return *this;


@@ -1108,7 +1412,7 @@ UnicodeString::doReplace(int32_t start,
   // now fill in the hole with the new string
   us_arrayCopy(srcChars, srcStart, newArray, start, srcLength);
 
   // now fill in the hole with the new string
   us_arrayCopy(srcChars, srcStart, newArray, start, srcLength);
 

-  setLength(newSize);
+  setLength(newLength);

 
   // delayed delete in case srcChars == fArray when we started, and
   // to keep oldArray alive for the above operations
 
   // delayed delete in case srcChars == fArray when we started, and
   // to keep oldArray alive for the above operations


@@ -1164,26 +1468,31 @@ UBool UnicodeString::hasMetaData() const {
 }
 
 UnicodeString&
 }
 
 UnicodeString&

-UnicodeString::doReverse(int32_t start,
-             int32_t length)
-{
-  if(this->length() <= 1 || !cloneArrayIfNeeded()) {
+UnicodeString::doReverse(int32_t start, int32_t length) {
+  if(length <= 1 || !cloneArrayIfNeeded()) {

     return *this;
   }
 
   // pin the indices to legal values
   pinIndices(start, length);
     return *this;
   }
 
   // pin the indices to legal values
   pinIndices(start, length);

+  if(length <= 1) {  // pinIndices() might have shrunk the length
+    return *this;
+  }

 
   UChar *left = getArrayStart() + start;
 
   UChar *left = getArrayStart() + start;

-  UChar *right = left + length;
+  UChar *right = left + length - 1;  // -1 for inclusive boundary (length>=2)

   UChar swap;
   UBool hasSupplementary = FALSE;
 
   UChar swap;
   UBool hasSupplementary = FALSE;
 

-  while(left < --right) {
-    hasSupplementary |= (UBool)UTF_IS_LEAD(swap = *left);
-    hasSupplementary |= (UBool)UTF_IS_LEAD(*left++ = *right);
-    *right = swap;
-  }
+  // Before the loop we know left<right because length>=2.
+  do {
+    hasSupplementary |= (UBool)U16_IS_LEAD(swap = *left);
+    hasSupplementary |= (UBool)U16_IS_LEAD(*left++ = *right);
+    *right-- = swap;
+  } while(left < right);
+  // Make sure to test the middle code unit of an odd-length string.
+  // Redundant if the length is even.
+  hasSupplementary |= (UBool)U16_IS_LEAD(*left);

 
   /* if there are supplementary code points in the reversed range, then re-swap their surrogates */
   if(hasSupplementary) {
 
   /* if there are supplementary code points in the reversed range, then re-swap their surrogates */
   if(hasSupplementary) {


@@ -1192,7 +1501,7 @@ UnicodeString::doReverse(int32_t start,
     left = getArrayStart() + start;
     right = left + length - 1; // -1 so that we can look at *(left+1) if left<right
     while(left < right) {
     left = getArrayStart() + start;
     right = left + length - 1; // -1 so that we can look at *(left+1) if left<right
     while(left < right) {

-      if(UTF_IS_TRAIL(swap = *left) && UTF_IS_LEAD(swap2 = *(left + 1))) {
+      if(U16_IS_TRAIL(swap = *left) && U16_IS_LEAD(swap2 = *(left + 1))) {

         *left++ = swap2;
         *left++ = swap;
       } else {
         *left++ = swap2;
         *left++ = swap;
       } else {


@@ -1253,7 +1562,7 @@ UnicodeString::doHashCode() const
 {
     /* Delegate hash computation to uhash.  This makes UnicodeString
      * hashing consistent with UChar* hashing.  */
 {
     /* Delegate hash computation to uhash.  This makes UnicodeString
      * hashing consistent with UChar* hashing.  */

-    int32_t hashCode = uhash_hashUCharsN(getArrayStart(), length());
+    int32_t hashCode = ustr_hashUCharsN(getArrayStart(), length());

     if (hashCode == kInvalidHashCode) {
         hashCode = kEmptyHashCode;
     }
     if (hashCode == kInvalidHashCode) {
         hashCode = kEmptyHashCode;
     }


@@ -1267,8 +1576,8 @@ UnicodeString::doHashCode() const
 UChar *
 UnicodeString::getBuffer(int32_t minCapacity) {
   if(minCapacity>=-1 && cloneArrayIfNeeded(minCapacity)) {
 UChar *
 UnicodeString::getBuffer(int32_t minCapacity) {
   if(minCapacity>=-1 && cloneArrayIfNeeded(minCapacity)) {

-    fFlags|=kOpenGetBuffer;
-    fShortLength=0;
+    fUnion.fFields.fLengthAndFlags|=kOpenGetBuffer;
+    setZeroLength();

     return getArrayStart();
   } else {
     return 0;
     return getArrayStart();
   } else {
     return 0;


@@ -1277,7 +1586,7 @@ UnicodeString::getBuffer(int32_t minCapacity) {
 
 void
 UnicodeString::releaseBuffer(int32_t newLength) {
 
 void
 UnicodeString::releaseBuffer(int32_t newLength) {

-  if(fFlags&kOpenGetBuffer && newLength>=-1) {
+  if(fUnion.fFields.fLengthAndFlags&kOpenGetBuffer && newLength>=-1) {

     // set the new fLength
     int32_t capacity=getCapacity();
     if(newLength==-1) {
     // set the new fLength
     int32_t capacity=getCapacity();
     if(newLength==-1) {


@@ -1291,7 +1600,7 @@ UnicodeString::releaseBuffer(int32_t newLength) {
       newLength=capacity;
     }
     setLength(newLength);
       newLength=capacity;
     }
     setLength(newLength);

-    fFlags&=~kOpenGetBuffer;
+    fUnion.fFields.fLengthAndFlags&=~kOpenGetBuffer;

   }
 }
 
   }
 }
 


@@ -1325,12 +1634,12 @@ UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
    * Return FALSE if memory could not be allocated.
    */
   if(forceClone ||
    * Return FALSE if memory could not be allocated.
    */
   if(forceClone ||

-     fFlags & kBufferIsReadonly ||
-     fFlags & kRefCounted && refCount() > 1 ||
+     fUnion.fFields.fLengthAndFlags & kBufferIsReadonly ||
+     (fUnion.fFields.fLengthAndFlags & kRefCounted && refCount() > 1) ||

      newCapacity > getCapacity()
   ) {
     // check growCapacity for default value and use of the stack buffer
      newCapacity > getCapacity()
   ) {
     // check growCapacity for default value and use of the stack buffer

-    if(growCapacity == -1) {
+    if(growCapacity < 0) {

       growCapacity = newCapacity;
     } else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) {
       growCapacity = US_STACKBUF_SIZE;
       growCapacity = newCapacity;
     } else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) {
       growCapacity = US_STACKBUF_SIZE;


@@ -1339,49 +1648,57 @@ UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
     // save old values
     UChar oldStackBuffer[US_STACKBUF_SIZE];
     UChar *oldArray;
     // save old values
     UChar oldStackBuffer[US_STACKBUF_SIZE];
     UChar *oldArray;

-    uint8_t flags = fFlags;
+    int32_t oldLength = length();
+    int16_t flags = fUnion.fFields.fLengthAndFlags;

 
     if(flags&kUsingStackBuffer) {
 
     if(flags&kUsingStackBuffer) {

+      U_ASSERT(!(flags&kRefCounted)); /* kRefCounted and kUsingStackBuffer are mutally exclusive */

       if(doCopyArray && growCapacity > US_STACKBUF_SIZE) {
         // copy the stack buffer contents because it will be overwritten with
         // fUnion.fFields values
       if(doCopyArray && growCapacity > US_STACKBUF_SIZE) {
         // copy the stack buffer contents because it will be overwritten with
         // fUnion.fFields values

-        us_arrayCopy(fUnion.fStackBuffer, 0, oldStackBuffer, 0, fShortLength);
+        us_arrayCopy(fUnion.fStackFields.fBuffer, 0, oldStackBuffer, 0, oldLength);

         oldArray = oldStackBuffer;
       } else {
         oldArray = oldStackBuffer;
       } else {

-        oldArray = 0; // no need to copy from stack buffer to itself
+        oldArray = NULL; // no need to copy from the stack buffer to itself

       }
     } else {
       oldArray = fUnion.fFields.fArray;
       }
     } else {
       oldArray = fUnion.fFields.fArray;

+      U_ASSERT(oldArray!=NULL); /* when stack buffer is not used, oldArray must have a non-NULL reference */

     }
 
     // allocate a new array
     if(allocate(growCapacity) ||
     }
 
     // allocate a new array
     if(allocate(growCapacity) ||

-       newCapacity < growCapacity && allocate(newCapacity)
+       (newCapacity < growCapacity && allocate(newCapacity))

     ) {
     ) {

-      if(doCopyArray && oldArray != 0) {
+      if(doCopyArray) {

         // copy the contents
         // do not copy more than what fits - it may be smaller than before
         // copy the contents
         // do not copy more than what fits - it may be smaller than before

-        int32_t minLength = length();
+        int32_t minLength = oldLength;

         newCapacity = getCapacity();
         if(newCapacity < minLength) {
           minLength = newCapacity;
         newCapacity = getCapacity();
         if(newCapacity < minLength) {
           minLength = newCapacity;

-          setLength(minLength);

         }
         }

-        us_arrayCopy(oldArray, 0, getArrayStart(), 0, minLength);
+        if(oldArray != NULL) {
+          us_arrayCopy(oldArray, 0, getArrayStart(), 0, minLength);
+        }
+        setLength(minLength);

       } else {
       } else {

-        fShortLength = 0;
+        setZeroLength();

       }
 
       // release the old array
       if(flags & kRefCounted) {
         // the array is refCounted; decrement and release if 0
       }
 
       // release the old array
       if(flags & kRefCounted) {
         // the array is refCounted; decrement and release if 0

-        int32_t *pRefCount = ((int32_t *)oldArray - 1);
+        u_atomic_int32_t *pRefCount = ((u_atomic_int32_t *)oldArray - 1);

         if(umtx_atomic_dec(pRefCount) == 0) {
           if(pBufferToDelete == 0) {
         if(umtx_atomic_dec(pRefCount) == 0) {
           if(pBufferToDelete == 0) {

-            uprv_free(pRefCount);
+              // Note: cast to (void *) is needed with MSVC, where u_atomic_int32_t
+              // is defined as volatile. (Volatile has useful non-standard behavior
+              //   with this compiler.)
+            uprv_free((void *)pRefCount);

           } else {
             // the caller requested to delete it himself
           } else {
             // the caller requested to delete it himself

-            *pBufferToDelete = pRefCount;
+            *pBufferToDelete = (int32_t *)pRefCount;

           }
         }
       }
           }
         }
       }


@@ -1391,15 +1708,85 @@ UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
       if(!(flags&kUsingStackBuffer)) {
         fUnion.fFields.fArray = oldArray;
       }
       if(!(flags&kUsingStackBuffer)) {
         fUnion.fFields.fArray = oldArray;
       }

-      fFlags = flags;
+      fUnion.fFields.fLengthAndFlags = flags;

       setToBogus();
       return FALSE;
     }
   }
   return TRUE;
 }
       setToBogus();
       return FALSE;
     }
   }
   return TRUE;
 }

+
+// UnicodeStringAppendable ------------------------------------------------- ***
+
+UnicodeStringAppendable::~UnicodeStringAppendable() {}
+
+UBool
+UnicodeStringAppendable::appendCodeUnit(UChar c) {
+  return str.doReplace(str.length(), 0, &c, 0, 1).isWritable();
+}
+
+UBool
+UnicodeStringAppendable::appendCodePoint(UChar32 c) {
+  UChar buffer[U16_MAX_LENGTH];
+  int32_t cLength = 0;
+  UBool isError = FALSE;
+  U16_APPEND(buffer, cLength, U16_MAX_LENGTH, c, isError);
+  return !isError && str.doReplace(str.length(), 0, buffer, 0, cLength).isWritable();
+}
+
+UBool
+UnicodeStringAppendable::appendString(const UChar *s, int32_t length) {
+  return str.doReplace(str.length(), 0, s, 0, length).isWritable();
+}
+
+UBool
+UnicodeStringAppendable::reserveAppendCapacity(int32_t appendCapacity) {
+  return str.cloneArrayIfNeeded(str.length() + appendCapacity);
+}
+
+UChar *
+UnicodeStringAppendable::getAppendBuffer(int32_t minCapacity,
+                                         int32_t desiredCapacityHint,
+                                         UChar *scratch, int32_t scratchCapacity,
+                                         int32_t *resultCapacity) {
+  if(minCapacity < 1 || scratchCapacity < minCapacity) {
+    *resultCapacity = 0;
+    return NULL;
+  }
+  int32_t oldLength = str.length();
+  if(str.cloneArrayIfNeeded(oldLength + minCapacity, oldLength + desiredCapacityHint)) {
+    *resultCapacity = str.getCapacity() - oldLength;
+    return str.getArrayStart() + oldLength;
+  }
+  *resultCapacity = scratchCapacity;
+  return scratch;
+}
+

 U_NAMESPACE_END
 
 U_NAMESPACE_END
 

+U_NAMESPACE_USE
+
+U_CAPI int32_t U_EXPORT2
+uhash_hashUnicodeString(const UElement key) {
+    const UnicodeString *str = (const UnicodeString*) key.pointer;
+    return (str == NULL) ? 0 : str->hashCode();
+}
+
+// Moved here from uhash_us.cpp so that using a UVector of UnicodeString*
+// does not depend on hashtable code.
+U_CAPI UBool U_EXPORT2
+uhash_compareUnicodeString(const UElement key1, const UElement key2) {
+    const UnicodeString *str1 = (const UnicodeString*) key1.pointer;
+    const UnicodeString *str2 = (const UnicodeString*) key2.pointer;
+    if (str1 == str2) {
+        return TRUE;
+    }
+    if (str1 == NULL || str2 == NULL) {
+        return FALSE;
+    }
+    return *str1 == *str2;
+}
+

 #ifdef U_STATIC_IMPLEMENTATION
 /*
 This should never be called. It is defined here to make sure that the
 #ifdef U_STATIC_IMPLEMENTATION
 /*
 This should never be called. It is defined here to make sure that the


@@ -1409,8 +1796,6 @@ but defining it here makes sure that it is included with this object file.
 This makes sure that static library dependencies are kept to a minimum.
 */
 static void uprv_UnicodeStringDummy(void) {
 This makes sure that static library dependencies are kept to a minimum.
 */
 static void uprv_UnicodeStringDummy(void) {

-    U_NAMESPACE_USE

     delete [] (new UnicodeString[2]);
 }
 #endif
     delete [] (new UnicodeString[2]);
 }
 #endif

-