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

Bug Summary

File:	out/../deps/icu-small/source/common/cmemory.h
Warning:	line 274, column 40 Returning null reference

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 filteredbrk.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/filteredbrk.cpp

../deps/icu-small/source/common/filteredbrk.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) 2014-2015, International Business Machines Corporation and
6* others. All Rights Reserved.
7*******************************************************************************
8*/

10#include "unicode/utypes.h"
11#if !UCONFIG_NO_BREAK_ITERATION0 && !UCONFIG_NO_FILTERED_BREAK_ITERATION0

13#include "cmemory.h"

15#include "unicode/filteredbrk.h"
16#include "unicode/ucharstriebuilder.h"
17#include "unicode/ures.h"

19#include "uresimp.h" // ures_getByKeyWithFallback
20#include "ubrkimpl.h" // U_ICUDATA_BRKITR
21#include "uvector.h"
22#include "cmemory.h"
23#include "umutex.h"

25U_NAMESPACE_BEGINnamespace icu_71 {

27#ifndef FB_DEBUG0
28#define FB_DEBUG0 0
29#endif

31#if FB_DEBUG0
32#include <stdio.h>
33static void _fb_trace(const char *m, const UnicodeString *s, UBool b, int32_t d, const char *f, int l) {
char buf[2048];
if(s) {
  s->extract(0,s->length(),buf,2048);
} else {
  strcpy(buf,"NULL");
}
fprintf(stderrstderr,"%s:%d: %s. s='%s'(%p), b=%c, d=%d\n",
        f, l, m, buf, (const void*)s, b?'T':'F',(int)d);
42}

44#define FB_TRACE(m,s,b,d) _fb_trace(m,s,b,d,__FILE__"../deps/icu-small/source/common/filteredbrk.cpp",__LINE__44)
45#else
46#define FB_TRACE(m,s,b,d)
47#endif

49/**
* Used with sortedInsert()
*/
52static int32_t U_CALLCONV compareUnicodeString(UElement t1, UElement t2) {
  const UnicodeString &a = *(const UnicodeString*)t1.pointer;
  const UnicodeString &b = *(const UnicodeString*)t2.pointer;
  return a.compare(b);
56}

58/**
* A UVector which implements a set of strings.
*/
61class U_COMMON_API UStringSet : public UVector {
public:
UStringSet(UErrorCode &status) : UVector(uprv_deleteUObjectuprv_deleteUObject_71,
                                         uhash_compareUnicodeStringuhash_compareUnicodeString_71,
                                         1,
                                         status) {}
virtual ~UStringSet();
/**
 * Is this UnicodeSet contained?
 */
inline UBool contains(const UnicodeString& s) {
  return contains((void*) &s);
}
using UVector::contains;
/**
 * Return the ith UnicodeString alias
 */
inline const UnicodeString* getStringAt(int32_t i) const {
  return (const UnicodeString*)elementAt(i);
}
/**
 * Adopt the UnicodeString if not already contained.
 * Caller no longer owns the pointer in any case.
 * @return true if adopted successfully, false otherwise (error, or else duplicate)
 */
inline UBool adopt(UnicodeString *str, UErrorCode &status) {
  if(U_FAILURE(status) || contains(*str)) {
    delete str;
    return false;
  } else {
    sortedInsert(str, compareUnicodeString, status);
    if(U_FAILURE(status)) {
      return false;
    }
    return true;
  }
}
/**
 * Add by value.
 * @return true if successfully adopted.
 */
inline UBool add(const UnicodeString& str, UErrorCode &status) {
  if(U_FAILURE(status)) return false;
  UnicodeString *t = new UnicodeString(str);
  if(t==NULL__null) {
    status = U_MEMORY_ALLOCATION_ERROR; return false;
  }
  return adopt(t, status);
}
/**
 * Remove this string.
 * @return true if successfully removed, false otherwise (error, or else it wasn't there)
 */
inline UBool remove(const UnicodeString &s, UErrorCode &status) {
  if(U_FAILURE(status)) return false;
  return removeElement((void*) &s);
}
118};

120/**
* Virtual, won't be inlined
*/
123UStringSet::~UStringSet() {}

125/* ----------------------------------------------------------- */


128/* Filtered Break constants */
129static const int32_t kPARTIAL = (1<<0); //< partial - need to run through forward trie
130static const int32_t kMATCH   = (1<<1); //< exact match - skip this one.
131static const int32_t kSuppressInReverse = (1<<0);
132static const int32_t kAddToForward = (1<<1);
133static const UChar   kFULLSTOP = 0x002E; // '.'

135/**
* Shared data for SimpleFilteredSentenceBreakIterator
*/
138class SimpleFilteredSentenceBreakData : public UMemory {
139public:
SimpleFilteredSentenceBreakData(UCharsTrie *forwards, UCharsTrie *backwards ) 
    : fForwardsPartialTrie(forwards), fBackwardsTrie(backwards), refcount(1) { }
  SimpleFilteredSentenceBreakData *incr() {
      umtx_atomic_inc(&refcount);
      return this;
  }
  SimpleFilteredSentenceBreakData *decr() {
      if(umtx_atomic_dec(&refcount) <= 0) {
          delete this;
      }
      return 0;
  }
  virtual ~SimpleFilteredSentenceBreakData();

  bool hasForwardsPartialTrie() const { return fForwardsPartialTrie.isValid(); }
  bool hasBackwardsTrie() const { return fBackwardsTrie.isValid(); }

  const UCharsTrie &getForwardsPartialTrie() const { return *fForwardsPartialTrie; }
  const UCharsTrie &getBackwardsTrie() const { return *fBackwardsTrie; }

160private:
  // These tries own their data arrays.
  // They are shared and must therefore not be modified.
  LocalPointer<UCharsTrie>    fForwardsPartialTrie; //  Has ".a" for "a.M."
  LocalPointer<UCharsTrie>    fBackwardsTrie; //  i.e. ".srM" for Mrs.
  u_atomic_int32_t            refcount;
166};

168SimpleFilteredSentenceBreakData::~SimpleFilteredSentenceBreakData() {}

170/**
* Concrete implementation
*/
173class SimpleFilteredSentenceBreakIterator : public BreakIterator {
174public:
SimpleFilteredSentenceBreakIterator(BreakIterator *adopt, UCharsTrie *forwards, UCharsTrie *backwards, UErrorCode &status);
SimpleFilteredSentenceBreakIterator(const SimpleFilteredSentenceBreakIterator& other);
virtual ~SimpleFilteredSentenceBreakIterator();
178private:
SimpleFilteredSentenceBreakData *fData;
LocalPointer<BreakIterator> fDelegate;
LocalUTextPointer           fText;

/* -- subclass interface -- */
184public:
/* -- cloning and other subclass stuff -- */
virtual BreakIterator *  createBufferClone(void * /*stackBuffer*/,
                                           int32_t &/*BufferSize*/,
                                           UErrorCode &status) override {
  // for now - always deep clone
  status = U_SAFECLONE_ALLOCATED_WARNING;
  return clone();
}
virtual SimpleFilteredSentenceBreakIterator* clone() const override { return new SimpleFilteredSentenceBreakIterator(*this); }
virtual UClassID getDynamicClassID(void) const override { return NULL__null; }
virtual bool operator==(const BreakIterator& o) const override { if(this==&o) return true; return false; }

/* -- text modifying -- */
virtual void setText(UText *text, UErrorCode &status) override { fDelegate->setText(text,status); }
virtual BreakIterator &refreshInputText(UText *input, UErrorCode &status) override { fDelegate->refreshInputText(input,status); return *this; }
virtual void adoptText(CharacterIterator* it) override { fDelegate->adoptText(it); }
virtual void setText(const UnicodeString &text) override { fDelegate->setText(text); }

/* -- other functions that are just delegated -- */
virtual UText *getUText(UText *fillIn, UErrorCode &status) const override { return fDelegate->getUText(fillIn,status); }
virtual CharacterIterator& getText(void) const override { return fDelegate->getText(); }

/* -- ITERATION -- */
virtual int32_t first(void) override;
virtual int32_t preceding(int32_t offset) override;
virtual int32_t previous(void) override;
virtual UBool isBoundary(int32_t offset) override;
virtual int32_t current(void) const override { return fDelegate->current(); } // we keep the delegate current, so this should be correct.

virtual int32_t next(void) override;

virtual int32_t next(int32_t n) override;
virtual int32_t following(int32_t offset) override;
virtual int32_t last(void) override;

220private:
  /**
   * Given that the fDelegate has already given its "initial" answer,
   * find the NEXT actual (non-excepted) break.
   * @param n initial position from delegate
   * @return new break position or UBRK_DONE
   */
  int32_t internalNext(int32_t n);
  /**
   * Given that the fDelegate has already given its "initial" answer,
   * find the PREV actual (non-excepted) break.
   * @param n initial position from delegate
   * @return new break position or UBRK_DONE
   */
  int32_t internalPrev(int32_t n);
  /**
   * set up the UText with the value of the fDelegate.
   * Call this before calling breakExceptionAt. 
   * May be able to avoid excess calls
   */
  void resetState(UErrorCode &status);
  /**
   * Is there a match  (exception) at this spot?
   */
  enum EFBMatchResult { kNoExceptionHere, kExceptionHere };
  /**
   * Determine if there is an exception at this spot
   * @param n spot to check
   * @return kNoExceptionHere or kExceptionHere
   **/
  enum EFBMatchResult breakExceptionAt(int32_t n);
251};

253SimpleFilteredSentenceBreakIterator::SimpleFilteredSentenceBreakIterator(const SimpleFilteredSentenceBreakIterator& other)
: BreakIterator(other), fData(other.fData->incr()), fDelegate(other.fDelegate->clone())
255{
256}


259SimpleFilteredSentenceBreakIterator::SimpleFilteredSentenceBreakIterator(BreakIterator *adopt, UCharsTrie *forwards, UCharsTrie *backwards, UErrorCode &status) :
BreakIterator(adopt->getLocale(ULOC_VALID_LOCALE,status),adopt->getLocale(ULOC_ACTUAL_LOCALE,status)),
fData(new SimpleFilteredSentenceBreakData(forwards, backwards)),
fDelegate(adopt)
263{
  if (fData == nullptr) {
      delete forwards;
      delete backwards;
      if (U_SUCCESS(status)) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
  }
271}

273SimpleFilteredSentenceBreakIterator::~SimpleFilteredSentenceBreakIterator() {
  fData = fData->decr();
275}

277void SimpleFilteredSentenceBreakIterator::resetState(UErrorCode &status) {
fText.adoptInstead(fDelegate->getUText(fText.orphan(), status));
279}

281SimpleFilteredSentenceBreakIterator::EFBMatchResult
282SimpleFilteredSentenceBreakIterator::breakExceptionAt(int32_t n) {
  int64_t bestPosn = -1;
  int32_t bestValue = -1;
  // loops while 'n' points to an exception.
  utext_setNativeIndexutext_setNativeIndex_71(fText.getAlias(), n); // from n..

  //if(debug2) u_printf(" n@ %d\n", n);
  // Assume a space is following the '.'  (so we handle the case:  "Mr. /Brown")
  if(utext_previous32utext_previous32_71(fText.getAlias())==u' ') {  // TODO: skip a class of chars here??
    // TODO only do this the 1st time?
    //if(debug2) u_printf("skipping prev: |%C| \n", (UChar)uch);
  } else {
    //if(debug2) u_printf("not skipping prev: |%C| \n", (UChar)uch);
    utext_next32utext_next32_71(fText.getAlias());
    //if(debug2) u_printf(" -> : |%C| \n", (UChar)uch);
  }

  {
      // Do not modify the shared trie!
      UCharsTrie iter(fData->getBackwardsTrie());
      UChar32 uch;
      while((uch=utext_previous32utext_previous32_71(fText.getAlias()))!=U_SENTINEL(-1)) {  // more to consume backwards
          UStringTrieResult r = iter.nextForCodePoint(uch);
          if(USTRINGTRIE_HAS_VALUE(r)((r)>=USTRINGTRIE_FINAL_VALUE)) { // remember the best match so far
              bestPosn = utext_getNativeIndexutext_getNativeIndex_71(fText.getAlias());
              bestValue = iter.getValue();
          }
          if(!USTRINGTRIE_HAS_NEXT(r)((r)&1)) {
              break;
          }
          //if(debug2) u_printf("rev< /%C/ cont?%d @%d\n", (UChar)uch, r, utext_getNativeIndex(fText.getAlias()));
      }
  }

  //if(bestValue >= 0) {
      //if(debug2) u_printf("rev<+/%C/+end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);
  //}

  if(bestPosn>=0) {
    //if(debug2) u_printf("rev< /%C/ end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);

    //if(USTRINGTRIE_MATCHES(r)) {  // matched - so, now what?
    //int32_t bestValue = iter.getValue();
    ////if(debug2) u_printf("rev< /%C/ matched, skip..%d  bestValue=%d\n", (UChar)uch, r, bestValue);

    if(bestValue == kMATCH) { // exact match!
      //if(debug2) u_printf(" exact backward match\n");
      return kExceptionHere; // See if the next is another exception.
    } else if(bestValue == kPARTIAL
              && fData->hasForwardsPartialTrie()) { // make sure there's a forward trie
      //if(debug2) u_printf(" partial backward match\n");
      // We matched the "Ph." in "Ph.D." - now we need to run everything through the forwards trie
      // to see if it matches something going forward.
      UStringTrieResult rfwd = USTRINGTRIE_INTERMEDIATE_VALUE;
      utext_setNativeIndexutext_setNativeIndex_71(fText.getAlias(), bestPosn); // hope that's close ..
      //if(debug2) u_printf("Retrying at %d\n", bestPosn);
      // Do not modify the shared trie!
      UCharsTrie iter(fData->getForwardsPartialTrie());
      UChar32 uch;
      while((uch=utext_next32utext_next32_71(fText.getAlias()))!=U_SENTINEL(-1) &&
            USTRINGTRIE_HAS_NEXT(rfwd=iter.nextForCodePoint(uch))((rfwd=iter.nextForCodePoint(uch))&1)) {
        //if(debug2) u_printf("fwd> /%C/ cont?%d @%d\n", (UChar)uch, rfwd, utext_getNativeIndex(fText.getAlias()));
      }
      if(USTRINGTRIE_MATCHES(rfwd)((rfwd)!=USTRINGTRIE_NO_MATCH)) {
        //if(debug2) u_printf("fwd> /%C/ == forward match!\n", (UChar)uch);
        // only full matches here, nothing to check
        // skip the next:
          return kExceptionHere;
      } else {
        //if(debug2) u_printf("fwd> /%C/ no match.\n", (UChar)uch);
        // no match (no exception) -return the 'underlying' break
        return kNoExceptionHere;
      }
    } else {
      return kNoExceptionHere; // internal error and/or no forwards trie
    }
  } else {
    //if(debug2) u_printf("rev< /%C/ .. no match..%d\n", (UChar)uch, r);  // no best match
    return kNoExceptionHere; // No match - so exit. Not an exception.
  }
362}

364// the workhorse single next.
365int32_t
366SimpleFilteredSentenceBreakIterator::internalNext(int32_t n) {
if(n == UBRK_DONE((int32_t) -1) || // at end  or
  !fData->hasBackwardsTrie()) { // .. no backwards table loaded == no exceptions
    return n;
}
// OK, do we need to break here?
UErrorCode status = U_ZERO_ERROR;
// refresh text
resetState(status);
if(U_FAILURE(status)) return UBRK_DONE((int32_t) -1); // bail out
int64_t utextLen = utext_nativeLengthutext_nativeLength_71(fText.getAlias());

//if(debug2) u_printf("str, native len=%d\n", utext_nativeLength(fText.getAlias()));
while (n != UBRK_DONE((int32_t) -1) && n != utextLen) { // outer loop runs once per underlying break (from fDelegate).
  SimpleFilteredSentenceBreakIterator::EFBMatchResult m = breakExceptionAt(n);

  switch(m) {
  case kExceptionHere:
    n = fDelegate->next(); // skip this one. Find the next lowerlevel break.
    continue;

  default:
  case kNoExceptionHere:
    return n;
  }    
}
return n;
393}

395int32_t
396SimpleFilteredSentenceBreakIterator::internalPrev(int32_t n) {
if(n == 0 || n == UBRK_DONE((int32_t) -1) || // at end  or
  !fData->hasBackwardsTrie()) { // .. no backwards table loaded == no exceptions
    return n;
}
// OK, do we need to break here?
UErrorCode status = U_ZERO_ERROR;
// refresh text
resetState(status);
if(U_FAILURE(status)) return UBRK_DONE((int32_t) -1); // bail out

//if(debug2) u_printf("str, native len=%d\n", utext_nativeLength(fText.getAlias()));
while (n != UBRK_DONE((int32_t) -1) && n != 0) { // outer loop runs once per underlying break (from fDelegate).
  SimpleFilteredSentenceBreakIterator::EFBMatchResult m = breakExceptionAt(n);

  switch(m) {
  case kExceptionHere:
    n = fDelegate->previous(); // skip this one. Find the next lowerlevel break.
    continue;

  default:
  case kNoExceptionHere:
    return n;
  }    
}
return n;
422}


425int32_t
426SimpleFilteredSentenceBreakIterator::next() {
return internalNext(fDelegate->next());
428}

430int32_t
431SimpleFilteredSentenceBreakIterator::first(void) {
// Don't suppress a break opportunity at the beginning of text.
return fDelegate->first();
434}

436int32_t
437SimpleFilteredSentenceBreakIterator::preceding(int32_t offset) {
return internalPrev(fDelegate->preceding(offset));
439}

441int32_t
442SimpleFilteredSentenceBreakIterator::previous(void) {
return internalPrev(fDelegate->previous());
444}

446UBool SimpleFilteredSentenceBreakIterator::isBoundary(int32_t offset) {
if (!fDelegate->isBoundary(offset)) return false; // no break to suppress

if (!fData->hasBackwardsTrie()) return true; // no data = no suppressions

UErrorCode status = U_ZERO_ERROR;
resetState(status);

SimpleFilteredSentenceBreakIterator::EFBMatchResult m = breakExceptionAt(offset);

switch(m) {
case kExceptionHere:
  return false;
default:
case kNoExceptionHere:
  return true;
}    
463}

465int32_t
466SimpleFilteredSentenceBreakIterator::next(int32_t offset) {
return internalNext(fDelegate->next(offset));
468}

470int32_t
471SimpleFilteredSentenceBreakIterator::following(int32_t offset) {
return internalNext(fDelegate->following(offset));
473}

475int32_t
476SimpleFilteredSentenceBreakIterator::last(void) {
// Don't suppress a break opportunity at the end of text.
return fDelegate->last();
479}


482/**
* Concrete implementation of builder class.
*/
485class U_COMMON_API SimpleFilteredBreakIteratorBuilder : public FilteredBreakIteratorBuilder {
486public:
virtual ~SimpleFilteredBreakIteratorBuilder();
SimpleFilteredBreakIteratorBuilder(const Locale &fromLocale, UErrorCode &status);
SimpleFilteredBreakIteratorBuilder(UErrorCode &status);
virtual UBool suppressBreakAfter(const UnicodeString& exception, UErrorCode& status) override;
virtual UBool unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status) override;
virtual BreakIterator *build(BreakIterator* adoptBreakIterator, UErrorCode& status) override;
493private:
UStringSet fSet;
495};

497SimpleFilteredBreakIteratorBuilder::~SimpleFilteredBreakIteratorBuilder()
498{
499}

501SimpleFilteredBreakIteratorBuilder::SimpleFilteredBreakIteratorBuilder(UErrorCode &status) 
: fSet(status)
503{
504}

506SimpleFilteredBreakIteratorBuilder::SimpleFilteredBreakIteratorBuilder(const Locale &fromLocale, UErrorCode &status)
: fSet(status)
508{
if(U_SUCCESS(status)) {
  UErrorCode subStatus = U_ZERO_ERROR;
  LocalUResourceBundlePointer b(ures_openures_open_71(U_ICUDATA_BRKITR"icudt" "71" "l" "-" "brkitr", fromLocale.getBaseName(), &subStatus));
  if (U_FAILURE(subStatus) || (subStatus == U_USING_DEFAULT_WARNING) ) {    
    status = subStatus; // copy the failing status 
514#if FB_DEBUG0
    fprintf(stderrstderr, "open BUNDLE %s : %s, %s\n", fromLocale.getBaseName(), "[exit]", u_errorNameu_errorName_71(status));
516#endif
    return;  // leaves the builder empty, if you try to use it.
  }
  LocalUResourceBundlePointer exceptions(ures_getByKeyWithFallbackures_getByKeyWithFallback_71(b.getAlias(), "exceptions", NULL__null, &subStatus));
  if (U_FAILURE(subStatus) || (subStatus == U_USING_DEFAULT_WARNING) ) {    
    status = subStatus; // copy the failing status 
522#if FB_DEBUG0
    fprintf(stderrstderr, "open EXCEPTIONS %s : %s, %s\n", fromLocale.getBaseName(), "[exit]", u_errorNameu_errorName_71(status));
524#endif
    return;  // leaves the builder empty, if you try to use it.
  }
  LocalUResourceBundlePointer breaks(ures_getByKeyWithFallbackures_getByKeyWithFallback_71(exceptions.getAlias(), "SentenceBreak", NULL__null, &subStatus));

529#if FB_DEBUG0
  {
    UErrorCode subsub = subStatus;
    fprintf(stderrstderr, "open SentenceBreak %s => %s, %s\n", fromLocale.getBaseName(), ures_getLocaleures_getLocale_71(breaks.getAlias(), &subsub), u_errorNameu_errorName_71(subStatus));
  }
534#endif
  
  if (U_FAILURE(subStatus) || (subStatus == U_USING_DEFAULT_WARNING) ) {    
    status = subStatus; // copy the failing status 
538#if FB_DEBUG0
    fprintf(stderrstderr, "open %s : %s, %s\n", fromLocale.getBaseName(), "[exit]", u_errorNameu_errorName_71(status));
540#endif
    return;  // leaves the builder empty, if you try to use it.
  }

  LocalUResourceBundlePointer strs;
  subStatus = status; // Pick up inherited warning status now 
  do {
    strs.adoptInstead(ures_getNextResourceures_getNextResource_71(breaks.getAlias(), strs.orphan(), &subStatus));
    if(strs.isValid() && U_SUCCESS(subStatus)) {
      UnicodeString str(ures_getUnicodeString(strs.getAlias(), &status));
      suppressBreakAfter(str, status); // load the string
    }
  } while (strs.isValid() && U_SUCCESS(subStatus));
  if(U_FAILURE(subStatus)&&subStatus!=U_INDEX_OUTOFBOUNDS_ERROR&&U_SUCCESS(status)) {
    status = subStatus;
  }
}
557}

559UBool
560SimpleFilteredBreakIteratorBuilder::suppressBreakAfter(const UnicodeString& exception, UErrorCode& status)
561{
UBool r = fSet.add(exception, status);
FB_TRACE("suppressBreakAfter",&exception,r,0);
return r;
565}

567UBool
568SimpleFilteredBreakIteratorBuilder::unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status)
569{
UBool r = fSet.remove(exception, status);
FB_TRACE("unsuppressBreakAfter",&exception,r,0);
return r;
573}

575/**
* Jitterbug 2974: MSVC has a bug whereby new X[0] behaves badly.
* Work around this.
*
* Note: "new UnicodeString[subCount]" ends up calling global operator new
* on MSVC2012 for some reason.
*/
582static inline UnicodeString* newUnicodeStringArray(size_t count) {
  return new UnicodeString[count ? count : 1];
584}

586BreakIterator *
587SimpleFilteredBreakIteratorBuilder::build(BreakIterator* adoptBreakIterator, UErrorCode& status) {
LocalPointer<BreakIterator> adopt(adoptBreakIterator);

LocalPointer<UCharsTrieBuilder> builder(new UCharsTrieBuilder(status), status);
LocalPointer<UCharsTrieBuilder> builder2(new UCharsTrieBuilder(status), status);
if(U_FAILURE(status)) {
1
Taking false branch→
  return NULL__null;
}

int32_t revCount = 0;
int32_t fwdCount = 0;

int32_t subCount = fSet.size();

UnicodeString *ustrs_ptr = newUnicodeStringArray(subCount);

LocalArray<UnicodeString> ustrs(ustrs_ptr);

LocalMemory<int> partials;
2
←
Passing null pointer value via 1st parameter 'p'→
3
←
Calling default constructor for 'LocalMemory<int>'→
8
←
Returning from default constructor for 'LocalMemory<int>'→
partials.allocateInsteadAndReset(subCount);

LocalPointer<UCharsTrie>    backwardsTrie; //  i.e. ".srM" for Mrs.
LocalPointer<UCharsTrie>    forwardsPartialTrie; //  Has ".a" for "a.M."

int n=0;
for ( int32_t i = 0;
9
←
Loop condition is true.  Entering loop body→
      i<fSet.size();
      i++) {
  const UnicodeString *abbr = fSet.getStringAt(i);
  if(abbr) {
10
←
Assuming 'abbr' is non-null→
11
←
Taking true branch→
    FB_TRACE("build",abbr,TRUE,i);
    ustrs[n] = *abbr; // copy by value
    FB_TRACE("ustrs[n]",&ustrs[n],TRUE,i);
  } else {
    FB_TRACE("build",abbr,FALSE,i);
    status = U_MEMORY_ALLOCATION_ERROR;
    return NULL__null;
  }
  partials[n] = 0; // default: not partial
12
←
Calling 'LocalMemory::operator[]'→
  n++;
}
// first pass - find partials.
for(int i=0;i<subCount;i++) {
  int nn = ustrs[i].indexOf(kFULLSTOP); // TODO: non-'.' abbreviations
  if(nn>-1 && (nn+1)!=ustrs[i].length()) {
    FB_TRACE("partial",&ustrs[i],FALSE,i);
    // is partial.
    // is it unique?
    int sameAs = -1;
    for(int j=0;j<subCount;j++) {
      if(j==i) continue;
      if(ustrs[i].compare(0,nn+1,ustrs[j],0,nn+1)==0) {
        FB_TRACE("prefix",&ustrs[j],FALSE,nn+1);
        //UBool otherIsPartial = ((nn+1)!=ustrs[j].length());  // true if ustrs[j] doesn't end at nn
        if(partials[j]==0) { // hasn't been processed yet
          partials[j] = kSuppressInReverse | kAddToForward;
          FB_TRACE("suppressing",&ustrs[j],FALSE,j);
        } else if(partials[j] & kSuppressInReverse) {
          sameAs = j; // the other entry is already in the reverse table.
        }
      }
    }
    FB_TRACE("for partial same-",&ustrs[i],FALSE,sameAs);
    FB_TRACE(" == partial #",&ustrs[i],FALSE,partials[i]);
    UnicodeString prefix(ustrs[i], 0, nn+1);
    if(sameAs == -1 && partials[i] == 0) {
      // first one - add the prefix to the reverse table.
      prefix.reverse();
      builder->add(prefix, kPARTIAL, status);
      revCount++;
      FB_TRACE("Added partial",&prefix,FALSE, i);
      FB_TRACE(u_errorName(status),&ustrs[i],FALSE,i);
      partials[i] = kSuppressInReverse | kAddToForward;
    } else {
      FB_TRACE("NOT adding partial",&prefix,FALSE, i);
      FB_TRACE(u_errorName(status),&ustrs[i],FALSE,i);
    }
  }
}
for(int i=0;i<subCount;i++) {
  if(partials[i]==0) {
    ustrs[i].reverse();
    builder->add(ustrs[i], kMATCH, status);
    revCount++;
    FB_TRACE(u_errorName(status), &ustrs[i], FALSE, i);
  } else {
    FB_TRACE("Adding fwd",&ustrs[i], FALSE, i);

    // an optimization would be to only add the portion after the '.'
    // for example, for "Ph.D." we store ".hP" in the reverse table. We could just store "D." in the forward,
    // instead of "Ph.D." since we already know the "Ph." part is a match.
    // would need the trie to be able to hold 0-length strings, though.
    builder2->add(ustrs[i], kMATCH, status); // forward
    fwdCount++;
    //ustrs[i].reverse();
    ////if(debug2) u_printf("SUPPRESS- not Added(%d):  /%S/ status=%s\n",partials[i], ustrs[i].getTerminatedBuffer(), u_errorName(status));
  }
}
FB_TRACE("AbbrCount",NULL,FALSE, subCount);

if(revCount>0) {
  backwardsTrie.adoptInstead(builder->build(USTRINGTRIE_BUILD_FAST, status));
  if(U_FAILURE(status)) {
    FB_TRACE(u_errorName(status),NULL,FALSE, -1);
    return NULL__null;
  }
}

if(fwdCount>0) {
  forwardsPartialTrie.adoptInstead(builder2->build(USTRINGTRIE_BUILD_FAST, status));
  if(U_FAILURE(status)) {
    FB_TRACE(u_errorName(status),NULL,FALSE, -1);
    return NULL__null;
  }
}

return new SimpleFilteredSentenceBreakIterator(adopt.orphan(), forwardsPartialTrie.orphan(), backwardsTrie.orphan(), status);
704}


707// ----------- Base class implementation

709FilteredBreakIteratorBuilder::FilteredBreakIteratorBuilder() {
710}

712FilteredBreakIteratorBuilder::~FilteredBreakIteratorBuilder() {
713}

715FilteredBreakIteratorBuilder *
716FilteredBreakIteratorBuilder::createInstance(const Locale& where, UErrorCode& status) {
if(U_FAILURE(status)) return NULL__null;
LocalPointer<FilteredBreakIteratorBuilder> ret(new SimpleFilteredBreakIteratorBuilder(where, status), status);
return (U_SUCCESS(status))? ret.orphan(): NULL__null;
720}

722FilteredBreakIteratorBuilder *
723FilteredBreakIteratorBuilder::createInstance(UErrorCode &status) {
return createEmptyInstance(status);
725}

727FilteredBreakIteratorBuilder *
728FilteredBreakIteratorBuilder::createEmptyInstance(UErrorCode& status) {
if(U_FAILURE(status)) return NULL__null;
LocalPointer<FilteredBreakIteratorBuilder> ret(new SimpleFilteredBreakIteratorBuilder(status), status);
return (U_SUCCESS(status))? ret.orphan(): NULL__null;
732}

734U_NAMESPACE_END}

736#endif //#if !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILTERED_BREAK_ITERATION

←

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

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5*
6*   Copyright (C) 1997-2016, International Business Machines
7*   Corporation and others.  All Rights Reserved.
8*
9******************************************************************************
10*
11* File CMEMORY.H
12*
13*  Contains stdlib.h/string.h memory functions
14*
15* @author       Bertrand A. Damiba
16*
17* Modification History:
18*
19*   Date        Name        Description
20*   6/20/98     Bertrand    Created.
21*  05/03/99     stephen     Changed from functions to macros.
22*
23******************************************************************************
24*/

26#ifndef CMEMORY_H
27#define CMEMORY_H

29#include "unicode/utypes.h"

31#include <stddef.h>
32#include <string.h>
33#include "unicode/localpointer.h"
34#include "uassert.h"

36#if U_DEBUG0 && defined(UPRV_MALLOC_COUNT)
37#include <stdio.h>
38#endif

40// uprv_memcpy and uprv_memmove
41#if defined(__clang__1)
42#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(dst, src,
 size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("clang diagnostic push")clang diagnostic push
 \
  _Pragma("clang diagnostic ignored \"-Waddress\"")clang diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(void)0; \
  U_ASSERT(src != NULL)(void)0; \
  _Pragma("clang diagnostic pop")clang diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
50} UPRV_BLOCK_MACRO_ENDwhile (false)
51#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(dst, src
, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("clang diagnostic push")clang diagnostic push
 \
  _Pragma("clang diagnostic ignored \"-Waddress\"")clang diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(void)0; \
  U_ASSERT(src != NULL)(void)0; \
  _Pragma("clang diagnostic pop")clang diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
59} UPRV_BLOCK_MACRO_ENDwhile (false)
60#elif defined(__GNUC__4)
61#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(dst, src,
 size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("GCC diagnostic push")GCC diagnostic push
 \
  _Pragma("GCC diagnostic ignored \"-Waddress\"")GCC diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(void)0; \
  U_ASSERT(src != NULL)(void)0; \
  _Pragma("GCC diagnostic pop")GCC diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
69} UPRV_BLOCK_MACRO_ENDwhile (false)
70#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(dst, src
, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("GCC diagnostic push")GCC diagnostic push
 \
  _Pragma("GCC diagnostic ignored \"-Waddress\"")GCC diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(void)0; \
  U_ASSERT(src != NULL)(void)0; \
  _Pragma("GCC diagnostic pop")GCC diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
78} UPRV_BLOCK_MACRO_ENDwhile (false)
79#else
80#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(dst, src,
 size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  U_ASSERT(dst != NULL)(void)0; \
  U_ASSERT(src != NULL)(void)0; \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
84} UPRV_BLOCK_MACRO_ENDwhile (false)
85#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(dst, src
, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  U_ASSERT(dst != NULL)(void)0; \
  U_ASSERT(src != NULL)(void)0; \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
89} UPRV_BLOCK_MACRO_ENDwhile (false)
90#endif

92/**
* \def UPRV_LENGTHOF
* Convenience macro to determine the length of a fixed array at compile-time.
* @param array A fixed length array
* @return The length of the array, in elements
* @internal
*/
99#define UPRV_LENGTHOF(array)(int32_t)(sizeof(array)/sizeof((array)[0])) (int32_t)(sizeof(array)/sizeof((array)[0]))
100#define uprv_memset(buffer, mark, size):: memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE:: memset(buffer, mark, size)
101#define uprv_memcmp(buffer1, buffer2, size):: memcmp(buffer1, buffer2,size) U_STANDARD_CPP_NAMESPACE:: memcmp(buffer1, buffer2,size)
102#define uprv_memchr(ptr, value, num):: memchr(ptr, value, num) U_STANDARD_CPP_NAMESPACE:: memchr(ptr, value, num)

104U_CAPIextern "C" void * U_EXPORT2
105uprv_mallocuprv_malloc_71(size_t s) U_MALLOC_ATTR__attribute__ ((__malloc__)) U_ALLOC_SIZE_ATTR(1)__attribute__ ((alloc_size(1)));

107U_CAPIextern "C" void * U_EXPORT2
108uprv_reallocuprv_realloc_71(void *mem, size_t size) U_ALLOC_SIZE_ATTR(2)__attribute__ ((alloc_size(2)));

110U_CAPIextern "C" void U_EXPORT2
111uprv_freeuprv_free_71(void *mem);

113U_CAPIextern "C" void * U_EXPORT2
114uprv_callocuprv_calloc_71(size_t num, size_t size) U_MALLOC_ATTR__attribute__ ((__malloc__)) U_ALLOC_SIZE_ATTR2(1,2)__attribute__ ((alloc_size(1,2)));

116/**
* Get the least significant bits of a pointer (a memory address).
* For example, with a mask of 3, the macro gets the 2 least significant bits,
* which will be 0 if the pointer is 32-bit (4-byte) aligned.
*
* uintptr_t is the most appropriate integer type to cast to.
*/
123#define U_POINTER_MASK_LSB(ptr, mask)((uintptr_t)(ptr) & (mask)) ((uintptr_t)(ptr) & (mask))

125/**
* Create & return an instance of "type" in statically allocated storage.
* e.g.
*    static std::mutex *myMutex = STATIC_NEW(std::mutex);
* To destroy an object created in this way, invoke the destructor explicitly, e.g.
*    myMutex->~mutex();
* DO NOT use delete.
* DO NOT use with class UMutex, which has specific support for static instances.
*
* STATIC_NEW is intended for use when
*   - We want a static (or global) object.
*   - We don't want it to ever be destructed, or to explicitly control destruction,
*     to avoid use-after-destruction problems.
*   - We want to avoid an ordinary heap allocated object,
*     to avoid the possibility of memory allocation failures, and
*     to avoid memory leak reports, from valgrind, for example.
* This is defined as a macro rather than a template function because each invocation
* must define distinct static storage for the object being returned.
*/
144#define STATIC_NEW(type)[] () { alignas(type) static char storage[sizeof(type)]; return
 new(storage) type();} () [] () { \
  alignas(type) static char storage[sizeof(type)]; \
  return new(storage) type();} ()

148/**
*  Heap clean up function, called from u_cleanup()
*    Clears any user heap functions from u_setMemoryFunctions()
*    Does NOT deallocate any remaining allocated memory.
*/
153U_CFUNCextern "C" UBool 
154cmemory_cleanupcmemory_cleanup_71(void);

156/**
* A function called by <TT>uhash_remove</TT>,
* <TT>uhash_close</TT>, or <TT>uhash_put</TT> to delete
* an existing key or value.
* @param obj A key or value stored in a hashtable
* @see uprv_deleteUObject
*/
163typedef void U_CALLCONV UObjectDeleter(void* obj);

165/**
* Deleter for UObject instances.
* Works for all subclasses of UObject because it has a virtual destructor.
*/
169U_CAPIextern "C" void U_EXPORT2
170uprv_deleteUObjectuprv_deleteUObject_71(void *obj);

172#ifdef __cplusplus201703L

174#include <utility>
175#include "unicode/uobject.h"

177U_NAMESPACE_BEGINnamespace icu_71 {

179/**
* "Smart pointer" class, deletes memory via uprv_free().
* For most methods see the LocalPointerBase base class.
* Adds operator[] for array item access.
*
* @see LocalPointerBase
*/
186template<typename T>
187class LocalMemory : public LocalPointerBase<T> {
188public:
  using LocalPointerBase<T>::operator*;
  using LocalPointerBase<T>::operator->;
  /**
   * Constructor takes ownership.
   * @param p simple pointer to an array of T items that is adopted
   */
  explicit LocalMemory(T *p=NULL__null) : LocalPointerBase<T>(p) {}
4
←
Passing null pointer value via 1st parameter 'p'→
5
←
Calling default constructor for 'LocalPointerBase<int>'→
7
←
Returning from default constructor for 'LocalPointerBase<int>'→
  /**
   * Move constructor, leaves src with isNull().
   * @param src source smart pointer
   */
  LocalMemory(LocalMemory<T> &&src) U_NOEXCEPTnoexcept : LocalPointerBase<T>(src.ptr) {
      src.ptr=NULL__null;
  }
  /**
   * Destructor deletes the memory it owns.
   */
  ~LocalMemory() {
      uprv_freeuprv_free_71(LocalPointerBase<T>::ptr);
  }
  /**
   * Move assignment operator, leaves src with isNull().
   * The behavior is undefined if *this and src are the same object.
   * @param src source smart pointer
   * @return *this
   */
  LocalMemory<T> &operator=(LocalMemory<T> &&src) U_NOEXCEPTnoexcept {
      uprv_freeuprv_free_71(LocalPointerBase<T>::ptr);
      LocalPointerBase<T>::ptr=src.ptr;
      src.ptr=NULL__null;
      return *this;
  }
  /**
   * Swap pointers.
   * @param other other smart pointer
   */
  void swap(LocalMemory<T> &other) U_NOEXCEPTnoexcept {
      T *temp=LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=other.ptr;
      other.ptr=temp;
  }
  /**
   * Non-member LocalMemory swap function.
   * @param p1 will get p2's pointer
   * @param p2 will get p1's pointer
   */
  friend inline void swap(LocalMemory<T> &p1, LocalMemory<T> &p2) U_NOEXCEPTnoexcept {
      p1.swap(p2);
  }
  /**
   * Deletes the array it owns,
   * and adopts (takes ownership of) the one passed in.
   * @param p simple pointer to an array of T items that is adopted
   */
  void adoptInstead(T *p) {
      uprv_freeuprv_free_71(LocalPointerBase<T>::ptr);
      LocalPointerBase<T>::ptr=p;
  }
  /**
   * Deletes the array it owns, allocates a new one and reset its bytes to 0.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns NULL.
   * @param newCapacity must be >0
   * @return the allocated array pointer, or NULL if the allocation failed
   */
  inline T *allocateInsteadAndReset(int32_t newCapacity=1);
  /**
   * Deletes the array it owns and allocates a new one, copying length T items.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns NULL.
   * @param newCapacity must be >0
   * @param length number of T items to be copied from the old array to the new one;
   *               must be no more than the capacity of the old array,
   *               which the caller must track because the LocalMemory does not track it
   * @return the allocated array pointer, or NULL if the allocation failed
   */
  inline T *allocateInsteadAndCopy(int32_t newCapacity=1, int32_t length=0);
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) const { return LocalPointerBase<T>::ptr[i]; }
13
←
Returning null reference
275};

277template<typename T>
278inline T *LocalMemory<T>::allocateInsteadAndReset(int32_t newCapacity) {
  if(newCapacity>0) {
      T *p=(T *)uprv_mallocuprv_malloc_71(newCapacity*sizeof(T));
      if(p!=NULL__null) {
          uprv_memset(p, 0, newCapacity*sizeof(T)):: memset(p, 0, newCapacity*sizeof(T));
          uprv_freeuprv_free_71(LocalPointerBase<T>::ptr);
          LocalPointerBase<T>::ptr=p;
      }
      return p;
  } else {
      return NULL__null;
  }
290}


293template<typename T>
294inline T *LocalMemory<T>::allocateInsteadAndCopy(int32_t newCapacity, int32_t length) {
  if(newCapacity>0) {
      T *p=(T *)uprv_mallocuprv_malloc_71(newCapacity*sizeof(T));
      if(p!=NULL__null) {
          if(length>0) {
              if(length>newCapacity) {
                  length=newCapacity;
              }
              uprv_memcpy(p, LocalPointerBase<T>::ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(p, LocalPointerBase
<T>::ptr, (size_t)length*sizeof(T)); } while (false);
          }
          uprv_freeuprv_free_71(LocalPointerBase<T>::ptr);
          LocalPointerBase<T>::ptr=p;
      }
      return p;
  } else {
      return NULL__null;
  }
311}

313/**
* Simple array/buffer management class using uprv_malloc() and uprv_free().
* Provides an internal array with fixed capacity. Can alias another array
* or allocate one.
*
* The array address is properly aligned for type T. It might not be properly
* aligned for types larger than T (or larger than the largest subtype of T).
*
* Unlike LocalMemory and LocalArray, this class never adopts
* (takes ownership of) another array.
*
* WARNING: MaybeStackArray only works with primitive (plain-old data) types.
* It does NOT know how to call a destructor! If you work with classes with
* destructors, consider:
*
* - LocalArray in localpointer.h if you know the length ahead of time
* - MaybeStackVector if you know the length at runtime
*/
331template<typename T, int32_t stackCapacity>
332class MaybeStackArray {
333public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) U_NOEXCEPTnoexcept = delete;
  static void* U_EXPORT2 operator new[](size_t) U_NOEXCEPTnoexcept = delete;
337#if U_HAVE_PLACEMENT_NEW1
  static void* U_EXPORT2 operator new(size_t, void*) U_NOEXCEPTnoexcept = delete;
339#endif

  /**
   * Default constructor initializes with internal T[stackCapacity] buffer.
   */
  MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {}
  /**
   * Automatically allocates the heap array if the argument is larger than the stack capacity.
   * Intended for use when an approximate capacity is known at compile time but the true
   * capacity is not known until runtime.
   */
  MaybeStackArray(int32_t newCapacity, UErrorCode status) : MaybeStackArray() {
      if (U_FAILURE(status)) {
          return;
      }
      if (capacity < newCapacity) {
          if (resize(newCapacity) == nullptr) {
              status = U_MEMORY_ALLOCATION_ERROR;
          }
      }
  }
  /**
   * Destructor deletes the array (if owned).
   */
  ~MaybeStackArray() { releaseArray(); }
  /**
   * Move constructor: transfers ownership or copies the stack array.
   */
  MaybeStackArray(MaybeStackArray<T, stackCapacity> &&src) U_NOEXCEPTnoexcept;
  /**
   * Move assignment: transfers ownership or copies the stack array.
   */
  MaybeStackArray<T, stackCapacity> &operator=(MaybeStackArray<T, stackCapacity> &&src) U_NOEXCEPTnoexcept;
  /**
   * Returns the array capacity (number of T items).
   * @return array capacity
   */
  int32_t getCapacity() const { return capacity; }
  /**
   * Access without ownership change.
   * @return the array pointer
   */
  T *getAlias() const { return ptr; }
  /**
   * Returns the array limit. Simple convenience method.
   * @return getAlias()+getCapacity()
   */
  T *getArrayLimit() const { return getAlias()+capacity; }
  // No "operator T *() const" because that can make
  // expressions like mbs[index] ambiguous for some compilers.
  /**
   * Array item access (const).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  const T &operator[](ptrdiff_t i) const { return ptr[i]; }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) { return ptr[i]; }
  /**
   * Deletes the array (if owned) and aliases another one, no transfer of ownership.
   * If the arguments are illegal, then the current array is unchanged.
   * @param otherArray must not be NULL
   * @param otherCapacity must be >0
   */
  void aliasInstead(T *otherArray, int32_t otherCapacity) {
      if(otherArray!=NULL__null && otherCapacity>0) {
          releaseArray();
          ptr=otherArray;
          capacity=otherCapacity;
          needToRelease=false;
      }
  }
  /**
   * Deletes the array (if owned) and allocates a new one, copying length T items.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns NULL.
   * @param newCapacity can be less than or greater than the current capacity;
   *                    must be >0
   * @param length number of T items to be copied from the old array to the new one
   * @return the allocated array pointer, or NULL if the allocation failed
   */
  inline T *resize(int32_t newCapacity, int32_t length=0);
  /**
   * Gives up ownership of the array if owned, or else clones it,
   * copying length T items; resets itself to the internal stack array.
   * Returns NULL if the allocation failed.
   * @param length number of T items to copy when cloning,
   *        and capacity of the clone when cloning
   * @param resultCapacity will be set to the returned array's capacity (output-only)
   * @return the array pointer;
   *         caller becomes responsible for deleting the array
   */
  inline T *orphanOrClone(int32_t length, int32_t &resultCapacity);

440protected:
  // Resizes the array to the size of src, then copies the contents of src.
  void copyFrom(const MaybeStackArray &src, UErrorCode &status) {
      if (U_FAILURE(status)) {
          return;
      }
      if (this->resize(src.capacity, 0) == NULL__null) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return;
      }
      uprv_memcpy(this->ptr, src.ptr, (size_t)capacity * sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(this->
ptr, src.ptr, (size_t)capacity * sizeof(T)); } while (false);
  }

453private:
  T *ptr;
  int32_t capacity;
  UBool needToRelease;
  T stackArray[stackCapacity];
  void releaseArray() {
      if(needToRelease) {
          uprv_freeuprv_free_71(ptr);
      }
  }
  void resetToStackArray() {
      ptr=stackArray;
      capacity=stackCapacity;
      needToRelease=false;
  }
  /* No comparison operators with other MaybeStackArray's. */
  bool operator==(const MaybeStackArray & /*other*/) = delete;
  bool operator!=(const MaybeStackArray & /*other*/) = delete;
  /* No ownership transfer: No copy constructor, no assignment operator. */
  MaybeStackArray(const MaybeStackArray & /*other*/) = delete;
  void operator=(const MaybeStackArray & /*other*/) = delete;
474};

476template<typename T, int32_t stackCapacity>
477icu::MaybeStackArray<T, stackCapacity>::MaybeStackArray(
      MaybeStackArray <T, stackCapacity>&& src) U_NOEXCEPTnoexcept
      : ptr(src.ptr), capacity(src.capacity), needToRelease(src.needToRelease) {
  if (src.ptr == src.stackArray) {
      ptr = stackArray;
      uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(stackArray
, src.stackArray, sizeof(T) * src.capacity); } while (false);
  } else {
      src.resetToStackArray();  // take ownership away from src
  }
486}

488template<typename T, int32_t stackCapacity>
489inline MaybeStackArray <T, stackCapacity>&
490MaybeStackArray<T, stackCapacity>::operator=(MaybeStackArray <T, stackCapacity>&& src) U_NOEXCEPTnoexcept {
  releaseArray();  // in case this instance had its own memory allocated
  capacity = src.capacity;
  needToRelease = src.needToRelease;
  if (src.ptr == src.stackArray) {
      ptr = stackArray;
      uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(stackArray
, src.stackArray, sizeof(T) * src.capacity); } while (false);
  } else {
      ptr = src.ptr;
      src.resetToStackArray();  // take ownership away from src
  }
  return *this;
502}

504template<typename T, int32_t stackCapacity>
505inline T *MaybeStackArray<T, stackCapacity>::resize(int32_t newCapacity, int32_t length) {
  if(newCapacity>0) {
507#if U_DEBUG0 && defined(UPRV_MALLOC_COUNT)
      ::fprintf(::stderrstderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T));
509#endif
      T *p=(T *)uprv_mallocuprv_malloc_71(newCapacity*sizeof(T));
      if(p!=NULL__null) {
          if(length>0) {
              if(length>capacity) {
                  length=capacity;
              }
              if(length>newCapacity) {
                  length=newCapacity;
              }
              uprv_memcpy(p, ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(p, ptr, (
size_t)length*sizeof(T)); } while (false);
          }
          releaseArray();
          ptr=p;
          capacity=newCapacity;
          needToRelease=true;
      }
      return p;
  } else {
      return NULL__null;
  }
530}

532template<typename T, int32_t stackCapacity>
533inline T *MaybeStackArray<T, stackCapacity>::orphanOrClone(int32_t length, int32_t &resultCapacity) {
  T *p;
  if(needToRelease) {
      p=ptr;
  } else if(length<=0) {
      return NULL__null;
  } else {
      if(length>capacity) {
          length=capacity;
      }
      p=(T *)uprv_mallocuprv_malloc_71(length*sizeof(T));
544#if U_DEBUG0 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStacArray (orphan) alloc %d * %lu\n", length,sizeof(T));
546#endif
      if(p==NULL__null) {
          return NULL__null;
      }
      uprv_memcpy(p, ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(p, ptr, (
size_t)length*sizeof(T)); } while (false);
  }
  resultCapacity=length;
  resetToStackArray();
  return p;
555}

557/**
* Variant of MaybeStackArray that allocates a header struct and an array
* in one contiguous memory block, using uprv_malloc() and uprv_free().
* Provides internal memory with fixed array capacity. Can alias another memory
* block or allocate one.
* The stackCapacity is the number of T items in the internal memory,
* not counting the H header.
* Unlike LocalMemory and LocalArray, this class never adopts
* (takes ownership of) another memory block.
*/
567template<typename H, typename T, int32_t stackCapacity>
568class MaybeStackHeaderAndArray {
569public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) U_NOEXCEPTnoexcept = delete;
  static void* U_EXPORT2 operator new[](size_t) U_NOEXCEPTnoexcept = delete;
573#if U_HAVE_PLACEMENT_NEW1
  static void* U_EXPORT2 operator new(size_t, void*) U_NOEXCEPTnoexcept = delete;
575#endif

  /**
   * Default constructor initializes with internal H+T[stackCapacity] buffer.
   */
  MaybeStackHeaderAndArray() : ptr(&stackHeader), capacity(stackCapacity), needToRelease(false) {}
  /**
   * Destructor deletes the memory (if owned).
   */
  ~MaybeStackHeaderAndArray() { releaseMemory(); }
  /**
   * Returns the array capacity (number of T items).
   * @return array capacity
   */
  int32_t getCapacity() const { return capacity; }
  /**
   * Access without ownership change.
   * @return the header pointer
   */
  H *getAlias() const { return ptr; }
  /**
   * Returns the array start.
   * @return array start, same address as getAlias()+1
   */
  T *getArrayStart() const { return reinterpret_cast<T *>(getAlias()+1); }
  /**
   * Returns the array limit.
   * @return array limit
   */
  T *getArrayLimit() const { return getArrayStart()+capacity; }
  /**
   * Access without ownership change. Same as getAlias().
   * A class instance can be used directly in expressions that take a T *.
   * @return the header pointer
   */
  operator H *() const { return ptr; }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) { return getArrayStart()[i]; }
  /**
   * Deletes the memory block (if owned) and aliases another one, no transfer of ownership.
   * If the arguments are illegal, then the current memory is unchanged.
   * @param otherArray must not be NULL
   * @param otherCapacity must be >0
   */
  void aliasInstead(H *otherMemory, int32_t otherCapacity) {
      if(otherMemory!=NULL__null && otherCapacity>0) {
          releaseMemory();
          ptr=otherMemory;
          capacity=otherCapacity;
          needToRelease=false;
      }
  }
  /**
   * Deletes the memory block (if owned) and allocates a new one,
   * copying the header and length T array items.
   * Returns the new header pointer.
   * If the allocation fails, then the current memory is unchanged and
   * this method returns NULL.
   * @param newCapacity can be less than or greater than the current capacity;
   *                    must be >0
   * @param length number of T items to be copied from the old array to the new one
   * @return the allocated pointer, or NULL if the allocation failed
   */
  inline H *resize(int32_t newCapacity, int32_t length=0);
  /**
   * Gives up ownership of the memory if owned, or else clones it,
   * copying the header and length T array items; resets itself to the internal memory.
   * Returns NULL if the allocation failed.
   * @param length number of T items to copy when cloning,
   *        and array capacity of the clone when cloning
   * @param resultCapacity will be set to the returned array's capacity (output-only)
   * @return the header pointer;
   *         caller becomes responsible for deleting the array
   */
  inline H *orphanOrClone(int32_t length, int32_t &resultCapacity);
655private:
  H *ptr;
  int32_t capacity;
  UBool needToRelease;
  // stackHeader must precede stackArray immediately.
  H stackHeader;
  T stackArray[stackCapacity];
  void releaseMemory() {
      if(needToRelease) {
          uprv_freeuprv_free_71(ptr);
      }
  }
  /* No comparison operators with other MaybeStackHeaderAndArray's. */
  bool operator==(const MaybeStackHeaderAndArray & /*other*/) {return false;}
  bool operator!=(const MaybeStackHeaderAndArray & /*other*/) {return true;}
  /* No ownership transfer: No copy constructor, no assignment operator. */
  MaybeStackHeaderAndArray(const MaybeStackHeaderAndArray & /*other*/) {}
  void operator=(const MaybeStackHeaderAndArray & /*other*/) {}
673};

675template<typename H, typename T, int32_t stackCapacity>
676inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::resize(int32_t newCapacity,
                                                              int32_t length) {
  if(newCapacity>=0) {
679#if U_DEBUG0 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStackHeaderAndArray alloc %d + %d * %ul\n", sizeof(H),newCapacity,sizeof(T));
681#endif
      H *p=(H *)uprv_mallocuprv_malloc_71(sizeof(H)+newCapacity*sizeof(T));
      if(p!=NULL__null) {
          if(length<0) {
              length=0;
          } else if(length>0) {
              if(length>capacity) {
                  length=capacity;
              }
              if(length>newCapacity) {
                  length=newCapacity;
              }
          }
          uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(p, ptr, sizeof
(H)+(size_t)length*sizeof(T)); } while (false);
          releaseMemory();
          ptr=p;
          capacity=newCapacity;
          needToRelease=true;
      }
      return p;
  } else {
      return NULL__null;
  }
704}

706template<typename H, typename T, int32_t stackCapacity>
707inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::orphanOrClone(int32_t length,
                                                                     int32_t &resultCapacity) {
  H *p;
  if(needToRelease) {
      p=ptr;
  } else {
      if(length<0) {
          length=0;
      } else if(length>capacity) {
          length=capacity;
      }
718#if U_DEBUG0 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStackHeaderAndArray (orphan) alloc %ul + %d * %lu\n", sizeof(H),length,sizeof(T));
720#endif
      p=(H *)uprv_mallocuprv_malloc_71(sizeof(H)+length*sizeof(T));
      if(p==NULL__null) {
          return NULL__null;
      }
      uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(p, ptr, sizeof
(H)+(size_t)length*sizeof(T)); } while (false);
  }
  resultCapacity=length;
  ptr=&stackHeader;
  capacity=stackCapacity;
  needToRelease=false;
  return p;
732}

734/**
* A simple memory management class that creates new heap allocated objects (of
* any class that has a public constructor), keeps track of them and eventually
* deletes them all in its own destructor.
*
* A typical use-case would be code like this:
*
*     MemoryPool<MyType> pool;
*
*     MyType* o1 = pool.create();
*     if (o1 != nullptr) {
*         foo(o1);
*     }
*
*     MyType* o2 = pool.create(1, 2, 3);
*     if (o2 != nullptr) {
*         bar(o2);
*     }
*
*     // MemoryPool will take care of deleting the MyType objects.
*
* It doesn't do anything more than that, and is intentionally kept minimalist.
*/
757template<typename T, int32_t stackCapacity = 8>
758class MemoryPool : public UMemory {
759public:
  MemoryPool() : fCount(0), fPool() {}

  ~MemoryPool() {
      for (int32_t i = 0; i < fCount; ++i) {
          delete fPool[i];
      }
  }

  MemoryPool(const MemoryPool&) = delete;
  MemoryPool& operator=(const MemoryPool&) = delete;

  MemoryPool(MemoryPool&& other) U_NOEXCEPTnoexcept : fCount(other.fCount),
                                              fPool(std::move(other.fPool)) {
      other.fCount = 0;
  }

  MemoryPool& operator=(MemoryPool&& other) U_NOEXCEPTnoexcept {
      // Since `this` may contain instances that need to be deleted, we can't
      // just throw them away and replace them with `other`. The normal way of
      // dealing with this in C++ is to swap `this` and `other`, rather than
      // simply overwrite: the destruction of `other` can then take care of
      // running MemoryPool::~MemoryPool() over the still-to-be-deallocated
      // instances.
      std::swap(fCount, other.fCount);
      std::swap(fPool, other.fPool);
      return *this;
  }

  /**
   * Creates a new object of typename T, by forwarding any and all arguments
   * to the typename T constructor.
   *
   * @param args Arguments to be forwarded to the typename T constructor.
   * @return A pointer to the newly created object, or nullptr on error.
   */
  template<typename... Args>
  T* create(Args&&... args) {
      int32_t capacity = fPool.getCapacity();
      if (fCount == capacity &&
          fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity,
                       capacity) == nullptr) {
          return nullptr;
      }
      return fPool[fCount++] = new T(std::forward<Args>(args)...);
  }

  template <typename... Args>
  T* createAndCheckErrorCode(UErrorCode &status, Args &&... args) {
      if (U_FAILURE(status)) {
          return nullptr;
      }
      T *pointer = this->create(args...);
      if (U_SUCCESS(status) && pointer == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return pointer;
  }

  /**
   * @return Number of elements that have been allocated.
   */
  int32_t count() const {
      return fCount;
  }

825protected:
  int32_t fCount;
  MaybeStackArray<T*, stackCapacity> fPool;
828};

830/**
* An internal Vector-like implementation based on MemoryPool.
*
* Heap-allocates each element and stores pointers.
*
* To append an item to the vector, use emplaceBack.
*
*     MaybeStackVector<MyType> vector;
*     MyType* element = vector.emplaceBack();
*     if (!element) {
*         status = U_MEMORY_ALLOCATION_ERROR;
*     }
*     // do stuff with element
*
* To loop over the vector, use a for loop with indices:
*
*     for (int32_t i = 0; i < vector.length(); i++) {
*         MyType* element = vector[i];
*     }
*/
850template<typename T, int32_t stackCapacity = 8>
851class MaybeStackVector : protected MemoryPool<T, stackCapacity> {
852public:
  template<typename... Args>
  T* emplaceBack(Args&&... args) {
      return this->create(args...);
  }

  template <typename... Args>
  T *emplaceBackAndCheckErrorCode(UErrorCode &status, Args &&... args) {
      return this->createAndCheckErrorCode(status, args...);
  }

  int32_t length() const {
      return this->fCount;
  }

  T** getAlias() {
      return this->fPool.getAlias();
  }

  const T *const *getAlias() const {
      return this->fPool.getAlias();
  }

  /**
   * Array item access (read-only).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  const T* operator[](ptrdiff_t i) const {
      return this->fPool[i];
  }

  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T* operator[](ptrdiff_t i) {
      return this->fPool[i];
  }
894};


897U_NAMESPACE_END}

899#endif  /* __cplusplus */
900#endif  /* CMEMORY_H */

←

../deps/icu-small/source/common/unicode/localpointer.h

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4*******************************************************************************
5*
6*   Copyright (C) 2009-2016, International Business Machines
7*   Corporation and others.  All Rights Reserved.
8*
9*******************************************************************************
10*   file name:  localpointer.h
11*   encoding:   UTF-8
12*   tab size:   8 (not used)
13*   indentation:4
14*
15*   created on: 2009nov13
16*   created by: Markus W. Scherer
17*/

19#ifndef __LOCALPOINTER_H__
20#define __LOCALPOINTER_H__

22/**
* \file
* \brief C++ API: "Smart pointers" for use with and in ICU4C C++ code.
*
* These classes are inspired by
* - std::auto_ptr
* - boost::scoped_ptr & boost::scoped_array
* - Taligent Safe Pointers (TOnlyPointerTo)
*
* but none of those provide for all of the goals for ICU smart pointers:
* - Smart pointer owns the object and releases it when it goes out of scope.
* - No transfer of ownership via copy/assignment to reduce misuse. Simpler & more robust.
* - ICU-compatible: No exceptions.
* - Need to be able to orphan/release the pointer and its ownership.
* - Need variants for normal C++ object pointers, C++ arrays, and ICU C service objects.
*
* For details see https://icu.unicode.org/design/cpp/scoped_ptr
*/

41#include "unicode/utypes.h"

43#if U_SHOW_CPLUSPLUS_API1

45#include <memory>

47U_NAMESPACE_BEGINnamespace icu_71 {

49/**
* "Smart pointer" base class; do not use directly: use LocalPointer etc.
*
* Base class for smart pointer classes that do not throw exceptions.
*
* Do not use this base class directly, since it does not delete its pointer.
* A subclass must implement methods that delete the pointer:
* Destructor and adoptInstead().
*
* There is no operator T *() provided because the programmer must decide
* whether to use getAlias() (without transfer of ownership) or orphan()
* (with transfer of ownership and NULLing of the pointer).
*
* @see LocalPointer
* @see LocalArray
* @see U_DEFINE_LOCAL_OPEN_POINTER
* @stable ICU 4.4
*/
67template<typename T>
68class LocalPointerBase {
69public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) = delete;
  static void* U_EXPORT2 operator new[](size_t) = delete;
73#if U_HAVE_PLACEMENT_NEW1
  static void* U_EXPORT2 operator new(size_t, void*) = delete;
75#endif

  /**
   * Constructor takes ownership.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  explicit LocalPointerBase(T *p=NULL__null) : ptr(p) {}
6
←
Null pointer value stored to 'partials.ptr'→
  /**
   * Destructor deletes the object it owns.
   * Subclass must override: Base class does nothing.
   * @stable ICU 4.4
   */
  ~LocalPointerBase() { /* delete ptr; */ }
  /**
   * NULL check.
   * @return true if ==NULL
   * @stable ICU 4.4
   */
  UBool isNull() const { return ptr==NULL__null; }
  /**
   * NULL check.
   * @return true if !=NULL
   * @stable ICU 4.4
   */
  UBool isValid() const { return ptr!=NULL__null; }
  /**
   * Comparison with a simple pointer, so that existing code
   * with ==NULL need not be changed.
   * @param other simple pointer for comparison
   * @return true if this pointer value equals other
   * @stable ICU 4.4
   */
  bool operator==(const T *other) const { return ptr==other; }
  /**
   * Comparison with a simple pointer, so that existing code
   * with !=NULL need not be changed.
   * @param other simple pointer for comparison
   * @return true if this pointer value differs from other
   * @stable ICU 4.4
   */
  bool operator!=(const T *other) const { return ptr!=other; }
  /**
   * Access without ownership change.
   * @return the pointer value
   * @stable ICU 4.4
   */
  T *getAlias() const { return ptr; }
  /**
   * Access without ownership change.
   * @return the pointer value as a reference
   * @stable ICU 4.4
   */
  T &operator*() const { return *ptr; }
  /**
   * Access without ownership change.
   * @return the pointer value
   * @stable ICU 4.4
   */
  T *operator->() const { return ptr; }
  /**
   * Gives up ownership; the internal pointer becomes NULL.
   * @return the pointer value;
   *         caller becomes responsible for deleting the object
   * @stable ICU 4.4
   */
  T *orphan() {
      T *p=ptr;
      ptr=NULL__null;
      return p;
  }
  /**
   * Deletes the object it owns,
   * and adopts (takes ownership of) the one passed in.
   * Subclass must override: Base class does not delete the object.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  void adoptInstead(T *p) {
      // delete ptr;
      ptr=p;
  }
157protected:
  /**
   * Actual pointer.
   * @internal
   */
  T *ptr;
163private:
  // No comparison operators with other LocalPointerBases.
  bool operator==(const LocalPointerBase<T> &other);
  bool operator!=(const LocalPointerBase<T> &other);
  // No ownership sharing: No copy constructor, no assignment operator.
  LocalPointerBase(const LocalPointerBase<T> &other);
  void operator=(const LocalPointerBase<T> &other);
170};

172/**
* "Smart pointer" class, deletes objects via the standard C++ delete operator.
* For most methods see the LocalPointerBase base class.
*
* Usage example:
* \code
* LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
* int32_t length=s->length();  // 2
* char16_t lead=s->charAt(0);  // 0xd900
* if(some condition) { return; }  // no need to explicitly delete the pointer
* s.adoptInstead(new UnicodeString((char16_t)0xfffc));
* length=s->length();  // 1
* // no need to explicitly delete the pointer
* \endcode
*
* @see LocalPointerBase
* @stable ICU 4.4
*/
190template<typename T>
191class LocalPointer : public LocalPointerBase<T> {
192public:
  using LocalPointerBase<T>::operator*;
  using LocalPointerBase<T>::operator->;
  /**
   * Constructor takes ownership.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  explicit LocalPointer(T *p=NULL__null) : LocalPointerBase<T>(p) {}
  /**
   * Constructor takes ownership and reports an error if NULL.
   *
   * This constructor is intended to be used with other-class constructors
   * that may report a failure UErrorCode,
   * so that callers need to check only for U_FAILURE(errorCode)
   * and not also separately for isNull().
   *
   * @param p simple pointer to an object that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==NULL and no other failure code had been set
   * @stable ICU 55
   */
  LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase<T>(p) {
      if(p==NULL__null && U_SUCCESS(errorCode)) {
          errorCode=U_MEMORY_ALLOCATION_ERROR;
      }
  }
  /**
   * Move constructor, leaves src with isNull().
   * @param src source smart pointer
   * @stable ICU 56
   */
  LocalPointer(LocalPointer<T> &&src) U_NOEXCEPTnoexcept : LocalPointerBase<T>(src.ptr) {
      src.ptr=NULL__null;
  }

  /**
   * Constructs a LocalPointer from a C++11 std::unique_ptr.
   * The LocalPointer steals the object owned by the std::unique_ptr.
   *
   * This constructor works via move semantics. If your std::unique_ptr is
   * in a local variable, you must use std::move.
   *
   * @param p The std::unique_ptr from which the pointer will be stolen.
   * @stable ICU 64
   */
  explicit LocalPointer(std::unique_ptr<T> &&p)
      : LocalPointerBase<T>(p.release()) {}

  /**
   * Destructor deletes the object it owns.
   * @stable ICU 4.4
   */
  ~LocalPointer() {
      delete LocalPointerBase<T>::ptr;
  }
  /**
   * Move assignment operator, leaves src with isNull().
   * The behavior is undefined if *this and src are the same object.
   * @param src source smart pointer
   * @return *this
   * @stable ICU 56
   */
  LocalPointer<T> &operator=(LocalPointer<T> &&src) U_NOEXCEPTnoexcept {
      delete LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=src.ptr;
      src.ptr=NULL__null;
      return *this;
  }

  /**
   * Move-assign from an std::unique_ptr to this LocalPointer.
   * Steals the pointer from the std::unique_ptr.
   *
   * @param p The std::unique_ptr from which the pointer will be stolen.
   * @return *this
   * @stable ICU 64
   */
  LocalPointer<T> &operator=(std::unique_ptr<T> &&p) U_NOEXCEPTnoexcept {
      adoptInstead(p.release());
      return *this;
  }

  /**
   * Swap pointers.
   * @param other other smart pointer
   * @stable ICU 56
   */
  void swap(LocalPointer<T> &other) U_NOEXCEPTnoexcept {
      T *temp=LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=other.ptr;
      other.ptr=temp;
  }
  /**
   * Non-member LocalPointer swap function.
   * @param p1 will get p2's pointer
   * @param p2 will get p1's pointer
   * @stable ICU 56
   */
  friend inline void swap(LocalPointer<T> &p1, LocalPointer<T> &p2) U_NOEXCEPTnoexcept {
      p1.swap(p2);
  }
  /**
   * Deletes the object it owns,
   * and adopts (takes ownership of) the one passed in.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  void adoptInstead(T *p) {
      delete LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=p;
  }
  /**
   * Deletes the object it owns,
   * and adopts (takes ownership of) the one passed in.
   *
   * If U_FAILURE(errorCode), then the current object is retained and the new one deleted.
   *
   * If U_SUCCESS(errorCode) but the input pointer is NULL,
   * then U_MEMORY_ALLOCATION_ERROR is set,
   * the current object is deleted, and NULL is set.
   *
   * @param p simple pointer to an object that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==NULL and no other failure code had been set
   * @stable ICU 55
   */
  void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) {
      if(U_SUCCESS(errorCode)) {
          delete LocalPointerBase<T>::ptr;
          LocalPointerBase<T>::ptr=p;
          if(p==NULL__null) {
              errorCode=U_MEMORY_ALLOCATION_ERROR;
          }
      } else {
          delete p;
      }
  }

  /**
   * Conversion operator to a C++11 std::unique_ptr.
   * Disowns the object and gives it to the returned std::unique_ptr.
   *
   * This operator works via move semantics. If your LocalPointer is
   * in a local variable, you must use std::move.
   *
   * @return An std::unique_ptr owning the pointer previously owned by this
   *         icu::LocalPointer.
   * @stable ICU 64
   */
  operator std::unique_ptr<T> () && {
      return std::unique_ptr<T>(LocalPointerBase<T>::orphan());
  }
345};

347/**
* "Smart pointer" class, deletes objects via the C++ array delete[] operator.
* For most methods see the LocalPointerBase base class.
* Adds operator[] for array item access.
*
* Usage example:
* \code
* LocalArray<UnicodeString> a(new UnicodeString[2]);
* a[0].append((char16_t)0x61);
* if(some condition) { return; }  // no need to explicitly delete the array
* a.adoptInstead(new UnicodeString[4]);
* a[3].append((char16_t)0x62).append((char16_t)0x63).reverse();
* // no need to explicitly delete the array
* \endcode
*
* @see LocalPointerBase
* @stable ICU 4.4
*/
365template<typename T>
366class LocalArray : public LocalPointerBase<T> {
367public:
  using LocalPointerBase<T>::operator*;
  using LocalPointerBase<T>::operator->;
  /**
   * Constructor takes ownership.
   * @param p simple pointer to an array of T objects that is adopted
   * @stable ICU 4.4
   */
  explicit LocalArray(T *p=NULL__null) : LocalPointerBase<T>(p) {}
  /**
   * Constructor takes ownership and reports an error if NULL.
   *
   * This constructor is intended to be used with other-class constructors
   * that may report a failure UErrorCode,
   * so that callers need to check only for U_FAILURE(errorCode)
   * and not also separately for isNull().
   *
   * @param p simple pointer to an array of T objects that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==NULL and no other failure code had been set
   * @stable ICU 56
   */
  LocalArray(T *p, UErrorCode &errorCode) : LocalPointerBase<T>(p) {
      if(p==NULL__null && U_SUCCESS(errorCode)) {
          errorCode=U_MEMORY_ALLOCATION_ERROR;
      }
  }
  /**
   * Move constructor, leaves src with isNull().
   * @param src source smart pointer
   * @stable ICU 56
   */
  LocalArray(LocalArray<T> &&src) U_NOEXCEPTnoexcept : LocalPointerBase<T>(src.ptr) {
      src.ptr=NULL__null;
  }

  /**
   * Constructs a LocalArray from a C++11 std::unique_ptr of an array type.
   * The LocalPointer steals the array owned by the std::unique_ptr.
   *
   * This constructor works via move semantics. If your std::unique_ptr is
   * in a local variable, you must use std::move.
   *
   * @param p The std::unique_ptr from which the array will be stolen.
   * @stable ICU 64
   */
  explicit LocalArray(std::unique_ptr<T[]> &&p)
      : LocalPointerBase<T>(p.release()) {}

  /**
   * Destructor deletes the array it owns.
   * @stable ICU 4.4
   */
  ~LocalArray() {
      delete[] LocalPointerBase<T>::ptr;
  }
  /**
   * Move assignment operator, leaves src with isNull().
   * The behavior is undefined if *this and src are the same object.
   * @param src source smart pointer
   * @return *this
   * @stable ICU 56
   */
  LocalArray<T> &operator=(LocalArray<T> &&src) U_NOEXCEPTnoexcept {
      delete[] LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=src.ptr;
      src.ptr=NULL__null;
      return *this;
  }

  /**
   * Move-assign from an std::unique_ptr to this LocalPointer.
   * Steals the array from the std::unique_ptr.
   *
   * @param p The std::unique_ptr from which the array will be stolen.
   * @return *this
   * @stable ICU 64
   */
  LocalArray<T> &operator=(std::unique_ptr<T[]> &&p) U_NOEXCEPTnoexcept {
      adoptInstead(p.release());
      return *this;
  }

  /**
   * Swap pointers.
   * @param other other smart pointer
   * @stable ICU 56
   */
  void swap(LocalArray<T> &other) U_NOEXCEPTnoexcept {
      T *temp=LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=other.ptr;
      other.ptr=temp;
  }
  /**
   * Non-member LocalArray swap function.
   * @param p1 will get p2's pointer
   * @param p2 will get p1's pointer
   * @stable ICU 56
   */
  friend inline void swap(LocalArray<T> &p1, LocalArray<T> &p2) U_NOEXCEPTnoexcept {
      p1.swap(p2);
  }
  /**
   * Deletes the array it owns,
   * and adopts (takes ownership of) the one passed in.
   * @param p simple pointer to an array of T objects that is adopted
   * @stable ICU 4.4
   */
  void adoptInstead(T *p) {
      delete[] LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=p;
  }
  /**
   * Deletes the array it owns,
   * and adopts (takes ownership of) the one passed in.
   *
   * If U_FAILURE(errorCode), then the current array is retained and the new one deleted.
   *
   * If U_SUCCESS(errorCode) but the input pointer is NULL,
   * then U_MEMORY_ALLOCATION_ERROR is set,
   * the current array is deleted, and NULL is set.
   *
   * @param p simple pointer to an array of T objects that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==NULL and no other failure code had been set
   * @stable ICU 56
   */
  void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) {
      if(U_SUCCESS(errorCode)) {
          delete[] LocalPointerBase<T>::ptr;
          LocalPointerBase<T>::ptr=p;
          if(p==NULL__null) {
              errorCode=U_MEMORY_ALLOCATION_ERROR;
          }
      } else {
          delete[] p;
      }
  }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   * @stable ICU 4.4
   */
  T &operator[](ptrdiff_t i) const { return LocalPointerBase<T>::ptr[i]; }

  /**
   * Conversion operator to a C++11 std::unique_ptr.
   * Disowns the object and gives it to the returned std::unique_ptr.
   *
   * This operator works via move semantics. If your LocalPointer is
   * in a local variable, you must use std::move.
   *
   * @return An std::unique_ptr owning the pointer previously owned by this
   *         icu::LocalPointer.
   * @stable ICU 64
   */
  operator std::unique_ptr<T[]> () && {
      return std::unique_ptr<T[]>(LocalPointerBase<T>::orphan());
  }
528};

530/**
* \def U_DEFINE_LOCAL_OPEN_POINTER
* "Smart pointer" definition macro, deletes objects via the closeFunction.
* Defines a subclass of LocalPointerBase which works just
* like LocalPointer<Type> except that this subclass will use the closeFunction
* rather than the C++ delete operator.
*
* Usage example:
* \code
* LocalUCaseMapPointer csm(ucasemap_open(localeID, options, &errorCode));
* utf8OutLength=ucasemap_utf8ToLower(csm.getAlias(),
*     utf8Out, (int32_t)sizeof(utf8Out),
*     utf8In, utf8InLength, &errorCode);
* if(U_FAILURE(errorCode)) { return; }  // no need to explicitly delete the UCaseMap
* \endcode
*
* @see LocalPointerBase
* @see LocalPointer
* @stable ICU 4.4
*/
550#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction)class LocalPointerClassName : public LocalPointerBase<Type
> { public: using LocalPointerBase<Type>::operator*;
 using LocalPointerBase<Type>::operator->; explicit LocalPointerClassName
(Type *p=__null) : LocalPointerBase<Type>(p) {} LocalPointerClassName
(LocalPointerClassName &&src) noexcept : LocalPointerBase
<Type>(src.ptr) { src.ptr=__null; } explicit LocalPointerClassName
(std::unique_ptr<Type, decltype(&closeFunction)> &&
p) : LocalPointerBase<Type>(p.release()) {} ~LocalPointerClassName
() { if (ptr != __null) { closeFunction(ptr); } } LocalPointerClassName
 &operator=(LocalPointerClassName &&src) noexcept
 { if (ptr != __null) { closeFunction(ptr); } LocalPointerBase
<Type>::ptr=src.ptr; src.ptr=__null; return *this; } LocalPointerClassName
 &operator=(std::unique_ptr<Type, decltype(&closeFunction
)> &&p) { adoptInstead(p.release()); return *this;
 } void swap(LocalPointerClassName &other) noexcept { Type
 *temp=LocalPointerBase<Type>::ptr; LocalPointerBase<
Type>::ptr=other.ptr; other.ptr=temp; } friend inline void
 swap(LocalPointerClassName &p1, LocalPointerClassName &
p2) noexcept { p1.swap(p2); } void adoptInstead(Type *p) { if
 (ptr != __null) { closeFunction(ptr); } ptr=p; } operator std
::unique_ptr<Type, decltype(&closeFunction)> () &&
 { return std::unique_ptr<Type, decltype(&closeFunction
)>(LocalPointerBase<Type>::orphan(), closeFunction);
 } } \
  class LocalPointerClassName : public LocalPointerBase<Type> { \
  public: \
      using LocalPointerBase<Type>::operator*; \
      using LocalPointerBase<Type>::operator->; \
      explicit LocalPointerClassName(Type *p=NULL__null) : LocalPointerBase<Type>(p) {} \
      LocalPointerClassName(LocalPointerClassName &&src) U_NOEXCEPTnoexcept \
              : LocalPointerBase<Type>(src.ptr) { \
          src.ptr=NULL__null; \
      } \
      /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */ \
      explicit LocalPointerClassName(std::unique_ptr<Type, decltype(&closeFunction)> &&p) \
              : LocalPointerBase<Type>(p.release()) {} \
      ~LocalPointerClassName() { if (ptr != NULL__null) { closeFunction(ptr); } } \
      LocalPointerClassName &operator=(LocalPointerClassName &&src) U_NOEXCEPTnoexcept { \
          if (ptr != NULL__null) { closeFunction(ptr); } \
          LocalPointerBase<Type>::ptr=src.ptr; \
          src.ptr=NULL__null; \
          return *this; \
      } \
      /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */ \
      LocalPointerClassName &operator=(std::unique_ptr<Type, decltype(&closeFunction)> &&p) { \
          adoptInstead(p.release()); \
          return *this; \
      } \
      void swap(LocalPointerClassName &other) U_NOEXCEPTnoexcept { \
          Type *temp=LocalPointerBase<Type>::ptr; \
          LocalPointerBase<Type>::ptr=other.ptr; \
          other.ptr=temp; \
      } \
      friend inline void swap(LocalPointerClassName &p1, LocalPointerClassName &p2) U_NOEXCEPTnoexcept { \
          p1.swap(p2); \
      } \
      void adoptInstead(Type *p) { \
          if (ptr != NULL__null) { closeFunction(ptr); } \
          ptr=p; \
      } \
      operator std::unique_ptr<Type, decltype(&closeFunction)> () && { \
          return std::unique_ptr<Type, decltype(&closeFunction)>(LocalPointerBase<Type>::orphan(), closeFunction); \
      } \
  }

592U_NAMESPACE_END}

594#endif  /* U_SHOW_CPLUSPLUS_API */
595#endif  /* __LOCALPOINTER_H__ */