../deps/icu-small/source/i18n/rulebasedcollator.cpp

Bug Summary

File:	out/../deps/icu-small/source/i18n/rulebasedcollator.cpp
Warning:	line 667, column 13 Null pointer passed to 1st parameter expecting 'nonnull'
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 rulebasedcollator.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_I18N_IMPLEMENTATION=1 -D U_IO_IMPLEMENTATION=1 -D U_TOOLUTIL_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 -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/tools/toolutil -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/i18n/rulebasedcollator.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) 1996-2015, International Business Machines
6* Corporation and others.  All Rights Reserved.
7*******************************************************************************
8* rulebasedcollator.cpp
9*
10* (replaced the former tblcoll.cpp)
11*
12* created on: 2012feb14 with new and old collation code
13* created by: Markus W. Scherer
14*/

16#include "unicode/utypes.h"

18#if !UCONFIG_NO_COLLATION0

20#include "unicode/coll.h"
21#include "unicode/coleitr.h"
22#include "unicode/localpointer.h"
23#include "unicode/locid.h"
24#include "unicode/sortkey.h"
25#include "unicode/tblcoll.h"
26#include "unicode/ucol.h"
27#include "unicode/uiter.h"
28#include "unicode/uloc.h"
29#include "unicode/uniset.h"
30#include "unicode/unistr.h"
31#include "unicode/usetiter.h"
32#include "unicode/utf8.h"
33#include "unicode/uversion.h"
34#include "bocsu.h"
35#include "charstr.h"
36#include "cmemory.h"
37#include "collation.h"
38#include "collationcompare.h"
39#include "collationdata.h"
40#include "collationdatareader.h"
41#include "collationfastlatin.h"
42#include "collationiterator.h"
43#include "collationkeys.h"
44#include "collationroot.h"
45#include "collationsets.h"
46#include "collationsettings.h"
47#include "collationtailoring.h"
48#include "cstring.h"
49#include "uassert.h"
50#include "ucol_imp.h"
51#include "uhash.h"
52#include "uitercollationiterator.h"
53#include "ustr_imp.h"
54#include "utf16collationiterator.h"
55#include "utf8collationiterator.h"
56#include "uvectr64.h"

58U_NAMESPACE_BEGINnamespace icu_71 {

60namespace {

62class FixedSortKeyByteSink : public SortKeyByteSink {
63public:
  FixedSortKeyByteSink(char *dest, int32_t destCapacity)
          : SortKeyByteSink(dest, destCapacity) {}
  virtual ~FixedSortKeyByteSink();

68private:
  virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length) override;
  virtual UBool Resize(int32_t appendCapacity, int32_t length) override;
71};

73FixedSortKeyByteSink::~FixedSortKeyByteSink() {}

75void
76FixedSortKeyByteSink::AppendBeyondCapacity(const char *bytes, int32_t /*n*/, int32_t length) {
  // buffer_ != NULL && bytes != NULL && n > 0 && appended_ > capacity_
  // Fill the buffer completely.
  int32_t available = capacity_ - length;
  if (available > 0) {
      uprv_memcpy(buffer_ + length, bytes, available)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(buffer_ +
 length, bytes, available); } while (false);
  }
83}

85UBool
86FixedSortKeyByteSink::Resize(int32_t /*appendCapacity*/, int32_t /*length*/) {
  return FALSE0;
88}

90}  // namespace

92// Not in an anonymous namespace, so that it can be a friend of CollationKey.
93class CollationKeyByteSink : public SortKeyByteSink {
94public:
  CollationKeyByteSink(CollationKey &key)
          : SortKeyByteSink(reinterpret_cast<char *>(key.getBytes()), key.getCapacity()),
            key_(key) {}
  virtual ~CollationKeyByteSink();

100private:
  virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length) override;
  virtual UBool Resize(int32_t appendCapacity, int32_t length) override;

  CollationKey &key_;
105};

107CollationKeyByteSink::~CollationKeyByteSink() {}

109void
110CollationKeyByteSink::AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length) {
  // buffer_ != NULL && bytes != NULL && n > 0 && appended_ > capacity_
  if (Resize(n, length)) {
      uprv_memcpy(buffer_ + length, bytes, n)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(buffer_ +
 length, bytes, n); } while (false);
  }
115}

117UBool
118CollationKeyByteSink::Resize(int32_t appendCapacity, int32_t length) {
  if (buffer_ == NULL__null) {
      return FALSE0;  // allocation failed before already
  }
  int32_t newCapacity = 2 * capacity_;
  int32_t altCapacity = length + 2 * appendCapacity;
  if (newCapacity < altCapacity) {
      newCapacity = altCapacity;
  }
  if (newCapacity < 200) {
      newCapacity = 200;
  }
  uint8_t *newBuffer = key_.reallocate(newCapacity, length);
  if (newBuffer == NULL__null) {
      SetNotOk();
      return FALSE0;
  }
  buffer_ = reinterpret_cast<char *>(newBuffer);
  capacity_ = newCapacity;
  return TRUE1;
138}

140RuleBasedCollator::RuleBasedCollator(const RuleBasedCollator &other)
      : Collator(other),
        data(other.data),
        settings(other.settings),
        tailoring(other.tailoring),
        cacheEntry(other.cacheEntry),
        validLocale(other.validLocale),
        explicitlySetAttributes(other.explicitlySetAttributes),
        actualLocaleIsSameAsValid(other.actualLocaleIsSameAsValid) {
  settings->addRef();
  cacheEntry->addRef();
151}

153RuleBasedCollator::RuleBasedCollator(const uint8_t *bin, int32_t length,
                                   const RuleBasedCollator *base, UErrorCode &errorCode)
      : data(NULL__null),
        settings(NULL__null),
        tailoring(NULL__null),
        cacheEntry(NULL__null),
        validLocale(""),
        explicitlySetAttributes(0),
        actualLocaleIsSameAsValid(FALSE0) {
  if(U_FAILURE(errorCode)) { return; }
  if(bin == NULL__null || length == 0 || base == NULL__null) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  const CollationTailoring *root = CollationRoot::getRoot(errorCode);
  if(U_FAILURE(errorCode)) { return; }
  if(base->tailoring != root) {
      errorCode = U_UNSUPPORTED_ERROR;
      return;
  }
  LocalPointer<CollationTailoring> t(new CollationTailoring(base->tailoring->settings));
  if(t.isNull() || t->isBogus()) {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  CollationDataReader::read(base->tailoring, bin, length, *t, errorCode);
  if(U_FAILURE(errorCode)) { return; }
  t->actualLocale.setToBogus();
  adoptTailoring(t.orphan(), errorCode);
182}

184RuleBasedCollator::RuleBasedCollator(const CollationCacheEntry *entry)
      : data(entry->tailoring->data),
        settings(entry->tailoring->settings),
        tailoring(entry->tailoring),
        cacheEntry(entry),
        validLocale(entry->validLocale),
        explicitlySetAttributes(0),
        actualLocaleIsSameAsValid(FALSE0) {
  settings->addRef();
  cacheEntry->addRef();
194}

196RuleBasedCollator::~RuleBasedCollator() {
  SharedObject::clearPtr(settings);
  SharedObject::clearPtr(cacheEntry);
199}

201void
202RuleBasedCollator::adoptTailoring(CollationTailoring *t, UErrorCode &errorCode) {
  if(U_FAILURE(errorCode)) {
      t->deleteIfZeroRefCount();
      return;
  }
  U_ASSERT(settings == NULL && data == NULL && tailoring == NULL && cacheEntry == NULL)(void)0;
  cacheEntry = new CollationCacheEntry(t->actualLocale, t);
  if(cacheEntry == NULL__null) {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
      t->deleteIfZeroRefCount();
      return;
  }
  data = t->data;
  settings = t->settings;
  settings->addRef();
  tailoring = t;
  cacheEntry->addRef();
  validLocale = t->actualLocale;
  actualLocaleIsSameAsValid = FALSE0;
221}

223RuleBasedCollator *
224RuleBasedCollator::clone() const {
  return new RuleBasedCollator(*this);
226}

228RuleBasedCollator &RuleBasedCollator::operator=(const RuleBasedCollator &other) {
  if(this == &other) { return *this; }
  SharedObject::copyPtr(other.settings, settings);
  tailoring = other.tailoring;
  SharedObject::copyPtr(other.cacheEntry, cacheEntry);
  data = tailoring->data;
  validLocale = other.validLocale;
  explicitlySetAttributes = other.explicitlySetAttributes;
  actualLocaleIsSameAsValid = other.actualLocaleIsSameAsValid;
  return *this;
238}

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

242bool
243RuleBasedCollator::operator==(const Collator& other) const {
  if(this == &other) { return true; }
  if(!Collator::operator==(other)) { return false; }
  const RuleBasedCollator &o = static_cast<const RuleBasedCollator &>(other);
  if(*settings != *o.settings) { return false; }
  if(data == o.data) { return true; }
  UBool thisIsRoot = data->base == NULL__null;
  UBool otherIsRoot = o.data->base == NULL__null;
  U_ASSERT(!thisIsRoot || !otherIsRoot)(void)0;  // otherwise their data pointers should be ==
  if(thisIsRoot != otherIsRoot) { return false; }
  if((thisIsRoot || !tailoring->rules.isEmpty()) &&
          (otherIsRoot || !o.tailoring->rules.isEmpty())) {
      // Shortcut: If both collators have valid rule strings, then compare those.
      if(tailoring->rules == o.tailoring->rules) { return true; }
  }
  // Different rule strings can result in the same or equivalent tailoring.
  // The rule strings are optional in ICU resource bundles, although included by default.
  // cloneBinary() drops the rule string.
  UErrorCode errorCode = U_ZERO_ERROR;
  LocalPointer<UnicodeSet> thisTailored(getTailoredSet(errorCode));
  LocalPointer<UnicodeSet> otherTailored(o.getTailoredSet(errorCode));
  if(U_FAILURE(errorCode)) { return false; }
  if(*thisTailored != *otherTailored) { return false; }
  // For completeness, we should compare all of the mappings;
  // or we should create a list of strings, sort it with one collator,
  // and check if both collators compare adjacent strings the same
  // (order & strength, down to quaternary); or similar.
  // Testing equality of collators seems unusual.
  return true;
272}

274int32_t
275RuleBasedCollator::hashCode() const {
  int32_t h = settings->hashCode();
  if(data->base == NULL__null) { return h; }  // root collator
  // Do not rely on the rule string, see comments in operator==().
  UErrorCode errorCode = U_ZERO_ERROR;
  LocalPointer<UnicodeSet> set(getTailoredSet(errorCode));
  if(U_FAILURE(errorCode)) { return 0; }
  UnicodeSetIterator iter(*set);
  while(iter.next() && !iter.isString()) {
      h ^= data->getCE32(iter.getCodepoint());
  }
  return h;
287}

289void
290RuleBasedCollator::setLocales(const Locale &requested, const Locale &valid,
                            const Locale &actual) {
  if(actual == tailoring->actualLocale) {
      actualLocaleIsSameAsValid = FALSE0;
  } else {
      U_ASSERT(actual == valid)(void)0;
      actualLocaleIsSameAsValid = TRUE1;
  }
  // Do not modify tailoring.actualLocale:
  // We cannot be sure that that would be thread-safe.
  validLocale = valid;
  (void)requested;  // Ignore, see also ticket #10477.
302}

304Locale
305RuleBasedCollator::getLocale(ULocDataLocaleType type, UErrorCode& errorCode) const {
  if(U_FAILURE(errorCode)) {
      return Locale::getRoot();
  }
  switch(type) {
  case ULOC_ACTUAL_LOCALE:
      return actualLocaleIsSameAsValid ? validLocale : tailoring->actualLocale;
  case ULOC_VALID_LOCALE:
      return validLocale;
  case ULOC_REQUESTED_LOCALE:
  default:
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return Locale::getRoot();
  }
319}

321const char *
322RuleBasedCollator::internalGetLocaleID(ULocDataLocaleType type, UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) {
      return NULL__null;
  }
  const Locale *result;
  switch(type) {
  case ULOC_ACTUAL_LOCALE:
      result = actualLocaleIsSameAsValid ? &validLocale : &tailoring->actualLocale;
      break;
  case ULOC_VALID_LOCALE:
      result = &validLocale;
      break;
  case ULOC_REQUESTED_LOCALE:
  default:
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }
  if(result->isBogus()) { return NULL__null; }
  const char *id = result->getName();
  return id[0] == 0 ? "root" : id;
342}

344const UnicodeString&
345RuleBasedCollator::getRules() const {
  return tailoring->rules;
347}

349void
350RuleBasedCollator::getRules(UColRuleOption delta, UnicodeString &buffer) const {
  if(delta == UCOL_TAILORING_ONLY) {
      buffer = tailoring->rules;
      return;
  }
  // UCOL_FULL_RULES
  buffer.remove();
  CollationLoader::appendRootRules(buffer);
  buffer.append(tailoring->rules).getTerminatedBuffer();
359}

361void
362RuleBasedCollator::getVersion(UVersionInfo version) const {
  uprv_memcpy(version, tailoring->version, U_MAX_VERSION_LENGTH)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(version, tailoring
->version, 4); } while (false);
  version[0] += (UCOL_RUNTIME_VERSION9 << 4) + (UCOL_RUNTIME_VERSION9 >> 4);
365}

367UnicodeSet *
368RuleBasedCollator::getTailoredSet(UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return NULL__null; }
  UnicodeSet *tailored = new UnicodeSet();
  if(tailored == NULL__null) {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
      return NULL__null;
  }
  if(data->base != NULL__null) {
      TailoredSet(tailored).forData(data, errorCode);
      if(U_FAILURE(errorCode)) {
          delete tailored;
          return NULL__null;
      }
  }
  return tailored;
383}

385void
386RuleBasedCollator::internalGetContractionsAndExpansions(
      UnicodeSet *contractions, UnicodeSet *expansions,
      UBool addPrefixes, UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return; }
  if(contractions != NULL__null) {
      contractions->clear();
  }
  if(expansions != NULL__null) {
      expansions->clear();
  }
  ContractionsAndExpansions(contractions, expansions, NULL__null, addPrefixes).forData(data, errorCode);
397}

399void
400RuleBasedCollator::internalAddContractions(UChar32 c, UnicodeSet &set, UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return; }
  ContractionsAndExpansions(&set, NULL__null, NULL__null, FALSE0).forCodePoint(data, c, errorCode);
403}

405const CollationSettings &
406RuleBasedCollator::getDefaultSettings() const {
  return *tailoring->settings;
408}

410UColAttributeValue
411RuleBasedCollator::getAttribute(UColAttribute attr, UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return UCOL_DEFAULT; }
  int32_t option;
  switch(attr) {
  case UCOL_FRENCH_COLLATION:
      option = CollationSettings::BACKWARD_SECONDARY;
      break;
  case UCOL_ALTERNATE_HANDLING:
      return settings->getAlternateHandling();
  case UCOL_CASE_FIRST:
      return settings->getCaseFirst();
  case UCOL_CASE_LEVEL:
      option = CollationSettings::CASE_LEVEL;
      break;
  case UCOL_NORMALIZATION_MODE:
      option = CollationSettings::CHECK_FCD;
      break;
  case UCOL_STRENGTH:
      return (UColAttributeValue)settings->getStrength();
  case UCOL_HIRAGANA_QUATERNARY_MODE:
      // Deprecated attribute, unsettable.
      return UCOL_OFF;
  case UCOL_NUMERIC_COLLATION:
      option = CollationSettings::NUMERIC;
      break;
  default:
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return UCOL_DEFAULT;
  }
  return ((settings->options & option) == 0) ? UCOL_OFF : UCOL_ON;
441}

443void
444RuleBasedCollator::setAttribute(UColAttribute attr, UColAttributeValue value,
                              UErrorCode &errorCode) {
  UColAttributeValue oldValue = getAttribute(attr, errorCode);
  if(U_FAILURE(errorCode)) { return; }
  if(value == oldValue) {
      setAttributeExplicitly(attr);
      return;
  }
  const CollationSettings &defaultSettings = getDefaultSettings();
  if(settings == &defaultSettings) {
      if(value == UCOL_DEFAULT) {
          setAttributeDefault(attr);
          return;
      }
  }
  CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
  if(ownedSettings == NULL__null) {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
      return;
  }

  switch(attr) {
  case UCOL_FRENCH_COLLATION:
      ownedSettings->setFlag(CollationSettings::BACKWARD_SECONDARY, value,
                             defaultSettings.options, errorCode);
      break;
  case UCOL_ALTERNATE_HANDLING:
      ownedSettings->setAlternateHandling(value, defaultSettings.options, errorCode);
      break;
  case UCOL_CASE_FIRST:
      ownedSettings->setCaseFirst(value, defaultSettings.options, errorCode);
      break;
  case UCOL_CASE_LEVEL:
      ownedSettings->setFlag(CollationSettings::CASE_LEVEL, value,
                             defaultSettings.options, errorCode);
      break;
  case UCOL_NORMALIZATION_MODE:
      ownedSettings->setFlag(CollationSettings::CHECK_FCD, value,
                             defaultSettings.options, errorCode);
      break;
  case UCOL_STRENGTH:
      ownedSettings->setStrength(value, defaultSettings.options, errorCode);
      break;
  case UCOL_HIRAGANA_QUATERNARY_MODE:
      // Deprecated attribute. Check for valid values but do not change anything.
      if(value != UCOL_OFF && value != UCOL_ON && value != UCOL_DEFAULT) {
          errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      }
      break;
  case UCOL_NUMERIC_COLLATION:
      ownedSettings->setFlag(CollationSettings::NUMERIC, value, defaultSettings.options, errorCode);
      break;
  default:
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      break;
  }
  if(U_FAILURE(errorCode)) { return; }
  setFastLatinOptions(*ownedSettings);
  if(value == UCOL_DEFAULT) {
      setAttributeDefault(attr);
  } else {
      setAttributeExplicitly(attr);
  }
507}

509Collator &
510RuleBasedCollator::setMaxVariable(UColReorderCode group, UErrorCode &errorCode) {
  if(U_FAILURE(errorCode)) { return *this; }
  // Convert the reorder code into a MaxVariable number, or UCOL_DEFAULT=-1.
  int32_t value;
  if(group == UCOL_REORDER_CODE_DEFAULT) {
      value = UCOL_DEFAULT;
  } else if(UCOL_REORDER_CODE_FIRST <= group && group <= UCOL_REORDER_CODE_CURRENCY) {
      value = group - UCOL_REORDER_CODE_FIRST;
  } else {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return *this;
  }
  CollationSettings::MaxVariable oldValue = settings->getMaxVariable();
  if(value == oldValue) {
      setAttributeExplicitly(ATTR_VARIABLE_TOP);
      return *this;
  }
  const CollationSettings &defaultSettings = getDefaultSettings();
  if(settings == &defaultSettings) {
      if(value == UCOL_DEFAULT) {
          setAttributeDefault(ATTR_VARIABLE_TOP);
          return *this;
      }
  }
  CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
  if(ownedSettings == NULL__null) {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
      return *this;
  }

  if(group == UCOL_REORDER_CODE_DEFAULT) {
      group = (UColReorderCode)(UCOL_REORDER_CODE_FIRST + defaultSettings.getMaxVariable());
  }
  uint32_t varTop = data->getLastPrimaryForGroup(group);
  U_ASSERT(varTop != 0)(void)0;
  ownedSettings->setMaxVariable(value, defaultSettings.options, errorCode);
  if(U_FAILURE(errorCode)) { return *this; }
  ownedSettings->variableTop = varTop;
  setFastLatinOptions(*ownedSettings);
  if(value == UCOL_DEFAULT) {
      setAttributeDefault(ATTR_VARIABLE_TOP);
  } else {
      setAttributeExplicitly(ATTR_VARIABLE_TOP);
  }
  return *this;
555}

557UColReorderCode
558RuleBasedCollator::getMaxVariable() const {
  return (UColReorderCode)(UCOL_REORDER_CODE_FIRST + settings->getMaxVariable());
560}

562uint32_t
563RuleBasedCollator::getVariableTop(UErrorCode & /*errorCode*/) const {
  return settings->variableTop;
565}

567uint32_t
568RuleBasedCollator::setVariableTop(const UChar *varTop, int32_t len, UErrorCode &errorCode) {
  if(U_FAILURE(errorCode)) { return 0; }
  if(varTop == NULL__null && len !=0) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  if(len < 0) { len = u_strlenu_strlen_71(varTop); }
  if(len == 0) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  UBool numeric = settings->isNumeric();
  int64_t ce1, ce2;
  if(settings->dontCheckFCD()) {
      UTF16CollationIterator ci(data, numeric, varTop, varTop, varTop + len);
      ce1 = ci.nextCE(errorCode);
      ce2 = ci.nextCE(errorCode);
  } else {
      FCDUTF16CollationIterator ci(data, numeric, varTop, varTop, varTop + len);
      ce1 = ci.nextCE(errorCode);
      ce2 = ci.nextCE(errorCode);
  }
  if(ce1 == Collation::NO_CE || ce2 != Collation::NO_CE) {
      errorCode = U_CE_NOT_FOUND_ERROR;
      return 0;
  }
  setVariableTop((uint32_t)(ce1 >> 32), errorCode);
  return settings->variableTop;
596}

598uint32_t
599RuleBasedCollator::setVariableTop(const UnicodeString &varTop, UErrorCode &errorCode) {
  return setVariableTop(varTop.getBuffer(), varTop.length(), errorCode);
601}

603void
604RuleBasedCollator::setVariableTop(uint32_t varTop, UErrorCode &errorCode) {
  if(U_FAILURE(errorCode)) { return; }
  if(varTop != settings->variableTop) {
      // Pin the variable top to the end of the reordering group which contains it.
      // Only a few special groups are supported.
      int32_t group = data->getGroupForPrimary(varTop);
      if(group < UCOL_REORDER_CODE_FIRST || UCOL_REORDER_CODE_CURRENCY < group) {
          errorCode = U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }
      uint32_t v = data->getLastPrimaryForGroup(group);
      U_ASSERT(v != 0 && v >= varTop)(void)0;
      varTop = v;
      if(varTop != settings->variableTop) {
          CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
          if(ownedSettings == NULL__null) {
              errorCode = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          ownedSettings->setMaxVariable(group - UCOL_REORDER_CODE_FIRST,
                                        getDefaultSettings().options, errorCode);
          if(U_FAILURE(errorCode)) { return; }
          ownedSettings->variableTop = varTop;
          setFastLatinOptions(*ownedSettings);
      }
  }
  if(varTop == getDefaultSettings().variableTop) {
      setAttributeDefault(ATTR_VARIABLE_TOP);
  } else {
      setAttributeExplicitly(ATTR_VARIABLE_TOP);
  }
635}

637int32_t
638RuleBasedCollator::getReorderCodes(int32_t *dest, int32_t capacity,
                                 UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return 0; }
  if(capacity < 0 || (dest == NULL__null && capacity > 0)) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  int32_t length = settings->reorderCodesLength;
  if(length == 0) { return 0; }
  if(length > capacity) {
      errorCode = U_BUFFER_OVERFLOW_ERROR;
      return length;
  }
  uprv_memcpy(dest, settings->reorderCodes, length * 4)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(dest, settings
->reorderCodes, length * 4); } while (false);
  return length;
653}

655void
656RuleBasedCollator::setReorderCodes(const int32_t *reorderCodes, int32_t length,
                                 UErrorCode &errorCode) {
  if(U_FAILURE(errorCode)) { return; }
  if(length < 0 || (reorderCodes == NULL__null && length > 0)) {
1
Assuming 'length' is >= 0→
2
←
Assuming 'reorderCodes' is equal to NULL→
3
←
Assuming 'length' is <= 0→
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  if(length3.1
'length' is not equal to 1
 == 1 && reorderCodes[0] == UCOL_REORDER_CODE_NONE) {
      length = 0;
  }
  if(length == settings->reorderCodesLength &&
4
←
Assuming 'length' is equal to field 'reorderCodesLength'→
          uprv_memcmp(reorderCodes, settings->reorderCodes, length * 4):: memcmp(reorderCodes, settings->reorderCodes,length * 4) == 0) {
5
←
Null pointer passed to 1st parameter expecting 'nonnull'
      return;
  }
  const CollationSettings &defaultSettings = getDefaultSettings();
  if(length == 1 && reorderCodes[0] == UCOL_REORDER_CODE_DEFAULT) {
      if(settings != &defaultSettings) {
          CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
          if(ownedSettings == NULL__null) {
              errorCode = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          ownedSettings->copyReorderingFrom(defaultSettings, errorCode);
          setFastLatinOptions(*ownedSettings);
      }
      return;
  }
  CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
  if(ownedSettings == NULL__null) {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  ownedSettings->setReordering(*data, reorderCodes, length, errorCode);
  setFastLatinOptions(*ownedSettings);
690}

692void
693RuleBasedCollator::setFastLatinOptions(CollationSettings &ownedSettings) const {
  ownedSettings.fastLatinOptions = CollationFastLatin::getOptions(
          data, ownedSettings,
          ownedSettings.fastLatinPrimaries, UPRV_LENGTHOF(ownedSettings.fastLatinPrimaries)(int32_t)(sizeof(ownedSettings.fastLatinPrimaries)/sizeof((ownedSettings
.fastLatinPrimaries)[0])));
697}

699UCollationResult
700RuleBasedCollator::compare(const UnicodeString &left, const UnicodeString &right,
                         UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
  return doCompare(left.getBuffer(), left.length(),
                   right.getBuffer(), right.length(), errorCode);
705}

707UCollationResult
708RuleBasedCollator::compare(const UnicodeString &left, const UnicodeString &right,
                         int32_t length, UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode) || length == 0) { return UCOL_EQUAL; }
  if(length < 0) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return UCOL_EQUAL;
  }
  int32_t leftLength = left.length();
  int32_t rightLength = right.length();
  if(leftLength > length) { leftLength = length; }
  if(rightLength > length) { rightLength = length; }
  return doCompare(left.getBuffer(), leftLength,
                   right.getBuffer(), rightLength, errorCode);
721}

723UCollationResult
724RuleBasedCollator::compare(const UChar *left, int32_t leftLength,
                         const UChar *right, int32_t rightLength,
                         UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
  if((left == NULL__null && leftLength != 0) || (right == NULL__null && rightLength != 0)) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return UCOL_EQUAL;
  }
  // Make sure both or neither strings have a known length.
  // We do not optimize for mixed length/termination.
  if(leftLength >= 0) {
      if(rightLength < 0) { rightLength = u_strlenu_strlen_71(right); }
  } else {
      if(rightLength >= 0) { leftLength = u_strlenu_strlen_71(left); }
  }
  return doCompare(left, leftLength, right, rightLength, errorCode);
740}

742UCollationResult
743RuleBasedCollator::compareUTF8(const StringPiece &left, const StringPiece &right,
                             UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
  const uint8_t *leftBytes = reinterpret_cast<const uint8_t *>(left.data());
  const uint8_t *rightBytes = reinterpret_cast<const uint8_t *>(right.data());
  if((leftBytes == NULL__null && !left.empty()) || (rightBytes == NULL__null && !right.empty())) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return UCOL_EQUAL;
  }
  return doCompare(leftBytes, left.length(), rightBytes, right.length(), errorCode);
753}

755UCollationResult
756RuleBasedCollator::internalCompareUTF8(const char *left, int32_t leftLength,
                                     const char *right, int32_t rightLength,
                                     UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
  if((left == NULL__null && leftLength != 0) || (right == NULL__null && rightLength != 0)) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return UCOL_EQUAL;
  }
  // Make sure both or neither strings have a known length.
  // We do not optimize for mixed length/termination.
  if(leftLength >= 0) {
      if(rightLength < 0) { rightLength = static_cast<int32_t>(uprv_strlen(right):: strlen(right)); }
  } else {
      if(rightLength >= 0) { leftLength = static_cast<int32_t>(uprv_strlen(left):: strlen(left)); }
  }
  return doCompare(reinterpret_cast<const uint8_t *>(left), leftLength,
                   reinterpret_cast<const uint8_t *>(right), rightLength, errorCode);
773}

775namespace {

777/**
* Abstract iterator for identical-level string comparisons.
* Returns FCD code points and handles temporary switching to NFD.
*/
781class NFDIterator : public UObject {
782public:
  NFDIterator() : index(-1), length(0) {}
  virtual ~NFDIterator() {}
  /**
   * Returns the next code point from the internal normalization buffer,
   * or else the next text code point.
   * Returns -1 at the end of the text.
   */
  UChar32 nextCodePoint() {
      if(index >= 0) {
          if(index == length) {
              index = -1;
          } else {
              UChar32 c;
              U16_NEXT_UNSAFE(decomp, index, c)do { (c)=(decomp)[(index)++]; if((((c)&0xfffffc00)==0xd800
)) { (c)=(((UChar32)((c))<<10UL)+(UChar32)((decomp)[(index
)++])-((0xd800<<10UL)+0xdc00-0x10000)); } } while (false
);
              return c;
          }
      }
      return nextRawCodePoint();
  }
  /**
   * @param nfcImpl
   * @param c the last code point returned by nextCodePoint() or nextDecomposedCodePoint()
   * @return the first code point in c's decomposition,
   *         or c itself if it was decomposed already or if it does not decompose
   */
  UChar32 nextDecomposedCodePoint(const Normalizer2Impl &nfcImpl, UChar32 c) {
      if(index >= 0) { return c; }
      decomp = nfcImpl.getDecomposition(c, buffer, length);
      if(decomp == NULL__null) { return c; }
      index = 0;
      U16_NEXT_UNSAFE(decomp, index, c)do { (c)=(decomp)[(index)++]; if((((c)&0xfffffc00)==0xd800
)) { (c)=(((UChar32)((c))<<10UL)+(UChar32)((decomp)[(index
)++])-((0xd800<<10UL)+0xdc00-0x10000)); } } while (false
);
      return c;
  }
816protected:
  /**
   * Returns the next text code point in FCD order.
   * Returns -1 at the end of the text.
   */
  virtual UChar32 nextRawCodePoint() = 0;
822private:
  const UChar *decomp;
  UChar buffer[4];
  int32_t index;
  int32_t length;
827};

829class UTF16NFDIterator : public NFDIterator {
830public:
  UTF16NFDIterator(const UChar *text, const UChar *textLimit) : s(text), limit(textLimit) {}
832protected:
  virtual UChar32 nextRawCodePoint() override {
      if(s == limit) { return U_SENTINEL(-1); }
      UChar32 c = *s++;
      if(limit == NULL__null && c == 0) {
          s = NULL__null;
          return U_SENTINEL(-1);
      }
      UChar trail;
      if(U16_IS_LEAD(c)(((c)&0xfffffc00)==0xd800) && s != limit && U16_IS_TRAIL(trail = *s)(((trail = *s)&0xfffffc00)==0xdc00)) {
          ++s;
          c = U16_GET_SUPPLEMENTARY(c, trail)(((UChar32)(c)<<10UL)+(UChar32)(trail)-((0xd800<<
10UL)+0xdc00-0x10000));
      }
      return c;
  }

  const UChar *s;
  const UChar *limit;
850};

852class FCDUTF16NFDIterator : public UTF16NFDIterator {
853public:
  FCDUTF16NFDIterator(const Normalizer2Impl &nfcImpl, const UChar *text, const UChar *textLimit)
          : UTF16NFDIterator(NULL__null, NULL__null) {
      UErrorCode errorCode = U_ZERO_ERROR;
      const UChar *spanLimit = nfcImpl.makeFCD(text, textLimit, NULL__null, errorCode);
      if(U_FAILURE(errorCode)) { return; }
      if(spanLimit == textLimit || (textLimit == NULL__null && *spanLimit == 0)) {
          s = text;
          limit = spanLimit;
      } else {
          str.setTo(text, (int32_t)(spanLimit - text));
          {
              ReorderingBuffer r_buffer(nfcImpl, str);
              if(r_buffer.init(str.length(), errorCode)) {
                  nfcImpl.makeFCD(spanLimit, textLimit, &r_buffer, errorCode);
              }
          }
          if(U_SUCCESS(errorCode)) {
              s = str.getBuffer();
              limit = s + str.length();
          }
      }
  }
876private:
  UnicodeString str;
878};

880class UTF8NFDIterator : public NFDIterator {
881public:
  UTF8NFDIterator(const uint8_t *text, int32_t textLength)
      : s(text), pos(0), length(textLength) {}
884protected:
  virtual UChar32 nextRawCodePoint() override {
      if(pos == length || (s[pos] == 0 && length < 0)) { return U_SENTINEL(-1); }
      UChar32 c;
      U8_NEXT_OR_FFFD(s, pos, length, c)do { (c)=(uint8_t)(s)[(pos)++]; if(!(((c)&0x80)==0)) { uint8_t
 __t = 0; if((pos)!=(length) && ((c)>=0xe0 ? ((c)<
0xf0 ? "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
[(c)&=0xf]&(1<<((__t=(s)[pos])>>5)) &&
 (__t&=0x3f, 1) : ((c)-=0xf0)<=4 && "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
[(__t=(s)[pos])>>4]&(1<<(c)) && ((c)=
((c)<<6)|(__t&0x3f), ++(pos)!=(length)) && (
__t=(s)[pos]-0x80)<=0x3f) && ((c)=((c)<<6)|__t
, ++(pos)!=(length)) : (c)>=0xc2 && ((c)&=0x1f
, 1)) && (__t=(s)[pos]-0x80)<=0x3f && ((c)
=((c)<<6)|__t, ++(pos), 1)) { } else { (c)=(0xfffd); } }
 } while (false);
      return c;
  }

  const uint8_t *s;
  int32_t pos;
  int32_t length;
895};

897class FCDUTF8NFDIterator : public NFDIterator {
898public:
  FCDUTF8NFDIterator(const CollationData *data, const uint8_t *text, int32_t textLength)
          : u8ci(data, FALSE0, text, 0, textLength) {}
901protected:
  virtual UChar32 nextRawCodePoint() override {
      UErrorCode errorCode = U_ZERO_ERROR;
      return u8ci.nextCodePoint(errorCode);
  }
906private:
  FCDUTF8CollationIterator u8ci;
908};

910class UIterNFDIterator : public NFDIterator {
911public:
  UIterNFDIterator(UCharIterator &it) : iter(it) {}
913protected:
  virtual UChar32 nextRawCodePoint() override {
      return uiter_next32uiter_next32_71(&iter);
  }
917private:
  UCharIterator &iter;
919};

921class FCDUIterNFDIterator : public NFDIterator {
922public:
  FCDUIterNFDIterator(const CollationData *data, UCharIterator &it, int32_t startIndex)
          : uici(data, FALSE0, it, startIndex) {}
925protected:
  virtual UChar32 nextRawCodePoint() override {
      UErrorCode errorCode = U_ZERO_ERROR;
      return uici.nextCodePoint(errorCode);
  }
930private:
  FCDUIterCollationIterator uici;
932};

934UCollationResult compareNFDIter(const Normalizer2Impl &nfcImpl,
                              NFDIterator &left, NFDIterator &right) {
  for(;;) {
      // Fetch the next FCD code point from each string.
      UChar32 leftCp = left.nextCodePoint();
      UChar32 rightCp = right.nextCodePoint();
      if(leftCp == rightCp) {
          if(leftCp < 0) { break; }
          continue;
      }
      // If they are different, then decompose each and compare again.
      if(leftCp < 0) {
          leftCp = -2;  // end of string
      } else if(leftCp == 0xfffe) {
          leftCp = -1;  // U+FFFE: merge separator
      } else {
          leftCp = left.nextDecomposedCodePoint(nfcImpl, leftCp);
      }
      if(rightCp < 0) {
          rightCp = -2;  // end of string
      } else if(rightCp == 0xfffe) {
          rightCp = -1;  // U+FFFE: merge separator
      } else {
          rightCp = right.nextDecomposedCodePoint(nfcImpl, rightCp);
      }
      if(leftCp < rightCp) { return UCOL_LESS; }
      if(leftCp > rightCp) { return UCOL_GREATER; }
  }
  return UCOL_EQUAL;
963}

965}  // namespace

967UCollationResult
968RuleBasedCollator::doCompare(const UChar *left, int32_t leftLength,
                           const UChar *right, int32_t rightLength,
                           UErrorCode &errorCode) const {
  // U_FAILURE(errorCode) checked by caller.
  if(left == right && leftLength == rightLength) {
      return UCOL_EQUAL;
  }

  // Identical-prefix test.
  const UChar *leftLimit;
  const UChar *rightLimit;
  int32_t equalPrefixLength = 0;
  if(leftLength < 0) {
      leftLimit = NULL__null;
      rightLimit = NULL__null;
      UChar c;
      while((c = left[equalPrefixLength]) == right[equalPrefixLength]) {
          if(c == 0) { return UCOL_EQUAL; }
          ++equalPrefixLength;
      }
  } else {
      leftLimit = left + leftLength;
      rightLimit = right + rightLength;
      for(;;) {
          if(equalPrefixLength == leftLength) {
              if(equalPrefixLength == rightLength) { return UCOL_EQUAL; }
              break;
          } else if(equalPrefixLength == rightLength ||
                    left[equalPrefixLength] != right[equalPrefixLength]) {
              break;
          }
          ++equalPrefixLength;
      }
  }

  UBool numeric = settings->isNumeric();
  if(equalPrefixLength > 0) {
      if((equalPrefixLength != leftLength &&
                  data->isUnsafeBackward(left[equalPrefixLength], numeric)) ||
              (equalPrefixLength != rightLength &&
                  data->isUnsafeBackward(right[equalPrefixLength], numeric))) {
          // Identical prefix: Back up to the start of a contraction or reordering sequence.
          while(--equalPrefixLength > 0 &&
                  data->isUnsafeBackward(left[equalPrefixLength], numeric)) {}
      }
      // Notes:
      // - A longer string can compare equal to a prefix of it if only ignorables follow.
      // - With a backward level, a longer string can compare less-than a prefix of it.

      // Pass the actual start of each string into the CollationIterators,
      // plus the equalPrefixLength position,
      // so that prefix matches back into the equal prefix work.
  }

  int32_t result;
  int32_t fastLatinOptions = settings->fastLatinOptions;
  if(fastLatinOptions >= 0 &&
          (equalPrefixLength == leftLength ||
              left[equalPrefixLength] <= CollationFastLatin::LATIN_MAX) &&
          (equalPrefixLength == rightLength ||
              right[equalPrefixLength] <= CollationFastLatin::LATIN_MAX)) {
      if(leftLength >= 0) {
          result = CollationFastLatin::compareUTF16(data->fastLatinTable,
                                                    settings->fastLatinPrimaries,
                                                    fastLatinOptions,
                                                    left + equalPrefixLength,
                                                    leftLength - equalPrefixLength,
                                                    right + equalPrefixLength,
                                                    rightLength - equalPrefixLength);
      } else {
          result = CollationFastLatin::compareUTF16(data->fastLatinTable,
                                                    settings->fastLatinPrimaries,
                                                    fastLatinOptions,
                                                    left + equalPrefixLength, -1,
                                                    right + equalPrefixLength, -1);
      }
  } else {
      result = CollationFastLatin::BAIL_OUT_RESULT;
  }

  if(result == CollationFastLatin::BAIL_OUT_RESULT) {
      if(settings->dontCheckFCD()) {
          UTF16CollationIterator leftIter(data, numeric,
                                          left, left + equalPrefixLength, leftLimit);
          UTF16CollationIterator rightIter(data, numeric,
                                          right, right + equalPrefixLength, rightLimit);
          result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
      } else {
          FCDUTF16CollationIterator leftIter(data, numeric,
                                            left, left + equalPrefixLength, leftLimit);
          FCDUTF16CollationIterator rightIter(data, numeric,
                                              right, right + equalPrefixLength, rightLimit);
          result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
      }
  }
  if(result != UCOL_EQUAL || settings->getStrength() < UCOL_IDENTICAL || U_FAILURE(errorCode)) {
      return (UCollationResult)result;
  }

  // Note: If NUL-terminated, we could get the actual limits from the iterators now.
  // That would complicate the iterators a bit, NUL-terminated strings are only a C convenience,
  // and the benefit seems unlikely to be measurable.

  // Compare identical level.
  const Normalizer2Impl &nfcImpl = data->nfcImpl;
  left += equalPrefixLength;
  right += equalPrefixLength;
  if(settings->dontCheckFCD()) {
      UTF16NFDIterator leftIter(left, leftLimit);
      UTF16NFDIterator rightIter(right, rightLimit);
      return compareNFDIter(nfcImpl, leftIter, rightIter);
  } else {
      FCDUTF16NFDIterator leftIter(nfcImpl, left, leftLimit);
      FCDUTF16NFDIterator rightIter(nfcImpl, right, rightLimit);
      return compareNFDIter(nfcImpl, leftIter, rightIter);
  }
1084}

1086UCollationResult
1087RuleBasedCollator::doCompare(const uint8_t *left, int32_t leftLength,
                           const uint8_t *right, int32_t rightLength,
                           UErrorCode &errorCode) const {
  // U_FAILURE(errorCode) checked by caller.
  if(left == right && leftLength == rightLength) {
      return UCOL_EQUAL;
  }

  // Identical-prefix test.
  int32_t equalPrefixLength = 0;
  if(leftLength < 0) {
      uint8_t c;
      while((c = left[equalPrefixLength]) == right[equalPrefixLength]) {
          if(c == 0) { return UCOL_EQUAL; }
          ++equalPrefixLength;
      }
  } else {
      for(;;) {
          if(equalPrefixLength == leftLength) {
              if(equalPrefixLength == rightLength) { return UCOL_EQUAL; }
              break;
          } else if(equalPrefixLength == rightLength ||
                    left[equalPrefixLength] != right[equalPrefixLength]) {
              break;
          }
          ++equalPrefixLength;
      }
  }
  // Back up to the start of a partially-equal code point.
  if(equalPrefixLength > 0 &&
          ((equalPrefixLength != leftLength && U8_IS_TRAIL(left[equalPrefixLength])((int8_t)(left[equalPrefixLength])<-0x40)) ||
          (equalPrefixLength != rightLength && U8_IS_TRAIL(right[equalPrefixLength])((int8_t)(right[equalPrefixLength])<-0x40)))) {
      while(--equalPrefixLength > 0 && U8_IS_TRAIL(left[equalPrefixLength])((int8_t)(left[equalPrefixLength])<-0x40)) {}
  }

  UBool numeric = settings->isNumeric();
  if(equalPrefixLength > 0) {
      UBool unsafe = FALSE0;
      if(equalPrefixLength != leftLength) {
          int32_t i = equalPrefixLength;
          UChar32 c;
          U8_NEXT_OR_FFFD(left, i, leftLength, c)do { (c)=(uint8_t)(left)[(i)++]; if(!(((c)&0x80)==0)) { uint8_t
 __t = 0; if((i)!=(leftLength) && ((c)>=0xe0 ? ((c
)<0xf0 ? "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
[(c)&=0xf]&(1<<((__t=(left)[i])>>5)) &&
 (__t&=0x3f, 1) : ((c)-=0xf0)<=4 && "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
[(__t=(left)[i])>>4]&(1<<(c)) && ((c)
=((c)<<6)|(__t&0x3f), ++(i)!=(leftLength)) &&
 (__t=(left)[i]-0x80)<=0x3f) && ((c)=((c)<<6
)|__t, ++(i)!=(leftLength)) : (c)>=0xc2 && ((c)&=
0x1f, 1)) && (__t=(left)[i]-0x80)<=0x3f &&
 ((c)=((c)<<6)|__t, ++(i), 1)) { } else { (c)=(0xfffd);
 } } } while (false);
          unsafe = data->isUnsafeBackward(c, numeric);
      }
      if(!unsafe && equalPrefixLength != rightLength) {
          int32_t i = equalPrefixLength;
          UChar32 c;
          U8_NEXT_OR_FFFD(right, i, rightLength, c)do { (c)=(uint8_t)(right)[(i)++]; if(!(((c)&0x80)==0)) { uint8_t
 __t = 0; if((i)!=(rightLength) && ((c)>=0xe0 ? ((
c)<0xf0 ? "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
[(c)&=0xf]&(1<<((__t=(right)[i])>>5)) &&
 (__t&=0x3f, 1) : ((c)-=0xf0)<=4 && "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
[(__t=(right)[i])>>4]&(1<<(c)) && ((c
)=((c)<<6)|(__t&0x3f), ++(i)!=(rightLength)) &&
 (__t=(right)[i]-0x80)<=0x3f) && ((c)=((c)<<
6)|__t, ++(i)!=(rightLength)) : (c)>=0xc2 && ((c)&=
0x1f, 1)) && (__t=(right)[i]-0x80)<=0x3f &&
 ((c)=((c)<<6)|__t, ++(i), 1)) { } else { (c)=(0xfffd);
 } } } while (false);
          unsafe = data->isUnsafeBackward(c, numeric);
      }
      if(unsafe) {
          // Identical prefix: Back up to the start of a contraction or reordering sequence.
          UChar32 c;
          do {
              U8_PREV_OR_FFFD(left, 0, equalPrefixLength, c)do { (c)=(uint8_t)(left)[--(equalPrefixLength)]; if(!(((c)&
0x80)==0)) { (c)=utf8_prevCharSafeBody_71((const uint8_t *)left
, 0, &(equalPrefixLength), c, -3); } } while (false);
          } while(equalPrefixLength > 0 && data->isUnsafeBackward(c, numeric));
      }
      // See the notes in the UTF-16 version.

      // Pass the actual start of each string into the CollationIterators,
      // plus the equalPrefixLength position,
      // so that prefix matches back into the equal prefix work.
  }

  int32_t result;
  int32_t fastLatinOptions = settings->fastLatinOptions;
  if(fastLatinOptions >= 0 &&
          (equalPrefixLength == leftLength ||
              left[equalPrefixLength] <= CollationFastLatin::LATIN_MAX_UTF8_LEAD) &&
          (equalPrefixLength == rightLength ||
              right[equalPrefixLength] <= CollationFastLatin::LATIN_MAX_UTF8_LEAD)) {
      if(leftLength >= 0) {
          result = CollationFastLatin::compareUTF8(data->fastLatinTable,
                                                   settings->fastLatinPrimaries,
                                                   fastLatinOptions,
                                                   left + equalPrefixLength,
                                                   leftLength - equalPrefixLength,
                                                   right + equalPrefixLength,
                                                   rightLength - equalPrefixLength);
      } else {
          result = CollationFastLatin::compareUTF8(data->fastLatinTable,
                                                   settings->fastLatinPrimaries,
                                                   fastLatinOptions,
                                                   left + equalPrefixLength, -1,
                                                   right + equalPrefixLength, -1);
      }
  } else {
      result = CollationFastLatin::BAIL_OUT_RESULT;
  }

  if(result == CollationFastLatin::BAIL_OUT_RESULT) {
      if(settings->dontCheckFCD()) {
          UTF8CollationIterator leftIter(data, numeric, left, equalPrefixLength, leftLength);
          UTF8CollationIterator rightIter(data, numeric, right, equalPrefixLength, rightLength);
          result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
      } else {
          FCDUTF8CollationIterator leftIter(data, numeric, left, equalPrefixLength, leftLength);
          FCDUTF8CollationIterator rightIter(data, numeric, right, equalPrefixLength, rightLength);
          result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
      }
  }
  if(result != UCOL_EQUAL || settings->getStrength() < UCOL_IDENTICAL || U_FAILURE(errorCode)) {
      return (UCollationResult)result;
  }

  // Note: If NUL-terminated, we could get the actual limits from the iterators now.
  // That would complicate the iterators a bit, NUL-terminated strings are only a C convenience,
  // and the benefit seems unlikely to be measurable.

  // Compare identical level.
  const Normalizer2Impl &nfcImpl = data->nfcImpl;
  left += equalPrefixLength;
  right += equalPrefixLength;
  if(leftLength > 0) {
      leftLength -= equalPrefixLength;
      rightLength -= equalPrefixLength;
  }
  if(settings->dontCheckFCD()) {
      UTF8NFDIterator leftIter(left, leftLength);
      UTF8NFDIterator rightIter(right, rightLength);
      return compareNFDIter(nfcImpl, leftIter, rightIter);
  } else {
      FCDUTF8NFDIterator leftIter(data, left, leftLength);
      FCDUTF8NFDIterator rightIter(data, right, rightLength);
      return compareNFDIter(nfcImpl, leftIter, rightIter);
  }
1213}

1215UCollationResult
1216RuleBasedCollator::compare(UCharIterator &left, UCharIterator &right,
                         UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode) || &left == &right) { return UCOL_EQUAL; }
  UBool numeric = settings->isNumeric();

  // Identical-prefix test.
  int32_t equalPrefixLength = 0;
  {
      UChar32 leftUnit;
      UChar32 rightUnit;
      while((leftUnit = left.next(&left)) == (rightUnit = right.next(&right))) {
          if(leftUnit < 0) { return UCOL_EQUAL; }
          ++equalPrefixLength;
      }

      // Back out the code units that differed, for the real collation comparison.
      if(leftUnit >= 0) { left.previous(&left); }
      if(rightUnit >= 0) { right.previous(&right); }

      if(equalPrefixLength > 0) {
          if((leftUnit >= 0 && data->isUnsafeBackward(leftUnit, numeric)) ||
                  (rightUnit >= 0 && data->isUnsafeBackward(rightUnit, numeric))) {
              // Identical prefix: Back up to the start of a contraction or reordering sequence.
              do {
                  --equalPrefixLength;
                  leftUnit = left.previous(&left);
                  right.previous(&right);
              } while(equalPrefixLength > 0 && data->isUnsafeBackward(leftUnit, numeric));
          }
          // See the notes in the UTF-16 version.
      }
  }

  UCollationResult result;
  if(settings->dontCheckFCD()) {
      UIterCollationIterator leftIter(data, numeric, left);
      UIterCollationIterator rightIter(data, numeric, right);
      result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
  } else {
      FCDUIterCollationIterator leftIter(data, numeric, left, equalPrefixLength);
      FCDUIterCollationIterator rightIter(data, numeric, right, equalPrefixLength);
      result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
  }
  if(result != UCOL_EQUAL || settings->getStrength() < UCOL_IDENTICAL || U_FAILURE(errorCode)) {
      return result;
  }

  // Compare identical level.
  left.move(&left, equalPrefixLength, UITER_ZERO);
  right.move(&right, equalPrefixLength, UITER_ZERO);
  const Normalizer2Impl &nfcImpl = data->nfcImpl;
  if(settings->dontCheckFCD()) {
      UIterNFDIterator leftIter(left);
      UIterNFDIterator rightIter(right);
      return compareNFDIter(nfcImpl, leftIter, rightIter);
  } else {
      FCDUIterNFDIterator leftIter(data, left, equalPrefixLength);
      FCDUIterNFDIterator rightIter(data, right, equalPrefixLength);
      return compareNFDIter(nfcImpl, leftIter, rightIter);
  }
1276}

1278CollationKey &
1279RuleBasedCollator::getCollationKey(const UnicodeString &s, CollationKey &key,
                                 UErrorCode &errorCode) const {
  return getCollationKey(s.getBuffer(), s.length(), key, errorCode);
1282}

1284CollationKey &
1285RuleBasedCollator::getCollationKey(const UChar *s, int32_t length, CollationKey& key,
                                 UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) {
      return key.setToBogus();
  }
  if(s == NULL__null && length != 0) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return key.setToBogus();
  }
  key.reset();  // resets the "bogus" state
  CollationKeyByteSink sink(key);
  writeSortKey(s, length, sink, errorCode);
  if(U_FAILURE(errorCode)) {
      key.setToBogus();
  } else if(key.isBogus()) {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
  } else {
      key.setLength(sink.NumberOfBytesAppended());
  }
  return key;
1305}

1307int32_t
1308RuleBasedCollator::getSortKey(const UnicodeString &s,
                            uint8_t *dest, int32_t capacity) const {
  return getSortKey(s.getBuffer(), s.length(), dest, capacity);
1311}

1313int32_t
1314RuleBasedCollator::getSortKey(const UChar *s, int32_t length,
                            uint8_t *dest, int32_t capacity) const {
  if((s == NULL__null && length != 0) || capacity < 0 || (dest == NULL__null && capacity > 0)) {
      return 0;
  }
  uint8_t noDest[1] = { 0 };
  if(dest == NULL__null) {
      // Distinguish pure preflighting from an allocation error.
      dest = noDest;
      capacity = 0;
  }
  FixedSortKeyByteSink sink(reinterpret_cast<char *>(dest), capacity);
  UErrorCode errorCode = U_ZERO_ERROR;
  writeSortKey(s, length, sink, errorCode);
  return U_SUCCESS(errorCode) ? sink.NumberOfBytesAppended() : 0;
1329}

1331void
1332RuleBasedCollator::writeSortKey(const UChar *s, int32_t length,
                              SortKeyByteSink &sink, UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return; }
  const UChar *limit = (length >= 0) ? s + length : NULL__null;
  UBool numeric = settings->isNumeric();
  CollationKeys::LevelCallback callback;
  if(settings->dontCheckFCD()) {
      UTF16CollationIterator iter(data, numeric, s, s, limit);
      CollationKeys::writeSortKeyUpToQuaternary(iter, data->compressibleBytes, *settings,
                                                sink, Collation::PRIMARY_LEVEL,
                                                callback, TRUE1, errorCode);
  } else {
      FCDUTF16CollationIterator iter(data, numeric, s, s, limit);
      CollationKeys::writeSortKeyUpToQuaternary(iter, data->compressibleBytes, *settings,
                                                sink, Collation::PRIMARY_LEVEL,
                                                callback, TRUE1, errorCode);
  }
  if(settings->getStrength() == UCOL_IDENTICAL) {
      writeIdenticalLevel(s, limit, sink, errorCode);
  }
  static const char terminator = 0;  // TERMINATOR_BYTE
  sink.Append(&terminator, 1);
1354}

1356void
1357RuleBasedCollator::writeIdenticalLevel(const UChar *s, const UChar *limit,
                                     SortKeyByteSink &sink, UErrorCode &errorCode) const {
  // NFD quick check
  const UChar *nfdQCYesLimit = data->nfcImpl.decompose(s, limit, NULL__null, errorCode);
  if(U_FAILURE(errorCode)) { return; }
  sink.Append(Collation::LEVEL_SEPARATOR_BYTE);
  UChar32 prev = 0;
  if(nfdQCYesLimit != s) {
      prev = u_writeIdenticalLevelRunu_writeIdenticalLevelRun_71(prev, s, (int32_t)(nfdQCYesLimit - s), sink);
  }
  // Is there non-NFD text?
  int32_t destLengthEstimate;
  if(limit != NULL__null) {
      if(nfdQCYesLimit == limit) { return; }
      destLengthEstimate = (int32_t)(limit - nfdQCYesLimit);
  } else {
      // s is NUL-terminated
      if(*nfdQCYesLimit == 0) { return; }
      destLengthEstimate = -1;
  }
  UnicodeString nfd;
  data->nfcImpl.decompose(nfdQCYesLimit, limit, nfd, destLengthEstimate, errorCode);
  u_writeIdenticalLevelRunu_writeIdenticalLevelRun_71(prev, nfd.getBuffer(), nfd.length(), sink);
1380}

1382namespace {

1384/**
* internalNextSortKeyPart() calls CollationKeys::writeSortKeyUpToQuaternary()
* with an instance of this callback class.
* When another level is about to be written, the callback
* records the level and the number of bytes that will be written until
* the sink (which is actually a FixedSortKeyByteSink) fills up.
*
* When internalNextSortKeyPart() is called again, it restarts with the last level
* and ignores as many bytes as were written previously for that level.
*/
1394class PartLevelCallback : public CollationKeys::LevelCallback {
1395public:
  PartLevelCallback(const SortKeyByteSink &s)
          : sink(s), level(Collation::PRIMARY_LEVEL) {
      levelCapacity = sink.GetRemainingCapacity();
  }
  virtual ~PartLevelCallback() {}
  virtual UBool needToWrite(Collation::Level l) override {
      if(!sink.Overflowed()) {
          // Remember a level that will be at least partially written.
          level = l;
          levelCapacity = sink.GetRemainingCapacity();
          return TRUE1;
      } else {
          return FALSE0;
      }
  }
  Collation::Level getLevel() const { return level; }
  int32_t getLevelCapacity() const { return levelCapacity; }

1414private:
  const SortKeyByteSink &sink;
  Collation::Level level;
  int32_t levelCapacity;
1418};

1420}  // namespace

1422int32_t
1423RuleBasedCollator::internalNextSortKeyPart(UCharIterator *iter, uint32_t state[2],
                                         uint8_t *dest, int32_t count, UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return 0; }
  if(iter == NULL__null || state == NULL__null || count < 0 || (count > 0 && dest == NULL__null)) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  if(count == 0) { return 0; }

  FixedSortKeyByteSink sink(reinterpret_cast<char *>(dest), count);
  sink.IgnoreBytes((int32_t)state[1]);
  iter->move(iter, 0, UITER_START);

  Collation::Level level = (Collation::Level)state[0];
  if(level <= Collation::QUATERNARY_LEVEL) {
      UBool numeric = settings->isNumeric();
      PartLevelCallback callback(sink);
      if(settings->dontCheckFCD()) {
          UIterCollationIterator ci(data, numeric, *iter);
          CollationKeys::writeSortKeyUpToQuaternary(ci, data->compressibleBytes, *settings,
                                                    sink, level, callback, FALSE0, errorCode);
      } else {
          FCDUIterCollationIterator ci(data, numeric, *iter, 0);
          CollationKeys::writeSortKeyUpToQuaternary(ci, data->compressibleBytes, *settings,
                                                    sink, level, callback, FALSE0, errorCode);
      }
      if(U_FAILURE(errorCode)) { return 0; }
      if(sink.NumberOfBytesAppended() > count) {
          state[0] = (uint32_t)callback.getLevel();
          state[1] = (uint32_t)callback.getLevelCapacity();
          return count;
      }
      // All of the normal levels are done.
      if(settings->getStrength() == UCOL_IDENTICAL) {
          level = Collation::IDENTICAL_LEVEL;
          iter->move(iter, 0, UITER_START);
      }
      // else fall through to setting ZERO_LEVEL
  }

  if(level == Collation::IDENTICAL_LEVEL) {
      int32_t levelCapacity = sink.GetRemainingCapacity();
      UnicodeString s;
      for(;;) {
          UChar32 c = iter->next(iter);
          if(c < 0) { break; }
          s.append((UChar)c);
      }
      const UChar *sArray = s.getBuffer();
      writeIdenticalLevel(sArray, sArray + s.length(), sink, errorCode);
      if(U_FAILURE(errorCode)) { return 0; }
      if(sink.NumberOfBytesAppended() > count) {
          state[0] = (uint32_t)level;
          state[1] = (uint32_t)levelCapacity;
          return count;
      }
  }

  // ZERO_LEVEL: Fill the remainder of dest with 00 bytes.
  state[0] = (uint32_t)Collation::ZERO_LEVEL;
  state[1] = 0;
  int32_t length = sink.NumberOfBytesAppended();
  int32_t i = length;
  while(i < count) { dest[i++] = 0; }
  return length;
1488}

1490void
1491RuleBasedCollator::internalGetCEs(const UnicodeString &str, UVector64 &ces,
                                UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return; }
  const UChar *s = str.getBuffer();
  const UChar *limit = s + str.length();
  UBool numeric = settings->isNumeric();
  if(settings->dontCheckFCD()) {
      UTF16CollationIterator iter(data, numeric, s, s, limit);
      int64_t ce;
      while((ce = iter.nextCE(errorCode)) != Collation::NO_CE) {
          ces.addElement(ce, errorCode);
      }
  } else {
      FCDUTF16CollationIterator iter(data, numeric, s, s, limit);
      int64_t ce;
      while((ce = iter.nextCE(errorCode)) != Collation::NO_CE) {
          ces.addElement(ce, errorCode);
      }
  }
1510}

1512namespace {

1514void appendSubtag(CharString &s, char letter, const char *subtag, int32_t length,
                UErrorCode &errorCode) {
  if(U_FAILURE(errorCode) || length == 0) { return; }
  if(!s.isEmpty()) {
      s.append('_', errorCode);
  }
  s.append(letter, errorCode);
  for(int32_t i = 0; i < length; ++i) {
      s.append(uprv_toupperuprv_toupper_71(subtag[i]), errorCode);
  }
1524}

1526void appendAttribute(CharString &s, char letter, UColAttributeValue value,
                   UErrorCode &errorCode) {
  if(U_FAILURE(errorCode)) { return; }
  if(!s.isEmpty()) {
      s.append('_', errorCode);
  }
  static const char *valueChars = "1234...........IXO..SN..LU......";
  s.append(letter, errorCode);
  s.append(valueChars[value], errorCode);
1535}

1537}  // namespace

1539int32_t
1540RuleBasedCollator::internalGetShortDefinitionString(const char *locale,
                                                  char *buffer, int32_t capacity,
                                                  UErrorCode &errorCode) const {
  if(U_FAILURE(errorCode)) { return 0; }
  if(buffer == NULL__null ? capacity != 0 : capacity < 0) {
      errorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  if(locale == NULL__null) {
      locale = internalGetLocaleID(ULOC_VALID_LOCALE, errorCode);
  }

  char resultLocale[ULOC_FULLNAME_CAPACITY157 + 1];
  int32_t length = ucol_getFunctionalEquivalentucol_getFunctionalEquivalent_71(resultLocale, ULOC_FULLNAME_CAPACITY157,
                                                "collation", locale,
                                                NULL__null, &errorCode);
  if(U_FAILURE(errorCode)) { return 0; }
  resultLocale[length] = 0;

  // Append items in alphabetic order of their short definition letters.
  CharString result;
  char subtag[ULOC_KEYWORD_AND_VALUES_CAPACITY100];

  if(attributeHasBeenSetExplicitly(UCOL_ALTERNATE_HANDLING)) {
      appendAttribute(result, 'A', getAttribute(UCOL_ALTERNATE_HANDLING, errorCode), errorCode);
  }
  // ATTR_VARIABLE_TOP not supported because 'B' was broken.
  // See ICU tickets #10372 and #10386.
  if(attributeHasBeenSetExplicitly(UCOL_CASE_FIRST)) {
      appendAttribute(result, 'C', getAttribute(UCOL_CASE_FIRST, errorCode), errorCode);
  }
  if(attributeHasBeenSetExplicitly(UCOL_NUMERIC_COLLATION)) {
      appendAttribute(result, 'D', getAttribute(UCOL_NUMERIC_COLLATION, errorCode), errorCode);
  }
  if(attributeHasBeenSetExplicitly(UCOL_CASE_LEVEL)) {
      appendAttribute(result, 'E', getAttribute(UCOL_CASE_LEVEL, errorCode), errorCode);
  }
  if(attributeHasBeenSetExplicitly(UCOL_FRENCH_COLLATION)) {
      appendAttribute(result, 'F', getAttribute(UCOL_FRENCH_COLLATION, errorCode), errorCode);
  }
  // Note: UCOL_HIRAGANA_QUATERNARY_MODE is deprecated and never changes away from default.
  length = uloc_getKeywordValueuloc_getKeywordValue_71(resultLocale, "collation", subtag, UPRV_LENGTHOF(subtag)(int32_t)(sizeof(subtag)/sizeof((subtag)[0])), &errorCode);
  appendSubtag(result, 'K', subtag, length, errorCode);
  length = uloc_getLanguageuloc_getLanguage_71(resultLocale, subtag, UPRV_LENGTHOF(subtag)(int32_t)(sizeof(subtag)/sizeof((subtag)[0])), &errorCode);
  if (length == 0) {
      appendSubtag(result, 'L', "root", 4, errorCode);
  } else {
      appendSubtag(result, 'L', subtag, length, errorCode);
  }
  if(attributeHasBeenSetExplicitly(UCOL_NORMALIZATION_MODE)) {
      appendAttribute(result, 'N', getAttribute(UCOL_NORMALIZATION_MODE, errorCode), errorCode);
  }
  length = uloc_getCountryuloc_getCountry_71(resultLocale, subtag, UPRV_LENGTHOF(subtag)(int32_t)(sizeof(subtag)/sizeof((subtag)[0])), &errorCode);
  appendSubtag(result, 'R', subtag, length, errorCode);
  if(attributeHasBeenSetExplicitly(UCOL_STRENGTH)) {
      appendAttribute(result, 'S', getAttribute(UCOL_STRENGTH, errorCode), errorCode);
  }
  length = uloc_getVariantuloc_getVariant_71(resultLocale, subtag, UPRV_LENGTHOF(subtag)(int32_t)(sizeof(subtag)/sizeof((subtag)[0])), &errorCode);
  appendSubtag(result, 'V', subtag, length, errorCode);
  length = uloc_getScriptuloc_getScript_71(resultLocale, subtag, UPRV_LENGTHOF(subtag)(int32_t)(sizeof(subtag)/sizeof((subtag)[0])), &errorCode);
  appendSubtag(result, 'Z', subtag, length, errorCode);

  if(U_FAILURE(errorCode)) { return 0; }
  return result.extract(buffer, capacity, errorCode);
1604}

1606UBool
1607RuleBasedCollator::isUnsafe(UChar32 c) const {
  return data->isUnsafeBackward(c, settings->isNumeric());
1609}

1611void U_CALLCONV
1612RuleBasedCollator::computeMaxExpansions(const CollationTailoring *t, UErrorCode &errorCode) {
  t->maxExpansions = CollationElementIterator::computeMaxExpansions(t->data, errorCode);
1614}

1616UBool
1617RuleBasedCollator::initMaxExpansions(UErrorCode &errorCode) const {
  umtx_initOnce(tailoring->maxExpansionsInitOnce, computeMaxExpansions, tailoring, errorCode);
  return U_SUCCESS(errorCode);
1620}

1622CollationElementIterator *
1623RuleBasedCollator::createCollationElementIterator(const UnicodeString& source) const {
  UErrorCode errorCode = U_ZERO_ERROR;
  if(!initMaxExpansions(errorCode)) { return NULL__null; }
  CollationElementIterator *cei = new CollationElementIterator(source, this, errorCode);
  if(U_FAILURE(errorCode)) {
      delete cei;
      return NULL__null;
  }
  return cei;
1632}

1634CollationElementIterator *
1635RuleBasedCollator::createCollationElementIterator(const CharacterIterator& source) const {
  UErrorCode errorCode = U_ZERO_ERROR;
  if(!initMaxExpansions(errorCode)) { return NULL__null; }
  CollationElementIterator *cei = new CollationElementIterator(source, this, errorCode);
  if(U_FAILURE(errorCode)) {
      delete cei;
      return NULL__null;
  }
  return cei;
1644}

1646int32_t
1647RuleBasedCollator::getMaxExpansion(int32_t order) const {
  UErrorCode errorCode = U_ZERO_ERROR;
  (void)initMaxExpansions(errorCode);
  return CollationElementIterator::getMaxExpansion(tailoring->maxExpansions, order);
1651}

1653U_NAMESPACE_END}

1655#endif  // !UCONFIG_NO_COLLATION