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

Bug Summary

File:	out/../deps/icu-small/source/i18n/msgfmt.cpp
Warning:	line 518, column 5 Forming reference to null pointer
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 msgfmt.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/msgfmt.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2015, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************
*
* File MSGFMT.CPP
*
* Modification History:
*
*   Date        Name        Description
*   02/19/97    aliu        Converted from java.
*   03/20/97    helena      Finished first cut of implementation.
*   04/10/97    aliu        Made to work on AIX.  Added stoi to replace wtoi.
*   06/11/97    helena      Fixed addPattern to take the pattern correctly.
*   06/17/97    helena      Fixed the getPattern to return the correct pattern.
*   07/09/97    helena      Made ParsePosition into a class.
*   02/22/99    stephen     Removed character literals for EBCDIC safety
*   11/01/09    kirtig      Added SelectFormat
********************************************************************/

24#include "unicode/utypes.h"

26#if !UCONFIG_NO_FORMATTING0

28#include "unicode/appendable.h"
29#include "unicode/choicfmt.h"
30#include "unicode/datefmt.h"
31#include "unicode/decimfmt.h"
32#include "unicode/localpointer.h"
33#include "unicode/msgfmt.h"
34#include "unicode/numberformatter.h"
35#include "unicode/plurfmt.h"
36#include "unicode/rbnf.h"
37#include "unicode/selfmt.h"
38#include "unicode/smpdtfmt.h"
39#include "unicode/umsg.h"
40#include "unicode/ustring.h"
41#include "cmemory.h"
42#include "patternprops.h"
43#include "messageimpl.h"
44#include "msgfmt_impl.h"
45#include "plurrule_impl.h"
46#include "uassert.h"
47#include "uelement.h"
48#include "uhash.h"
49#include "ustrfmt.h"
50#include "util.h"
51#include "uvector.h"
52#include "number_decimalquantity.h"

54// *****************************************************************************
55// class MessageFormat
56// *****************************************************************************

58#define SINGLE_QUOTE((UChar)0x0027)      ((UChar)0x0027)
59#define COMMA((UChar)0x002C)             ((UChar)0x002C)
60#define LEFT_CURLY_BRACE((UChar)0x007B)  ((UChar)0x007B)
61#define RIGHT_CURLY_BRACE((UChar)0x007D) ((UChar)0x007D)

63//---------------------------------------
64// static data

66static const UChar ID_NUMBER[]    = {
  0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0  /* "number" */
68};
69static const UChar ID_DATE[]      = {
  0x64, 0x61, 0x74, 0x65, 0              /* "date" */
71};
72static const UChar ID_TIME[]      = {
  0x74, 0x69, 0x6D, 0x65, 0              /* "time" */
74};
75static const UChar ID_SPELLOUT[]  = {
  0x73, 0x70, 0x65, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0 /* "spellout" */
77};
78static const UChar ID_ORDINAL[]   = {
  0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0 /* "ordinal" */
80};
81static const UChar ID_DURATION[]  = {
  0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0 /* "duration" */
83};

85// MessageFormat Type List  Number, Date, Time or Choice
86static const UChar * const TYPE_IDS[] = {
  ID_NUMBER,
  ID_DATE,
  ID_TIME,
  ID_SPELLOUT,
  ID_ORDINAL,
  ID_DURATION,
  NULL__null,
94};

96static const UChar ID_EMPTY[]     = {
  0 /* empty string, used for default so that null can mark end of list */
98};
99static const UChar ID_CURRENCY[]  = {
  0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, 0x79, 0  /* "currency" */
101};
102static const UChar ID_PERCENT[]   = {
  0x70, 0x65, 0x72, 0x63, 0x65, 0x6E, 0x74, 0        /* "percent" */
104};
105static const UChar ID_INTEGER[]   = {
  0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0        /* "integer" */
107};

109// NumberFormat modifier list, default, currency, percent or integer
110static const UChar * const NUMBER_STYLE_IDS[] = {
  ID_EMPTY,
  ID_CURRENCY,
  ID_PERCENT,
  ID_INTEGER,
  NULL__null,
116};

118static const UChar ID_SHORT[]     = {
  0x73, 0x68, 0x6F, 0x72, 0x74, 0        /* "short" */
120};
121static const UChar ID_MEDIUM[]    = {
  0x6D, 0x65, 0x64, 0x69, 0x75, 0x6D, 0  /* "medium" */
123};
124static const UChar ID_LONG[]      = {
  0x6C, 0x6F, 0x6E, 0x67, 0              /* "long" */
126};
127static const UChar ID_FULL[]      = {
  0x66, 0x75, 0x6C, 0x6C, 0              /* "full" */
129};

131// DateFormat modifier list, default, short, medium, long or full
132static const UChar * const DATE_STYLE_IDS[] = {
  ID_EMPTY,
  ID_SHORT,
  ID_MEDIUM,
  ID_LONG,
  ID_FULL,
  NULL__null,
139};

141static const icu::DateFormat::EStyle DATE_STYLES[] = {
  icu::DateFormat::kDefault,
  icu::DateFormat::kShort,
  icu::DateFormat::kMedium,
  icu::DateFormat::kLong,
  icu::DateFormat::kFull,
147};

149static const int32_t DEFAULT_INITIAL_CAPACITY = 10;

151static const UChar NULL_STRING[] = {
  0x6E, 0x75, 0x6C, 0x6C, 0  // "null"
153};

155static const UChar OTHER_STRING[] = {
  0x6F, 0x74, 0x68, 0x65, 0x72, 0  // "other"
157};

159U_CDECL_BEGINextern "C" {
160static UBool U_CALLCONV equalFormatsForHash(const UHashTok key1,
                                          const UHashTok key2) {
  return icu::MessageFormat::equalFormats(key1.pointer, key2.pointer);
163}

165U_CDECL_END}

167U_NAMESPACE_BEGINnamespace icu_71 {

169// -------------------------------------
170UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MessageFormat)UClassID MessageFormat::getStaticClassID() { static char classID
 = 0; return (UClassID)&classID; } UClassID MessageFormat
::getDynamicClassID() const { return MessageFormat::getStaticClassID
(); }
171UOBJECT_DEFINE_RTTI_IMPLEMENTATION(FormatNameEnumeration)UClassID FormatNameEnumeration::getStaticClassID() { static char
 classID = 0; return (UClassID)&classID; } UClassID FormatNameEnumeration
::getDynamicClassID() const { return FormatNameEnumeration::getStaticClassID
(); }

173//--------------------------------------------------------------------

175/**
* Convert an integer value to a string and append the result to
* the given UnicodeString.
*/
179static UnicodeString& itos(int32_t i, UnicodeString& appendTo) {
  UChar temp[16];
  uprv_itouuprv_itou_71(temp,16,i,10,0); // 10 == radix
  appendTo.append(temp, -1);
  return appendTo;
184}


187// AppendableWrapper: encapsulates the result of formatting, keeping track
188// of the string and its length.
189class AppendableWrapper : public UMemory {
190public:
  AppendableWrapper(Appendable& appendable) : app(appendable), len(0) {
  }
  void append(const UnicodeString& s) {
      app.appendString(s.getBuffer(), s.length());
      len += s.length();
  }
  void append(const UChar* s, const int32_t sLength) {
      app.appendString(s, sLength);
      len += sLength;
  }
  void append(const UnicodeString& s, int32_t start, int32_t length) {
      append(s.tempSubString(start, length));
  }
  void formatAndAppend(const Format* formatter, const Formattable& arg, UErrorCode& ec) {
      UnicodeString s;
      formatter->format(arg, s, ec);
      if (U_SUCCESS(ec)) {
          append(s);
      }
  }
  void formatAndAppend(const Format* formatter, const Formattable& arg,
                       const UnicodeString &argString, UErrorCode& ec) {
      if (!argString.isEmpty()) {
          if (U_SUCCESS(ec)) {
              append(argString);
          }
      } else {
          formatAndAppend(formatter, arg, ec);
      }
  }
  int32_t length() {
      return len;
  }
224private:
  Appendable& app;
  int32_t len;
227};


230// -------------------------------------
231// Creates a MessageFormat instance based on the pattern.

233MessageFormat::MessageFormat(const UnicodeString& pattern,
                           UErrorCode& success)
fLocale(Locale::getDefault()),  // Uses the default locale
msgPattern(success),
formatAliases(NULL__null),
formatAliasesCapacity(0),
argTypes(NULL__null),
argTypeCount(0),
argTypeCapacity(0),
hasArgTypeConflicts(FALSE0),
defaultNumberFormat(NULL__null),
defaultDateFormat(NULL__null),
cachedFormatters(NULL__null),
customFormatArgStarts(NULL__null),
pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
249{
  setLocaleIDs(fLocale.getName(), fLocale.getName());
  applyPattern(pattern, success);
252}

254MessageFormat::MessageFormat(const UnicodeString& pattern,
                           const Locale& newLocale,
                           UErrorCode& success)
fLocale(newLocale),
msgPattern(success),
formatAliases(NULL__null),
formatAliasesCapacity(0),
argTypes(NULL__null),
argTypeCount(0),
argTypeCapacity(0),
hasArgTypeConflicts(FALSE0),
defaultNumberFormat(NULL__null),
defaultDateFormat(NULL__null),
cachedFormatters(NULL__null),
customFormatArgStarts(NULL__null),
pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
271{
  setLocaleIDs(fLocale.getName(), fLocale.getName());
  applyPattern(pattern, success);
274}

276MessageFormat::MessageFormat(const UnicodeString& pattern,
                           const Locale& newLocale,
                           UParseError& parseError,
                           UErrorCode& success)
fLocale(newLocale),
msgPattern(success),
formatAliases(NULL__null),
formatAliasesCapacity(0),
argTypes(NULL__null),
argTypeCount(0),
argTypeCapacity(0),
hasArgTypeConflicts(FALSE0),
defaultNumberFormat(NULL__null),
defaultDateFormat(NULL__null),
cachedFormatters(NULL__null),
customFormatArgStarts(NULL__null),
pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
294{
  setLocaleIDs(fLocale.getName(), fLocale.getName());
  applyPattern(pattern, parseError, success);
297}

299MessageFormat::MessageFormat(const MessageFormat& that)

Format(that),
fLocale(that.fLocale),
msgPattern(that.msgPattern),
formatAliases(NULL__null),
formatAliasesCapacity(0),
argTypes(NULL__null),
argTypeCount(0),
argTypeCapacity(0),
hasArgTypeConflicts(that.hasArgTypeConflicts),
defaultNumberFormat(NULL__null),
defaultDateFormat(NULL__null),
cachedFormatters(NULL__null),
customFormatArgStarts(NULL__null),
pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
316{
  // This will take care of creating the hash tables (since they are NULL).
  UErrorCode ec = U_ZERO_ERROR;
  copyObjects(that, ec);
  if (U_FAILURE(ec)) {
      resetPattern();
  }
323}

325MessageFormat::~MessageFormat()
326{
  uhash_closeuhash_close_71(cachedFormatters);
  uhash_closeuhash_close_71(customFormatArgStarts);

  uprv_freeuprv_free_71(argTypes);
  uprv_freeuprv_free_71(formatAliases);
  delete defaultNumberFormat;
  delete defaultDateFormat;
334}

336//--------------------------------------------------------------------
337// Variable-size array management

339/**
* Allocate argTypes[] to at least the given capacity and return
* TRUE if successful.  If not, leave argTypes[] unchanged.
*
* If argTypes is NULL, allocate it.  If it is not NULL, enlarge it
* if necessary to be at least as large as specified.
*/
346UBool MessageFormat::allocateArgTypes(int32_t capacity, UErrorCode& status) {
  if (U_FAILURE(status)) {
      return FALSE0;
  }
  if (argTypeCapacity >= capacity) {
      return TRUE1;
  }
  if (capacity < DEFAULT_INITIAL_CAPACITY) {
      capacity = DEFAULT_INITIAL_CAPACITY;
  } else if (capacity < 2*argTypeCapacity) {
      capacity = 2*argTypeCapacity;
  }
  Formattable::Type* a = (Formattable::Type*)
          uprv_reallocuprv_realloc_71(argTypes, sizeof(*argTypes) * capacity);
  if (a == NULL__null) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return FALSE0;
  }
  argTypes = a;
  argTypeCapacity = capacity;
  return TRUE1;
367}

369// -------------------------------------
370// assignment operator

372const MessageFormat&
373MessageFormat::operator=(const MessageFormat& that)
374{
  if (this != &that) {
      // Calls the super class for assignment first.
      Format::operator=(that);

      setLocale(that.fLocale);
      msgPattern = that.msgPattern;
      hasArgTypeConflicts = that.hasArgTypeConflicts;

      UErrorCode ec = U_ZERO_ERROR;
      copyObjects(that, ec);
      if (U_FAILURE(ec)) {
          resetPattern();
      }
  }
  return *this;
390}

392bool
393MessageFormat::operator==(const Format& rhs) const
394{
  if (this == &rhs) return true;

  MessageFormat& that = (MessageFormat&)rhs;

  // Check class ID before checking MessageFormat members
  if (!Format::operator==(rhs) ||
      msgPattern != that.msgPattern ||
      fLocale != that.fLocale) {
      return false;
  }

  // Compare hashtables.
  if ((customFormatArgStarts == NULL__null) != (that.customFormatArgStarts == NULL__null)) {
      return false;
  }
  if (customFormatArgStarts == NULL__null) {
      return true;
  }

  UErrorCode ec = U_ZERO_ERROR;
  const int32_t count = uhash_countuhash_count_71(customFormatArgStarts);
  const int32_t rhs_count = uhash_countuhash_count_71(that.customFormatArgStarts);
  if (count != rhs_count) {
      return false;
  }
  int32_t idx = 0, rhs_idx = 0, pos = UHASH_FIRST(-1), rhs_pos = UHASH_FIRST(-1);
  for (; idx < count && rhs_idx < rhs_count && U_SUCCESS(ec); ++idx, ++rhs_idx) {
      const UHashElement* cur = uhash_nextElementuhash_nextElement_71(customFormatArgStarts, &pos);
      const UHashElement* rhs_cur = uhash_nextElementuhash_nextElement_71(that.customFormatArgStarts, &rhs_pos);
      if (cur->key.integer != rhs_cur->key.integer) {
          return false;
      }
      const Format* format = (const Format*)uhash_igetuhash_iget_71(cachedFormatters, cur->key.integer);
      const Format* rhs_format = (const Format*)uhash_igetuhash_iget_71(that.cachedFormatters, rhs_cur->key.integer);
      if (*format != *rhs_format) {
          return false;
      }
  }
  return true;
434}

436// -------------------------------------
437// Creates a copy of this MessageFormat, the caller owns the copy.

439MessageFormat*
440MessageFormat::clone() const
441{
  return new MessageFormat(*this);
443}

445// -------------------------------------
446// Sets the locale of this MessageFormat object to theLocale.

448void
449MessageFormat::setLocale(const Locale& theLocale)
450{
  if (fLocale != theLocale) {
      delete defaultNumberFormat;
      defaultNumberFormat = NULL__null;
      delete defaultDateFormat;
      defaultDateFormat = NULL__null;
      fLocale = theLocale;
      setLocaleIDs(fLocale.getName(), fLocale.getName());
      pluralProvider.reset();
      ordinalProvider.reset();
  }
461}

463// -------------------------------------
464// Gets the locale of this MessageFormat object.

466const Locale&
467MessageFormat::getLocale() const
468{
  return fLocale;
470}

472void
473MessageFormat::applyPattern(const UnicodeString& newPattern,
                          UErrorCode& status)
475{
  UParseError parseError;
  applyPattern(newPattern,parseError,status);
478}


481// -------------------------------------
482// Applies the new pattern and returns an error if the pattern
483// is not correct.
484void
485MessageFormat::applyPattern(const UnicodeString& pattern,
                          UParseError& parseError,
                          UErrorCode& ec)
488{
  if(U_FAILURE(ec)) {
      return;
  }
  msgPattern.parse(pattern, &parseError, ec);
  cacheExplicitFormats(ec);

  if (U_FAILURE(ec)) {
      resetPattern();
  }
498}

500void MessageFormat::resetPattern() {
  msgPattern.clear();
  uhash_closeuhash_close_71(cachedFormatters);
  cachedFormatters = NULL__null;
  uhash_closeuhash_close_71(customFormatArgStarts);
  customFormatArgStarts = NULL__null;
  argTypeCount = 0;
  hasArgTypeConflicts = FALSE0;
508}

510void
511MessageFormat::applyPattern(const UnicodeString& pattern,
                          UMessagePatternApostropheMode aposMode,
                          UParseError* parseError,
                          UErrorCode& status) {
  if (aposMode != msgPattern.getApostropheMode()) {
35
←
Assuming the condition is false→
36
←
Taking false branch→
      msgPattern.clearPatternAndSetApostropheMode(aposMode);
  }
  applyPattern(pattern, *parseError, status);
37
←
Forming reference to null pointer
519}

521// -------------------------------------
522// Converts this MessageFormat instance to a pattern.

524UnicodeString&
525MessageFormat::toPattern(UnicodeString& appendTo) const {
  if ((customFormatArgStarts != NULL__null && 0 != uhash_countuhash_count_71(customFormatArgStarts)) ||
      0 == msgPattern.countParts()
  ) {
      appendTo.setToBogus();
      return appendTo;
  }
  return appendTo.append(msgPattern.getPatternString());
533}

535int32_t MessageFormat::nextTopLevelArgStart(int32_t partIndex) const {
  if (partIndex != 0) {
      partIndex = msgPattern.getLimitPartIndex(partIndex);
  }
  for (;;) {
      UMessagePatternPartType type = msgPattern.getPartType(++partIndex);
      if (type == UMSGPAT_PART_TYPE_ARG_START) {
          return partIndex;
      }
      if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) {
          return -1;
      }
  }
548}

550void MessageFormat::setArgStartFormat(int32_t argStart,
                                    Format* formatter,
                                    UErrorCode& status) {
  if (U_FAILURE(status)) {
      delete formatter;
      return;
  }
  if (cachedFormatters == NULL__null) {
      cachedFormatters=uhash_openuhash_open_71(uhash_hashLonguhash_hashLong_71, uhash_compareLonguhash_compareLong_71,
                                  equalFormatsForHash, &status);
      if (U_FAILURE(status)) {
          delete formatter;
          return;
      }
      uhash_setValueDeleteruhash_setValueDeleter_71(cachedFormatters, uprv_deleteUObjectuprv_deleteUObject_71);
  }
  if (formatter == NULL__null) {
      formatter = new DummyFormat();
  }
  uhash_iputuhash_iput_71(cachedFormatters, argStart, formatter, &status);
570}


573UBool MessageFormat::argNameMatches(int32_t partIndex, const UnicodeString& argName, int32_t argNumber) {
  const MessagePattern::Part& part = msgPattern.getPart(partIndex);
  return part.getType() == UMSGPAT_PART_TYPE_ARG_NAME ?
      msgPattern.partSubstringMatches(part, argName) :
      part.getValue() == argNumber;  // ARG_NUMBER
578}

580// Sets a custom formatter for a MessagePattern ARG_START part index.
581// "Custom" formatters are provided by the user via setFormat() or similar APIs.
582void MessageFormat::setCustomArgStartFormat(int32_t argStart,
                                          Format* formatter,
                                          UErrorCode& status) {
  setArgStartFormat(argStart, formatter, status);
  if (customFormatArgStarts == NULL__null) {
      customFormatArgStarts=uhash_openuhash_open_71(uhash_hashLonguhash_hashLong_71, uhash_compareLonguhash_compareLong_71,
                                       NULL__null, &status);
  }
  uhash_iputiuhash_iputi_71(customFormatArgStarts, argStart, 1, &status);
591}

593Format* MessageFormat::getCachedFormatter(int32_t argumentNumber) const {
  if (cachedFormatters == NULL__null) {
      return NULL__null;
  }
  void* ptr = uhash_igetuhash_iget_71(cachedFormatters, argumentNumber);
  if (ptr != NULL__null && dynamic_cast<DummyFormat*>((Format*)ptr) == NULL__null) {
      return (Format*) ptr;
  } else {
      // Not cached, or a DummyFormat representing setFormat(NULL).
      return NULL__null;
  }
604}

606// -------------------------------------
607// Adopts the new formats array and updates the array count.
608// This MessageFormat instance owns the new formats.
609void
610MessageFormat::adoptFormats(Format** newFormats,
                          int32_t count) {
  if (newFormats == NULL__null || count < 0) {
      return;
  }
  // Throw away any cached formatters.
  if (cachedFormatters != NULL__null) {
      uhash_removeAlluhash_removeAll_71(cachedFormatters);
  }
  if (customFormatArgStarts != NULL__null) {
      uhash_removeAlluhash_removeAll_71(customFormatArgStarts);
  }

  int32_t formatNumber = 0;
  UErrorCode status = U_ZERO_ERROR;
  for (int32_t partIndex = 0;
      formatNumber < count && U_SUCCESS(status) &&
          (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
      setCustomArgStartFormat(partIndex, newFormats[formatNumber], status);
      ++formatNumber;
  }
  // Delete those that didn't get used (if any).
  for (; formatNumber < count; ++formatNumber) {
      delete newFormats[formatNumber];
  }

636}

638// -------------------------------------
639// Sets the new formats array and updates the array count.
640// This MessageFormat instance makes a copy of the new formats.

642void
643MessageFormat::setFormats(const Format** newFormats,
                        int32_t count) {
  if (newFormats == NULL__null || count < 0) {
      return;
  }
  // Throw away any cached formatters.
  if (cachedFormatters != NULL__null) {
      uhash_removeAlluhash_removeAll_71(cachedFormatters);
  }
  if (customFormatArgStarts != NULL__null) {
      uhash_removeAlluhash_removeAll_71(customFormatArgStarts);
  }

  UErrorCode status = U_ZERO_ERROR;
  int32_t formatNumber = 0;
  for (int32_t partIndex = 0;
      formatNumber < count && U_SUCCESS(status) && (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
    Format* newFormat = NULL__null;
    if (newFormats[formatNumber] != NULL__null) {
        newFormat = newFormats[formatNumber]->clone();
        if (newFormat == NULL__null) {
            status = U_MEMORY_ALLOCATION_ERROR;
        }
    }
    setCustomArgStartFormat(partIndex, newFormat, status);
    ++formatNumber;
  }
  if (U_FAILURE(status)) {
      resetPattern();
  }
673}

675// -------------------------------------
676// Adopt a single format by format number.
677// Do nothing if the format number is not less than the array count.

679void
680MessageFormat::adoptFormat(int32_t n, Format *newFormat) {
  LocalPointer<Format> p(newFormat);
  if (n >= 0) {
      int32_t formatNumber = 0;
      for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
          if (n == formatNumber) {
              UErrorCode status = U_ZERO_ERROR;
              setCustomArgStartFormat(partIndex, p.orphan(), status);
              return;
          }
          ++formatNumber;
      }
  }
693}

695// -------------------------------------
696// Adopt a single format by format name.
697// Do nothing if there is no match of formatName.
698void
699MessageFormat::adoptFormat(const UnicodeString& formatName,
                         Format* formatToAdopt,
                         UErrorCode& status) {
  LocalPointer<Format> p(formatToAdopt);
  if (U_FAILURE(status)) {
      return;
  }
  int32_t argNumber = MessagePattern::validateArgumentName(formatName);
  if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  for (int32_t partIndex = 0;
      (partIndex = nextTopLevelArgStart(partIndex)) >= 0 && U_SUCCESS(status);
  ) {
      if (argNameMatches(partIndex + 1, formatName, argNumber)) {
          Format* f;
          if (p.isValid()) {
              f = p.orphan();
          } else if (formatToAdopt == NULL__null) {
              f = NULL__null;
          } else {
              f = formatToAdopt->clone();
              if (f == NULL__null) {
                  status = U_MEMORY_ALLOCATION_ERROR;
                  return;
              }
          }
          setCustomArgStartFormat(partIndex, f, status);
      }
  }
730}

732// -------------------------------------
733// Set a single format.
734// Do nothing if the variable is not less than the array count.
735void
736MessageFormat::setFormat(int32_t n, const Format& newFormat) {

  if (n >= 0) {
      int32_t formatNumber = 0;
      for (int32_t partIndex = 0;
           (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
          if (n == formatNumber) {
              Format* new_format = newFormat.clone();
              if (new_format) {
                  UErrorCode status = U_ZERO_ERROR;
                  setCustomArgStartFormat(partIndex, new_format, status);
              }
              return;
          }
          ++formatNumber;
      }
  }
753}

755// -------------------------------------
756// Get a single format by format name.
757// Do nothing if the variable is not less than the array count.
758Format *
759MessageFormat::getFormat(const UnicodeString& formatName, UErrorCode& status) {
  if (U_FAILURE(status) || cachedFormatters == NULL__null) return NULL__null;

  int32_t argNumber = MessagePattern::validateArgumentName(formatName);
  if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }
  for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
      if (argNameMatches(partIndex + 1, formatName, argNumber)) {
          return getCachedFormatter(partIndex);
      }
  }
  return NULL__null;
773}

775// -------------------------------------
776// Set a single format by format name
777// Do nothing if the variable is not less than the array count.
778void
779MessageFormat::setFormat(const UnicodeString& formatName,
                       const Format& newFormat,
                       UErrorCode& status) {
  if (U_FAILURE(status)) return;

  int32_t argNumber = MessagePattern::validateArgumentName(formatName);
  if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  for (int32_t partIndex = 0;
      (partIndex = nextTopLevelArgStart(partIndex)) >= 0 && U_SUCCESS(status);
  ) {
      if (argNameMatches(partIndex + 1, formatName, argNumber)) {
          Format* new_format = newFormat.clone();
          if (new_format == NULL__null) {
              status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          setCustomArgStartFormat(partIndex, new_format, status);
      }
  }
801}

803// -------------------------------------
804// Gets the format array.
805const Format**
806MessageFormat::getFormats(int32_t& cnt) const
807{
  // This old API returns an array (which we hold) of Format*
  // pointers.  The array is valid up to the next call to any
  // method on this object.  We construct and resize an array
  // on demand that contains aliases to the subformats[i].format
  // pointers.

  // Get total required capacity first (it's refreshed on each call).
  int32_t totalCapacity = 0;
  for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0; ++totalCapacity) {}

  MessageFormat* t = const_cast<MessageFormat*> (this);
  cnt = 0;
  if (formatAliases == nullptr) {
      t->formatAliasesCapacity = totalCapacity;
      Format** a = (Format**)
          uprv_mallocuprv_malloc_71(sizeof(Format*) * formatAliasesCapacity);
      if (a == nullptr) {
          t->formatAliasesCapacity = 0;
          return nullptr;
      }
      t->formatAliases = a;
  } else if (totalCapacity > formatAliasesCapacity) {
      Format** a = (Format**)
          uprv_reallocuprv_realloc_71(formatAliases, sizeof(Format*) * totalCapacity);
      if (a == nullptr) {
          t->formatAliasesCapacity = 0;
          return nullptr;
      }
      t->formatAliases = a;
      t->formatAliasesCapacity = totalCapacity;
  }

  for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
      t->formatAliases[cnt++] = getCachedFormatter(partIndex);
  }

  return (const Format**)formatAliases;
845}


848UnicodeString MessageFormat::getArgName(int32_t partIndex) {
  const MessagePattern::Part& part = msgPattern.getPart(partIndex);
  return msgPattern.getSubstring(part);
851}

853StringEnumeration*
854MessageFormat::getFormatNames(UErrorCode& status) {
  if (U_FAILURE(status))  return NULL__null;

  LocalPointer<UVector> formatNames(new UVector(status), status);
  if (U_FAILURE(status)) {
      return nullptr;
  }
  formatNames->setDeleter(uprv_deleteUObjectuprv_deleteUObject_71);

  for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
      LocalPointer<UnicodeString> name(getArgName(partIndex + 1).clone(), status);
      formatNames->adoptElement(name.orphan(), status);
      if (U_FAILURE(status))  return nullptr;
  }

  LocalPointer<StringEnumeration> nameEnumerator(
      new FormatNameEnumeration(std::move(formatNames), status), status);
  return U_SUCCESS(status) ? nameEnumerator.orphan() : nullptr;
872}

874// -------------------------------------
875// Formats the source Formattable array and copy into the result buffer.
876// Ignore the FieldPosition result for error checking.

878UnicodeString&
879MessageFormat::format(const Formattable* source,
                    int32_t cnt,
                    UnicodeString& appendTo,
                    FieldPosition& ignore,
                    UErrorCode& success) const
884{
  return format(source, NULL__null, cnt, appendTo, &ignore, success);
886}

888// -------------------------------------
889// Internally creates a MessageFormat instance based on the
890// pattern and formats the arguments Formattable array and
891// copy into the appendTo buffer.

893UnicodeString&
894MessageFormat::format(  const UnicodeString& pattern,
                      const Formattable* arguments,
                      int32_t cnt,
                      UnicodeString& appendTo,
                      UErrorCode& success)
899{
  MessageFormat temp(pattern, success);
  return temp.format(arguments, NULL__null, cnt, appendTo, NULL__null, success);
902}

904// -------------------------------------
905// Formats the source Formattable object and copy into the
906// appendTo buffer.  The Formattable object must be an array
907// of Formattable instances, returns error otherwise.

909UnicodeString&
910MessageFormat::format(const Formattable& source,
                    UnicodeString& appendTo,
                    FieldPosition& ignore,
                    UErrorCode& success) const
914{
  if (U_FAILURE(success))
      return appendTo;
  if (source.getType() != Formattable::kArray) {
      success = U_ILLEGAL_ARGUMENT_ERROR;
      return appendTo;
  }
  int32_t cnt;
  const Formattable* tmpPtr = source.getArray(cnt);
  return format(tmpPtr, NULL__null, cnt, appendTo, &ignore, success);
924}

926UnicodeString&
927MessageFormat::format(const UnicodeString* argumentNames,
                    const Formattable* arguments,
                    int32_t count,
                    UnicodeString& appendTo,
                    UErrorCode& success) const {
  return format(arguments, argumentNames, count, appendTo, NULL__null, success);
1
Calling 'MessageFormat::format'→
933}

935// Does linear search to find the match for an ArgName.
936const Formattable* MessageFormat::getArgFromListByName(const Formattable* arguments,
                                                     const UnicodeString *argumentNames,
                                                     int32_t cnt, UnicodeString& name) const {
  for (int32_t i = 0; i < cnt; ++i) {
      if (0 == argumentNames[i].compare(name)) {
          return arguments + i;
      }
  }
  return NULL__null;
945}


948UnicodeString&
949MessageFormat::format(const Formattable* arguments,
                    const UnicodeString *argumentNames,
                    int32_t cnt,
                    UnicodeString& appendTo,
                    FieldPosition* pos,
                    UErrorCode& status) const {
  if (U_FAILURE(status)) {
2
←
Taking false branch→
      return appendTo;
  }

  UnicodeStringAppendable usapp(appendTo);
  AppendableWrapper app(usapp);
  format(0, NULL__null, arguments, argumentNames, cnt, app, pos, status);
3
←
Calling 'MessageFormat::format'→
  return appendTo;
963}

965namespace {

967/**
* Mutable input/output values for the PluralSelectorProvider.
* Separate so that it is possible to make MessageFormat Freezable.
*/
971class PluralSelectorContext {
972public:
  PluralSelectorContext(int32_t start, const UnicodeString &name,
                        const Formattable &num, double off, UErrorCode &errorCode)
          : startIndex(start), argName(name), offset(off),
            numberArgIndex(-1), formatter(NULL__null), forReplaceNumber(FALSE0) {
      // number needs to be set even when select() is not called.
      // Keep it as a Number/Formattable:
      // For format() methods, and to preserve information (e.g., BigDecimal).
      if(off == 0) {
          number = num;
      } else {
          number = num.getDouble(errorCode) - off;
      }
  }

  // Input values for plural selection with decimals.
  int32_t startIndex;
  const UnicodeString &argName;
  /** argument number - plural offset */
  Formattable number;
  double offset;
  // Output values for plural selection with decimals.
  /** -1 if REPLACE_NUMBER, 0 arg not found, >0 ARG_START index */
  int32_t numberArgIndex;
  const Format *formatter;
  /** formatted argument number - plural offset */
  UnicodeString numberString;
  /** TRUE if number-offset was formatted with the stock number formatter */
  UBool forReplaceNumber;
1001};

1003}  // namespace

1005// if argumentNames is NULL, this means arguments is a numeric array.
1006// arguments can not be NULL.
1007// We use const void *plNumber rather than const PluralSelectorContext *pluralNumber
1008// so that we need not declare the PluralSelectorContext in the public header file.
1009void MessageFormat::format(int32_t msgStart, const void *plNumber,
                         const Formattable* arguments,
                         const UnicodeString *argumentNames,
                         int32_t cnt,
                         AppendableWrapper& appendTo,
                         FieldPosition* ignore,
                         UErrorCode& success) const {
  if (U_FAILURE(success)) {
4
←
Taking false branch→
      return;
  }

  const UnicodeString& msgString = msgPattern.getPatternString();
  int32_t prevIndex = msgPattern.getPart(msgStart).getLimit();
  for (int32_t i = msgStart + 1; U_SUCCESS(success) ; ++i) {
5
←
Loop condition is true.  Entering loop body→
      const MessagePattern::Part* part = &msgPattern.getPart(i);
      const UMessagePatternPartType type = part->getType();
      int32_t index = part->getIndex();
      appendTo.append(msgString, prevIndex, index - prevIndex);
      if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) {
6
←
Assuming 'type' is not equal to UMSGPAT_PART_TYPE_MSG_LIMIT→
7
←
Taking false branch→
          return;
      }
      prevIndex = part->getLimit();
      if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) {
8
←
Assuming 'type' is not equal to UMSGPAT_PART_TYPE_REPLACE_NUMBER→
9
←
Taking false branch→
          const PluralSelectorContext &pluralNumber =
              *static_cast<const PluralSelectorContext *>(plNumber);
          if(pluralNumber.forReplaceNumber) {
              // number-offset was already formatted.
              appendTo.formatAndAppend(pluralNumber.formatter,
                      pluralNumber.number, pluralNumber.numberString, success);
          } else {
              const NumberFormat* nf = getDefaultNumberFormat(success);
              appendTo.formatAndAppend(nf, pluralNumber.number, success);
          }
          continue;
      }
      if (type != UMSGPAT_PART_TYPE_ARG_START) {
10
←
Assuming 'type' is equal to UMSGPAT_PART_TYPE_ARG_START→
11
←
Taking false branch→
          continue;
      }
      int32_t argLimit = msgPattern.getLimitPartIndex(i);
      UMessagePatternArgType argType = part->getArgType();
      part = &msgPattern.getPart(++i);
      const Formattable* arg;
      UBool noArg = FALSE0;
      UnicodeString argName = msgPattern.getSubstring(*part);
      if (argumentNames == NULL__null) {
12
←
Assuming 'argumentNames' is not equal to NULL→
13
←
Taking false branch→
          int32_t argNumber = part->getValue();  // ARG_NUMBER
          if (0 <= argNumber && argNumber < cnt) {
              arg = arguments + argNumber;
          } else {
              arg = NULL__null;
              noArg = TRUE1;
          }
      } else {
          arg = getArgFromListByName(arguments, argumentNames, cnt, argName);
          if (arg == NULL__null) {
14
←
Assuming 'arg' is not equal to NULL→
15
←
Taking false branch→
              noArg = TRUE1;
          }
      }
      ++i;
      int32_t prevDestLength = appendTo.length();
      const Format* formatter = NULL__null;
      if (noArg15.1
'noArg' is 0
) {
16
←
Taking false branch→
          appendTo.append(
              UnicodeString(LEFT_CURLY_BRACE((UChar)0x007B)).append(argName).append(RIGHT_CURLY_BRACE((UChar)0x007D)));
      } else if (arg16.1
'arg' is not equal to NULL
 == NULL__null) {
          appendTo.append(NULL_STRING, 4);
      } else if(plNumber16.2
'plNumber' is equal to NULL
!=NULL__null &&
              static_cast<const PluralSelectorContext *>(plNumber)->numberArgIndex==(i-2)) {
          const PluralSelectorContext &pluralNumber =
              *static_cast<const PluralSelectorContext *>(plNumber);
          if(pluralNumber.offset == 0) {
              // The number was already formatted with this formatter.
              appendTo.formatAndAppend(pluralNumber.formatter, pluralNumber.number,
                                       pluralNumber.numberString, success);
          } else {
              // Do not use the formatted (number-offset) string for a named argument
              // that formats the number without subtracting the offset.
              appendTo.formatAndAppend(pluralNumber.formatter, *arg, success);
          }
      } else if ((formatter = getCachedFormatter(i -2)) != 0) {
          // Handles all ArgType.SIMPLE, and formatters from setFormat() and its siblings.
          if (dynamic_cast<const ChoiceFormat*>(formatter) ||
              dynamic_cast<const PluralFormat*>(formatter) ||
              dynamic_cast<const SelectFormat*>(formatter)) {
              // We only handle nested formats here if they were provided via
              // setFormat() or its siblings. Otherwise they are not cached and instead
              // handled below according to argType.
              UnicodeString subMsgString;
              formatter->format(*arg, subMsgString, success);
              if (subMsgString.indexOf(LEFT_CURLY_BRACE((UChar)0x007B)) >= 0 ||
                  (subMsgString.indexOf(SINGLE_QUOTE((UChar)0x0027)) >= 0 && !MessageImpl::jdkAposMode(msgPattern))
              ) {
                  MessageFormat subMsgFormat(subMsgString, fLocale, success);
                  subMsgFormat.format(0, NULL__null, arguments, argumentNames, cnt, appendTo, ignore, success);
              } else {
                  appendTo.append(subMsgString);
              }
          } else {
              appendTo.formatAndAppend(formatter, *arg, success);
          }
      } else if (argType == UMSGPAT_ARG_TYPE_NONE || (cachedFormatters17.1
Field 'cachedFormatters' is non-null
 && uhash_igetuhash_iget_71(cachedFormatters, i - 2))) {
17
←
Assuming 'argType' is not equal to UMSGPAT_ARG_TYPE_NONE→
18
←
Assuming the condition is false→
19
←
Taking false branch→
          // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table.
          // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check
          // for the hash table containing DummyFormat.
          if (arg->isNumeric()) {
              const NumberFormat* nf = getDefaultNumberFormat(success);
              appendTo.formatAndAppend(nf, *arg, success);
          } else if (arg->getType() == Formattable::kDate) {
              const DateFormat* df = getDefaultDateFormat(success);
              appendTo.formatAndAppend(df, *arg, success);
          } else {
              appendTo.append(arg->getString(success));
          }
      } else if (argType == UMSGPAT_ARG_TYPE_CHOICE) {
20
←
Assuming 'argType' is equal to UMSGPAT_ARG_TYPE_CHOICE→
21
←
Taking true branch→
          if (!arg->isNumeric()) {
22
←
Assuming the condition is false→
23
←
Taking false branch→
              success = U_ILLEGAL_ARGUMENT_ERROR;
              return;
          }
          // We must use the Formattable::getDouble() variant with the UErrorCode parameter
          // because only this one converts non-double numeric types to double.
          const double number = arg->getDouble(success);
          int32_t subMsgStart = ChoiceFormat::findSubMessage(msgPattern, i, number);
          formatComplexSubMessage(subMsgStart, NULL__null, arguments, argumentNames,
24
←
Calling 'MessageFormat::formatComplexSubMessage'→
                                  cnt, appendTo, success);
      } else if (UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType)((argType)==UMSGPAT_ARG_TYPE_PLURAL || (argType)==UMSGPAT_ARG_TYPE_SELECTORDINAL
)) {
          if (!arg->isNumeric()) {
              success = U_ILLEGAL_ARGUMENT_ERROR;
              return;
          }
          const PluralSelectorProvider &selector =
              argType == UMSGPAT_ARG_TYPE_PLURAL ? pluralProvider : ordinalProvider;
          // We must use the Formattable::getDouble() variant with the UErrorCode parameter
          // because only this one converts non-double numeric types to double.
          double offset = msgPattern.getPluralOffset(i);
          PluralSelectorContext context(i, argName, *arg, offset, success);
          int32_t subMsgStart = PluralFormat::findSubMessage(
                  msgPattern, i, selector, &context, arg->getDouble(success), success);
          formatComplexSubMessage(subMsgStart, &context, arguments, argumentNames,
                                  cnt, appendTo, success);
      } else if (argType == UMSGPAT_ARG_TYPE_SELECT) {
          int32_t subMsgStart = SelectFormat::findSubMessage(msgPattern, i, arg->getString(success), success);
          formatComplexSubMessage(subMsgStart, NULL__null, arguments, argumentNames,
                                  cnt, appendTo, success);
      } else {
          // This should never happen.
          success = U_INTERNAL_PROGRAM_ERROR;
          return;
      }
      ignore = updateMetaData(appendTo, prevDestLength, ignore, arg);
      prevIndex = msgPattern.getPart(argLimit).getLimit();
      i = argLimit;
  }
1161}


1164void MessageFormat::formatComplexSubMessage(int32_t msgStart,
                                          const void *plNumber,
                                          const Formattable* arguments,
                                          const UnicodeString *argumentNames,
                                          int32_t cnt,
                                          AppendableWrapper& appendTo,
                                          UErrorCode& success) const {
  if (U_FAILURE(success)) {
25
←
Taking false branch→
      return;
  }

  if (!MessageImpl::jdkAposMode(msgPattern)) {
26
←
Taking false branch→
      format(msgStart, plNumber, arguments, argumentNames, cnt, appendTo, NULL__null, success);
      return;
  }

  // JDK compatibility mode: (see JDK MessageFormat.format() API docs)
  // - remove SKIP_SYNTAX; that is, remove half of the apostrophes
  // - if the result string contains an open curly brace '{' then
  //   instantiate a temporary MessageFormat object and format again;
  //   otherwise just append the result string
  const UnicodeString& msgString = msgPattern.getPatternString();
  UnicodeString sb;
  int32_t prevIndex = msgPattern.getPart(msgStart).getLimit();
  for (int32_t i = msgStart;;) {
27
←
Loop condition is true.  Entering loop body→
      const MessagePattern::Part& part = msgPattern.getPart(++i);
      const UMessagePatternPartType type = part.getType();
      int32_t index = part.getIndex();
      if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) {
28
←
Assuming 'type' is equal to UMSGPAT_PART_TYPE_MSG_LIMIT→
29
←
Taking true branch→
          sb.append(msgString, prevIndex, index - prevIndex);
          break;
      } else if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER || type == UMSGPAT_PART_TYPE_SKIP_SYNTAX) {
          sb.append(msgString, prevIndex, index - prevIndex);
          if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) {
              const PluralSelectorContext &pluralNumber =
                  *static_cast<const PluralSelectorContext *>(plNumber);
              if(pluralNumber.forReplaceNumber) {
                  // number-offset was already formatted.
                  sb.append(pluralNumber.numberString);
              } else {
                  const NumberFormat* nf = getDefaultNumberFormat(success);
                  sb.append(nf->format(pluralNumber.number, sb, success));
              }
          }
          prevIndex = part.getLimit();
      } else if (type == UMSGPAT_PART_TYPE_ARG_START) {
          sb.append(msgString, prevIndex, index - prevIndex);
          prevIndex = index;
          i = msgPattern.getLimitPartIndex(i);
          index = msgPattern.getPart(i).getLimit();
          MessageImpl::appendReducedApostrophes(msgString, prevIndex, index, sb);
          prevIndex = index;
      }
  }
  if (sb.indexOf(LEFT_CURLY_BRACE((UChar)0x007B)) >= 0) {
30
←
 Execution continues on line 1218→
31
←
Assuming the condition is true→
32
←
Taking true branch→
      UnicodeString emptyPattern;  // gcc 3.3.3 fails with "UnicodeString()" as the first parameter.
      MessageFormat subMsgFormat(emptyPattern, fLocale, success);
      subMsgFormat.applyPattern(sb, UMSGPAT_APOS_DOUBLE_REQUIRED, NULL__null, success);
33
←
Passing null pointer value via 3rd parameter 'parseError'→
34
←
Calling 'MessageFormat::applyPattern'→
      subMsgFormat.format(0, NULL__null, arguments, argumentNames, cnt, appendTo, NULL__null, success);
  } else {
      appendTo.append(sb);
  }
1226}


1229UnicodeString MessageFormat::getLiteralStringUntilNextArgument(int32_t from) const {
  const UnicodeString& msgString=msgPattern.getPatternString();
  int32_t prevIndex=msgPattern.getPart(from).getLimit();
  UnicodeString b;
  for (int32_t i = from + 1; ; ++i) {
      const MessagePattern::Part& part = msgPattern.getPart(i);
      const UMessagePatternPartType type=part.getType();
      int32_t index=part.getIndex();
      b.append(msgString, prevIndex, index - prevIndex);
      if(type==UMSGPAT_PART_TYPE_ARG_START || type==UMSGPAT_PART_TYPE_MSG_LIMIT) {
          return b;
      }
      // Unexpected Part "part" in parsed message.
      U_ASSERT(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX || type==UMSGPAT_PART_TYPE_INSERT_CHAR)(void)0;
      prevIndex=part.getLimit();
  }
1245}


1248FieldPosition* MessageFormat::updateMetaData(AppendableWrapper& /*dest*/, int32_t /*prevLength*/,
                           FieldPosition* /*fp*/, const Formattable* /*argId*/) const {
  // Unlike in Java, there are no field attributes defined for MessageFormat. Do nothing.
  return NULL__null;
  /*
    if (fp != NULL && Field.ARGUMENT.equals(fp.getFieldAttribute())) {
        fp->setBeginIndex(prevLength);
        fp->setEndIndex(dest.get_length());
        return NULL;
    }
    return fp;
  */
1260}

1262int32_t
1263MessageFormat::findOtherSubMessage(int32_t partIndex) const {
  int32_t count=msgPattern.countParts();
  const MessagePattern::Part *part = &msgPattern.getPart(partIndex);
  if(MessagePattern::Part::hasNumericValue(part->getType())) {
      ++partIndex;
  }
  // Iterate over (ARG_SELECTOR [ARG_INT|ARG_DOUBLE] message) tuples
  // until ARG_LIMIT or end of plural-only pattern.
  UnicodeString other(FALSE0, OTHER_STRING, 5);
  do {
      part=&msgPattern.getPart(partIndex++);
      UMessagePatternPartType type=part->getType();
      if(type==UMSGPAT_PART_TYPE_ARG_LIMIT) {
          break;
      }
      U_ASSERT(type==UMSGPAT_PART_TYPE_ARG_SELECTOR)(void)0;
      // part is an ARG_SELECTOR followed by an optional explicit value, and then a message
      if(msgPattern.partSubstringMatches(*part, other)) {
          return partIndex;
      }
      if(MessagePattern::Part::hasNumericValue(msgPattern.getPartType(partIndex))) {
          ++partIndex;  // skip the numeric-value part of "=1" etc.
      }
      partIndex=msgPattern.getLimitPartIndex(partIndex);
  } while(++partIndex<count);
  return 0;
1289}

1291int32_t
1292MessageFormat::findFirstPluralNumberArg(int32_t msgStart, const UnicodeString &argName) const {
  for(int32_t i=msgStart+1;; ++i) {
      const MessagePattern::Part &part=msgPattern.getPart(i);
      UMessagePatternPartType type=part.getType();
      if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) {
          return 0;
      }
      if(type==UMSGPAT_PART_TYPE_REPLACE_NUMBER) {
          return -1;
      }
      if(type==UMSGPAT_PART_TYPE_ARG_START) {
          UMessagePatternArgType argType=part.getArgType();
          if(!argName.isEmpty() && (argType==UMSGPAT_ARG_TYPE_NONE || argType==UMSGPAT_ARG_TYPE_SIMPLE)) {
              // ARG_NUMBER or ARG_NAME
              if(msgPattern.partSubstringMatches(msgPattern.getPart(i+1), argName)) {
                  return i;
              }
          }
          i=msgPattern.getLimitPartIndex(i);
      }
  }
1313}

1315void MessageFormat::copyObjects(const MessageFormat& that, UErrorCode& ec) {
  // Deep copy pointer fields.
  // We need not copy the formatAliases because they are re-filled
  // in each getFormats() call.
  // The defaultNumberFormat, defaultDateFormat and pluralProvider.rules
  // also get created on demand.
  argTypeCount = that.argTypeCount;
  if (argTypeCount > 0) {
      if (!allocateArgTypes(argTypeCount, ec)) {
          return;
      }
      uprv_memcpy(argTypes, that.argTypes, argTypeCount * sizeof(argTypes[0]))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(argTypes,
 that.argTypes, argTypeCount * sizeof(argTypes[0])); } while (
false);
  }
  if (cachedFormatters != NULL__null) {
      uhash_removeAlluhash_removeAll_71(cachedFormatters);
  }
  if (customFormatArgStarts != NULL__null) {
      uhash_removeAlluhash_removeAll_71(customFormatArgStarts);
  }
  if (that.cachedFormatters) {
      if (cachedFormatters == NULL__null) {
          cachedFormatters=uhash_openuhash_open_71(uhash_hashLonguhash_hashLong_71, uhash_compareLonguhash_compareLong_71,
                                      equalFormatsForHash, &ec);
          if (U_FAILURE(ec)) {
              return;
          }
          uhash_setValueDeleteruhash_setValueDeleter_71(cachedFormatters, uprv_deleteUObjectuprv_deleteUObject_71);
      }

      const int32_t count = uhash_countuhash_count_71(that.cachedFormatters);
      int32_t pos, idx;
      for (idx = 0, pos = UHASH_FIRST(-1); idx < count && U_SUCCESS(ec); ++idx) {
          const UHashElement* cur = uhash_nextElementuhash_nextElement_71(that.cachedFormatters, &pos);
          Format* newFormat = ((Format*)(cur->value.pointer))->clone();
          if (newFormat) {
              uhash_iputuhash_iput_71(cachedFormatters, cur->key.integer, newFormat, &ec);
          } else {
              ec = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
      }
  }
  if (that.customFormatArgStarts) {
      if (customFormatArgStarts == NULL__null) {
          customFormatArgStarts=uhash_openuhash_open_71(uhash_hashLonguhash_hashLong_71, uhash_compareLonguhash_compareLong_71,
                                            NULL__null, &ec);
      }
      const int32_t count = uhash_countuhash_count_71(that.customFormatArgStarts);
      int32_t pos, idx;
      for (idx = 0, pos = UHASH_FIRST(-1); idx < count && U_SUCCESS(ec); ++idx) {
          const UHashElement* cur = uhash_nextElementuhash_nextElement_71(that.customFormatArgStarts, &pos);
          uhash_iputiuhash_iputi_71(customFormatArgStarts, cur->key.integer, cur->value.integer, &ec);
      }
  }
1369}


1372Formattable*
1373MessageFormat::parse(int32_t msgStart,
                   const UnicodeString& source,
                   ParsePosition& pos,
                   int32_t& count,
                   UErrorCode& ec) const {
  count = 0;
  if (U_FAILURE(ec)) {
      pos.setErrorIndex(pos.getIndex());
      return NULL__null;
  }
  // parse() does not work with named arguments.
  if (msgPattern.hasNamedArguments()) {
      ec = U_ARGUMENT_TYPE_MISMATCH;
      pos.setErrorIndex(pos.getIndex());
      return NULL__null;
  }
  LocalArray<Formattable> resultArray(new Formattable[argTypeCount ? argTypeCount : 1]);
  const UnicodeString& msgString=msgPattern.getPatternString();
  int32_t prevIndex=msgPattern.getPart(msgStart).getLimit();
  int32_t sourceOffset = pos.getIndex();
  ParsePosition tempStatus(0);

  for(int32_t i=msgStart+1; ; ++i) {
      UBool haveArgResult = FALSE0;
      const MessagePattern::Part* part=&msgPattern.getPart(i);
      const UMessagePatternPartType type=part->getType();
      int32_t index=part->getIndex();
      // Make sure the literal string matches.
      int32_t len = index - prevIndex;
      if (len == 0 || (0 == msgString.compare(prevIndex, len, source, sourceOffset, len))) {
          sourceOffset += len;
          prevIndex += len;
      } else {
          pos.setErrorIndex(sourceOffset);
          return NULL__null; // leave index as is to signal error
      }
      if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) {
          // Things went well! Done.
          pos.setIndex(sourceOffset);
          return resultArray.orphan();
      }
      if(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX || type==UMSGPAT_PART_TYPE_INSERT_CHAR) {
          prevIndex=part->getLimit();
          continue;
      }
      // We do not support parsing Plural formats. (No REPLACE_NUMBER here.)
      // Unexpected Part "part" in parsed message.
      U_ASSERT(type==UMSGPAT_PART_TYPE_ARG_START)(void)0;
      int32_t argLimit=msgPattern.getLimitPartIndex(i);

      UMessagePatternArgType argType=part->getArgType();
      part=&msgPattern.getPart(++i);
      int32_t argNumber = part->getValue();  // ARG_NUMBER
      UnicodeString key;
      ++i;
      const Format* formatter = NULL__null;
      Formattable& argResult = resultArray[argNumber];

      if(cachedFormatters!=NULL__null && (formatter = getCachedFormatter(i - 2))!=NULL__null) {
          // Just parse using the formatter.
          tempStatus.setIndex(sourceOffset);
          formatter->parseObject(source, argResult, tempStatus);
          if (tempStatus.getIndex() == sourceOffset) {
              pos.setErrorIndex(sourceOffset);
              return NULL__null; // leave index as is to signal error
          }
          sourceOffset = tempStatus.getIndex();
          haveArgResult = TRUE1;
      } else if(
          argType==UMSGPAT_ARG_TYPE_NONE || (cachedFormatters && uhash_igetuhash_iget_71(cachedFormatters, i -2))) {
          // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table.
          // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check
          // for the hash table containing DummyFormat.

          // Match as a string.
          // if at end, use longest possible match
          // otherwise uses first match to intervening string
          // does NOT recursively try all possibilities
          UnicodeString stringAfterArgument = getLiteralStringUntilNextArgument(argLimit);
          int32_t next;
          if (!stringAfterArgument.isEmpty()) {
              next = source.indexOf(stringAfterArgument, sourceOffset);
          } else {
              next = source.length();
          }
          if (next < 0) {
              pos.setErrorIndex(sourceOffset);
              return NULL__null; // leave index as is to signal error
          } else {
              UnicodeString strValue(source.tempSubString(sourceOffset, next - sourceOffset));
              UnicodeString compValue;
              compValue.append(LEFT_CURLY_BRACE((UChar)0x007B));
              itos(argNumber, compValue);
              compValue.append(RIGHT_CURLY_BRACE((UChar)0x007D));
              if (0 != strValue.compare(compValue)) {
                  argResult.setString(strValue);
                  haveArgResult = TRUE1;
              }
              sourceOffset = next;
          }
      } else if(argType==UMSGPAT_ARG_TYPE_CHOICE) {
          tempStatus.setIndex(sourceOffset);
          double choiceResult = ChoiceFormat::parseArgument(msgPattern, i, source, tempStatus);
          if (tempStatus.getIndex() == sourceOffset) {
              pos.setErrorIndex(sourceOffset);
              return NULL__null; // leave index as is to signal error
          }
          argResult.setDouble(choiceResult);
          haveArgResult = TRUE1;
          sourceOffset = tempStatus.getIndex();
      } else if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType)((argType)==UMSGPAT_ARG_TYPE_PLURAL || (argType)==UMSGPAT_ARG_TYPE_SELECTORDINAL
) || argType==UMSGPAT_ARG_TYPE_SELECT) {
          // Parsing not supported.
          ec = U_UNSUPPORTED_ERROR;
          return NULL__null;
      } else {
          // This should never happen.
          ec = U_INTERNAL_PROGRAM_ERROR;
          return NULL__null;
      }
      if (haveArgResult && count <= argNumber) {
          count = argNumber + 1;
      }
      prevIndex=msgPattern.getPart(argLimit).getLimit();
      i=argLimit;
  }
1498}
1499// -------------------------------------
1500// Parses the source pattern and returns the Formattable objects array,
1501// the array count and the ending parse position.  The caller of this method
1502// owns the array.

1504Formattable*
1505MessageFormat::parse(const UnicodeString& source,
                   ParsePosition& pos,
                   int32_t& count) const {
  UErrorCode ec = U_ZERO_ERROR;
  return parse(0, source, pos, count, ec);
1510}

1512// -------------------------------------
1513// Parses the source string and returns the array of
1514// Formattable objects and the array count.  The caller
1515// owns the returned array.

1517Formattable*
1518MessageFormat::parse(const UnicodeString& source,
                   int32_t& cnt,
                   UErrorCode& success) const
1521{
  if (msgPattern.hasNamedArguments()) {
      success = U_ARGUMENT_TYPE_MISMATCH;
      return NULL__null;
  }
  ParsePosition status(0);
  // Calls the actual implementation method and starts
  // from zero offset of the source text.
  Formattable* result = parse(source, status, cnt);
  if (status.getIndex() == 0) {
      success = U_MESSAGE_PARSE_ERROR;
      delete[] result;
      return NULL__null;
  }
  return result;
1536}

1538// -------------------------------------
1539// Parses the source text and copy into the result buffer.

1541void
1542MessageFormat::parseObject( const UnicodeString& source,
                          Formattable& result,
                          ParsePosition& status) const
1545{
  int32_t cnt = 0;
  Formattable* tmpResult = parse(source, status, cnt);
  if (tmpResult != NULL__null)
      result.adoptArray(tmpResult, cnt);
1550}

1552UnicodeString
1553MessageFormat::autoQuoteApostrophe(const UnicodeString& pattern, UErrorCode& status) {
  UnicodeString result;
  if (U_SUCCESS(status)) {
      int32_t plen = pattern.length();
      const UChar* pat = pattern.getBuffer();
      int32_t blen = plen * 2 + 1; // space for null termination, convenience
      UChar* buf = result.getBuffer(blen);
      if (buf == NULL__null) {
          status = U_MEMORY_ALLOCATION_ERROR;
      } else {
          int32_t len = umsg_autoQuoteApostropheumsg_autoQuoteApostrophe_71(pat, plen, buf, blen, &status);
          result.releaseBuffer(U_SUCCESS(status) ? len : 0);
      }
  }
  if (U_FAILURE(status)) {
      result.setToBogus();
  }
  return result;
1571}

1573// -------------------------------------

1575static Format* makeRBNF(URBNFRuleSetTag tag, const Locale& locale, const UnicodeString& defaultRuleSet, UErrorCode& ec) {
  RuleBasedNumberFormat* fmt = new RuleBasedNumberFormat(tag, locale, ec);
  if (fmt == NULL__null) {
      ec = U_MEMORY_ALLOCATION_ERROR;
  } else if (U_SUCCESS(ec) && defaultRuleSet.length() > 0) {
      UErrorCode localStatus = U_ZERO_ERROR; // ignore unrecognized default rule set
      fmt->setDefaultRuleSet(defaultRuleSet, localStatus);
  }
  return fmt;
1584}

1586void MessageFormat::cacheExplicitFormats(UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }

  if (cachedFormatters != NULL__null) {
      uhash_removeAlluhash_removeAll_71(cachedFormatters);
  }
  if (customFormatArgStarts != NULL__null) {
      uhash_removeAlluhash_removeAll_71(customFormatArgStarts);
  }

  // The last two "parts" can at most be ARG_LIMIT and MSG_LIMIT
  // which we need not examine.
  int32_t limit = msgPattern.countParts() - 2;
  argTypeCount = 0;
  // We also need not look at the first two "parts"
  // (at most MSG_START and ARG_START) in this loop.
  // We determine the argTypeCount first so that we can allocateArgTypes
  // so that the next loop can set argTypes[argNumber].
  // (This is for the C API which needs the argTypes to read its va_arg list.)
  for (int32_t i = 2; i < limit && U_SUCCESS(status); ++i) {
      const MessagePattern::Part& part = msgPattern.getPart(i);
      if (part.getType() == UMSGPAT_PART_TYPE_ARG_NUMBER) {
          const int argNumber = part.getValue();
          if (argNumber >= argTypeCount) {
              argTypeCount = argNumber + 1;
          }
      }
  }
  if (!allocateArgTypes(argTypeCount, status)) {
      return;
  }
  // Set all argTypes to kObject, as a "none" value, for lack of any better value.
  // We never use kObject for real arguments.
  // We use it as "no argument yet" for the check for hasArgTypeConflicts.
  for (int32_t i = 0; i < argTypeCount; ++i) {
      argTypes[i] = Formattable::kObject;
  }
  hasArgTypeConflicts = FALSE0;

  // This loop starts at part index 1 because we do need to examine
  // ARG_START parts. (But we can ignore the MSG_START.)
  for (int32_t i = 1; i < limit && U_SUCCESS(status); ++i) {
      const MessagePattern::Part* part = &msgPattern.getPart(i);
      if (part->getType() != UMSGPAT_PART_TYPE_ARG_START) {
          continue;
      }
      UMessagePatternArgType argType = part->getArgType();

      int32_t argNumber = -1;
      part = &msgPattern.getPart(i + 1);
      if (part->getType() == UMSGPAT_PART_TYPE_ARG_NUMBER) {
          argNumber = part->getValue();
      }
      Formattable::Type formattableType;

      switch (argType) {
      case UMSGPAT_ARG_TYPE_NONE:
          formattableType = Formattable::kString;
          break;
      case UMSGPAT_ARG_TYPE_SIMPLE: {
          int32_t index = i;
          i += 2;
          UnicodeString explicitType = msgPattern.getSubstring(msgPattern.getPart(i++));
          UnicodeString style;
          if ((part = &msgPattern.getPart(i))->getType() == UMSGPAT_PART_TYPE_ARG_STYLE) {
              style = msgPattern.getSubstring(*part);
              ++i;
          }
          UParseError parseError;
          Format* formatter = createAppropriateFormat(explicitType, style, formattableType, parseError, status);
          setArgStartFormat(index, formatter, status);
          break;
      }
      case UMSGPAT_ARG_TYPE_CHOICE:
      case UMSGPAT_ARG_TYPE_PLURAL:
      case UMSGPAT_ARG_TYPE_SELECTORDINAL:
          formattableType = Formattable::kDouble;
          break;
      case UMSGPAT_ARG_TYPE_SELECT:
          formattableType = Formattable::kString;
          break;
      default:
          status = U_INTERNAL_PROGRAM_ERROR;  // Should be unreachable.
          formattableType = Formattable::kString;
          break;
      }
      if (argNumber != -1) {
          if (argTypes[argNumber] != Formattable::kObject && argTypes[argNumber] != formattableType) {
              hasArgTypeConflicts = TRUE1;
          }
          argTypes[argNumber] = formattableType;
      }
  }
1681}

1683Format* MessageFormat::createAppropriateFormat(UnicodeString& type, UnicodeString& style,
                                             Formattable::Type& formattableType, UParseError& parseError,
                                             UErrorCode& ec) {
  if (U_FAILURE(ec)) {
      return NULL__null;
  }
  Format* fmt = NULL__null;
  int32_t typeID, styleID;
  DateFormat::EStyle date_style;
  int32_t firstNonSpace;

  switch (typeID = findKeyword(type, TYPE_IDS)) {
  case 0: // number
      formattableType = Formattable::kDouble;
      switch (findKeyword(style, NUMBER_STYLE_IDS)) {
      case 0: // default
          fmt = NumberFormat::createInstance(fLocale, ec);
          break;
      case 1: // currency
          fmt = NumberFormat::createCurrencyInstance(fLocale, ec);
          break;
      case 2: // percent
          fmt = NumberFormat::createPercentInstance(fLocale, ec);
          break;
      case 3: // integer
          formattableType = Formattable::kLong;
          fmt = createIntegerFormat(fLocale, ec);
          break;
      default: // pattern or skeleton
          firstNonSpace = PatternProps::skipWhiteSpace(style, 0);
          if (style.compare(firstNonSpace, 2, u"::", 0, 2) == 0) {
              // Skeleton
              UnicodeString skeleton = style.tempSubString(firstNonSpace + 2);
              fmt = number::NumberFormatter::forSkeleton(skeleton, ec).locale(fLocale).toFormat(ec);
          } else {
              // Pattern
              fmt = NumberFormat::createInstance(fLocale, ec);
              if (fmt) {
                  auto* decfmt = dynamic_cast<DecimalFormat*>(fmt);
                  if (decfmt != nullptr) {
                      decfmt->applyPattern(style, parseError, ec);
                  }
              }
          }
          break;
      }
      break;

  case 1: // date
  case 2: // time
      formattableType = Formattable::kDate;
      firstNonSpace = PatternProps::skipWhiteSpace(style, 0);
      if (style.compare(firstNonSpace, 2, u"::", 0, 2) == 0) {
          // Skeleton
          UnicodeString skeleton = style.tempSubString(firstNonSpace + 2);
          fmt = DateFormat::createInstanceForSkeleton(skeleton, fLocale, ec);
      } else {
          // Pattern
          styleID = findKeyword(style, DATE_STYLE_IDS);
          date_style = (styleID >= 0) ? DATE_STYLES[styleID] : DateFormat::kDefault;

          if (typeID == 1) {
              fmt = DateFormat::createDateInstance(date_style, fLocale);
          } else {
              fmt = DateFormat::createTimeInstance(date_style, fLocale);
          }

          if (styleID < 0 && fmt != NULL__null) {
              SimpleDateFormat* sdtfmt = dynamic_cast<SimpleDateFormat*>(fmt);
              if (sdtfmt != NULL__null) {
                  sdtfmt->applyPattern(style);
              }
          }
      }
      break;

  case 3: // spellout
      formattableType = Formattable::kDouble;
      fmt = makeRBNF(URBNF_SPELLOUT, fLocale, style, ec);
      break;
  case 4: // ordinal
      formattableType = Formattable::kDouble;
      fmt = makeRBNF(URBNF_ORDINAL, fLocale, style, ec);
      break;
  case 5: // duration
      formattableType = Formattable::kDouble;
      fmt = makeRBNF(URBNF_DURATION, fLocale, style, ec);
      break;
  default:
      formattableType = Formattable::kString;
      ec = U_ILLEGAL_ARGUMENT_ERROR;
      break;
  }

  return fmt;
1778}


1781//-------------------------------------
1782// Finds the string, s, in the string array, list.
1783int32_t MessageFormat::findKeyword(const UnicodeString& s,
                                 const UChar * const *list)
1785{
  if (s.isEmpty()) {
      return 0; // default
  }

  int32_t length = s.length();
  const UChar *ps = PatternProps::trimWhiteSpace(s.getBuffer(), length);
  UnicodeString buffer(FALSE0, ps, length);
  // Trims the space characters and turns all characters
  // in s to lower case.
  buffer.toLower("");
  for (int32_t i = 0; list[i]; ++i) {
      if (!buffer.compare(list[i], u_strlenu_strlen_71(list[i]))) {
          return i;
      }
  }
  return -1;
1802}

1804/**
* Convenience method that ought to be in NumberFormat
*/
1807NumberFormat*
1808MessageFormat::createIntegerFormat(const Locale& locale, UErrorCode& status) const {
  NumberFormat *temp = NumberFormat::createInstance(locale, status);
  DecimalFormat *temp2;
  if (temp != NULL__null && (temp2 = dynamic_cast<DecimalFormat*>(temp)) != NULL__null) {
      temp2->setMaximumFractionDigits(0);
      temp2->setDecimalSeparatorAlwaysShown(FALSE0);
      temp2->setParseIntegerOnly(TRUE1);
  }

  return temp;
1818}

1820/**
* Return the default number format.  Used to format a numeric
* argument when subformats[i].format is NULL.  Returns NULL
* on failure.
*
* Semantically const but may modify *this.
*/
1827const NumberFormat* MessageFormat::getDefaultNumberFormat(UErrorCode& ec) const {
  if (defaultNumberFormat == NULL__null) {
      MessageFormat* t = (MessageFormat*) this;
      t->defaultNumberFormat = NumberFormat::createInstance(fLocale, ec);
      if (U_FAILURE(ec)) {
          delete t->defaultNumberFormat;
          t->defaultNumberFormat = NULL__null;
      } else if (t->defaultNumberFormat == NULL__null) {
          ec = U_MEMORY_ALLOCATION_ERROR;
      }
  }
  return defaultNumberFormat;
1839}

1841/**
* Return the default date format.  Used to format a date
* argument when subformats[i].format is NULL.  Returns NULL
* on failure.
*
* Semantically const but may modify *this.
*/
1848const DateFormat* MessageFormat::getDefaultDateFormat(UErrorCode& ec) const {
  if (defaultDateFormat == NULL__null) {
      MessageFormat* t = (MessageFormat*) this;
      t->defaultDateFormat = DateFormat::createDateTimeInstance(DateFormat::kShort, DateFormat::kShort, fLocale);
      if (t->defaultDateFormat == NULL__null) {
          ec = U_MEMORY_ALLOCATION_ERROR;
      }
  }
  return defaultDateFormat;
1857}

1859UBool
1860MessageFormat::usesNamedArguments() const {
  return msgPattern.hasNamedArguments();
1862}

1864int32_t
1865MessageFormat::getArgTypeCount() const {
  return argTypeCount;
1867}

1869UBool MessageFormat::equalFormats(const void* left, const void* right) {
  return *(const Format*)left==*(const Format*)right;
1871}


1874bool MessageFormat::DummyFormat::operator==(const Format&) const {
  return true;
1876}

1878MessageFormat::DummyFormat* MessageFormat::DummyFormat::clone() const {
  return new DummyFormat();
1880}

1882UnicodeString& MessageFormat::DummyFormat::format(const Formattable&,
                        UnicodeString& appendTo,
                        UErrorCode& status) const {
  if (U_SUCCESS(status)) {
      status = U_UNSUPPORTED_ERROR;
  }
  return appendTo;
1889}

1891UnicodeString& MessageFormat::DummyFormat::format(const Formattable&,
                        UnicodeString& appendTo,
                        FieldPosition&,
                        UErrorCode& status) const {
  if (U_SUCCESS(status)) {
      status = U_UNSUPPORTED_ERROR;
  }
  return appendTo;
1899}

1901UnicodeString& MessageFormat::DummyFormat::format(const Formattable&,
                        UnicodeString& appendTo,
                        FieldPositionIterator*,
                        UErrorCode& status) const {
  if (U_SUCCESS(status)) {
      status = U_UNSUPPORTED_ERROR;
  }
  return appendTo;
1909}

1911void MessageFormat::DummyFormat::parseObject(const UnicodeString&,
                                                   Formattable&,
                                                   ParsePosition& ) const {
1914}


1917FormatNameEnumeration::FormatNameEnumeration(LocalPointer<UVector> nameList, UErrorCode& /*status*/) {
  pos=0;
  fFormatNames = std::move(nameList);
1920}

1922const UnicodeString*
1923FormatNameEnumeration::snext(UErrorCode& status) {
  if (U_SUCCESS(status) && pos < fFormatNames->size()) {
      return (const UnicodeString*)fFormatNames->elementAt(pos++);
  }
  return NULL__null;
1928}

1930void
1931FormatNameEnumeration::reset(UErrorCode& /*status*/) {
  pos=0;
1933}

1935int32_t
1936FormatNameEnumeration::count(UErrorCode& /*status*/) const {
  return (fFormatNames==NULL__null) ? 0 : fFormatNames->size();
1938}

1940FormatNameEnumeration::~FormatNameEnumeration() {
1941}

1943MessageFormat::PluralSelectorProvider::PluralSelectorProvider(const MessageFormat &mf, UPluralType t)
      : msgFormat(mf), rules(NULL__null), type(t) {
1945}

1947MessageFormat::PluralSelectorProvider::~PluralSelectorProvider() {
  delete rules;
1949}

1951UnicodeString MessageFormat::PluralSelectorProvider::select(void *ctx, double number,
                                                          UErrorCode& ec) const {
  if (U_FAILURE(ec)) {
      return UnicodeString(FALSE0, OTHER_STRING, 5);
  }
  MessageFormat::PluralSelectorProvider* t = const_cast<MessageFormat::PluralSelectorProvider*>(this);
  if(rules == NULL__null) {
      t->rules = PluralRules::forLocale(msgFormat.fLocale, type, ec);
      if (U_FAILURE(ec)) {
          return UnicodeString(FALSE0, OTHER_STRING, 5);
      }
  }
  // Select a sub-message according to how the number is formatted,
  // which is specified in the selected sub-message.
  // We avoid this circle by looking at how
  // the number is formatted in the "other" sub-message
  // which must always be present and usually contains the number.
  // Message authors should be consistent across sub-messages.
  PluralSelectorContext &context = *static_cast<PluralSelectorContext *>(ctx);
  int32_t otherIndex = msgFormat.findOtherSubMessage(context.startIndex);
  context.numberArgIndex = msgFormat.findFirstPluralNumberArg(otherIndex, context.argName);
  if(context.numberArgIndex > 0 && msgFormat.cachedFormatters != NULL__null) {
      context.formatter =
          (const Format*)uhash_igetuhash_iget_71(msgFormat.cachedFormatters, context.numberArgIndex);
  }
  if(context.formatter == NULL__null) {
      context.formatter = msgFormat.getDefaultNumberFormat(ec);
      context.forReplaceNumber = TRUE1;
  }
  if (context.number.getDouble(ec) != number) {
      ec = U_INTERNAL_PROGRAM_ERROR;
      return UnicodeString(FALSE0, OTHER_STRING, 5);
  }
  context.formatter->format(context.number, context.numberString, ec);
  auto* decFmt = dynamic_cast<const DecimalFormat *>(context.formatter);
  if(decFmt != NULL__null) {
      number::impl::DecimalQuantity dq;
      decFmt->formatToDecimalQuantity(context.number, dq, ec);
      if (U_FAILURE(ec)) {
          return UnicodeString(FALSE0, OTHER_STRING, 5);
      }
      return rules->select(dq);
  } else {
      return rules->select(number);
  }
1996}

1998void MessageFormat::PluralSelectorProvider::reset() {
  delete rules;
  rules = NULL__null;
2001}


2004U_NAMESPACE_END}

2006#endif /* #if !UCONFIG_NO_FORMATTING */

2008//eof