ICU 56 update step 1

source/common/unistr.cpp

 /*
 ******************************************************************************
-* Copyright (C) 1999-2014, International Business Machines Corporation and
+* Copyright (C) 1999-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 ******************************************************************************
 *
 * File unistr.cpp
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   09/25/98    stephen     Creation.
 *   04/20/99    stephen     Overhauled per 4/16 code review.
@@ skipping 112 matching lines @@
   return umtx_atomic_dec((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
 }
 
 int32_t
 UnicodeString::refCount() const {
   return umtx_loadAcquire(*((u_atomic_int32_t *)fUnion.fFields.fArray - 1));
 }
 
 void
 UnicodeString::releaseArray() {
-  if((fFlags & kRefCounted) && removeRef() == 0) {
+  if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) {
     uprv_free((int32_t *)fUnion.fFields.fArray - 1);
   }
 }
 
 
 
 //========================================
 // Constructors
 //========================================
 
 // The default constructor is inline in unistr.h.
 
-UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count)
-  : fShortLength(0),
-    fFlags(0)
-{
+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
     int32_t unitCount = U16_LENGTH(c), length = count * unitCount;
     if(capacity < length) {
       capacity = length;
     }
     if(allocate(capacity)) {
@@ skipping 21 matching lines @@
           while(unitIdx < unitCount) {
             array[i++]=units[unitIdx++];
           }
         }
       }
     }
     setLength(length);
   }
 }
 
-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;
-  U16_APPEND(fUnion.fStackBuffer, i, US_STACKBUF_SIZE, ch, isError);
+  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) {
-    fShortLength = (int8_t)i;
+    setShortLength(i);
   }
 }
 
-UnicodeString::UnicodeString(const UChar *text)
-  : fShortLength(0),
-    fFlags(kShortString)
-{
-  doReplace(0, 0, text, 0, -1);
+UnicodeString::UnicodeString(const UChar *text) {
+  fUnion.fFields.fLengthAndFlags = kShortString;
+  doAppend(text, 0, -1);
 }
 
 UnicodeString::UnicodeString(const UChar *text,
-                             int32_t textLength)
-  : fShortLength(0),
-    fFlags(kShortString)
-{
-  doReplace(0, 0, text, 0, textLength);
+                             int32_t textLength) {
+  fUnion.fFields.fLengthAndFlags = kShortString;
+  doAppend(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();
   } else if(textLength < -1 ||
             (textLength == -1 && !isTerminated) ||
             (textLength >= 0 && isTerminated && text[textLength] != 0)
   ) {
     setToBogus();
   } else {
     if(textLength == -1) {
       // text is terminated, or else it would have failed the above test
       textLength = u_strlen(text);
     }
     setArray((UChar *)text, textLength, isTerminated ? textLength + 1 : textLength);
   }
 }
 
 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();
   } else if(buffLength < -1 || buffCapacity < 0 || buffLength > buffCapacity) {
     setToBogus();
   } else {
     if(buffLength == -1) {
       // fLength = u_strlen(buff); but do not look beyond buffCapacity
       const UChar *p = buff, *limit = buff + buffCapacity;
       while(p != limit && *p != 0) {
         ++p;
       }
       buffLength = (int32_t)(p - buff);
     }
     setArray(buff, buffLength, buffCapacity);
   }
 }
 
-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(length<0) {
       length=(int32_t)uprv_strlen(src);
     }
     if(cloneArrayIfNeeded(length, length, FALSE)) {
       u_charsToUChars(src, getArrayStart(), length);
       setLength(length);
     } else {
       setToBogus();
     }
   }
 }
 
 #if U_CHARSET_IS_UTF8
 
-UnicodeString::UnicodeString(const char *codepageData)
-  : fShortLength(0),
-    fFlags(kShortString) {
+UnicodeString::UnicodeString(const char *codepageData) {
+  fUnion.fFields.fLengthAndFlags = kShortString;
   if(codepageData != 0) {
     setToUTF8(codepageData);
   }
 }
 
-UnicodeString::UnicodeString(const char *codepageData, int32_t dataLength)
-  : fShortLength(0),
-    fFlags(kShortString) {
+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)
-  : Replaceable(),
-    fShortLength(0),
-    fFlags(kShortString)
-{
+UnicodeString::UnicodeString(const UnicodeString& that) {
+  fUnion.fFields.fLengthAndFlags = kShortString;
   copyFrom(that);
 }
 
+#if U_HAVE_RVALUE_REFERENCES
+UnicodeString::UnicodeString(UnicodeString &&src) U_NOEXCEPT {
+  fUnion.fFields.fLengthAndFlags = kShortString;
+  moveFrom(src);
+}
+#endif
+
 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,
-                             int32_t srcLength)
-  : Replaceable(),
-    fShortLength(0),
-    fFlags(kShortString)
-{
+                             int32_t srcLength) {
+  fUnion.fFields.fLengthAndFlags = kShortString;
   setTo(that, srcStart, srcLength);
 }
 
 // Replaceable base class clone() default implementation, does not clone
 Replaceable *
 Replaceable::clone() const {
   return NULL;
 }
 
 // UnicodeString overrides clone() with a real implementation
 Replaceable *
 UnicodeString::clone() const {
   return new UnicodeString(*this);
 }
 
 //========================================
 // array allocation
 //========================================
 
 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
     // 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
       *array++ = 1;
 
       // 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 {
-      fShortLength = 0;
+      fUnion.fFields.fLengthAndFlags = kIsBogus;
       fUnion.fFields.fArray = 0;
       fUnion.fFields.fCapacity = 0;
-      fFlags = kIsBogus;
       return FALSE;
     }
   }
   return TRUE;
 }
 
 //========================================
 // Destructor
 //========================================
+
+#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS
+static u_atomic_int32_t finalLengthCounts[0x400];  // UnicodeString::kMaxShortLength+1
+static u_atomic_int32_t beyondCount(0);
+
+U_CAPI void unistr_printLengths() {
+  int32_t i;
+  for(i = 0; i <= 59; ++i) {
+    printf("%2d,  %9d\n", i, (int32_t)finalLengthCounts[i]);
+  }
+  int32_t beyond = beyondCount;
+  for(; i < UPRV_LENGTHOF(finalLengthCounts); ++i) {
+    beyond += finalLengthCounts[i];
+  }
+  printf(">59, %9d\n", beyond);
+}
+#endif
+
 UnicodeString::~UnicodeString()
 {
+#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS
+  // Count lengths of strings at the end of their lifetime.
+  // Useful for discussion of a desirable stack buffer size.
+  // Count the contents length, not the optional NUL terminator nor further capacity.
+  // Ignore open-buffer strings and strings which alias external storage.
+  if((fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kReadonlyAlias|kWritableAlias)) == 0) {
+    if(hasShortLength()) {
+      umtx_atomic_inc(finalLengthCounts + getShortLength());
+    } else {
+      umtx_atomic_inc(&beyondCount);
+    }
+  }
+#endif
+
   releaseArray();
 }
 
 //========================================
 // Factory methods
 //========================================
 
 UnicodeString UnicodeString::fromUTF8(const StringPiece &utf8) {
   UnicodeString result;
   result.setToUTF8(utf8);
@@ skipping 61 matching lines @@
 
   // delete the current contents
   releaseArray();
 
   if(src.isEmpty()) {
     // empty string - use the stack buffer
     setToEmpty();
     return *this;
   }
 
-  // we always copy the length
-  int32_t srcLength = src.length();
-  setLength(srcLength);
-
   // 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
-    fFlags = kShortString;
-    uprv_memcpy(fUnion.fStackBuffer, src.fUnion.fStackBuffer, srcLength * 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
-    // 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;
-    fFlags = src.fFlags;
+    if(!hasShortLength()) {
+      fUnion.fFields.fLength = src.fUnion.fFields.fLength;
+    }
     break;
   case kReadonlyAlias:
     if(fastCopy) {
       // src is a readonly alias, do the same
       // -> 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
-  case kWritableAlias:
+  case kWritableAlias: {
     // 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);
+      setLength(srcLength);
       break;
     }
     // if there is not enough memory, then fall through to setting 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;
-    fFlags = kIsBogus;
     break;
   }
 
   return *this;
 }
 
+UnicodeString &UnicodeString::moveFrom(UnicodeString &src) U_NOEXCEPT {
+  // No explicit check for self move assignment, consistent with standard library.
+  // Self move assignment causes no crash nor leak but might make the object bogus.
+  releaseArray();
+  copyFieldsFrom(src, TRUE);
+  return *this;
+}
+
+// Same as moveFrom() except without memory management.
+void UnicodeString::copyFieldsFrom(UnicodeString &src, UBool setSrcToBogus) U_NOEXCEPT {
+  int16_t lengthAndFlags = fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags;
+  if(lengthAndFlags & kUsingStackBuffer) {
+    // Short string using the stack buffer, copy the contents.
+    // Check for self assignment to prevent "overlap in memcpy" warnings,
+    // although it should be harmless to copy a buffer to itself exactly.
+    if(this != &src) {
+      uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer,
+                  getShortLength() * U_SIZEOF_UCHAR);
+    }
+  } else {
+    // In all other cases, copy all fields.
+    fUnion.fFields.fArray = src.fUnion.fFields.fArray;
+    fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;
+    if(!hasShortLength()) {
+      fUnion.fFields.fLength = src.fUnion.fFields.fLength;
+    }
+    if(setSrcToBogus) {
+      // Set src to bogus without releasing any memory.
+      src.fUnion.fFields.fLengthAndFlags = kIsBogus;
+      src.fUnion.fFields.fArray = NULL;
+      src.fUnion.fFields.fCapacity = 0;
+    }
+  }
+}
+
+void UnicodeString::swap(UnicodeString &other) U_NOEXCEPT {
+  UnicodeString temp;  // Empty short string: Known not to need releaseArray().
+  // Copy fields without resetting source values in between.
+  temp.copyFieldsFrom(*this, FALSE);
+  this->copyFieldsFrom(other, FALSE);
+  other.copyFieldsFrom(temp, FALSE);
+  // Set temp to an empty string so that other's memory is not released twice.
+  temp.fUnion.fFields.fLengthAndFlags = kShortString;
+}
+
 //========================================
 // Miscellaneous operations
 //========================================
 
 UnicodeString UnicodeString::unescape() const {
     UnicodeString result(length(), (UChar32)0, (int32_t)0); // construct with capacity
+    if (result.isBogus()) {
+        return result;
+    }
     const UChar *array = getBuffer();
     int32_t len = length();
     int32_t prev = 0;
     for (int32_t i=0;;) {
         if (i == len) {
             result.append(array, prev, len - prev);
             break;
         }
         if (array[i++] == 0x5C /*'\\'*/) {
             result.append(array, prev, (i - 1) - prev);
@@ skipping 272 matching lines @@
   }
   UErrorCode status = U_ZERO_ERROR;
   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.fStackBuffer;  // anything not NULL because that would make an empty string
+    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;
@@ skipping 263 matching lines @@
 
   return *this;
 }
 
 
 void
 UnicodeString::setToBogus()
 {
   releaseArray();
 
-  fShortLength = 0;
+  fUnion.fFields.fLengthAndFlags = kIsBogus;
   fUnion.fFields.fArray = 0;
   fUnion.fFields.fCapacity = 0;
-  fFlags = kIsBogus;
 }
 
 // turn a bogus string into an empty one
 void
 UnicodeString::unBogus() {
-  if(fFlags & kIsBogus) {
+  if(fUnion.fFields.fLengthAndFlags & kIsBogus) {
     setToEmpty();
   }
 }
 
 const UChar *
 UnicodeString::getTerminatedBuffer() {
   if(!isWritable()) {
     return 0;
   }
   UChar *array = getArrayStart();
   int32_t len = length();
   if(len < getCapacity()) {
-    if(fFlags & kBufferIsReadonly) {
+    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(((fFlags & kRefCounted) == 0 || refCount() == 1)) {
+    } 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)
 {
-  if(fFlags & kOpenGetBuffer) {
+  if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {
     // do not modify a string that has an "open" getBuffer(minCapacity)
     return *this;
   }
 
   if(text == NULL) {
     // treat as an empty string, do not alias
     releaseArray();
     setToEmpty();
     return *this;
   }
 
   if( textLength < -1 ||
       (textLength == -1 && !isTerminated) ||
       (textLength >= 0 && isTerminated && text[textLength] != 0)
   ) {
     setToBogus();
     return *this;
   }
 
   releaseArray();
 
   if(textLength == -1) {
     // 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);
-
-  fFlags = kReadonlyAlias;
   return *this;
 }
 
 // setTo() analogous to the writable-aliasing constructor with the same signature
 UnicodeString &
 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;
   }
 
   if(buffer == NULL) {
     // treat as an empty string, do not alias
     releaseArray();
     setToEmpty();
     return *this;
   }
 
   if(buffLength < -1 || buffCapacity < 0 || buffLength > buffCapacity) {
     setToBogus();
     return *this;
   } else if(buffLength == -1) {
     // buffLength = u_strlen(buff); but do not look beyond buffCapacity
     const UChar *p = buffer, *limit = buffer + buffCapacity;
     while(p != limit && *p != 0) {
       ++p;
     }
     buffLength = (int32_t)(p - buffer);
   }
 
   releaseArray();
 
+  fUnion.fFields.fLengthAndFlags = kWritableAlias;
   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;
@@ skipping 46 matching lines @@
   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);
+  // If isError then _length==0 which turns the doAppend() into a no-op anyway.
+  return isError ? *this : doAppend(buffer, 0, _length);
 }
 
 UnicodeString&
 UnicodeString::doReplace( int32_t start,
               int32_t length,
               const UnicodeString& src,
               int32_t srcStart,
               int32_t srcLength)
 {
-  if(!src.isBogus()) {
-    // pin the indices to legal values
-    src.pinIndices(srcStart, srcLength);
+  // pin the indices to legal values
+  src.pinIndices(srcStart, srcLength);
 
-    // get the characters from src
-    // and replace the range in ourselves with them
-    return doReplace(start, length, src.getArrayStart(), srcStart, srcLength);
-  } else {
-    // remove the range
-    return doReplace(start, length, 0, 0, 0);
-  }
+  // get the characters from src
+  // and replace the range in ourselves with them
+  return doReplace(start, length, src.getArrayStart(), srcStart, srcLength);
 }
 
 UnicodeString&
 UnicodeString::doReplace(int32_t start,
              int32_t length,
              const UChar *srcChars,
              int32_t srcStart,
              int32_t srcLength)
 {
   if(!isWritable()) {
     return *this;
   }
 
   int32_t oldLength = this->length();
 
   // optimize (read-only alias).remove(0, start) and .remove(start, end)
-  if((fFlags&kBufferIsReadonly) && srcLength == 0) {
+  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(start == oldLength) {
+    return doAppend(srcChars, srcStart, srcLength);
+  }
+
   if(srcChars == 0) {
     srcStart = srcLength = 0;
   } else if(srcLength < 0) {
     // get the srcLength if necessary
     srcLength = u_strlen(srcChars + srcStart);
   }
 
+  // pin the indices to legal values
+  pinIndices(start, length);
+
   // calculate the size of the string after the replace
-  int32_t newLength;
+  int32_t newLength = oldLength - length + srcLength;
 
-  // optimize append() onto a large-enough, owned string
-  if(start >= oldLength) {
-    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
-      start = oldLength;
-      length = 0;
-    }
-  } else {
-    // pin the indices to legal values
-    pinIndices(start, length);
-
-    newLength = oldLength - length + srcLength;
-  }
-
-  // the following may change fArray but will not copy the current contents;
+  // cloneArrayIfNeeded(doCopyArray=FALSE) 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) && (newLength > 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
-    u_memcpy(oldStackBuffer, fUnion.fStackBuffer, oldLength);
+    u_memcpy(oldStackBuffer, fUnion.fStackFields.fBuffer, oldLength);
     oldArray = oldStackBuffer;
   } else {
     oldArray = getArrayStart();
   }
 
   // clone our array and allocate a bigger array if needed
   int32_t *bufferToDelete = 0;
   if(!cloneArrayIfNeeded(newLength, newLength + (newLength >> 2) + kGrowSize,
                          FALSE, &bufferToDelete)
   ) {
@@ skipping 23 matching lines @@
 
   // delayed delete in case srcChars == fArray when we started, and
   // to keep oldArray alive for the above operations
   if (bufferToDelete) {
     uprv_free(bufferToDelete);
   }
 
   return *this;
 }
 
+// Versions of doReplace() only for append() variants.
+// doReplace() and doAppend() optimize for different cases.
+
+UnicodeString&
+UnicodeString::doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcLength) {
+  if(srcLength == 0) {
+    return *this;
+  }
+
+  // pin the indices to legal values
+  src.pinIndices(srcStart, srcLength);
+  return doAppend(src.getArrayStart(), srcStart, srcLength);
+}
+
+UnicodeString&
+UnicodeString::doAppend(const UChar *srcChars, int32_t srcStart, int32_t srcLength) {
+  if(!isWritable() || srcLength == 0 || srcChars == NULL) {
+    return *this;
+  }
+
+  if(srcLength < 0) {
+    // get the srcLength if necessary
+    if((srcLength = u_strlen(srcChars + srcStart)) == 0) {
+      return *this;
+    }
+  }
+
+  int32_t oldLength = length();
+  int32_t newLength = oldLength + srcLength;
+  // optimize append() onto a large-enough, owned string
+  if((newLength <= getCapacity() && isBufferWritable()) ||
+      cloneArrayIfNeeded(newLength, newLength + (newLength >> 2) + kGrowSize)) {
+    UChar *newArray = 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 != newArray + oldLength) {
+      us_arrayCopy(srcChars, srcStart, newArray, oldLength, srcLength);
+    }
+    setLength(newLength);
+  }
+  return *this;
+}
+
 /**
  * Replaceable API
  */
 void
 UnicodeString::handleReplaceBetween(int32_t start,
                                     int32_t limit,
                                     const UnicodeString& text) {
     replaceBetween(start, limit, text);
 }
 
@@ skipping 133 matching lines @@
     return hashCode;
 }
 
 //========================================
 // External Buffer
 //========================================
 
 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;
   }
 }
 
 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) {
       // the new length is the string length, capped by fCapacity
       const UChar *array=getArrayStart(), *p=array, *limit=array+capacity;
       while(p<limit && *p!=0) {
         ++p;
       }
       newLength=(int32_t)(p-array);
     } else if(newLength>capacity) {
       newLength=capacity;
     }
     setLength(newLength);
-    fFlags&=~kOpenGetBuffer;
+    fUnion.fFields.fLengthAndFlags&=~kOpenGetBuffer;
   }
 }
 
 //========================================
 // Miscellaneous
 //========================================
 UBool
 UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
                                   int32_t growCapacity,
                                   UBool doCopyArray,
@@ skipping 13 matching lines @@
   }
 
   /*
    * We need to make a copy of the array if
    * the buffer is read-only, or
    * the buffer is refCounted (shared), and refCount>1, or
    * the buffer is too small.
    * 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
     if(growCapacity < 0) {
       growCapacity = newCapacity;
     } else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) {
       growCapacity = US_STACKBUF_SIZE;
     }
 
     // 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) {
       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
-        us_arrayCopy(fUnion.fStackBuffer, 0, oldStackBuffer, 0, fShortLength);
+        us_arrayCopy(fUnion.fStackFields.fBuffer, 0, oldStackBuffer, 0, oldLength);
         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;
       U_ASSERT(oldArray!=NULL); /* when stack buffer is not used, oldArray must have a non-NULL reference */
     }
 
     // allocate a new array
     if(allocate(growCapacity) ||
        (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
-        int32_t minLength = length();
+        int32_t minLength = oldLength;
         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 {
-        fShortLength = 0;
+        setZeroLength();
       }
 
       // release the old array
       if(flags & kRefCounted) {
         // the array is refCounted; decrement and release if 0
         u_atomic_int32_t *pRefCount = ((u_atomic_int32_t *)oldArray - 1);
         if(umtx_atomic_dec(pRefCount) == 0) {
           if(pBufferToDelete == 0) {
               // 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
             *pBufferToDelete = (int32_t *)pRefCount;
           }
         }
       }
     } else {
       // not enough memory for growCapacity and not even for the smaller newCapacity
       // reset the old values for setToBogus() to release the array
       if(!(flags&kUsingStackBuffer)) {
         fUnion.fFields.fArray = oldArray;
       }
-      fFlags = flags;
+      fUnion.fFields.fLengthAndFlags = flags;
       setToBogus();
       return FALSE;
     }
   }
   return TRUE;
 }
 
 // UnicodeStringAppendable ------------------------------------------------- ***
 
 UnicodeStringAppendable::~UnicodeStringAppendable() {}
 
 UBool
 UnicodeStringAppendable::appendCodeUnit(UChar c) {
-  return str.doReplace(str.length(), 0, &c, 0, 1).isWritable();
+  return str.doAppend(&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();
+  return !isError && str.doAppend(buffer, 0, cLength).isWritable();
 }
 
 UBool
 UnicodeStringAppendable::appendString(const UChar *s, int32_t length) {
-  return str.doReplace(str.length(), 0, s, 0, length).isWritable();
+  return str.doAppend(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,
@@ skipping 42 matching lines @@
 This should never be called. It is defined here to make sure that the
 virtual vector deleting destructor is defined within unistr.cpp.
 The vector deleting destructor is already a part of UObject,
 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) {
     delete [] (new UnicodeString[2]);
 }
 #endif