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