icuSources/i18n/msgfmt.cpp

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