icuSources/i18n/msgfmt.cpp

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