../deps/icu-small/source/common/umutex.h

Bug Summary

File:	out/../deps/icu-small/source/common/umutex.h
Warning:	line 89, column 12 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name unistr.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/common/unistr.cpp

../deps/icu-small/source/common/unistr.cpp

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5* Copyright (C) 1999-2016, International Business Machines Corporation and
6* others. All Rights Reserved.
7******************************************************************************
8*
9* File unistr.cpp
10*
11* Modification History:
12*
13*   Date        Name        Description
14*   09/25/98    stephen     Creation.
15*   04/20/99    stephen     Overhauled per 4/16 code review.
16*   07/09/99    stephen     Renamed {hi,lo},{byte,word} to icu_X for HP/UX
17*   11/18/99    aliu        Added handleReplaceBetween() to make inherit from
18*                           Replaceable.
19*   06/25/01    grhoten     Removed the dependency on iostream
20******************************************************************************
21*/

23#include "unicode/utypes.h"
24#include "unicode/appendable.h"
25#include "unicode/putil.h"
26#include "cstring.h"
27#include "cmemory.h"
28#include "unicode/ustring.h"
29#include "unicode/unistr.h"
30#include "unicode/utf.h"
31#include "unicode/utf16.h"
32#include "uelement.h"
33#include "ustr_imp.h"
34#include "umutex.h"
35#include "uassert.h"

37#if 0

39#include <iostream>
40using namespace std;

42//DEBUGGING
43void
44print(const UnicodeString& s,
    const char *name)
46{
UChar c;
cout << name << ":|";
for(int i = 0; i < s.length(); ++i) {
  c = s[i];
  if(c>= 0x007E || c < 0x0020)
    cout << "[0x" << hex << s[i] << "]";
  else
    cout << (char) s[i];
}
cout << '|' << endl;
57}

59void
60print(const UChar *s,
    int32_t len,
    const char *name)
63{
UChar c;
cout << name << ":|";
for(int i = 0; i < len; ++i) {
  c = s[i];
  if(c>= 0x007E || c < 0x0020)
    cout << "[0x" << hex << s[i] << "]";
  else
    cout << (char) s[i];
}
cout << '|' << endl;
74}
75// END DEBUGGING
76#endif

78// Local function definitions for now

80// need to copy areas that may overlap
81static
82inline void
83us_arrayCopy(const UChar *src, int32_t srcStart,
       UChar *dst, int32_t dstStart, int32_t count)
85{
if(count>0) {
  uprv_memmove(dst+dstStart, src+srcStart, (size_t)count*sizeof(*src))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(dst+dstStart
, src+srcStart, (size_t)count*sizeof(*src)); } while (false);
}
89}

91// u_unescapeAt() callback to get a UChar from a UnicodeString
92U_CDECL_BEGINextern "C" {
93static UChar U_CALLCONV
94UnicodeString_charAt(int32_t offset, void *context) {
  return ((icu::UnicodeString*) context)->charAt(offset);
96}
97U_CDECL_END}

99U_NAMESPACE_BEGINnamespace icu_71 {

101/* The Replaceable virtual destructor can't be defined in the header
 due to how AIX works with multiple definitions of virtual functions.
103*/
104Replaceable::~Replaceable() {}

106UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeString)UClassID UnicodeString::getStaticClassID() { static char classID
 = 0; return (UClassID)&classID; } UClassID UnicodeString
::getDynamicClassID() const { return UnicodeString::getStaticClassID
(); }

108UnicodeString U_EXPORT2
109operator+ (const UnicodeString &s1, const UnicodeString &s2) {
  return
      UnicodeString(s1.length()+s2.length()+1, (UChar32)0, 0).
          append(s1).
              append(s2);
114}

116//========================================
117// Reference Counting functions, put at top of file so that optimizing compilers
118//                               have a chance to automatically inline.
119//========================================

121void
122UnicodeString::addRef() {
umtx_atomic_inc((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
124}

126int32_t
127UnicodeString::removeRef() {
return umtx_atomic_dec((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
21
←
Passing null pointer value via 1st parameter 'var'→
22
←
Calling 'umtx_atomic_dec'→
129}

131int32_t
132UnicodeString::refCount() const {
return umtx_loadAcquire(*((u_atomic_int32_t *)fUnion.fFields.fArray - 1));
134}

136void
137UnicodeString::releaseArray() {
if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) {
19
←
Assuming the condition is true→
20
←
Calling 'UnicodeString::removeRef'→
  uprv_freeuprv_free_71((int32_t *)fUnion.fFields.fArray - 1);
}
141}



145//========================================
146// Constructors
147//========================================

149// The default constructor is inline in unistr.h.

151UnicodeString::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 if(c <= 0xffff) {
  int32_t length = count;
  if(capacity < length) {
    capacity = length;
  }
  if(allocate(capacity)) {
    UChar *array = getArrayStart();
    UChar unit = (UChar)c;
    for(int32_t i = 0; i < length; ++i) {
      array[i] = unit;
    }
    setLength(length);
  }
} else {  // supplementary code point, write surrogate pairs
  if(count > (INT32_MAX(2147483647) / 2)) {
    // We would get more than 2G UChars.
    allocate(capacity);
    return;
  }
  int32_t length = count * 2;
  if(capacity < length) {
    capacity = length;
  }
  if(allocate(capacity)) {
    UChar *array = getArrayStart();
    UChar lead = U16_LEAD(c)(UChar)(((c)>>10)+0xd7c0);
    UChar trail = U16_TRAIL(c)(UChar)(((c)&0x3ff)|0xdc00);
    for(int32_t i = 0; i < length; i += 2) {
      array[i] = lead;
      array[i + 1] = trail;
    }
    setLength(length);
  }
}
190}

192UnicodeString::UnicodeString(UChar ch) {
fUnion.fFields.fLengthAndFlags = kLength1 | kShortString;
fUnion.fStackFields.fBuffer[0] = ch;
195}

197UnicodeString::UnicodeString(UChar32 ch) {
fUnion.fFields.fLengthAndFlags = kShortString;
int32_t i = 0;
UBool isError = FALSE0;
U16_APPEND(fUnion.fStackFields.fBuffer, i, US_STACKBUF_SIZE, ch, isError)do { if((uint32_t)(ch)<=0xffff) { (fUnion.fStackFields.fBuffer
)[(i)++]=(uint16_t)(ch); } else if((uint32_t)(ch)<=0x10ffff
 && (i)+1<(US_STACKBUF_SIZE)) { (fUnion.fStackFields
.fBuffer)[(i)++]=(uint16_t)(((ch)>>10)+0xd7c0); (fUnion
.fStackFields.fBuffer)[(i)++]=(uint16_t)(((ch)&0x3ff)|0xdc00
); } else { (isError)=true; } } while (false);
// 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);
}
207}

209UnicodeString::UnicodeString(const UChar *text) {
fUnion.fFields.fLengthAndFlags = kShortString;
doAppend(text, 0, -1);
212}

214UnicodeString::UnicodeString(const UChar *text,
                           int32_t textLength) {
fUnion.fFields.fLengthAndFlags = kShortString;
doAppend(text, 0, textLength);
218}

220UnicodeString::UnicodeString(UBool isTerminated,
                           ConstChar16Ptr textPtr,
                           int32_t textLength) {
fUnion.fFields.fLengthAndFlags = kReadonlyAlias;
const UChar *text = textPtr;
if(text == NULL__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_strlenu_strlen_71(text);
  }
  setArray(const_cast<UChar *>(text), textLength,
           isTerminated ? textLength + 1 : textLength);
}
241}

243UnicodeString::UnicodeString(UChar *buff,
                           int32_t buffLength,
                           int32_t buffCapacity) {
fUnion.fFields.fLengthAndFlags = kWritableAlias;
if(buff == NULL__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);
}
263}

265UnicodeString::UnicodeString(const char *src, int32_t length, EInvariant) {
fUnion.fFields.fLengthAndFlags = kShortString;
if(src==NULL__null) {
  // treat as an empty string
} else {
  if(length<0) {
    length=(int32_t)uprv_strlen(src):: strlen(src);
  }
  if(cloneArrayIfNeeded(length, length, FALSE0)) {
    u_charsToUCharsu_charsToUChars_71(src, getArrayStart(), length);
    setLength(length);
  } else {
    setToBogus();
  }
}
280}

282#if U_CHARSET_IS_UTF81

284UnicodeString::UnicodeString(const char *codepageData) {
fUnion.fFields.fLengthAndFlags = kShortString;
if(codepageData != 0) {
  setToUTF8(codepageData);
}
289}

291UnicodeString::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):: strlen(codepageData);
}
setToUTF8(StringPiece(codepageData, dataLength));
301}

303// else see unistr_cnv.cpp
304#endif

306UnicodeString::UnicodeString(const UnicodeString& that) {
fUnion.fFields.fLengthAndFlags = kShortString;
copyFrom(that);
309}

311UnicodeString::UnicodeString(UnicodeString &&src) U_NOEXCEPTnoexcept {
copyFieldsFrom(src, TRUE1);
313}

315UnicodeString::UnicodeString(const UnicodeString& that,
                           int32_t srcStart) {
fUnion.fFields.fLengthAndFlags = kShortString;
setTo(that, srcStart);
319}

321UnicodeString::UnicodeString(const UnicodeString& that,
                           int32_t srcStart,
                           int32_t srcLength) {
fUnion.fFields.fLengthAndFlags = kShortString;
setTo(that, srcStart, srcLength);
326}

328// Replaceable base class clone() default implementation, does not clone
329Replaceable *
330Replaceable::clone() const {
return NULL__null;
332}

334// UnicodeString overrides clone() with a real implementation
335UnicodeString *
336UnicodeString::clone() const {
LocalPointer<UnicodeString> clonedString(new UnicodeString(*this));
return clonedString.isValid() && !clonedString->isBogus() ? clonedString.orphan() : nullptr;
339}

341//========================================
342// array allocation
343//========================================

345namespace {

347const int32_t kGrowSize = 128;

349// The number of bytes for one int32_t reference counter and capacity UChars
350// must fit into a 32-bit size_t (at least when on a 32-bit platform).
351// We also add one for the NUL terminator, to avoid reallocation in getTerminatedBuffer(),
352// and round up to a multiple of 16 bytes.
353// This means that capacity must be at most (0xfffffff0 - 4) / 2 - 1 = 0x7ffffff5.
354// (With more complicated checks we could go up to 0x7ffffffd without rounding up,
355// but that does not seem worth it.)
356const int32_t kMaxCapacity = 0x7ffffff5;

358int32_t getGrowCapacity(int32_t newLength) {
int32_t growSize = (newLength >> 2) + kGrowSize;
if(growSize <= (kMaxCapacity - newLength)) {
  return newLength + growSize;
} else {
  return kMaxCapacity;
}
365}

367}  // namespace

369UBool
370UnicodeString::allocate(int32_t capacity) {
if(capacity10.1
'capacity' is > US_STACKBUF_SIZE
1
'capacity' is > US_STACKBUF_SIZE
 <= US_STACKBUF_SIZE) {
11
←
Taking false branch→
  fUnion.fFields.fLengthAndFlags = kShortString;
  return TRUE1;
}
if(capacity <= kMaxCapacity) {
12
←
Assuming 'capacity' is > 'kMaxCapacity'→
13
←
Taking false branch→
  ++capacity;  // for the NUL
  // Switch to size_t which is unsigned so that we can allocate up to 4GB.
  // Reference counter + UChars.
  size_t numBytes = sizeof(int32_t) + (size_t)capacity * U_SIZEOF_UCHAR2;
  // Round up to a multiple of 16.
  numBytes = (numBytes + 15) & ~15;
  int32_t *array = (int32_t *) uprv_mallocuprv_malloc_71(numBytes);
  if(array != NULL__null) {
    // set initial refCount and point behind the refCount
    *array++ = 1;
    numBytes -= sizeof(int32_t);

    // have fArray point to the first UChar
    fUnion.fFields.fArray = (UChar *)array;
    fUnion.fFields.fCapacity = (int32_t)(numBytes / U_SIZEOF_UCHAR2);
    fUnion.fFields.fLengthAndFlags = kLongString;
    return TRUE1;
  }
}
fUnion.fFields.fLengthAndFlags = kIsBogus;
fUnion.fFields.fArray = 0;
14
←
Null pointer value stored to field 'fArray'→
fUnion.fFields.fCapacity = 0;
return FALSE0;
399}

401//========================================
402// Destructor
403//========================================

405#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS
406static u_atomic_int32_t finalLengthCounts[0x400];  // UnicodeString::kMaxShortLength+1
407static u_atomic_int32_t beyondCount(0);

409U_CAPIextern "C" 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)(int32_t)(sizeof(finalLengthCounts)/sizeof((finalLengthCounts
)[0])); ++i) {
  beyond += finalLengthCounts[i];
}
printf(">59, %9d\n", beyond);
419}
420#endif

422UnicodeString::~UnicodeString()
423{
424#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);
  }
}
436#endif

releaseArray();
439}

441//========================================
442// Factory methods
443//========================================

445UnicodeString UnicodeString::fromUTF8(StringPiece utf8) {
UnicodeString result;
result.setToUTF8(utf8);
return result;
449}

451UnicodeString 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_strFromUTF32WithSubu_strFromUTF32WithSub_71(utf16, result.getCapacity(), &length16,
      utf32, length,
      0xfffd,  // Substitution character.
      NULL__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(TRUE1);
return result;
481}

483//========================================
484// Assignment
485//========================================

487UnicodeString &
488UnicodeString::operator=(const UnicodeString &src) {
return copyFrom(src);
490}

492UnicodeString &
493UnicodeString::fastCopyFrom(const UnicodeString &src) {
return copyFrom(src, TRUE1);
495}

497UnicodeString &
498UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) {
// if assigning to ourselves, do nothing
if(this == &src) {
  return *this;
}

// is the right side bogus?
if(src.isBogus()) {
  setToBogus();
  return *this;
}

// delete the current contents
releaseArray();

if(src.isEmpty()) {
  // empty string - use the stack buffer
  setToEmpty();
  return *this;
}

// fLength>0 and not an "open" src.getBuffer(minCapacity)
fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags;
switch(src.fUnion.fFields.fLengthAndFlags & kAllStorageFlags) {
case kShortString:
  // short string using the stack buffer, do the same
  uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer,do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false)
              getShortLength() * U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false);
  break;
case kLongString:
  // src uses a refCounted string buffer, use that buffer with refCount
  // 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;
  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;
    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
  U_FALLTHROUGH[[clang::fallthrough]];
case kWritableAlias: {
  // src is a writable alias; we make a copy of that instead
  int32_t srcLength = src.length();
  if(allocate(srcLength)) {
    u_memcpyu_memcpy_71(getArrayStart(), src.getArrayStart(), srcLength);
    setLength(srcLength);
    break;
  }
  // if there is not enough memory, then fall through to setting to bogus
  U_FALLTHROUGH[[clang::fallthrough]];
}
default:
  // if src is bogus, set ourselves to bogus
  // 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;
  break;
}

return *this;
573}

575UnicodeString &UnicodeString::operator=(UnicodeString &&src) U_NOEXCEPTnoexcept {
// 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, TRUE1);
return *this;
581}

583// Same as move assignment except without memory management.
584void UnicodeString::copyFieldsFrom(UnicodeString &src, UBool setSrcToBogus) U_NOEXCEPTnoexcept {
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,do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false)
                getShortLength() * U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false);
  }
} 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__null;
    src.fUnion.fFields.fCapacity = 0;
  }
}
608}

610void UnicodeString::swap(UnicodeString &other) U_NOEXCEPTnoexcept {
UnicodeString temp;  // Empty short string: Known not to need releaseArray().
// Copy fields without resetting source values in between.
temp.copyFieldsFrom(*this, FALSE0);
this->copyFieldsFrom(other, FALSE0);
other.copyFieldsFrom(temp, FALSE0);
// Set temp to an empty string so that other's memory is not released twice.
temp.fUnion.fFields.fLengthAndFlags = kShortString;
618}

620//========================================
621// Miscellaneous operations
622//========================================

624UnicodeString 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);
          UChar32 c = unescapeAt(i); // advances i
          if (c < 0) {
              result.remove(); // return empty string
              break; // invalid escape sequence
          }
          result.append(c);
          prev = i;
      }
  }
  return result;
649}

651UChar32 UnicodeString::unescapeAt(int32_t &offset) const {
  return u_unescapeAtu_unescapeAt_71(UnicodeString_charAt, &offset, length(), (void*)this);
653}

655//========================================
656// Read-only implementation
657//========================================
658UBool
659UnicodeString::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):: memcmp(getArrayStart(), text.getArrayStart(),len * 2) == 0;
663}

665int8_t
666UnicodeString::doCompare( int32_t start,
            int32_t length,
            const UChar *srcChars,
            int32_t srcStart,
            int32_t srcLength) const
671{
// compare illegal string values
if(isBogus()) {
  return -1;
}

// pin indices to legal values
pinIndices(start, length);

if(srcChars == NULL__null) {
  // treat const UChar *srcChars==NULL as an empty string
  return length == 0 ? 0 : 1;
}

// get the correct pointer
const UChar *chars = getArrayStart();

chars += start;
srcChars += srcStart;

int32_t minLength;
int8_t lengthResult;

// get the srcLength if necessary
if(srcLength < 0) {
  srcLength = u_strlenu_strlen_71(srcChars + srcStart);
}

// are we comparing different lengths?
if(length != srcLength) {
  if(length < srcLength) {
    minLength = length;
    lengthResult = -1;
  } else {
    minLength = srcLength;
    lengthResult = 1;
  }
} else {
  minLength = length;
  lengthResult = 0;
}

/*
 * note that uprv_memcmp() returns an int but we return an int8_t;
 * we need to take care not to truncate the result -
 * one way to do this is to right-shift the value to
 * move the sign bit into the lower 8 bits and making sure that this
 * does not become 0 itself
 */

if(minLength > 0 && chars != srcChars) {
  int32_t result;

724#   if U_IS_BIG_ENDIAN(1234 == 4321) 
    // big-endian: byte comparison works
    result = uprv_memcmp(chars, srcChars, minLength * sizeof(UChar)):: memcmp(chars, srcChars,minLength * sizeof(UChar));
    if(result != 0) {
      return (int8_t)(result >> 15 | 1);
    }
730#   else
    // little-endian: compare UChar units
    do {
      result = ((int32_t)*(chars++) - (int32_t)*(srcChars++));
      if(result != 0) {
        return (int8_t)(result >> 15 | 1);
      }
    } while(--minLength > 0);
738#   endif
}
return lengthResult;
741}

743/* String compare in code point order - doCompare() compares in code unit order. */
744int8_t
745UnicodeString::doCompareCodePointOrder(int32_t start,
                                     int32_t length,
                                     const UChar *srcChars,
                                     int32_t srcStart,
                                     int32_t srcLength) const
750{
// compare illegal string values
// treat const UChar *srcChars==NULL as an empty string
if(isBogus()) {
  return -1;
}

// pin indices to legal values
pinIndices(start, length);

if(srcChars == NULL__null) {
  srcStart = srcLength = 0;
}

int32_t diff = uprv_strCompareuprv_strCompare_71(getArrayStart() + start, length, (srcChars!=NULL__null)?(srcChars + srcStart):NULL__null, srcLength, FALSE0, TRUE1);
/* translate the 32-bit result into an 8-bit one */
if(diff!=0) {
  return (int8_t)(diff >> 15 | 1);
} else {
  return 0;
}
771}

773int32_t
774UnicodeString::getLength() const {
  return length();
776}

778UChar
779UnicodeString::getCharAt(int32_t offset) const {
return charAt(offset);
781}

783UChar32
784UnicodeString::getChar32At(int32_t offset) const {
return char32At(offset);
786}

788UChar32
789UnicodeString::char32At(int32_t offset) const
790{
int32_t len = length();
if((uint32_t)offset < (uint32_t)len) {
  const UChar *array = getArrayStart();
  UChar32 c;
  U16_GET(array, 0, offset, len, c)do { (c)=(array)[offset]; if((((c)&0xfffff800)==0xd800)) {
 uint16_t __c2; if((((c)&0x400)==0)) { if((offset)+1!=(len
) && (((__c2=(array)[(offset)+1])&0xfffffc00)==0xdc00
)) { (c)=(((UChar32)((c))<<10UL)+(UChar32)(__c2)-((0xd800
<<10UL)+0xdc00-0x10000)); } } else { if((offset)>(0)
 && (((__c2=(array)[(offset)-1])&0xfffffc00)==0xd800
)) { (c)=(((UChar32)(__c2)<<10UL)+(UChar32)((c))-((0xd800
<<10UL)+0xdc00-0x10000)); } } } } while (false);
  return c;
} else {
  return kInvalidUChar;
}
800}

802int32_t
803UnicodeString::getChar32Start(int32_t offset) const {
if((uint32_t)offset < (uint32_t)length()) {
  const UChar *array = getArrayStart();
  U16_SET_CP_START(array, 0, offset)do { if(((((array)[offset])&0xfffffc00)==0xdc00) &&
 (offset)>(0) && ((((array)[(offset)-1])&0xfffffc00
)==0xd800)) { --(offset); } } while (false);
  return offset;
} else {
  return 0;
}
811}

813int32_t
814UnicodeString::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)do { if((0)<(offset) && ((offset)<(len) || (len
)<0) && ((((array)[(offset)-1])&0xfffffc00)==0xd800
) && ((((array)[offset])&0xfffffc00)==0xdc00)) { ++
(offset); } } while (false);
  return offset;
} else {
  return len;
}
823}

825int32_t
826UnicodeString::countChar32(int32_t start, int32_t length) const {
pinIndices(start, length);
// if(isBogus()) then fArray==0 and start==0 - u_countChar32() checks for NULL
return u_countChar32u_countChar32_71(getArrayStart()+start, length);
830}

832UBool
833UnicodeString::hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const {
pinIndices(start, length);
// if(isBogus()) then fArray==0 and start==0 - u_strHasMoreChar32Than() checks for NULL
return u_strHasMoreChar32Thanu_strHasMoreChar32Than_71(getArrayStart()+start, length, number);
837}

839int32_t
840UnicodeString::moveIndex32(int32_t index, int32_t delta) const {
// pin index
int32_t len = length();
if(index<0) {
  index=0;
} else if(index>len) {
  index=len;
}

const UChar *array = getArrayStart();
if(delta>0) {
  U16_FWD_N(array, index, len, delta)do { int32_t __N=(delta); while(__N>0 && ((index)<
(len) || ((len)<0 && (array)[index]!=0))) { do { if
(((((array)[(index)++])&0xfffffc00)==0xd800) && (
index)!=(len) && ((((array)[index])&0xfffffc00)==
0xdc00)) { ++(index); } } while (false); --__N; } } while (false
);
} else {
  U16_BACK_N(array, 0, index, -delta)do { int32_t __N=(-delta); while(__N>0 && (index)>
(0)) { do { if(((((array)[--(index)])&0xfffffc00)==0xdc00
) && (index)>(0) && ((((array)[(index)-1])
&0xfffffc00)==0xd800)) { --(index); } } while (false); --
__N; } } while (false);
}

return index;
857}

859void
860UnicodeString::doExtract(int32_t start,
           int32_t length,
           UChar *dst,
           int32_t dstStart) const
864{
// pin indices to legal values
pinIndices(start, length);

// do not copy anything if we alias dst itself
const UChar *array = getArrayStart();
if(array + start != dst + dstStart) {
  us_arrayCopy(array, start, dst, dstStart, length);
}
873}

875int32_t
876UnicodeString::extract(Char16Ptr dest, int32_t destCapacity,
                     UErrorCode &errorCode) const {
int32_t len = length();
if(U_SUCCESS(errorCode)) {
  if(isBogus() || destCapacity<0 || (destCapacity>0 && dest==0)) {
    errorCode=U_ILLEGAL_ARGUMENT_ERROR;
  } else {
    const UChar *array = getArrayStart();
    if(len>0 && len<=destCapacity && array!=dest) {
      u_memcpyu_memcpy_71(dest, array, len);
    }
    return u_terminateUCharsu_terminateUChars_71(dest, destCapacity, len, &errorCode);
  }
}

return len;
892}

894int32_t
895UnicodeString::extract(int32_t start,
                     int32_t length,
                     char *target,
                     int32_t targetCapacity,
                     enum EInvariant) const
900{
// if the arguments are illegal, then do nothing
if(targetCapacity < 0 || (targetCapacity > 0 && target == NULL__null)) {
  return 0;
}

// pin the indices to legal values
pinIndices(start, length);

if(length <= targetCapacity) {
  u_UCharsToCharsu_UCharsToChars_71(getArrayStart() + start, target, length);
}
UErrorCode status = U_ZERO_ERROR;
return u_terminateCharsu_terminateChars_71(target, targetCapacity, length, &status);
914}

916UnicodeString
917UnicodeString::tempSubString(int32_t start, int32_t len) const {
pinIndices(start, len);
const UChar *array = getBuffer();  // not getArrayStart() to check kIsBogus & kOpenGetBuffer
if(array==NULL__null) {
  array=fUnion.fStackFields.fBuffer;  // anything not NULL because that would make an empty string
  len=-2;  // bogus result string
}
return UnicodeString(FALSE0, array + start, len);
925}

927int32_t
928UnicodeString::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_strToUTF8WithSubu_strToUTF8WithSub_71(target, capacity, &length8,
                   getBuffer() + start, len,
                   0xFFFD,  // Standard substitution character.
                   NULL__null,    // Don't care about number of substitutions.
                   &errorCode);
return length8;
939}

941#if U_CHARSET_IS_UTF81

943int32_t
944UnicodeString::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);
951}

953// else see unistr_cnv.cpp
954#endif

956void 
957UnicodeString::extractBetween(int32_t start,
                int32_t limit,
                UnicodeString& target) const {
pinIndex(start);
pinIndex(limit);
doExtract(start, limit - start, target);
963}

965// When converting from UTF-16 to UTF-8, the result will have at most 3 times
966// as many bytes as the source has UChars.
967// The "worst cases" are writing systems like Indic, Thai and CJK with
968// 3:1 bytes:UChars.
969void
970UnicodeString::toUTF8(ByteSink &sink) const {
int32_t length16 = length();
if(length16 != 0) {
  char stackBuffer[1024];
  int32_t capacity = (int32_t)sizeof(stackBuffer);
  UBool utf8IsOwned = FALSE0;
  char *utf8 = sink.GetAppendBuffer(length16 < capacity ? length16 : capacity,
                                    3*length16,
                                    stackBuffer, capacity,
                                    &capacity);
  int32_t length8 = 0;
  UErrorCode errorCode = U_ZERO_ERROR;
  u_strToUTF8WithSubu_strToUTF8WithSub_71(utf8, capacity, &length8,
                     getBuffer(), length16,
                     0xFFFD,  // Standard substitution character.
                     NULL__null,    // Don't care about number of substitutions.
                     &errorCode);
  if(errorCode == U_BUFFER_OVERFLOW_ERROR) {
    utf8 = (char *)uprv_mallocuprv_malloc_71(length8);
    if(utf8 != NULL__null) {
      utf8IsOwned = TRUE1;
      errorCode = U_ZERO_ERROR;
      u_strToUTF8WithSubu_strToUTF8WithSub_71(utf8, length8, &length8,
                         getBuffer(), length16,
                         0xFFFD,  // Standard substitution character.
                         NULL__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_freeuprv_free_71(utf8);
  }
}
1009}

1011int32_t
1012UnicodeString::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_strToUTF32WithSubu_strToUTF32WithSub_71(utf32, capacity, &length32,
      getBuffer(), length(),
      0xfffd,  // Substitution character.
      NULL__null,    // Don't care about number of substitutions.
      &errorCode);
}
return length32;
1023}

1025int32_t 
1026UnicodeString::indexOf(const UChar *srcChars,
             int32_t srcStart,
             int32_t srcLength,
             int32_t start,
             int32_t length) const
1031{
if(isBogus() || srcChars == 0 || srcStart < 0 || srcLength == 0) {
  return -1;
}

// UnicodeString does not find empty substrings
if(srcLength < 0 && srcChars[srcStart] == 0) {
  return -1;
}

// get the indices within bounds
pinIndices(start, length);

// find the first occurrence of the substring
const UChar *array = getArrayStart();
const UChar *match = u_strFindFirstu_strFindFirst_71(array + start, length, srcChars + srcStart, srcLength);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1052}

1054int32_t
1055UnicodeString::doIndexOf(UChar c,
           int32_t start,
           int32_t length) const
1058{
// pin indices
pinIndices(start, length);

// find the first occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memchru_memchr_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1070}

1072int32_t
1073UnicodeString::doIndexOf(UChar32 c,
                       int32_t start,
                       int32_t length) const {
// pin indices
pinIndices(start, length);

// find the first occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memchr32u_memchr32_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1087}

1089int32_t 
1090UnicodeString::lastIndexOf(const UChar *srcChars,
             int32_t srcStart,
             int32_t srcLength,
             int32_t start,
             int32_t length) const
1095{
if(isBogus() || srcChars == 0 || srcStart < 0 || srcLength == 0) {
  return -1;
}

// UnicodeString does not find empty substrings
if(srcLength < 0 && srcChars[srcStart] == 0) {
  return -1;
}

// get the indices within bounds
pinIndices(start, length);

// find the last occurrence of the substring
const UChar *array = getArrayStart();
const UChar *match = u_strFindLastu_strFindLast_71(array + start, length, srcChars + srcStart, srcLength);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1116}

1118int32_t
1119UnicodeString::doLastIndexOf(UChar c,
               int32_t start,
               int32_t length) const
1122{
if(isBogus()) {
  return -1;
}

// pin indices
pinIndices(start, length);

// find the last occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memrchru_memrchr_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1138}

1140int32_t
1141UnicodeString::doLastIndexOf(UChar32 c,
                           int32_t start,
                           int32_t length) const {
// pin indices
pinIndices(start, length);

// find the last occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memrchr32u_memrchr32_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1155}

1157//========================================
1158// Write implementation
1159//========================================

1161UnicodeString& 
1162UnicodeString::findAndReplace(int32_t start,
                int32_t length,
                const UnicodeString& oldText,
                int32_t oldStart,
                int32_t oldLength,
                const UnicodeString& newText,
                int32_t newStart,
                int32_t newLength)
1170{
if(isBogus() || oldText.isBogus() || newText.isBogus()) {
  return *this;
}

pinIndices(start, length);
oldText.pinIndices(oldStart, oldLength);
newText.pinIndices(newStart, newLength);

if(oldLength == 0) {
  return *this;
}

while(length > 0 && length >= oldLength) {
  int32_t pos = indexOf(oldText, oldStart, oldLength, start, length);
  if(pos < 0) {
    // no more oldText's here: done
    break;
  } else {
    // we found oldText, replace it by newText and go beyond it
    replace(pos, oldLength, newText, newStart, newLength);
    length -= pos + oldLength - start;
    start = pos + newLength;
  }
}

return *this;
1197}


1200void
1201UnicodeString::setToBogus()
1202{
releaseArray();
18
←
Calling 'UnicodeString::releaseArray'→

fUnion.fFields.fLengthAndFlags = kIsBogus;
fUnion.fFields.fArray = 0;
fUnion.fFields.fCapacity = 0;
1208}

1210// turn a bogus string into an empty one
1211void
1212UnicodeString::unBogus() {
if(fUnion.fFields.fLengthAndFlags & kIsBogus) {
  setToEmpty();
}
1216}

1218const char16_t *
1219UnicodeString::getTerminatedBuffer() {
if(!isWritable()) {
  return nullptr;
}
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(len<INT32_MAX(2147483647) && cloneArrayIfNeeded(len+1)) {
  array = getArrayStart();
  array[len] = 0;
  return array;
} else {
  return nullptr;
}
1254}

1256// setTo() analogous to the readonly-aliasing constructor with the same signature
1257UnicodeString &
1258UnicodeString::setTo(UBool isTerminated,
                   ConstChar16Ptr textPtr,
                   int32_t textLength)
1261{
if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {
  // do not modify a string that has an "open" getBuffer(minCapacity)
  return *this;
}

const UChar *text = textPtr;
if(text == NULL__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_strlenu_strlen_71(text);
}
fUnion.fFields.fLengthAndFlags = kReadonlyAlias;
setArray((UChar *)text, textLength, isTerminated ? textLength + 1 : textLength);
return *this;
1292}

1294// setTo() analogous to the writable-aliasing constructor with the same signature
1295UnicodeString &
1296UnicodeString::setTo(UChar *buffer,
                   int32_t buffLength,
                   int32_t buffCapacity) {
if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {
  // do not modify a string that has an "open" getBuffer(minCapacity)
  return *this;
}

if(buffer == NULL__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);
return *this;
1328}

1330UnicodeString &UnicodeString::setToUTF8(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_strFromUTF8WithSubu_strFromUTF8WithSub_71(utf16, getCapacity(), &length16,
    utf8.data(), length,
    0xfffd,  // Substitution character.
    NULL__null,    // Don't care about number of substitutions.
    &errorCode);
releaseBuffer(length16);
if(U_FAILURE(errorCode)) {
  setToBogus();
}
return *this;
1353}

1355UnicodeString&
1356UnicodeString::setCharAt(int32_t offset,
           UChar c)
1358{
int32_t len = length();
if(cloneArrayIfNeeded() && len > 0) {
  if(offset < 0) {
    offset = 0;
  } else if(offset >= len) {
    offset = len - 1;
  }

  getArrayStart()[offset] = c;
}
return *this;
1370}

1372UnicodeString&
1373UnicodeString::replace(int32_t start,
             int32_t _length,
             UChar32 srcChar) {
UChar buffer[U16_MAX_LENGTH2];
int32_t count = 0;
UBool isError = FALSE0;
U16_APPEND(buffer, count, U16_MAX_LENGTH, srcChar, isError)do { if((uint32_t)(srcChar)<=0xffff) { (buffer)[(count)++]
=(uint16_t)(srcChar); } else if((uint32_t)(srcChar)<=0x10ffff
 && (count)+1<(2)) { (buffer)[(count)++]=(uint16_t
)(((srcChar)>>10)+0xd7c0); (buffer)[(count)++]=(uint16_t
)(((srcChar)&0x3ff)|0xdc00); } else { (isError)=true; } }
 while (false);
// 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);
1384}

1386UnicodeString&
1387UnicodeString::append(UChar32 srcChar) {
UChar buffer[U16_MAX_LENGTH2];
int32_t _length = 0;
UBool isError = FALSE0;
U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError)do { if((uint32_t)(srcChar)<=0xffff) { (buffer)[(_length)++
]=(uint16_t)(srcChar); } else if((uint32_t)(srcChar)<=0x10ffff
 && (_length)+1<(2)) { (buffer)[(_length)++]=(uint16_t
)(((srcChar)>>10)+0xd7c0); (buffer)[(_length)++]=(uint16_t
)(((srcChar)&0x3ff)|0xdc00); } else { (isError)=true; } }
 while (false);
// We test isError so that the compiler does not complain that we don't.
// If isError then _length==0 which turns the doAppend() into a no-op anyway.
return isError ? *this : doAppend(buffer, 0, _length);
1395}

1397UnicodeString&
1398UnicodeString::doReplace( int32_t start,
            int32_t length,
            const UnicodeString& src,
            int32_t srcStart,
            int32_t srcLength)
1403{
// 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);
1410}

1412UnicodeString&
1413UnicodeString::doReplace(int32_t start,
           int32_t length,
           const UChar *srcChars,
           int32_t srcStart,
           int32_t srcLength)
1418{
if(!isWritable()) {
  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(start == oldLength) {
  return doAppend(srcChars, srcStart, srcLength);
}

if(srcChars == 0) {
  srcLength = 0;
} else {
  // Perform all remaining operations relative to srcChars + srcStart.
  // From this point forward, do not use srcStart.
  srcChars += srcStart;
  if (srcLength < 0) {
    // get the srcLength if necessary
    srcLength = u_strlenu_strlen_71(srcChars);
  }
}

// pin the indices to legal values
pinIndices(start, length);

// Calculate the size of the string after the replace.
// Avoid int32_t overflow.
int32_t newLength = oldLength - length;
if(srcLength > (INT32_MAX(2147483647) - newLength)) {
  setToBogus();
  return *this;
}
newLength += srcLength;

// Check for insertion into ourself
const UChar *oldArray = getArrayStart();
if (isBufferWritable() &&
    oldArray < srcChars + srcLength &&
    srcChars < oldArray + oldLength) {
  // Copy into a new UnicodeString and start over
  UnicodeString copy(srcChars, srcLength);
  if (copy.isBogus()) {
    setToBogus();
    return *this;
  }
  return doReplace(start, length, copy.getArrayStart(), 0, srcLength);
}

// 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];
if((fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) && (newLength > US_STACKBUF_SIZE)) {
  // copy the stack buffer contents because it will be overwritten with
  // fUnion.fFields values
  u_memcpyu_memcpy_71(oldStackBuffer, oldArray, oldLength);
  oldArray = oldStackBuffer;
}

// clone our array and allocate a bigger array if needed
int32_t *bufferToDelete = 0;
if(!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength),
                       FALSE0, &bufferToDelete)
) {
  return *this;
}

// now do the replace

UChar *newArray = getArrayStart();
if(newArray != oldArray) {
  // if fArray changed, then we need to copy everything except what will change
  us_arrayCopy(oldArray, 0, newArray, 0, start);
  us_arrayCopy(oldArray, start + length,
               newArray, start + srcLength,
               oldLength - (start + length));
} else if(length != srcLength) {
  // fArray did not change; copy only the portion that isn't changing, leaving a hole
  us_arrayCopy(oldArray, start + length,
               newArray, start + srcLength,
               oldLength - (start + length));
}

// now fill in the hole with the new string
us_arrayCopy(srcChars, 0, newArray, start, srcLength);

setLength(newLength);

// delayed delete in case srcChars == fArray when we started, and
// to keep oldArray alive for the above operations
if (bufferToDelete) {
  uprv_freeuprv_free_71(bufferToDelete);
}

return *this;
1533}

1535// Versions of doReplace() only for append() variants.
1536// doReplace() and doAppend() optimize for different cases.

1538UnicodeString&
1539UnicodeString::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);
1547}

1549UnicodeString&
1550UnicodeString::doAppend(const UChar *srcChars, int32_t srcStart, int32_t srcLength) {
if(!isWritable() || srcLength == 0 || srcChars == NULL__null) {
  return *this;
}

// Perform all remaining operations relative to srcChars + srcStart.
// From this point forward, do not use srcStart.
srcChars += srcStart;

if(srcLength < 0) {
  // get the srcLength if necessary
  if((srcLength = u_strlenu_strlen_71(srcChars)) == 0) {
    return *this;
  }
}

int32_t oldLength = length();
int32_t newLength;
if (uprv_add32_overflowuprv_add32_overflow_71(oldLength, srcLength, &newLength)) {
  setToBogus();
  return *this;
}

// Check for append onto ourself
const UChar* oldArray = getArrayStart();
if (isBufferWritable() &&
    oldArray < srcChars + srcLength &&
    srcChars < oldArray + oldLength) {
  // Copy into a new UnicodeString and start over
  UnicodeString copy(srcChars, srcLength);
  if (copy.isBogus()) {
    setToBogus();
    return *this;
  }
  return doAppend(copy.getArrayStart(), 0, srcLength);
}

// optimize append() onto a large-enough, owned string
if((newLength <= getCapacity() && isBufferWritable()) ||
    cloneArrayIfNeeded(newLength, getGrowCapacity(newLength))) {
  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 != newArray + oldLength) {
    us_arrayCopy(srcChars, 0, newArray, oldLength, srcLength);
  }
  setLength(newLength);
}
return *this;
1604}

1606/**
* Replaceable API
*/
1609void
1610UnicodeString::handleReplaceBetween(int32_t start,
                                  int32_t limit,
                                  const UnicodeString& text) {
  replaceBetween(start, limit, text);
1614}

1616/**
* Replaceable API
*/
1619void 
1620UnicodeString::copy(int32_t start, int32_t limit, int32_t dest) {
  if (limit <= start) {
      return; // Nothing to do; avoid bogus malloc call
  }
  UChar* text = (UChar*) uprv_mallocuprv_malloc_71( sizeof(UChar) * (limit - start) );
  // Check to make sure text is not null.
  if (text != NULL__null) {
   extractBetween(start, limit, text, 0);
   insert(dest, text, 0, limit - start);    
   uprv_freeuprv_free_71(text);
  }
1631}

1633/**
* Replaceable API
*
* NOTE: This is for the Replaceable class.  There is no rep.cpp,
* so we implement this function here.
*/
1639UBool Replaceable::hasMetaData() const {
  return TRUE1;
1641}

1643/**
* Replaceable API
*/
1646UBool UnicodeString::hasMetaData() const {
  return FALSE0;
1648}

1650UnicodeString&
1651UnicodeString::doReverse(int32_t start, int32_t length) {
if(length <= 1 || !cloneArrayIfNeeded()) {
  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 *right = left + length - 1;  // -1 for inclusive boundary (length>=2)
UChar swap;
UBool hasSupplementary = FALSE0;

// Before the loop we know left<right because length>=2.
do {
  hasSupplementary |= (UBool)U16_IS_LEAD(swap = *left)(((swap = *left)&0xfffffc00)==0xd800);
  hasSupplementary |= (UBool)U16_IS_LEAD(*left++ = *right)(((*left++ = *right)&0xfffffc00)==0xd800);
  *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)(((*left)&0xfffffc00)==0xd800);

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

  left = getArrayStart() + start;
  right = left + length - 1; // -1 so that we can look at *(left+1) if left<right
  while(left < right) {
    if(U16_IS_TRAIL(swap = *left)(((swap = *left)&0xfffffc00)==0xdc00) && U16_IS_LEAD(swap2 = *(left + 1))(((swap2 = *(left + 1))&0xfffffc00)==0xd800)) {
      *left++ = swap2;
      *left++ = swap;
    } else {
      ++left;
    }
  }
}

return *this;
1694}

1696UBool 
1697UnicodeString::padLeading(int32_t targetLength,
                        UChar padChar)
1699{
int32_t oldLength = length();
if(oldLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
  return FALSE0;
} else {
  // move contents up by padding width
  UChar *array = getArrayStart();
  int32_t start = targetLength - oldLength;
  us_arrayCopy(array, 0, array, start, oldLength);

  // fill in padding character
  while(--start >= 0) {
    array[start] = padChar;
  }
  setLength(targetLength);
  return TRUE1;
}
1716}

1718UBool 
1719UnicodeString::padTrailing(int32_t targetLength,
                         UChar padChar)
1721{
int32_t oldLength = length();
if(oldLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
  return FALSE0;
} else {
  // fill in padding character
  UChar *array = getArrayStart();
  int32_t length = targetLength;
  while(--length >= oldLength) {
    array[length] = padChar;
  }
  setLength(targetLength);
  return TRUE1;
}
1735}

1737//========================================
1738// Hashing
1739//========================================
1740int32_t
1741UnicodeString::doHashCode() const
1742{
  /* Delegate hash computation to uhash.  This makes UnicodeString
   * hashing consistent with UChar* hashing.  */
  int32_t hashCode = ustr_hashUCharsNustr_hashUCharsN_71(getArrayStart(), length());
  if (hashCode == kInvalidHashCode) {
      hashCode = kEmptyHashCode;
  }
  return hashCode;
1750}

1752//========================================
1753// External Buffer
1754//========================================

1756char16_t *
1757UnicodeString::getBuffer(int32_t minCapacity) {
if(minCapacity>=-1 && cloneArrayIfNeeded(minCapacity)) {
  fUnion.fFields.fLengthAndFlags|=kOpenGetBuffer;
  setZeroLength();
  return getArrayStart();
} else {
  return nullptr;
}
1765}

1767void
1768UnicodeString::releaseBuffer(int32_t newLength) {
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);
  fUnion.fFields.fLengthAndFlags&=~kOpenGetBuffer;
}
1785}

1787//========================================
1788// Miscellaneous
1789//========================================
1790UBool
1791UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
                                int32_t growCapacity,
                                UBool doCopyArray,
                                int32_t **pBufferToDelete,
                                UBool forceClone) {
// default parameters need to be static, therefore
// the defaults are -1 to have convenience defaults
if(newCapacity == -1) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
  newCapacity = getCapacity();
}

// while a getBuffer(minCapacity) is "open",
// prevent any modifications of the string by returning FALSE here
// if the string is bogus, then only an assignment or similar can revive it
if(!isWritable()) {
  return FALSE0;
}

/*
 * 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(forceClone3.1
'forceClone' is 0
1
'forceClone' is 0
 ||
   fUnion.fFields.fLengthAndFlags & kBufferIsReadonly ||
4
←
Assuming the condition is true→
   (fUnion.fFields.fLengthAndFlags & kRefCounted && refCount() > 1) ||
   newCapacity > getCapacity()
) {
  // check growCapacity for default value and use of the stack buffer
  if(growCapacity4.1
'growCapacity' is < 0
1
'growCapacity' is < 0
 < 0) {
5
←
Taking true branch→
    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;
  int32_t oldLength = length();
  int16_t flags = fUnion.fFields.fLengthAndFlags;

  if(flags&kUsingStackBuffer) {
6
←
Assuming the condition is true→
7
←
Taking true branch→
    U_ASSERT(!(flags&kRefCounted))(void)0; /* kRefCounted and kUsingStackBuffer are mutally exclusive */
    if(doCopyArray7.1
'doCopyArray' is 1
1
'doCopyArray' is 1
 && growCapacity > US_STACKBUF_SIZE) {
8
←
Assuming 'growCapacity' is > US_STACKBUF_SIZE→
9
←
Taking true branch→
      // copy the stack buffer contents because it will be overwritten with
      // fUnion.fFields values
      us_arrayCopy(fUnion.fStackFields.fBuffer, 0, oldStackBuffer, 0, oldLength);
      oldArray = oldStackBuffer;
    } else {
      oldArray = NULL__null; // no need to copy from the stack buffer to itself
    }
  } else {
    oldArray = fUnion.fFields.fArray;
    U_ASSERT(oldArray!=NULL)(void)0; /* when stack buffer is not used, oldArray must have a non-NULL reference */
  }

  // allocate a new array
  if(allocate(growCapacity) ||
10
←
Calling 'UnicodeString::allocate'→
15
←
Returning from 'UnicodeString::allocate'→
     (newCapacity15.1
'newCapacity' is >= 'growCapacity'
1
'newCapacity' is >= 'growCapacity'
 < growCapacity && allocate(newCapacity))
  ) {
    if(doCopyArray) {
      // copy the contents
      // do not copy more than what fits - it may be smaller than before
      int32_t minLength = oldLength;
      newCapacity = getCapacity();
      if(newCapacity < minLength) {
        minLength = newCapacity;
      }
      if(oldArray != NULL__null) {
        us_arrayCopy(oldArray, 0, getArrayStart(), 0, minLength);
      }
      setLength(minLength);
    } else {
      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_freeuprv_free_71((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)) {
16
←
Taking false branch→
      fUnion.fFields.fArray = oldArray;
    }
    fUnion.fFields.fLengthAndFlags = flags;
    setToBogus();
17
←
Calling 'UnicodeString::setToBogus'→
    return FALSE0;
  }
}
return TRUE1;
1897}

1899// UnicodeStringAppendable ------------------------------------------------- ***

1901UnicodeStringAppendable::~UnicodeStringAppendable() {}

1903UBool
1904UnicodeStringAppendable::appendCodeUnit(UChar c) {
return str.doAppend(&c, 0, 1).isWritable();
1906}

1908UBool
1909UnicodeStringAppendable::appendCodePoint(UChar32 c) {
UChar buffer[U16_MAX_LENGTH2];
int32_t cLength = 0;
UBool isError = FALSE0;
U16_APPEND(buffer, cLength, U16_MAX_LENGTH, c, isError)do { if((uint32_t)(c)<=0xffff) { (buffer)[(cLength)++]=(uint16_t
)(c); } else if((uint32_t)(c)<=0x10ffff && (cLength
)+1<(2)) { (buffer)[(cLength)++]=(uint16_t)(((c)>>10
)+0xd7c0); (buffer)[(cLength)++]=(uint16_t)(((c)&0x3ff)|0xdc00
); } else { (isError)=true; } } while (false);
return !isError && str.doAppend(buffer, 0, cLength).isWritable();
1915}

1917UBool
1918UnicodeStringAppendable::appendString(const UChar *s, int32_t length) {
return str.doAppend(s, 0, length).isWritable();
1920}

1922UBool
1923UnicodeStringAppendable::reserveAppendCapacity(int32_t appendCapacity) {
return str.cloneArrayIfNeeded(str.length() + appendCapacity);
1
Calling 'UnicodeString::cloneArrayIfNeeded'→
1925}

1927UChar *
1928UnicodeStringAppendable::getAppendBuffer(int32_t minCapacity,
                                       int32_t desiredCapacityHint,
                                       UChar *scratch, int32_t scratchCapacity,
                                       int32_t *resultCapacity) {
if(minCapacity < 1 || scratchCapacity < minCapacity) {
  *resultCapacity = 0;
  return NULL__null;
}
int32_t oldLength = str.length();
if(minCapacity <= (kMaxCapacity - oldLength) &&
    desiredCapacityHint <= (kMaxCapacity - oldLength) &&
    str.cloneArrayIfNeeded(oldLength + minCapacity, oldLength + desiredCapacityHint)) {
  *resultCapacity = str.getCapacity() - oldLength;
  return str.getArrayStart() + oldLength;
}
*resultCapacity = scratchCapacity;
return scratch;
1945}

1947U_NAMESPACE_END}

1949U_NAMESPACE_USEusing namespace icu_71;

1951U_CAPIextern "C" int32_t U_EXPORT2
1952uhash_hashUnicodeStringuhash_hashUnicodeString_71(const UElement key) {
  const UnicodeString *str = (const UnicodeString*) key.pointer;
  return (str == NULL__null) ? 0 : str->hashCode();
1955}

1957// Moved here from uhash_us.cpp so that using a UVector of UnicodeString*
1958// does not depend on hashtable code.
1959U_CAPIextern "C" UBool U_EXPORT2
1960uhash_compareUnicodeStringuhash_compareUnicodeString_71(const UElement key1, const UElement key2) {
  const UnicodeString *str1 = (const UnicodeString*) key1.pointer;
  const UnicodeString *str2 = (const UnicodeString*) key2.pointer;
  if (str1 == str2) {
      return TRUE1;
  }
  if (str1 == NULL__null || str2 == NULL__null) {
      return FALSE0;
  }
  return *str1 == *str2;
1970}

1972#ifdef U_STATIC_IMPLEMENTATION1
1973/*
1974This should never be called. It is defined here to make sure that the
1975virtual vector deleting destructor is defined within unistr.cpp.
1976The vector deleting destructor is already a part of UObject,
1977but defining it here makes sure that it is included with this object file.
1978This makes sure that static library dependencies are kept to a minimum.
1979*/
1980#if defined(__clang__1) || U_GCC_MAJOR_MINOR(4 * 100 + 2) >= 1100
1981#pragma GCC diagnostic push
1982#pragma GCC diagnostic ignored "-Wunused-function"
1983static void uprv_UnicodeStringDummy(void) {
  delete [] (new UnicodeString[2]);
1985}
1986#pragma GCC diagnostic pop
1987#endif
1988#endif

←

../deps/icu-small/source/common/umutex.h

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4**********************************************************************
5*   Copyright (C) 1997-2015, International Business Machines
6*   Corporation and others.  All Rights Reserved.
7**********************************************************************
8*
9* File UMUTEX.H
10*
11* Modification History:
12*
13*   Date        Name        Description
14*   04/02/97  aliu        Creation.
15*   04/07/99  srl         rewrite - C interface, multiple mutices
16*   05/13/99  stephen     Changed to umutex (from cmutex)
17******************************************************************************
18*/
19 
20#ifndef UMUTEX_H
21#define UMUTEX_H
22 
23#include <atomic>
24#include <condition_variable>
25#include <mutex>
26#include <type_traits>
27 
28#include "unicode/utypes.h"
29#include "unicode/uclean.h"
30#include "unicode/uobject.h"
31 
32#include "putilimp.h"
33 
34#if defined(U_USER_ATOMICS_H) || defined(U_USER_MUTEX_H)
35// Support for including an alternate implementation of atomic & mutex operations has been withdrawn.
36// See issue ICU-20185.
37#error U_USER_ATOMICS and U_USER_MUTEX_H are not supported
38#endif
39 
40// Export an explicit template instantiation of std::atomic<int32_t>. 
41// When building DLLs for Windows this is required as it is used as a data member of the exported SharedObject class.
42// See digitlst.h, pluralaffix.h, datefmt.h, and others for similar examples.
43//
44// Similar story for std::atomic<std::mutex *>, and the exported UMutex class.
45#if U_PF_WINDOWS1000 <= U_PLATFORM4000 && U_PLATFORM4000 <= U_PF_CYGWIN1900 && !defined(U_IN_DOXYGEN)
46#if defined(__clang__1) || defined(_MSC_VER)
47  #if defined(__clang__1)
48    // Suppress the warning that the explicit instantiation after explicit specialization has no effect.
49    #pragma clang diagnostic push
50    #pragma clang diagnostic ignored "-Winstantiation-after-specialization"
51  #endif
52template struct U_COMMON_API std::atomic<int32_t>;
53template struct U_COMMON_API std::atomic<std::mutex *>;
54  #if defined(__clang__1)
55    #pragma clang diagnostic pop
56  #endif
57#elif defined(__GNUC__4)
58// For GCC this class is already exported/visible, so no need for U_COMMON_API.
59template struct std::atomic<int32_t>;
60template struct std::atomic<std::mutex *>;
61#endif
62#endif
63 
64 
65U_NAMESPACE_BEGINnamespace icu_71 {
66 
67/****************************************************************************
68 *
69 *   Low Level Atomic Operations, ICU wrappers for.
70 *
71 ****************************************************************************/
72 
73typedef std::atomic<int32_t> u_atomic_int32_t;
74#define ATOMIC_INT32_T_INITIALIZER(val){ val } ATOMIC_VAR_INIT(val){ val }
75 
76inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) {
77    return var.load(std::memory_order_acquire);
78}
79 
80inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
81    var.store(val, std::memory_order_release);
82}
83 
84inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) {
85    return var->fetch_add(1) + 1;
86}
87 
88inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) {
89    return var->fetch_sub(1) - 1;
23
←
Called C++ object pointer is null
90}
91 
92 
93/*************************************************************************************************
94 *
95 *  UInitOnce Definitions.
96 *
97 *************************************************************************************************/
98 
99struct UInitOnce {
100    u_atomic_int32_t   fState;
101    UErrorCode       fErrCode;
102    void reset() {fState = 0;}
103    UBool isReset() {return umtx_loadAcquire(fState) == 0;}
104// Note: isReset() is used by service registration code.
105//                 Thread safety of this usage needs review.
106};
107 
108#define U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR} {ATOMIC_INT32_T_INITIALIZER(0){ 0 }, U_ZERO_ERROR}
109 
110 
111U_COMMON_API UBool U_EXPORT2 umtx_initImplPreInit(UInitOnce &);
112U_COMMON_API void  U_EXPORT2 umtx_initImplPostInit(UInitOnce &);
113 
114template<class T> void umtx_initOnce(UInitOnce &uio, T *obj, void (U_CALLCONV T::*fp)()) {
115    if (umtx_loadAcquire(uio.fState) == 2) {
116        return;
117    }
118    if (umtx_initImplPreInit(uio)) {
119        (obj->*fp)();
120        umtx_initImplPostInit(uio);
121    }
122}
123 
124 
125// umtx_initOnce variant for plain functions, or static class functions.
126//               No context parameter.
127inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)()) {
128    if (umtx_loadAcquire(uio.fState) == 2) {
129        return;
130    }
131    if (umtx_initImplPreInit(uio)) {
132        (*fp)();
133        umtx_initImplPostInit(uio);
134    }
135}
136 
137// umtx_initOnce variant for plain functions, or static class functions.
138//               With ErrorCode, No context parameter.
139inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(UErrorCode &), UErrorCode &errCode) {
140    if (U_FAILURE(errCode)) {
141        return;
142    }
143    if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) {
144        // We run the initialization.
145        (*fp)(errCode);
146        uio.fErrCode = errCode;
147        umtx_initImplPostInit(uio);
148    } else {
149        // Someone else already ran the initialization.
150        if (U_FAILURE(uio.fErrCode)) {
151            errCode = uio.fErrCode;
152        }
153    }
154}
155 
156// umtx_initOnce variant for plain functions, or static class functions,
157//               with a context parameter.
158template<class T> void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T), T context) {
159    if (umtx_loadAcquire(uio.fState) == 2) {
160        return;
161    }
162    if (umtx_initImplPreInit(uio)) {
163        (*fp)(context);
164        umtx_initImplPostInit(uio);
165    }
166}
167 
168// umtx_initOnce variant for plain functions, or static class functions,
169//               with a context parameter and an error code.
170template<class T> void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) {
171    if (U_FAILURE(errCode)) {
172        return;
173    }
174    if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) {
175        // We run the initialization.
176        (*fp)(context, errCode);
177        uio.fErrCode = errCode;
178        umtx_initImplPostInit(uio);
179    } else {
180        // Someone else already ran the initialization.
181        if (U_FAILURE(uio.fErrCode)) {
182            errCode = uio.fErrCode;
183        }
184    }
185}
186 
187// UMutex should be constexpr-constructible, so that no initialization code
188// is run during startup.
189// This works on all C++ libraries except MS VS before VS2019.
190#if (defined(_CPPLIB_VER) && !defined(_MSVC_STL_VERSION)) || \
191    (defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION < 142)
192    // (VS std lib older than VS2017) || (VS std lib version < VS2019)
193#   define UMUTEX_CONSTEXPRconstexpr
194#else
195#   define UMUTEX_CONSTEXPRconstexpr constexpr
196#endif
197 
198/**
199 * UMutex - ICU Mutex class.
200 *
201 * This is the preferred Mutex class for use within ICU implementation code.
202 * It is a thin wrapper over C++ std::mutex, with these additions:
203 *    - Static instances are safe, not triggering static construction or destruction,
204 *      and the associated order of construction or destruction issues.
205 *    - Plumbed into u_cleanup() for destructing the underlying std::mutex,
206 *      which frees any OS level resources they may be holding.
207 *
208 * Limitations:
209 *    - Static or global instances only. Cannot be heap allocated. Cannot appear as a
210 *      member of another class.
211 *    - No condition variables or other advanced features. If needed, you will need to use
212 *      std::mutex and std::condition_variable directly. For an example, see unifiedcache.cpp
213 *
214 * Typical Usage:
215 *    static UMutex myMutex;
216 *
217 *    {
218 *       Mutex lock(myMutex);
219 *       ...    // Do stuff that is protected by myMutex;
220 *    }         // myMutex is released when lock goes out of scope.
221 */
222 
223class U_COMMON_API UMutex {
224public:
225    UMUTEX_CONSTEXPRconstexpr UMutex() {}
226    ~UMutex() = default;
227 
228    UMutex(const UMutex &other) = delete;
229    UMutex &operator =(const UMutex &other) = delete;
230    void *operator new(size_t) = delete;
231 
232    // requirements for C++ BasicLockable, allows UMutex to work with std::lock_guard
233    void lock() {
234        std::mutex *m = fMutex.load(std::memory_order_acquire);
235        if (m == nullptr) { m = getMutex(); }
236        m->lock();
237    }
238    void unlock() { fMutex.load(std::memory_order_relaxed)->unlock(); }
239 
240    static void cleanup();
241 
242private:
243    alignas(std::mutex) char fStorage[sizeof(std::mutex)] {};
244    std::atomic<std::mutex *> fMutex { nullptr };
245 
246    /** All initialized UMutexes are kept in a linked list, so that they can be found,
247     * and the underlying std::mutex destructed, by u_cleanup().
248     */
249    UMutex *fListLink { nullptr };
250    static UMutex *gListHead;
251 
252    /** Out-of-line function to lazily initialize a UMutex on first use.
253     * Initial fast check is inline, in lock().  The returned value may never
254     * be nullptr.
255     */
256    std::mutex *getMutex();
257};
258 
259 
260/* Lock a mutex.
261 * @param mutex The given mutex to be locked.  Pass NULL to specify
262 *              the global ICU mutex.  Recursive locks are an error
263 *              and may cause a deadlock on some platforms.
264 */
265U_CAPIextern "C" void U_EXPORT2 umtx_lockumtx_lock_71(UMutex* mutex);
266 
267/* Unlock a mutex.
268 * @param mutex The given mutex to be unlocked.  Pass NULL to specify
269 *              the global ICU mutex.
270 */
271U_CAPIextern "C" void U_EXPORT2 umtx_unlockumtx_unlock_71 (UMutex* mutex);
272 
273 
274U_NAMESPACE_END}
275 
276#endif /* UMUTEX_H */
277/*eof*/