icuSources/i18n/msgfmt.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2015, International Business Machines Corporation and
   6  * others. All Rights Reserved.
   7  ********************************************************************
   8  *
   9  * File MSGFMT.CPP
  10  *
  11  * Modification History:
  12  *
  13  *   Date        Name        Description
  14  *   02/19/97    aliu        Converted from java.
  15  *   03/20/97    helena      Finished first cut of implementation.
  16  *   04/10/97    aliu        Made to work on AIX.  Added stoi to replace wtoi.
  17  *   06/11/97    helena      Fixed addPattern to take the pattern correctly.
  18  *   06/17/97    helena      Fixed the getPattern to return the correct pattern.
  19  *   07/09/97    helena      Made ParsePosition into a class.
  20  *   02/22/99    stephen     Removed character literals for EBCDIC safety
  21  *   11/01/09    kirtig      Added SelectFormat
  22  ********************************************************************/
  23
  24 #include "unicode/utypes.h"
  25
  26 #if !UCONFIG_NO_FORMATTING
  27
  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 "visibledigits.h"
  53
  54 // *****************************************************************************
  55 // class MessageFormat
  56 // *****************************************************************************
  57
  58 #define SINGLE_QUOTE      ((UChar)0x0027)
  59 #define COMMA             ((UChar)0x002C)
  60 #define LEFT_CURLY_BRACE  ((UChar)0x007B)
  61 #define RIGHT_CURLY_BRACE ((UChar)0x007D)
  62
  63 //---------------------------------------
  64 // static data
  65
  66 static const UChar ID_NUMBER[]    = {
  67     0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0  /* "number" */
  68 };
  69 static const UChar ID_DATE[]      = {
  70     0x64, 0x61, 0x74, 0x65, 0              /* "date" */
  71 };
  72 static const UChar ID_TIME[]      = {
  73     0x74, 0x69, 0x6D, 0x65, 0              /* "time" */
  74 };
  75 static const UChar ID_SPELLOUT[]  = {
  76     0x73, 0x70, 0x65, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0 /* "spellout" */
  77 };
  78 static const UChar ID_ORDINAL[]   = {
  79     0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0 /* "ordinal" */
  80 };
  81 static const UChar ID_DURATION[]  = {
  82     0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0 /* "duration" */
  83 };
  84
  85 // MessageFormat Type List  Number, Date, Time or Choice
  86 static const UChar * const TYPE_IDS[] = {
  87     ID_NUMBER,
  88     ID_DATE,
  89     ID_TIME,
  90     ID_SPELLOUT,
  91     ID_ORDINAL,
  92     ID_DURATION,
  93     NULL,
  94 };
  95
  96 static const UChar ID_EMPTY[]     = {
  97     0 /* empty string, used for default so that null can mark end of list */
  98 };
  99 static const UChar ID_CURRENCY[]  = {
 100     0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, 0x79, 0  /* "currency" */
 101 };
 102 static const UChar ID_PERCENT[]   = {
 103     0x70, 0x65, 0x72, 0x63, 0x65, 0x6E, 0x74, 0        /* "percent" */
 104 };
 105 static const UChar ID_INTEGER[]   = {
 106     0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0        /* "integer" */
 107 };
 108
 109 // NumberFormat modifier list, default, currency, percent or integer
 110 static const UChar * const NUMBER_STYLE_IDS[] = {
 111     ID_EMPTY,
 112     ID_CURRENCY,
 113     ID_PERCENT,
 114     ID_INTEGER,
 115     NULL,
 116 };
 117
 118 static const UChar ID_SHORT[]     = {
 119     0x73, 0x68, 0x6F, 0x72, 0x74, 0        /* "short" */
 120 };
 121 static const UChar ID_MEDIUM[]    = {
 122     0x6D, 0x65, 0x64, 0x69, 0x75, 0x6D, 0  /* "medium" */
 123 };
 124 static const UChar ID_LONG[]      = {
 125     0x6C, 0x6F, 0x6E, 0x67, 0              /* "long" */
 126 };
 127 static const UChar ID_FULL[]      = {
 128     0x66, 0x75, 0x6C, 0x6C, 0              /* "full" */
 129 };
 130
 131 // DateFormat modifier list, default, short, medium, long or full
 132 static const UChar * const DATE_STYLE_IDS[] = {
 133     ID_EMPTY,
 134     ID_SHORT,
 135     ID_MEDIUM,
 136     ID_LONG,
 137     ID_FULL,
 138     NULL,
 139 };
 140
 141 static const icu::DateFormat::EStyle DATE_STYLES[] = {
 142     icu::DateFormat::kDefault,
 143     icu::DateFormat::kShort,
 144     icu::DateFormat::kMedium,
 145     icu::DateFormat::kLong,
 146     icu::DateFormat::kFull,
 147 };
 148
 149 static const int32_t DEFAULT_INITIAL_CAPACITY = 10;
 150
 151 static const UChar NULL_STRING[] = {
 152     0x6E, 0x75, 0x6C, 0x6C, 0  // "null"
 153 };
 154
 155 static const UChar OTHER_STRING[] = {
 156     0x6F, 0x74, 0x68, 0x65, 0x72, 0  // "other"
 157 };
 158
 159 U_CDECL_BEGIN
 160 static UBool U_CALLCONV equalFormatsForHash(const UHashTok key1,
 161                                             const UHashTok key2) {
 162     return icu::MessageFormat::equalFormats(key1.pointer, key2.pointer);
 163 }
 164
 165 U_CDECL_END
 166
 167 U_NAMESPACE_BEGIN
 168
 169 // -------------------------------------
 170 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MessageFormat)
 171 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(FormatNameEnumeration)
 172
 173 //--------------------------------------------------------------------
 174
 175 /**
 176  * Convert an integer value to a string and append the result to
 177  * the given UnicodeString.
 178  */
 179 static UnicodeString& itos(int32_t i, UnicodeString& appendTo) {
 180     UChar temp[16];
 181     uprv_itou(temp,16,i,10,0); // 10 == radix
 182     appendTo.append(temp, -1);
 183     return appendTo;
 184 }
 185
 186
 187 // AppendableWrapper: encapsulates the result of formatting, keeping track
 188 // of the string and its length.
 189 class AppendableWrapper : public UMemory {
 190 public:
 191     AppendableWrapper(Appendable& appendable) : app(appendable), len(0) {
 192     }
 193     void append(const UnicodeString& s) {
 194         app.appendString(s.getBuffer(), s.length());
 195         len += s.length();
 196     }
 197     void append(const UChar* s, const int32_t sLength) {
 198         app.appendString(s, sLength);
 199         len += sLength;
 200     }
 201     void append(const UnicodeString& s, int32_t start, int32_t length) {
 202         append(s.tempSubString(start, length));
 203     }
 204     void formatAndAppend(const Format* formatter, const Formattable& arg, UErrorCode& ec) {
 205         UnicodeString s;
 206         formatter->format(arg, s, ec);
 207         if (U_SUCCESS(ec)) {
 208             append(s);
 209         }
 210     }
 211     void formatAndAppend(const Format* formatter, const Formattable& arg,
 212                          const UnicodeString &argString, UErrorCode& ec) {
 213         if (!argString.isEmpty()) {
 214             if (U_SUCCESS(ec)) {
 215                 append(argString);
 216             }
 217         } else {
 218             formatAndAppend(formatter, arg, ec);
 219         }
 220     }
 221     int32_t length() {
 222         return len;
 223     }
 224 private:
 225     Appendable& app;
 226     int32_t len;
 227 };
 228
 229
 230 // -------------------------------------
 231 // Creates a MessageFormat instance based on the pattern.
 232
 233 MessageFormat::MessageFormat(const UnicodeString& pattern,
 234                              UErrorCode& success)
 235 : fLocale(Locale::getDefault()),  // Uses the default locale
 236   msgPattern(success),
 237   formatAliases(NULL),
 238   formatAliasesCapacity(0),
 239   argTypes(NULL),
 240   argTypeCount(0),
 241   argTypeCapacity(0),
 242   hasArgTypeConflicts(FALSE),
 243   defaultNumberFormat(NULL),
 244   defaultDateFormat(NULL),
 245   cachedFormatters(NULL),
 246   customFormatArgStarts(NULL),
 247   pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
 248   ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
 249 {
 250     setLocaleIDs(fLocale.getName(), fLocale.getName());
 251     applyPattern(pattern, success);
 252 }
 253
 254 MessageFormat::MessageFormat(const UnicodeString& pattern,
 255                              const Locale& newLocale,
 256                              UErrorCode& success)
 257 : fLocale(newLocale),
 258   msgPattern(success),
 259   formatAliases(NULL),
 260   formatAliasesCapacity(0),
 261   argTypes(NULL),
 262   argTypeCount(0),
 263   argTypeCapacity(0),
 264   hasArgTypeConflicts(FALSE),
 265   defaultNumberFormat(NULL),
 266   defaultDateFormat(NULL),
 267   cachedFormatters(NULL),
 268   customFormatArgStarts(NULL),
 269   pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
 270   ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
 271 {
 272     setLocaleIDs(fLocale.getName(), fLocale.getName());
 273     applyPattern(pattern, success);
 274 }
 275
 276 MessageFormat::MessageFormat(const UnicodeString& pattern,
 277                              const Locale& newLocale,
 278                              UParseError& parseError,
 279                              UErrorCode& success)
 280 : fLocale(newLocale),
 281   msgPattern(success),
 282   formatAliases(NULL),
 283   formatAliasesCapacity(0),
 284   argTypes(NULL),
 285   argTypeCount(0),
 286   argTypeCapacity(0),
 287   hasArgTypeConflicts(FALSE),
 288   defaultNumberFormat(NULL),
 289   defaultDateFormat(NULL),
 290   cachedFormatters(NULL),
 291   customFormatArgStarts(NULL),
 292   pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
 293   ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
 294 {
 295     setLocaleIDs(fLocale.getName(), fLocale.getName());
 296     applyPattern(pattern, parseError, success);
 297 }
 298
 299 MessageFormat::MessageFormat(const MessageFormat& that)
 300 :
 301   Format(that),
 302   fLocale(that.fLocale),
 303   msgPattern(that.msgPattern),
 304   formatAliases(NULL),
 305   formatAliasesCapacity(0),
 306   argTypes(NULL),
 307   argTypeCount(0),
 308   argTypeCapacity(0),
 309   hasArgTypeConflicts(that.hasArgTypeConflicts),
 310   defaultNumberFormat(NULL),
 311   defaultDateFormat(NULL),
 312   cachedFormatters(NULL),
 313   customFormatArgStarts(NULL),
 314   pluralProvider(*this, UPLURAL_TYPE_CARDINAL),
 315   ordinalProvider(*this, UPLURAL_TYPE_ORDINAL)
 316 {
 317     // This will take care of creating the hash tables (since they are NULL).
 318     UErrorCode ec = U_ZERO_ERROR;
 319     copyObjects(that, ec);
 320     if (U_FAILURE(ec)) {
 321         resetPattern();
 322     }
 323 }
 324
 325 MessageFormat::~MessageFormat()
 326 {
 327     uhash_close(cachedFormatters);
 328     uhash_close(customFormatArgStarts);
 329
 330     uprv_free(argTypes);
 331     uprv_free(formatAliases);
 332     delete defaultNumberFormat;
 333     delete defaultDateFormat;
 334 }
 335
 336 //--------------------------------------------------------------------
 337 // Variable-size array management
 338
 339 /**
 340  * Allocate argTypes[] to at least the given capacity and return
 341  * TRUE if successful.  If not, leave argTypes[] unchanged.
 342  *
 343  * If argTypes is NULL, allocate it.  If it is not NULL, enlarge it
 344  * if necessary to be at least as large as specified.
 345  */
 346 UBool MessageFormat::allocateArgTypes(int32_t capacity, UErrorCode& status) {
 347     if (U_FAILURE(status)) {
 348         return FALSE;
 349     }
 350     if (argTypeCapacity >= capacity) {
 351         return TRUE;
 352     }
 353     if (capacity < DEFAULT_INITIAL_CAPACITY) {
 354         capacity = DEFAULT_INITIAL_CAPACITY;
 355     } else if (capacity < 2*argTypeCapacity) {
 356         capacity = 2*argTypeCapacity;
 357     }
 358     Formattable::Type* a = (Formattable::Type*)
 359             uprv_realloc(argTypes, sizeof(*argTypes) * capacity);
 360     if (a == NULL) {
 361         status = U_MEMORY_ALLOCATION_ERROR;
 362         return FALSE;
 363     }
 364     argTypes = a;
 365     argTypeCapacity = capacity;
 366     return TRUE;
 367 }
 368
 369 // -------------------------------------
 370 // assignment operator
 371
 372 const MessageFormat&
 373 MessageFormat::operator=(const MessageFormat& that)
 374 {
 375     if (this != &that) {
 376         // Calls the super class for assignment first.
 377         Format::operator=(that);
 378
 379         setLocale(that.fLocale);
 380         msgPattern = that.msgPattern;
 381         hasArgTypeConflicts = that.hasArgTypeConflicts;
 382
 383         UErrorCode ec = U_ZERO_ERROR;
 384         copyObjects(that, ec);
 385         if (U_FAILURE(ec)) {
 386             resetPattern();
 387         }
 388     }
 389     return *this;
 390 }
 391
 392 UBool
 393 MessageFormat::operator==(const Format& rhs) const
 394 {
 395     if (this == &rhs) return TRUE;
 396
 397     MessageFormat& that = (MessageFormat&)rhs;
 398
 399     // Check class ID before checking MessageFormat members
 400     if (!Format::operator==(rhs) ||
 401         msgPattern != that.msgPattern ||
 402         fLocale != that.fLocale) {
 403         return FALSE;
 404     }
 405
 406     // Compare hashtables.
 407     if ((customFormatArgStarts == NULL) != (that.customFormatArgStarts == NULL)) {
 408         return FALSE;
 409     }
 410     if (customFormatArgStarts == NULL) {
 411         return TRUE;
 412     }
 413
 414     UErrorCode ec = U_ZERO_ERROR;
 415     const int32_t count = uhash_count(customFormatArgStarts);
 416     const int32_t rhs_count = uhash_count(that.customFormatArgStarts);
 417     if (count != rhs_count) {
 418         return FALSE;
 419     }
 420     int32_t idx = 0, rhs_idx = 0, pos = UHASH_FIRST, rhs_pos = UHASH_FIRST;
 421     for (; idx < count && rhs_idx < rhs_count && U_SUCCESS(ec); ++idx, ++rhs_idx) {
 422         const UHashElement* cur = uhash_nextElement(customFormatArgStarts, &pos);
 423         const UHashElement* rhs_cur = uhash_nextElement(that.customFormatArgStarts, &rhs_pos);
 424         if (cur->key.integer != rhs_cur->key.integer) {
 425             return FALSE;
 426         }
 427         const Format* format = (const Format*)uhash_iget(cachedFormatters, cur->key.integer);
 428         const Format* rhs_format = (const Format*)uhash_iget(that.cachedFormatters, rhs_cur->key.integer);
 429         if (*format != *rhs_format) {
 430             return FALSE;
 431         }
 432     }
 433     return TRUE;
 434 }
 435
 436 // -------------------------------------
 437 // Creates a copy of this MessageFormat, the caller owns the copy.
 438
 439 Format*
 440 MessageFormat::clone() const
 441 {
 442     return new MessageFormat(*this);
 443 }
 444
 445 // -------------------------------------
 446 // Sets the locale of this MessageFormat object to theLocale.
 447
 448 void
 449 MessageFormat::setLocale(const Locale& theLocale)
 450 {
 451     if (fLocale != theLocale) {
 452         delete defaultNumberFormat;
 453         defaultNumberFormat = NULL;
 454         delete defaultDateFormat;
 455         defaultDateFormat = NULL;
 456         fLocale = theLocale;
 457         setLocaleIDs(fLocale.getName(), fLocale.getName());
 458         pluralProvider.reset();
 459         ordinalProvider.reset();
 460     }
 461 }
 462
 463 // -------------------------------------
 464 // Gets the locale of this MessageFormat object.
 465
 466 const Locale&
 467 MessageFormat::getLocale() const
 468 {
 469     return fLocale;
 470 }
 471
 472 void
 473 MessageFormat::applyPattern(const UnicodeString& newPattern,
 474                             UErrorCode& status)
 475 {
 476     UParseError parseError;
 477     applyPattern(newPattern,parseError,status);
 478 }
 479
 480
 481 // -------------------------------------
 482 // Applies the new pattern and returns an error if the pattern
 483 // is not correct.
 484 void
 485 MessageFormat::applyPattern(const UnicodeString& pattern,
 486                             UParseError& parseError,
 487                             UErrorCode& ec)
 488 {
 489     if(U_FAILURE(ec)) {
 490         return;
 491     }
 492     msgPattern.parse(pattern, &parseError, ec);
 493     cacheExplicitFormats(ec);
 494
 495     if (U_FAILURE(ec)) {
 496         resetPattern();
 497     }
 498 }
 499
 500 void MessageFormat::resetPattern() {
 501     msgPattern.clear();
 502     uhash_close(cachedFormatters);
 503     cachedFormatters = NULL;
 504     uhash_close(customFormatArgStarts);
 505     customFormatArgStarts = NULL;
 506     argTypeCount = 0;
 507     hasArgTypeConflicts = FALSE;
 508 }
 509
 510 void
 511 MessageFormat::applyPattern(const UnicodeString& pattern,
 512                             UMessagePatternApostropheMode aposMode,
 513                             UParseError* parseError,
 514                             UErrorCode& status) {
 515     if (aposMode != msgPattern.getApostropheMode()) {
 516         msgPattern.clearPatternAndSetApostropheMode(aposMode);
 517     }
 518     applyPattern(pattern, *parseError, status);
 519 }
 520
 521 // -------------------------------------
 522 // Converts this MessageFormat instance to a pattern.
 523
 524 UnicodeString&
 525 MessageFormat::toPattern(UnicodeString& appendTo) const {
 526     if ((customFormatArgStarts != NULL && 0 != uhash_count(customFormatArgStarts)) ||
 527         0 == msgPattern.countParts()
 528     ) {
 529         appendTo.setToBogus();
 530         return appendTo;
 531     }
 532     return appendTo.append(msgPattern.getPatternString());
 533 }
 534
 535 int32_t MessageFormat::nextTopLevelArgStart(int32_t partIndex) const {
 536     if (partIndex != 0) {
 537         partIndex = msgPattern.getLimitPartIndex(partIndex);
 538     }
 539     for (;;) {
 540         UMessagePatternPartType type = msgPattern.getPartType(++partIndex);
 541         if (type == UMSGPAT_PART_TYPE_ARG_START) {
 542             return partIndex;
 543         }
 544         if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) {
 545             return -1;
 546         }
 547     }
 548 }
 549
 550 void MessageFormat::setArgStartFormat(int32_t argStart,
 551                                       Format* formatter,
 552                                       UErrorCode& status) {
 553     if (U_FAILURE(status)) {
 554         delete formatter;
 555         return;
 556     }
 557     if (cachedFormatters == NULL) {
 558         cachedFormatters=uhash_open(uhash_hashLong, uhash_compareLong,
 559                                     equalFormatsForHash, &status);
 560         if (U_FAILURE(status)) {
 561             delete formatter;
 562             return;
 563         }
 564         uhash_setValueDeleter(cachedFormatters, uprv_deleteUObject);
 565     }
 566     if (formatter == NULL) {
 567         formatter = new DummyFormat();
 568     }
 569     uhash_iput(cachedFormatters, argStart, formatter, &status);
 570 }
 571
 572
 573 UBool MessageFormat::argNameMatches(int32_t partIndex, const UnicodeString& argName, int32_t argNumber) {
 574     const MessagePattern::Part& part = msgPattern.getPart(partIndex);
 575     return part.getType() == UMSGPAT_PART_TYPE_ARG_NAME ?
 576         msgPattern.partSubstringMatches(part, argName) :
 577         part.getValue() == argNumber;  // ARG_NUMBER
 578 }
 579
 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.
 582 void MessageFormat::setCustomArgStartFormat(int32_t argStart,
 583                                             Format* formatter,
 584                                             UErrorCode& status) {
 585     setArgStartFormat(argStart, formatter, status);
 586     if (customFormatArgStarts == NULL) {
 587         customFormatArgStarts=uhash_open(uhash_hashLong, uhash_compareLong,
 588                                          NULL, &status);
 589     }
 590     uhash_iputi(customFormatArgStarts, argStart, 1, &status);
 591 }
 592
 593 Format* MessageFormat::getCachedFormatter(int32_t argumentNumber) const {
 594     if (cachedFormatters == NULL) {
 595         return NULL;
 596     }
 597     void* ptr = uhash_iget(cachedFormatters, argumentNumber);
 598     if (ptr != NULL && dynamic_cast<DummyFormat*>((Format*)ptr) == NULL) {
 599         return (Format*) ptr;
 600     } else {
 601         // Not cached, or a DummyFormat representing setFormat(NULL).
 602         return NULL;
 603     }
 604 }
 605
 606 // -------------------------------------
 607 // Adopts the new formats array and updates the array count.
 608 // This MessageFormat instance owns the new formats.
 609 void
 610 MessageFormat::adoptFormats(Format** newFormats,
 611                             int32_t count) {
 612     if (newFormats == NULL || count < 0) {
 613         return;
 614     }
 615     // Throw away any cached formatters.
 616     if (cachedFormatters != NULL) {
 617         uhash_removeAll(cachedFormatters);
 618     }
 619     if (customFormatArgStarts != NULL) {
 620         uhash_removeAll(customFormatArgStarts);
 621     }
 622
 623     int32_t formatNumber = 0;
 624     UErrorCode status = U_ZERO_ERROR;
 625     for (int32_t partIndex = 0;
 626         formatNumber < count && U_SUCCESS(status) &&
 627             (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
 628         setCustomArgStartFormat(partIndex, newFormats[formatNumber], status);
 629         ++formatNumber;
 630     }
 631     // Delete those that didn't get used (if any).
 632     for (; formatNumber < count; ++formatNumber) {
 633         delete newFormats[formatNumber];
 634     }
 635
 636 }
 637
 638 // -------------------------------------
 639 // Sets the new formats array and updates the array count.
 640 // This MessageFormat instance maks a copy of the new formats.
 641
 642 void
 643 MessageFormat::setFormats(const Format** newFormats,
 644                           int32_t count) {
 645     if (newFormats == NULL || count < 0) {
 646         return;
 647     }
 648     // Throw away any cached formatters.
 649     if (cachedFormatters != NULL) {
 650         uhash_removeAll(cachedFormatters);
 651     }
 652     if (customFormatArgStarts != NULL) {
 653         uhash_removeAll(customFormatArgStarts);
 654     }
 655
 656     UErrorCode status = U_ZERO_ERROR;
 657     int32_t formatNumber = 0;
 658     for (int32_t partIndex = 0;
 659         formatNumber < count && U_SUCCESS(status) && (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
 660       Format* newFormat = NULL;
 661       if (newFormats[formatNumber] != NULL) {
 662           newFormat = newFormats[formatNumber]->clone();
 663           if (newFormat == NULL) {
 664               status = U_MEMORY_ALLOCATION_ERROR;
 665           }
 666       }
 667       setCustomArgStartFormat(partIndex, newFormat, status);
 668       ++formatNumber;
 669     }
 670     if (U_FAILURE(status)) {
 671         resetPattern();
 672     }
 673 }
 674
 675 // -------------------------------------
 676 // Adopt a single format by format number.
 677 // Do nothing if the format number is not less than the array count.
 678
 679 void
 680 MessageFormat::adoptFormat(int32_t n, Format *newFormat) {
 681     LocalPointer<Format> p(newFormat);
 682     if (n >= 0) {
 683         int32_t formatNumber = 0;
 684         for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
 685             if (n == formatNumber) {
 686                 UErrorCode status = U_ZERO_ERROR;
 687                 setCustomArgStartFormat(partIndex, p.orphan(), status);
 688                 return;
 689             }
 690             ++formatNumber;
 691         }
 692     }
 693 }
 694
 695 // -------------------------------------
 696 // Adopt a single format by format name.
 697 // Do nothing if there is no match of formatName.
 698 void
 699 MessageFormat::adoptFormat(const UnicodeString& formatName,
 700                            Format* formatToAdopt,
 701                            UErrorCode& status) {
 702     LocalPointer<Format> p(formatToAdopt);
 703     if (U_FAILURE(status)) {
 704         return;
 705     }
 706     int32_t argNumber = MessagePattern::validateArgumentName(formatName);
 707     if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) {
 708         status = U_ILLEGAL_ARGUMENT_ERROR;
 709         return;
 710     }
 711     for (int32_t partIndex = 0;
 712         (partIndex = nextTopLevelArgStart(partIndex)) >= 0 && U_SUCCESS(status);
 713     ) {
 714         if (argNameMatches(partIndex + 1, formatName, argNumber)) {
 715             Format* f;
 716             if (p.isValid()) {
 717                 f = p.orphan();
 718             } else if (formatToAdopt == NULL) {
 719                 f = NULL;
 720             } else {
 721                 f = formatToAdopt->clone();
 722                 if (f == NULL) {
 723                     status = U_MEMORY_ALLOCATION_ERROR;
 724                     return;
 725                 }
 726             }
 727             setCustomArgStartFormat(partIndex, f, status);
 728         }
 729     }
 730 }
 731
 732 // -------------------------------------
 733 // Set a single format.
 734 // Do nothing if the variable is not less than the array count.
 735 void
 736 MessageFormat::setFormat(int32_t n, const Format& newFormat) {
 737
 738     if (n >= 0) {
 739         int32_t formatNumber = 0;
 740         for (int32_t partIndex = 0;
 741              (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
 742             if (n == formatNumber) {
 743                 Format* new_format = newFormat.clone();
 744                 if (new_format) {
 745                     UErrorCode status = U_ZERO_ERROR;
 746                     setCustomArgStartFormat(partIndex, new_format, status);
 747                 }
 748                 return;
 749             }
 750             ++formatNumber;
 751         }
 752     }
 753 }
 754
 755 // -------------------------------------
 756 // Get a single format by format name.
 757 // Do nothing if the variable is not less than the array count.
 758 Format *
 759 MessageFormat::getFormat(const UnicodeString& formatName, UErrorCode& status) {
 760     if (U_FAILURE(status) || cachedFormatters == NULL) return NULL;
 761
 762     int32_t argNumber = MessagePattern::validateArgumentName(formatName);
 763     if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) {
 764         status = U_ILLEGAL_ARGUMENT_ERROR;
 765         return NULL;
 766     }
 767     for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
 768         if (argNameMatches(partIndex + 1, formatName, argNumber)) {
 769             return getCachedFormatter(partIndex);
 770         }
 771     }
 772     return NULL;
 773 }
 774
 775 // -------------------------------------
 776 // Set a single format by format name
 777 // Do nothing if the variable is not less than the array count.
 778 void
 779 MessageFormat::setFormat(const UnicodeString& formatName,
 780                          const Format& newFormat,
 781                          UErrorCode& status) {
 782     if (U_FAILURE(status)) return;
 783
 784     int32_t argNumber = MessagePattern::validateArgumentName(formatName);
 785     if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) {
 786         status = U_ILLEGAL_ARGUMENT_ERROR;
 787         return;
 788     }
 789     for (int32_t partIndex = 0;
 790         (partIndex = nextTopLevelArgStart(partIndex)) >= 0 && U_SUCCESS(status);
 791     ) {
 792         if (argNameMatches(partIndex + 1, formatName, argNumber)) {
 793             Format* new_format = newFormat.clone();
 794             if (new_format == NULL) {
 795                 status = U_MEMORY_ALLOCATION_ERROR;
 796                 return;
 797             }
 798             setCustomArgStartFormat(partIndex, new_format, status);
 799         }
 800     }
 801 }
 802
 803 // -------------------------------------
 804 // Gets the format array.
 805 const Format**
 806 MessageFormat::getFormats(int32_t& cnt) const
 807 {
 808     // This old API returns an array (which we hold) of Format*
 809     // pointers.  The array is valid up to the next call to any
 810     // method on this object.  We construct and resize an array
 811     // on demand that contains aliases to the subformats[i].format
 812     // pointers.
 813     MessageFormat* t = const_cast<MessageFormat*> (this);
 814     cnt = 0;
 815     if (formatAliases == NULL) {
 816         t->formatAliasesCapacity = (argTypeCount<10) ? 10 : argTypeCount;
 817         Format** a = (Format**)
 818             uprv_malloc(sizeof(Format*) * formatAliasesCapacity);
 819         if (a == NULL) {
 820             t->formatAliasesCapacity = 0;
 821             return NULL;
 822         }
 823         t->formatAliases = a;
 824     } else if (argTypeCount > formatAliasesCapacity) {
 825         Format** a = (Format**)
 826             uprv_realloc(formatAliases, sizeof(Format*) * argTypeCount);
 827         if (a == NULL) {
 828             t->formatAliasesCapacity = 0;
 829             return NULL;
 830         }
 831         t->formatAliases = a;
 832         t->formatAliasesCapacity = argTypeCount;
 833     }
 834
 835     for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
 836         t->formatAliases[cnt++] = getCachedFormatter(partIndex);
 837     }
 838
 839     return (const Format**)formatAliases;
 840 }
 841
 842
 843 UnicodeString MessageFormat::getArgName(int32_t partIndex) {
 844     const MessagePattern::Part& part = msgPattern.getPart(partIndex);
 845     return msgPattern.getSubstring(part);
 846 }
 847
 848 StringEnumeration*
 849 MessageFormat::getFormatNames(UErrorCode& status) {
 850     if (U_FAILURE(status))  return NULL;
 851
 852     UVector *fFormatNames = new UVector(status);
 853     if (U_FAILURE(status)) {
 854         status = U_MEMORY_ALLOCATION_ERROR;
 855         return NULL;
 856     }
 857     fFormatNames->setDeleter(uprv_deleteUObject);
 858
 859     for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) {
 860         fFormatNames->addElement(new UnicodeString(getArgName(partIndex + 1)), status);
 861     }
 862
 863     StringEnumeration* nameEnumerator = new FormatNameEnumeration(fFormatNames, status);
 864     return nameEnumerator;
 865 }
 866
 867 // -------------------------------------
 868 // Formats the source Formattable array and copy into the result buffer.
 869 // Ignore the FieldPosition result for error checking.
 870
 871 UnicodeString&
 872 MessageFormat::format(const Formattable* source,
 873                       int32_t cnt,
 874                       UnicodeString& appendTo,
 875                       FieldPosition& ignore,
 876                       UErrorCode& success) const
 877 {
 878     return format(source, NULL, cnt, appendTo, &ignore, success);
 879 }
 880
 881 // -------------------------------------
 882 // Internally creates a MessageFormat instance based on the
 883 // pattern and formats the arguments Formattable array and
 884 // copy into the appendTo buffer.
 885
 886 UnicodeString&
 887 MessageFormat::format(  const UnicodeString& pattern,
 888                         const Formattable* arguments,
 889                         int32_t cnt,
 890                         UnicodeString& appendTo,
 891                         UErrorCode& success)
 892 {
 893     MessageFormat temp(pattern, success);
 894     return temp.format(arguments, NULL, cnt, appendTo, NULL, success);
 895 }
 896
 897 // -------------------------------------
 898 // Formats the source Formattable object and copy into the
 899 // appendTo buffer.  The Formattable object must be an array
 900 // of Formattable instances, returns error otherwise.
 901
 902 UnicodeString&
 903 MessageFormat::format(const Formattable& source,
 904                       UnicodeString& appendTo,
 905                       FieldPosition& ignore,
 906                       UErrorCode& success) const
 907 {
 908     if (U_FAILURE(success))
 909         return appendTo;
 910     if (source.getType() != Formattable::kArray) {
 911         success = U_ILLEGAL_ARGUMENT_ERROR;
 912         return appendTo;
 913     }
 914     int32_t cnt;
 915     const Formattable* tmpPtr = source.getArray(cnt);
 916     return format(tmpPtr, NULL, cnt, appendTo, &ignore, success);
 917 }
 918
 919 UnicodeString&
 920 MessageFormat::format(const UnicodeString* argumentNames,
 921                       const Formattable* arguments,
 922                       int32_t count,
 923                       UnicodeString& appendTo,
 924                       UErrorCode& success) const {
 925     return format(arguments, argumentNames, count, appendTo, NULL, success);
 926 }
 927
 928 // Does linear search to find the match for an ArgName.
 929 const Formattable* MessageFormat::getArgFromListByName(const Formattable* arguments,
 930                                                        const UnicodeString *argumentNames,
 931                                                        int32_t cnt, UnicodeString& name) const {
 932     for (int32_t i = 0; i < cnt; ++i) {
 933         if (0 == argumentNames[i].compare(name)) {
 934             return arguments + i;
 935         }
 936     }
 937     return NULL;
 938 }
 939
 940
 941 UnicodeString&
 942 MessageFormat::format(const Formattable* arguments,
 943                       const UnicodeString *argumentNames,
 944                       int32_t cnt,
 945                       UnicodeString& appendTo,
 946                       FieldPosition* pos,
 947                       UErrorCode& status) const {
 948     if (U_FAILURE(status)) {
 949         return appendTo;
 950     }
 951
 952     UnicodeStringAppendable usapp(appendTo);
 953     AppendableWrapper app(usapp);
 954     format(0, NULL, arguments, argumentNames, cnt, app, pos, status);
 955     return appendTo;
 956 }
 957
 958 namespace {
 959
 960 /**
 961  * Mutable input/output values for the PluralSelectorProvider.
 962  * Separate so that it is possible to make MessageFormat Freezable.
 963  */
 964 class PluralSelectorContext {
 965 public:
 966     PluralSelectorContext(int32_t start, const UnicodeString &name,
 967                           const Formattable &num, double off, UErrorCode &errorCode)
 968             : startIndex(start), argName(name), offset(off),
 969               numberArgIndex(-1), formatter(NULL), forReplaceNumber(FALSE) {
 970         // number needs to be set even when select() is not called.
 971         // Keep it as a Number/Formattable:
 972         // For format() methods, and to preserve information (e.g., BigDecimal).
 973         if(off == 0) {
 974             number = num;
 975         } else {
 976             number = num.getDouble(errorCode) - off;
 977         }
 978     }
 979
 980     // Input values for plural selection with decimals.
 981     int32_t startIndex;
 982     const UnicodeString &argName;
 983     /** argument number - plural offset */
 984     Formattable number;
 985     double offset;
 986     // Output values for plural selection with decimals.
 987     /** -1 if REPLACE_NUMBER, 0 arg not found, >0 ARG_START index */
 988     int32_t numberArgIndex;
 989     const Format *formatter;
 990     /** formatted argument number - plural offset */
 991     UnicodeString numberString;
 992     /** TRUE if number-offset was formatted with the stock number formatter */
 993     UBool forReplaceNumber;
 994 };
 995
 996 }  // namespace
 997
 998 // if argumentNames is NULL, this means arguments is a numeric array.
 999 // arguments can not be NULL.
1000 // We use const void *plNumber rather than const PluralSelectorContext *pluralNumber
1001 // so that we need not declare the PluralSelectorContext in the public header file.
1002 void MessageFormat::format(int32_t msgStart, const void *plNumber,
1003                            const Formattable* arguments,
1004                            const UnicodeString *argumentNames,
1005                            int32_t cnt,
1006                            AppendableWrapper& appendTo,
1007                            FieldPosition* ignore,
1008                            UErrorCode& success) const {
1009     if (U_FAILURE(success)) {
1010         return;
1011     }
1012
1013     const UnicodeString& msgString = msgPattern.getPatternString();
1014     int32_t prevIndex = msgPattern.getPart(msgStart).getLimit();
1015     for (int32_t i = msgStart + 1; U_SUCCESS(success) ; ++i) {
1016         const MessagePattern::Part* part = &msgPattern.getPart(i);
1017         const UMessagePatternPartType type = part->getType();
1018         int32_t index = part->getIndex();
1019         appendTo.append(msgString, prevIndex, index - prevIndex);
1020         if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) {
1021             return;
1022         }
1023         prevIndex = part->getLimit();
1024         if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) {
1025             const PluralSelectorContext &pluralNumber =
1026                 *static_cast<const PluralSelectorContext *>(plNumber);
1027             if(pluralNumber.forReplaceNumber) {
1028                 // number-offset was already formatted.
1029                 appendTo.formatAndAppend(pluralNumber.formatter,
1030                         pluralNumber.number, pluralNumber.numberString, success);
1031             } else {
1032                 const NumberFormat* nf = getDefaultNumberFormat(success);
1033                 appendTo.formatAndAppend(nf, pluralNumber.number, success);
1034             }
1035             continue;
1036         }
1037         if (type != UMSGPAT_PART_TYPE_ARG_START) {
1038             continue;
1039         }
1040         int32_t argLimit = msgPattern.getLimitPartIndex(i);
1041         UMessagePatternArgType argType = part->getArgType();
1042         part = &msgPattern.getPart(++i);
1043         const Formattable* arg;
1044         UBool noArg = FALSE;
1045         UnicodeString argName = msgPattern.getSubstring(*part);
1046         if (argumentNames == NULL) {
1047             int32_t argNumber = part->getValue();  // ARG_NUMBER
1048             if (0 <= argNumber && argNumber < cnt) {
1049                 arg = arguments + argNumber;
1050             } else {
1051                 arg = NULL;
1052                 noArg = TRUE;
1053             }
1054         } else {
1055             arg = getArgFromListByName(arguments, argumentNames, cnt, argName);
1056             if (arg == NULL) {
1057                 noArg = TRUE;
1058             }
1059         }
1060         ++i;
1061         int32_t prevDestLength = appendTo.length();
1062         const Format* formatter = NULL;
1063         if (noArg) {
1064             appendTo.append(
1065                 UnicodeString(LEFT_CURLY_BRACE).append(argName).append(RIGHT_CURLY_BRACE));
1066         } else if (arg == NULL) {
1067             appendTo.append(NULL_STRING, 4);
1068         } else if(plNumber!=NULL &&
1069                 static_cast<const PluralSelectorContext *>(plNumber)->numberArgIndex==(i-2)) {
1070             const PluralSelectorContext &pluralNumber =
1071                 *static_cast<const PluralSelectorContext *>(plNumber);
1072             if(pluralNumber.offset == 0) {
1073                 // The number was already formatted with this formatter.
1074                 appendTo.formatAndAppend(pluralNumber.formatter, pluralNumber.number,
1075                                          pluralNumber.numberString, success);
1076             } else {
1077                 // Do not use the formatted (number-offset) string for a named argument
1078                 // that formats the number without subtracting the offset.
1079                 appendTo.formatAndAppend(pluralNumber.formatter, *arg, success);
1080             }
1081         } else if ((formatter = getCachedFormatter(i -2))) {
1082             // Handles all ArgType.SIMPLE, and formatters from setFormat() and its siblings.
1083             if (dynamic_cast<const ChoiceFormat*>(formatter) ||
1084                 dynamic_cast<const PluralFormat*>(formatter) ||
1085                 dynamic_cast<const SelectFormat*>(formatter)) {
1086                 // We only handle nested formats here if they were provided via
1087                 // setFormat() or its siblings. Otherwise they are not cached and instead
1088                 // handled below according to argType.
1089                 UnicodeString subMsgString;
1090                 formatter->format(*arg, subMsgString, success);
1091                 if (subMsgString.indexOf(LEFT_CURLY_BRACE) >= 0 ||
1092                     (subMsgString.indexOf(SINGLE_QUOTE) >= 0 && !MessageImpl::jdkAposMode(msgPattern))
1093                 ) {
1094                     MessageFormat subMsgFormat(subMsgString, fLocale, success);
1095                     subMsgFormat.format(0, NULL, arguments, argumentNames, cnt, appendTo, ignore, success);
1096                 } else {
1097                     appendTo.append(subMsgString);
1098                 }
1099             } else {
1100                 appendTo.formatAndAppend(formatter, *arg, success);
1101             }
1102         } else if (argType == UMSGPAT_ARG_TYPE_NONE || (cachedFormatters && uhash_iget(cachedFormatters, i - 2))) {
1103             // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table.
1104             // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check
1105             // for the hash table containind DummyFormat.
1106             if (arg->isNumeric()) {
1107                 const NumberFormat* nf = getDefaultNumberFormat(success);
1108                 appendTo.formatAndAppend(nf, *arg, success);
1109             } else if (arg->getType() == Formattable::kDate) {
1110                 const DateFormat* df = getDefaultDateFormat(success);
1111                 appendTo.formatAndAppend(df, *arg, success);
1112             } else {
1113                 appendTo.append(arg->getString(success));
1114             }
1115         } else if (argType == UMSGPAT_ARG_TYPE_CHOICE) {
1116             if (!arg->isNumeric()) {
1117                 success = U_ILLEGAL_ARGUMENT_ERROR;
1118                 return;
1119             }
1120             // We must use the Formattable::getDouble() variant with the UErrorCode parameter
1121             // because only this one converts non-double numeric types to double.
1122             const double number = arg->getDouble(success);
1123             int32_t subMsgStart = ChoiceFormat::findSubMessage(msgPattern, i, number);
1124             formatComplexSubMessage(subMsgStart, NULL, arguments, argumentNames,
1125                                     cnt, appendTo, success);
1126         } else if (UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType)) {
1127             if (!arg->isNumeric()) {
1128                 success = U_ILLEGAL_ARGUMENT_ERROR;
1129                 return;
1130             }
1131             const PluralSelectorProvider &selector =
1132                 argType == UMSGPAT_ARG_TYPE_PLURAL ? pluralProvider : ordinalProvider;
1133             // We must use the Formattable::getDouble() variant with the UErrorCode parameter
1134             // because only this one converts non-double numeric types to double.
1135             double offset = msgPattern.getPluralOffset(i);
1136             PluralSelectorContext context(i, argName, *arg, offset, success);
1137             int32_t subMsgStart = PluralFormat::findSubMessage(
1138                     msgPattern, i, selector, &context, arg->getDouble(success), success);
1139             formatComplexSubMessage(subMsgStart, &context, arguments, argumentNames,
1140                                     cnt, appendTo, success);
1141         } else if (argType == UMSGPAT_ARG_TYPE_SELECT) {
1142             int32_t subMsgStart = SelectFormat::findSubMessage(msgPattern, i, arg->getString(success), success);
1143             formatComplexSubMessage(subMsgStart, NULL, arguments, argumentNames,
1144                                     cnt, appendTo, success);
1145         } else {
1146             // This should never happen.
1147             success = U_INTERNAL_PROGRAM_ERROR;
1148             return;
1149         }
1150         ignore = updateMetaData(appendTo, prevDestLength, ignore, arg);
1151         prevIndex = msgPattern.getPart(argLimit).getLimit();
1152         i = argLimit;
1153     }
1154 }
1155
1156
1157 void MessageFormat::formatComplexSubMessage(int32_t msgStart,
1158                                             const void *plNumber,
1159                                             const Formattable* arguments,
1160                                             const UnicodeString *argumentNames,
1161                                             int32_t cnt,
1162                                             AppendableWrapper& appendTo,
1163                                             UErrorCode& success) const {
1164     if (U_FAILURE(success)) {
1165         return;
1166     }
1167
1168     if (!MessageImpl::jdkAposMode(msgPattern)) {
1169         format(msgStart, plNumber, arguments, argumentNames, cnt, appendTo, NULL, success);
1170         return;
1171     }
1172
1173     // JDK compatibility mode: (see JDK MessageFormat.format() API docs)
1174     // - remove SKIP_SYNTAX; that is, remove half of the apostrophes
1175     // - if the result string contains an open curly brace '{' then
1176     //   instantiate a temporary MessageFormat object and format again;
1177     //   otherwise just append the result string
1178     const UnicodeString& msgString = msgPattern.getPatternString();
1179     UnicodeString sb;
1180     int32_t prevIndex = msgPattern.getPart(msgStart).getLimit();
1181     for (int32_t i = msgStart;;) {
1182         const MessagePattern::Part& part = msgPattern.getPart(++i);
1183         const UMessagePatternPartType type = part.getType();
1184         int32_t index = part.getIndex();
1185         if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) {
1186             sb.append(msgString, prevIndex, index - prevIndex);
1187             break;
1188         } else if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER || type == UMSGPAT_PART_TYPE_SKIP_SYNTAX) {
1189             sb.append(msgString, prevIndex, index - prevIndex);
1190             if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) {
1191                 const PluralSelectorContext &pluralNumber =
1192                     *static_cast<const PluralSelectorContext *>(plNumber);
1193                 if(pluralNumber.forReplaceNumber) {
1194                     // number-offset was already formatted.
1195                     sb.append(pluralNumber.numberString);
1196                 } else {
1197                     const NumberFormat* nf = getDefaultNumberFormat(success);
1198                     sb.append(nf->format(pluralNumber.number, sb, success));
1199                 }
1200             }
1201             prevIndex = part.getLimit();
1202         } else if (type == UMSGPAT_PART_TYPE_ARG_START) {
1203             sb.append(msgString, prevIndex, index - prevIndex);
1204             prevIndex = index;
1205             i = msgPattern.getLimitPartIndex(i);
1206             index = msgPattern.getPart(i).getLimit();
1207             MessageImpl::appendReducedApostrophes(msgString, prevIndex, index, sb);
1208             prevIndex = index;
1209         }
1210     }
1211     if (sb.indexOf(LEFT_CURLY_BRACE) >= 0) {
1212         UnicodeString emptyPattern;  // gcc 3.3.3 fails with "UnicodeString()" as the first parameter.
1213         MessageFormat subMsgFormat(emptyPattern, fLocale, success);
1214         subMsgFormat.applyPattern(sb, UMSGPAT_APOS_DOUBLE_REQUIRED, NULL, success);
1215         subMsgFormat.format(0, NULL, arguments, argumentNames, cnt, appendTo, NULL, success);
1216     } else {
1217         appendTo.append(sb);
1218     }
1219 }
1220
1221
1222 UnicodeString MessageFormat::getLiteralStringUntilNextArgument(int32_t from) const {
1223     const UnicodeString& msgString=msgPattern.getPatternString();
1224     int32_t prevIndex=msgPattern.getPart(from).getLimit();
1225     UnicodeString b;
1226     for (int32_t i = from + 1; ; ++i) {
1227         const MessagePattern::Part& part = msgPattern.getPart(i);
1228         const UMessagePatternPartType type=part.getType();
1229         int32_t index=part.getIndex();
1230         b.append(msgString, prevIndex, index - prevIndex);
1231         if(type==UMSGPAT_PART_TYPE_ARG_START || type==UMSGPAT_PART_TYPE_MSG_LIMIT) {
1232             return b;
1233         }
1234         // Unexpected Part "part" in parsed message.
1235         U_ASSERT(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX || type==UMSGPAT_PART_TYPE_INSERT_CHAR);
1236         prevIndex=part.getLimit();
1237     }
1238 }
1239
1240
1241 FieldPosition* MessageFormat::updateMetaData(AppendableWrapper& /*dest*/, int32_t /*prevLength*/,
1242                              FieldPosition* /*fp*/, const Formattable* /*argId*/) const {
1243     // Unlike in Java, there are no field attributes defined for MessageFormat. Do nothing.
1244     return NULL;
1245     /*
1246       if (fp != NULL && Field.ARGUMENT.equals(fp.getFieldAttribute())) {
1247           fp->setBeginIndex(prevLength);
1248           fp->setEndIndex(dest.get_length());
1249           return NULL;
1250       }
1251       return fp;
1252     */
1253 }
1254
1255 int32_t
1256 MessageFormat::findOtherSubMessage(int32_t partIndex) const {
1257     int32_t count=msgPattern.countParts();
1258     const MessagePattern::Part *part = &msgPattern.getPart(partIndex);
1259     if(MessagePattern::Part::hasNumericValue(part->getType())) {
1260         ++partIndex;
1261     }
1262     // Iterate over (ARG_SELECTOR [ARG_INT|ARG_DOUBLE] message) tuples
1263     // until ARG_LIMIT or end of plural-only pattern.
1264     UnicodeString other(FALSE, OTHER_STRING, 5);
1265     do {
1266         part=&msgPattern.getPart(partIndex++);
1267         UMessagePatternPartType type=part->getType();
1268         if(type==UMSGPAT_PART_TYPE_ARG_LIMIT) {
1269             break;
1270         }
1271         U_ASSERT(type==UMSGPAT_PART_TYPE_ARG_SELECTOR);
1272         // part is an ARG_SELECTOR followed by an optional explicit value, and then a message
1273         if(msgPattern.partSubstringMatches(*part, other)) {
1274             return partIndex;
1275         }
1276         if(MessagePattern::Part::hasNumericValue(msgPattern.getPartType(partIndex))) {
1277             ++partIndex;  // skip the numeric-value part of "=1" etc.
1278         }
1279         partIndex=msgPattern.getLimitPartIndex(partIndex);
1280     } while(++partIndex<count);
1281     return 0;
1282 }
1283
1284 int32_t
1285 MessageFormat::findFirstPluralNumberArg(int32_t msgStart, const UnicodeString &argName) const {
1286     for(int32_t i=msgStart+1;; ++i) {
1287         const MessagePattern::Part &part=msgPattern.getPart(i);
1288         UMessagePatternPartType type=part.getType();
1289         if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) {
1290             return 0;
1291         }
1292         if(type==UMSGPAT_PART_TYPE_REPLACE_NUMBER) {
1293             return -1;
1294         }
1295         if(type==UMSGPAT_PART_TYPE_ARG_START) {
1296             UMessagePatternArgType argType=part.getArgType();
1297             if(!argName.isEmpty() && (argType==UMSGPAT_ARG_TYPE_NONE || argType==UMSGPAT_ARG_TYPE_SIMPLE)) {
1298                 // ARG_NUMBER or ARG_NAME
1299                 if(msgPattern.partSubstringMatches(msgPattern.getPart(i+1), argName)) {
1300                     return i;
1301                 }
1302             }
1303             i=msgPattern.getLimitPartIndex(i);
1304         }
1305     }
1306 }
1307
1308 void MessageFormat::copyObjects(const MessageFormat& that, UErrorCode& ec) {
1309     // Deep copy pointer fields.
1310     // We need not copy the formatAliases because they are re-filled
1311     // in each getFormats() call.
1312     // The defaultNumberFormat, defaultDateFormat and pluralProvider.rules
1313     // also get created on demand.
1314     argTypeCount = that.argTypeCount;
1315     if (argTypeCount > 0) {
1316         if (!allocateArgTypes(argTypeCount, ec)) {
1317             return;
1318         }
1319         uprv_memcpy(argTypes, that.argTypes, argTypeCount * sizeof(argTypes[0]));
1320     }
1321     if (cachedFormatters != NULL) {
1322         uhash_removeAll(cachedFormatters);
1323     }
1324     if (customFormatArgStarts != NULL) {
1325         uhash_removeAll(customFormatArgStarts);
1326     }
1327     if (that.cachedFormatters) {
1328         if (cachedFormatters == NULL) {
1329             cachedFormatters=uhash_open(uhash_hashLong, uhash_compareLong,
1330                                         equalFormatsForHash, &ec);
1331             if (U_FAILURE(ec)) {
1332                 return;
1333             }
1334             uhash_setValueDeleter(cachedFormatters, uprv_deleteUObject);
1335         }
1336
1337         const int32_t count = uhash_count(that.cachedFormatters);
1338         int32_t pos, idx;
1339         for (idx = 0, pos = UHASH_FIRST; idx < count && U_SUCCESS(ec); ++idx) {
1340             const UHashElement* cur = uhash_nextElement(that.cachedFormatters, &pos);
1341             Format* newFormat = ((Format*)(cur->value.pointer))->clone();
1342             if (newFormat) {
1343                 uhash_iput(cachedFormatters, cur->key.integer, newFormat, &ec);
1344             } else {
1345                 ec = U_MEMORY_ALLOCATION_ERROR;
1346                 return;
1347             }
1348         }
1349     }
1350     if (that.customFormatArgStarts) {
1351         if (customFormatArgStarts == NULL) {
1352             customFormatArgStarts=uhash_open(uhash_hashLong, uhash_compareLong,
1353                                               NULL, &ec);
1354         }
1355         const int32_t count = uhash_count(that.customFormatArgStarts);
1356         int32_t pos, idx;
1357         for (idx = 0, pos = UHASH_FIRST; idx < count && U_SUCCESS(ec); ++idx) {
1358             const UHashElement* cur = uhash_nextElement(that.customFormatArgStarts, &pos);
1359             uhash_iputi(customFormatArgStarts, cur->key.integer, cur->value.integer, &ec);
1360         }
1361     }
1362 }
1363
1364
1365 Formattable*
1366 MessageFormat::parse(int32_t msgStart,
1367                      const UnicodeString& source,
1368                      ParsePosition& pos,
1369                      int32_t& count,
1370                      UErrorCode& ec) const {
1371     count = 0;
1372     if (U_FAILURE(ec)) {
1373         pos.setErrorIndex(pos.getIndex());
1374         return NULL;
1375     }
1376     // parse() does not work with named arguments.
1377     if (msgPattern.hasNamedArguments()) {
1378         ec = U_ARGUMENT_TYPE_MISMATCH;
1379         pos.setErrorIndex(pos.getIndex());
1380         return NULL;
1381     }
1382     LocalArray<Formattable> resultArray(new Formattable[argTypeCount ? argTypeCount : 1]);
1383     const UnicodeString& msgString=msgPattern.getPatternString();
1384     int32_t prevIndex=msgPattern.getPart(msgStart).getLimit();
1385     int32_t sourceOffset = pos.getIndex();
1386     ParsePosition tempStatus(0);
1387
1388     for(int32_t i=msgStart+1; ; ++i) {
1389         UBool haveArgResult = FALSE;
1390         const MessagePattern::Part* part=&msgPattern.getPart(i);
1391         const UMessagePatternPartType type=part->getType();
1392         int32_t index=part->getIndex();
1393         // Make sure the literal string matches.
1394         int32_t len = index - prevIndex;
1395         if (len == 0 || (0 == msgString.compare(prevIndex, len, source, sourceOffset, len))) {
1396             sourceOffset += len;
1397             prevIndex += len;
1398         } else {
1399             pos.setErrorIndex(sourceOffset);
1400             return NULL; // leave index as is to signal error
1401         }
1402         if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) {
1403             // Things went well! Done.
1404             pos.setIndex(sourceOffset);
1405             return resultArray.orphan();
1406         }
1407         if(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX || type==UMSGPAT_PART_TYPE_INSERT_CHAR) {
1408             prevIndex=part->getLimit();
1409             continue;
1410         }
1411         // We do not support parsing Plural formats. (No REPLACE_NUMBER here.)
1412         // Unexpected Part "part" in parsed message.
1413         U_ASSERT(type==UMSGPAT_PART_TYPE_ARG_START);
1414         int32_t argLimit=msgPattern.getLimitPartIndex(i);
1415
1416         UMessagePatternArgType argType=part->getArgType();
1417         part=&msgPattern.getPart(++i);
1418         int32_t argNumber = part->getValue();  // ARG_NUMBER
1419         UnicodeString key;
1420         ++i;
1421         const Format* formatter = NULL;
1422         Formattable& argResult = resultArray[argNumber];
1423
1424         if(cachedFormatters!=NULL && (formatter = getCachedFormatter(i - 2))!=NULL) {
1425             // Just parse using the formatter.
1426             tempStatus.setIndex(sourceOffset);
1427             formatter->parseObject(source, argResult, tempStatus);
1428             if (tempStatus.getIndex() == sourceOffset) {
1429                 pos.setErrorIndex(sourceOffset);
1430                 return NULL; // leave index as is to signal error
1431             }
1432             sourceOffset = tempStatus.getIndex();
1433             haveArgResult = TRUE;
1434         } else if(
1435             argType==UMSGPAT_ARG_TYPE_NONE || (cachedFormatters && uhash_iget(cachedFormatters, i -2))) {
1436             // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table.
1437             // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check
1438             // for the hash table containind DummyFormat.
1439
1440             // Match as a string.
1441             // if at end, use longest possible match
1442             // otherwise uses first match to intervening string
1443             // does NOT recursively try all possibilities
1444             UnicodeString stringAfterArgument = getLiteralStringUntilNextArgument(argLimit);
1445             int32_t next;
1446             if (!stringAfterArgument.isEmpty()) {
1447                 next = source.indexOf(stringAfterArgument, sourceOffset);
1448             } else {
1449                 next = source.length();
1450             }
1451             if (next < 0) {
1452                 pos.setErrorIndex(sourceOffset);
1453                 return NULL; // leave index as is to signal error
1454             } else {
1455                 UnicodeString strValue(source.tempSubString(sourceOffset, next - sourceOffset));
1456                 UnicodeString compValue;
1457                 compValue.append(LEFT_CURLY_BRACE);
1458                 itos(argNumber, compValue);
1459                 compValue.append(RIGHT_CURLY_BRACE);
1460                 if (0 != strValue.compare(compValue)) {
1461                     argResult.setString(strValue);
1462                     haveArgResult = TRUE;
1463                 }
1464                 sourceOffset = next;
1465             }
1466         } else if(argType==UMSGPAT_ARG_TYPE_CHOICE) {
1467             tempStatus.setIndex(sourceOffset);
1468             double choiceResult = ChoiceFormat::parseArgument(msgPattern, i, source, tempStatus);
1469             if (tempStatus.getIndex() == sourceOffset) {
1470                 pos.setErrorIndex(sourceOffset);
1471                 return NULL; // leave index as is to signal error
1472             }
1473             argResult.setDouble(choiceResult);
1474             haveArgResult = TRUE;
1475             sourceOffset = tempStatus.getIndex();
1476         } else if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) || argType==UMSGPAT_ARG_TYPE_SELECT) {
1477             // Parsing not supported.
1478             ec = U_UNSUPPORTED_ERROR;
1479             return NULL;
1480         } else {
1481             // This should never happen.
1482             ec = U_INTERNAL_PROGRAM_ERROR;
1483             return NULL;
1484         }
1485         if (haveArgResult && count <= argNumber) {
1486             count = argNumber + 1;
1487         }
1488         prevIndex=msgPattern.getPart(argLimit).getLimit();
1489         i=argLimit;
1490     }
1491 }
1492 // -------------------------------------
1493 // Parses the source pattern and returns the Formattable objects array,
1494 // the array count and the ending parse position.  The caller of this method
1495 // owns the array.
1496
1497 Formattable*
1498 MessageFormat::parse(const UnicodeString& source,
1499                      ParsePosition& pos,
1500                      int32_t& count) const {
1501     UErrorCode ec = U_ZERO_ERROR;
1502     return parse(0, source, pos, count, ec);
1503 }
1504
1505 // -------------------------------------
1506 // Parses the source string and returns the array of
1507 // Formattable objects and the array count.  The caller
1508 // owns the returned array.
1509
1510 Formattable*
1511 MessageFormat::parse(const UnicodeString& source,
1512                      int32_t& cnt,
1513                      UErrorCode& success) const
1514 {
1515     if (msgPattern.hasNamedArguments()) {
1516         success = U_ARGUMENT_TYPE_MISMATCH;
1517         return NULL;
1518     }
1519     ParsePosition status(0);
1520     // Calls the actual implementation method and starts
1521     // from zero offset of the source text.
1522     Formattable* result = parse(source, status, cnt);
1523     if (status.getIndex() == 0) {
1524         success = U_MESSAGE_PARSE_ERROR;
1525         delete[] result;
1526         return NULL;
1527     }
1528     return result;
1529 }
1530
1531 // -------------------------------------
1532 // Parses the source text and copy into the result buffer.
1533
1534 void
1535 MessageFormat::parseObject( const UnicodeString& source,
1536                             Formattable& result,
1537                             ParsePosition& status) const
1538 {
1539     int32_t cnt = 0;
1540     Formattable* tmpResult = parse(source, status, cnt);
1541     if (tmpResult != NULL)
1542         result.adoptArray(tmpResult, cnt);
1543 }
1544
1545 UnicodeString
1546 MessageFormat::autoQuoteApostrophe(const UnicodeString& pattern, UErrorCode& status) {
1547     UnicodeString result;
1548     if (U_SUCCESS(status)) {
1549         int32_t plen = pattern.length();
1550         const UChar* pat = pattern.getBuffer();
1551         int32_t blen = plen * 2 + 1; // space for null termination, convenience
1552         UChar* buf = result.getBuffer(blen);
1553         if (buf == NULL) {
1554             status = U_MEMORY_ALLOCATION_ERROR;
1555         } else {
1556             int32_t len = umsg_autoQuoteApostrophe(pat, plen, buf, blen, &status);
1557             result.releaseBuffer(U_SUCCESS(status) ? len : 0);
1558         }
1559     }
1560     if (U_FAILURE(status)) {
1561         result.setToBogus();
1562     }
1563     return result;
1564 }
1565
1566 // -------------------------------------
1567
1568 static Format* makeRBNF(URBNFRuleSetTag tag, const Locale& locale, const UnicodeString& defaultRuleSet, UErrorCode& ec) {
1569     RuleBasedNumberFormat* fmt = new RuleBasedNumberFormat(tag, locale, ec);
1570     if (fmt == NULL) {
1571         ec = U_MEMORY_ALLOCATION_ERROR;
1572     } else if (U_SUCCESS(ec) && defaultRuleSet.length() > 0) {
1573         UErrorCode localStatus = U_ZERO_ERROR; // ignore unrecognized default rule set
1574         fmt->setDefaultRuleSet(defaultRuleSet, localStatus);
1575     }
1576     return fmt;
1577 }
1578
1579 void MessageFormat::cacheExplicitFormats(UErrorCode& status) {
1580     if (U_FAILURE(status)) {
1581         return;
1582     }
1583
1584     if (cachedFormatters != NULL) {
1585         uhash_removeAll(cachedFormatters);
1586     }
1587     if (customFormatArgStarts != NULL) {
1588         uhash_removeAll(customFormatArgStarts);
1589     }
1590
1591     // The last two "parts" can at most be ARG_LIMIT and MSG_LIMIT
1592     // which we need not examine.
1593     int32_t limit = msgPattern.countParts() - 2;
1594     argTypeCount = 0;
1595     // We also need not look at the first two "parts"
1596     // (at most MSG_START and ARG_START) in this loop.
1597     // We determine the argTypeCount first so that we can allocateArgTypes
1598     // so that the next loop can set argTypes[argNumber].
1599     // (This is for the C API which needs the argTypes to read its va_arg list.)
1600     for (int32_t i = 2; i < limit && U_SUCCESS(status); ++i) {
1601         const MessagePattern::Part& part = msgPattern.getPart(i);
1602         if (part.getType() == UMSGPAT_PART_TYPE_ARG_NUMBER) {
1603             const int argNumber = part.getValue();
1604             if (argNumber >= argTypeCount) {
1605                 argTypeCount = argNumber + 1;
1606             }
1607         }
1608     }
1609     if (!allocateArgTypes(argTypeCount, status)) {
1610         return;
1611     }
1612     // Set all argTypes to kObject, as a "none" value, for lack of any better value.
1613     // We never use kObject for real arguments.
1614     // We use it as "no argument yet" for the check for hasArgTypeConflicts.
1615     for (int32_t i = 0; i < argTypeCount; ++i) {
1616         argTypes[i] = Formattable::kObject;
1617     }
1618     hasArgTypeConflicts = FALSE;
1619
1620     // This loop starts at part index 1 because we do need to examine
1621     // ARG_START parts. (But we can ignore the MSG_START.)
1622     for (int32_t i = 1; i < limit && U_SUCCESS(status); ++i) {
1623         const MessagePattern::Part* part = &msgPattern.getPart(i);
1624         if (part->getType() != UMSGPAT_PART_TYPE_ARG_START) {
1625             continue;
1626         }
1627         UMessagePatternArgType argType = part->getArgType();
1628
1629         int32_t argNumber = -1;
1630         part = &msgPattern.getPart(i + 1);
1631         if (part->getType() == UMSGPAT_PART_TYPE_ARG_NUMBER) {
1632             argNumber = part->getValue();
1633         }
1634         Formattable::Type formattableType;
1635
1636         switch (argType) {
1637         case UMSGPAT_ARG_TYPE_NONE:
1638             formattableType = Formattable::kString;
1639             break;
1640         case UMSGPAT_ARG_TYPE_SIMPLE: {
1641             int32_t index = i;
1642             i += 2;
1643             UnicodeString explicitType = msgPattern.getSubstring(msgPattern.getPart(i++));
1644             UnicodeString style;
1645             if ((part = &msgPattern.getPart(i))->getType() == UMSGPAT_PART_TYPE_ARG_STYLE) {
1646                 style = msgPattern.getSubstring(*part);
1647                 ++i;
1648             }
1649             UParseError parseError;
1650             Format* formatter = createAppropriateFormat(explicitType, style, formattableType, parseError, status);
1651             setArgStartFormat(index, formatter, status);
1652             break;
1653         }
1654         case UMSGPAT_ARG_TYPE_CHOICE:
1655         case UMSGPAT_ARG_TYPE_PLURAL:
1656         case UMSGPAT_ARG_TYPE_SELECTORDINAL:
1657             formattableType = Formattable::kDouble;
1658             break;
1659         case UMSGPAT_ARG_TYPE_SELECT:
1660             formattableType = Formattable::kString;
1661             break;
1662         default:
1663             status = U_INTERNAL_PROGRAM_ERROR;  // Should be unreachable.
1664             formattableType = Formattable::kString;
1665             break;
1666         }
1667         if (argNumber != -1) {
1668             if (argTypes[argNumber] != Formattable::kObject && argTypes[argNumber] != formattableType) {
1669                 hasArgTypeConflicts = TRUE;
1670             }
1671             argTypes[argNumber] = formattableType;
1672         }
1673     }
1674 }
1675
1676
1677 Format* MessageFormat::createAppropriateFormat(UnicodeString& type, UnicodeString& style,
1678                                                Formattable::Type& formattableType, UParseError& parseError,
1679                                                UErrorCode& ec) {
1680     if (U_FAILURE(ec)) {
1681         return NULL;
1682     }
1683     Format* fmt = NULL;
1684     int32_t typeID, styleID;
1685     DateFormat::EStyle date_style;
1686
1687     switch (typeID = findKeyword(type, TYPE_IDS)) {
1688     case 0: // number
1689         formattableType = Formattable::kDouble;
1690         switch (findKeyword(style, NUMBER_STYLE_IDS)) {
1691         case 0: // default
1692             fmt = NumberFormat::createInstance(fLocale, ec);
1693             break;
1694         case 1: // currency
1695             fmt = NumberFormat::createCurrencyInstance(fLocale, ec);
1696             break;
1697         case 2: // percent
1698             fmt = NumberFormat::createPercentInstance(fLocale, ec);
1699             break;
1700         case 3: // integer
1701             formattableType = Formattable::kLong;
1702             fmt = createIntegerFormat(fLocale, ec);
1703             break;
1704         default: // pattern or skeleton
1705             int32_t i = 0;
1706             for (; PatternProps::isWhiteSpace(style.charAt(i)); i++);
1707             if (style.compare(i, 2, u"::", 0, 2) == 0) {
1708                 // Skeleton
1709                 UnicodeString skeleton = style.tempSubString(i + 2);
1710                 fmt = number::NumberFormatter::forSkeleton(skeleton, ec).locale(fLocale).toFormat(ec);
1711             } else {
1712                 // Pattern
1713                 fmt = NumberFormat::createInstance(fLocale, ec);
1714                 if (fmt) {
1715                     DecimalFormat* decfmt = dynamic_cast<DecimalFormat*>(fmt);
1716                     if (decfmt != NULL) {
1717                         decfmt->applyPattern(style, parseError, ec);
1718                     }
1719                 }
1720             }
1721             break;
1722         }
1723         break;
1724
1725     case 1: // date
1726     case 2: // time
1727         formattableType = Formattable::kDate;
1728         styleID = findKeyword(style, DATE_STYLE_IDS);
1729         date_style = (styleID >= 0) ? DATE_STYLES[styleID] : DateFormat::kDefault;
1730
1731         if (typeID == 1) {
1732             fmt = DateFormat::createDateInstance(date_style, fLocale);
1733         } else {
1734             fmt = DateFormat::createTimeInstance(date_style, fLocale);
1735         }
1736
1737         if (styleID < 0 && fmt != NULL) {
1738             SimpleDateFormat* sdtfmt = dynamic_cast<SimpleDateFormat*>(fmt);
1739             if (sdtfmt != NULL) {
1740                 sdtfmt->applyPattern(style);
1741             }
1742         }
1743         break;
1744
1745     case 3: // spellout
1746         formattableType = Formattable::kDouble;
1747         fmt = makeRBNF(URBNF_SPELLOUT, fLocale, style, ec);
1748         break;
1749     case 4: // ordinal
1750         formattableType = Formattable::kDouble;
1751         fmt = makeRBNF(URBNF_ORDINAL, fLocale, style, ec);
1752         break;
1753     case 5: // duration
1754         formattableType = Formattable::kDouble;
1755         fmt = makeRBNF(URBNF_DURATION, fLocale, style, ec);
1756         break;
1757     default:
1758         formattableType = Formattable::kString;
1759         ec = U_ILLEGAL_ARGUMENT_ERROR;
1760         break;
1761     }
1762
1763     return fmt;
1764 }
1765
1766
1767 //-------------------------------------
1768 // Finds the string, s, in the string array, list.
1769 int32_t MessageFormat::findKeyword(const UnicodeString& s,
1770                                    const UChar * const *list)
1771 {
1772     if (s.isEmpty()) {
1773         return 0; // default
1774     }
1775
1776     int32_t length = s.length();
1777     const UChar *ps = PatternProps::trimWhiteSpace(s.getBuffer(), length);
1778     UnicodeString buffer(FALSE, ps, length);
1779     // Trims the space characters and turns all characters
1780     // in s to lower case.
1781     buffer.toLower("");
1782     for (int32_t i = 0; list[i]; ++i) {
1783         if (!buffer.compare(list[i], u_strlen(list[i]))) {
1784             return i;
1785         }
1786     }
1787     return -1;
1788 }
1789
1790 /**
1791  * Convenience method that ought to be in NumberFormat
1792  */
1793 NumberFormat*
1794 MessageFormat::createIntegerFormat(const Locale& locale, UErrorCode& status) const {
1795     NumberFormat *temp = NumberFormat::createInstance(locale, status);
1796     DecimalFormat *temp2;
1797     if (temp != NULL && (temp2 = dynamic_cast<DecimalFormat*>(temp)) != NULL) {
1798         temp2->setMaximumFractionDigits(0);
1799         temp2->setDecimalSeparatorAlwaysShown(FALSE);
1800         temp2->setParseIntegerOnly(TRUE);
1801     }
1802
1803     return temp;
1804 }
1805
1806 /**
1807  * Return the default number format.  Used to format a numeric
1808  * argument when subformats[i].format is NULL.  Returns NULL
1809  * on failure.
1810  *
1811  * Semantically const but may modify *this.
1812  */
1813 const NumberFormat* MessageFormat::getDefaultNumberFormat(UErrorCode& ec) const {
1814     if (defaultNumberFormat == NULL) {
1815         MessageFormat* t = (MessageFormat*) this;
1816         t->defaultNumberFormat = NumberFormat::createInstance(fLocale, ec);
1817         if (U_FAILURE(ec)) {
1818             delete t->defaultNumberFormat;
1819             t->defaultNumberFormat = NULL;
1820         } else if (t->defaultNumberFormat == NULL) {
1821             ec = U_MEMORY_ALLOCATION_ERROR;
1822         }
1823     }
1824     return defaultNumberFormat;
1825 }
1826
1827 /**
1828  * Return the default date format.  Used to format a date
1829  * argument when subformats[i].format is NULL.  Returns NULL
1830  * on failure.
1831  *
1832  * Semantically const but may modify *this.
1833  */
1834 const DateFormat* MessageFormat::getDefaultDateFormat(UErrorCode& ec) const {
1835     if (defaultDateFormat == NULL) {
1836         MessageFormat* t = (MessageFormat*) this;
1837         t->defaultDateFormat = DateFormat::createDateTimeInstance(DateFormat::kShort, DateFormat::kShort, fLocale);
1838         if (t->defaultDateFormat == NULL) {
1839             ec = U_MEMORY_ALLOCATION_ERROR;
1840         }
1841     }
1842     return defaultDateFormat;
1843 }
1844
1845 UBool
1846 MessageFormat::usesNamedArguments() const {
1847     return msgPattern.hasNamedArguments();
1848 }
1849
1850 int32_t
1851 MessageFormat::getArgTypeCount() const {
1852     return argTypeCount;
1853 }
1854
1855 UBool MessageFormat::equalFormats(const void* left, const void* right) {
1856     return *(const Format*)left==*(const Format*)right;
1857 }
1858
1859
1860 UBool MessageFormat::DummyFormat::operator==(const Format&) const {
1861     return TRUE;
1862 }
1863
1864 Format* MessageFormat::DummyFormat::clone() const {
1865     return new DummyFormat();
1866 }
1867
1868 UnicodeString& MessageFormat::DummyFormat::format(const Formattable&,
1869                           UnicodeString& appendTo,
1870                           UErrorCode& status) const {
1871     if (U_SUCCESS(status)) {
1872         status = U_UNSUPPORTED_ERROR;
1873     }
1874     return appendTo;
1875 }
1876
1877 UnicodeString& MessageFormat::DummyFormat::format(const Formattable&,
1878                           UnicodeString& appendTo,
1879                           FieldPosition&,
1880                           UErrorCode& status) const {
1881     if (U_SUCCESS(status)) {
1882         status = U_UNSUPPORTED_ERROR;
1883     }
1884     return appendTo;
1885 }
1886
1887 UnicodeString& MessageFormat::DummyFormat::format(const Formattable&,
1888                           UnicodeString& appendTo,
1889                           FieldPositionIterator*,
1890                           UErrorCode& status) const {
1891     if (U_SUCCESS(status)) {
1892         status = U_UNSUPPORTED_ERROR;
1893     }
1894     return appendTo;
1895 }
1896
1897 void MessageFormat::DummyFormat::parseObject(const UnicodeString&,
1898                                                      Formattable&,
1899                                                      ParsePosition& ) const {
1900 }
1901
1902
1903 FormatNameEnumeration::FormatNameEnumeration(UVector *fNameList, UErrorCode& /*status*/) {
1904     pos=0;
1905     fFormatNames = fNameList;
1906 }
1907
1908 const UnicodeString*
1909 FormatNameEnumeration::snext(UErrorCode& status) {
1910     if (U_SUCCESS(status) && pos < fFormatNames->size()) {
1911         return (const UnicodeString*)fFormatNames->elementAt(pos++);
1912     }
1913     return NULL;
1914 }
1915
1916 void
1917 FormatNameEnumeration::reset(UErrorCode& /*status*/) {
1918     pos=0;
1919 }
1920
1921 int32_t
1922 FormatNameEnumeration::count(UErrorCode& /*status*/) const {
1923     return (fFormatNames==NULL) ? 0 : fFormatNames->size();
1924 }
1925
1926 FormatNameEnumeration::~FormatNameEnumeration() {
1927     delete fFormatNames;
1928 }
1929
1930 MessageFormat::PluralSelectorProvider::PluralSelectorProvider(const MessageFormat &mf, UPluralType t)
1931         : msgFormat(mf), rules(NULL), type(t) {
1932 }
1933
1934 MessageFormat::PluralSelectorProvider::~PluralSelectorProvider() {
1935     delete rules;
1936 }
1937
1938 UnicodeString MessageFormat::PluralSelectorProvider::select(void *ctx, double number,
1939                                                             UErrorCode& ec) const {
1940     if (U_FAILURE(ec)) {
1941         return UnicodeString(FALSE, OTHER_STRING, 5);
1942     }
1943     MessageFormat::PluralSelectorProvider* t = const_cast<MessageFormat::PluralSelectorProvider*>(this);
1944     if(rules == NULL) {
1945         t->rules = PluralRules::forLocale(msgFormat.fLocale, type, ec);
1946         if (U_FAILURE(ec)) {
1947             return UnicodeString(FALSE, OTHER_STRING, 5);
1948         }
1949     }
1950     // Select a sub-message according to how the number is formatted,
1951     // which is specified in the selected sub-message.
1952     // We avoid this circle by looking at how
1953     // the number is formatted in the "other" sub-message
1954     // which must always be present and usually contains the number.
1955     // Message authors should be consistent across sub-messages.
1956     PluralSelectorContext &context = *static_cast<PluralSelectorContext *>(ctx);
1957     int32_t otherIndex = msgFormat.findOtherSubMessage(context.startIndex);
1958     context.numberArgIndex = msgFormat.findFirstPluralNumberArg(otherIndex, context.argName);
1959     if(context.numberArgIndex > 0 && msgFormat.cachedFormatters != NULL) {
1960         context.formatter =
1961             (const Format*)uhash_iget(msgFormat.cachedFormatters, context.numberArgIndex);
1962     }
1963     if(context.formatter == NULL) {
1964         context.formatter = msgFormat.getDefaultNumberFormat(ec);
1965         context.forReplaceNumber = TRUE;
1966     }
1967     if (context.number.getDouble(ec) != number) {
1968         ec = U_INTERNAL_PROGRAM_ERROR;
1969         return UnicodeString(FALSE, OTHER_STRING, 5);
1970     }
1971     context.formatter->format(context.number, context.numberString, ec);
1972     const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(context.formatter);
1973     if(decFmt != NULL) {
1974         VisibleDigitsWithExponent digits;
1975         decFmt->initVisibleDigitsWithExponent(context.number, digits, ec);
1976         if (U_FAILURE(ec)) {
1977             return UnicodeString(FALSE, OTHER_STRING, 5);
1978         }
1979         return rules->select(digits);
1980     } else {
1981         return rules->select(number);
1982     }
1983 }
1984
1985 void MessageFormat::PluralSelectorProvider::reset() {
1986     delete rules;
1987     rules = NULL;
1988 }
1989
1990
1991 U_NAMESPACE_END
1992
1993 #endif /* #if !UCONFIG_NO_FORMATTING */
1994
1995 //eof