1 /* 2 ******************************************************************************* 3 * Copyright (C) 1997-2013, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ******************************************************************************* 6 * 7 * File NUMFMT.CPP 8 * 9 * Modification History: 10 * 11 * Date Name Description 12 * 02/19/97 aliu Converted from java. 13 * 03/18/97 clhuang Implemented with C++ APIs. 14 * 04/17/97 aliu Enlarged MAX_INTEGER_DIGITS to fully accomodate the 15 * largest double, by default. 16 * Changed DigitCount to int per code review. 17 * 07/20/98 stephen Changed operator== to check for grouping 18 * Changed setMaxIntegerDigits per Java implementation. 19 * Changed setMinIntegerDigits per Java implementation. 20 * Changed setMinFractionDigits per Java implementation. 21 * Changed setMaxFractionDigits per Java implementation. 22 ******************************************************************************** 23 */ 24 25 #include "unicode/utypes.h" 26 27 #if !UCONFIG_NO_FORMATTING 28 29 #include "unicode/numfmt.h" 30 #include "unicode/locid.h" 31 #include "unicode/dcfmtsym.h" 32 #include "unicode/decimfmt.h" 33 #include "unicode/ustring.h" 34 #include "unicode/ucurr.h" 35 #include "unicode/curramt.h" 36 #include "unicode/numsys.h" 37 #include "unicode/rbnf.h" 38 #include "unicode/localpointer.h" 39 #include "charstr.h" 40 #include "winnmfmt.h" 41 #include "uresimp.h" 42 #include "uhash.h" 43 #include "cmemory.h" 44 #include "servloc.h" 45 #include "ucln_in.h" 46 #include "cstring.h" 47 #include "putilimp.h" 48 #include "uassert.h" 49 #include "umutex.h" 50 #include "mutex.h" 51 #include "digitlst.h" 52 #include <float.h> 53 54 //#define FMT_DEBUG 55 56 #ifdef FMT_DEBUG 57 #include <stdio.h> 58 static inline void debugout(UnicodeString s) { 59 char buf[2000]; 60 s.extract((int32_t) 0, s.length(), buf); 61 printf("%s", buf); 62 } 63 #define debug(x) printf("%s", x); 64 #else 65 #define debugout(x) 66 #define debug(x) 67 #endif 68 69 // If no number pattern can be located for a locale, this is the last 70 // resort. 71 static const UChar gLastResortDecimalPat[] = { 72 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0x3B, 0x2D, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0 /* "#0.###;-#0.###" */ 73 }; 74 static const UChar gLastResortCurrencyPat[] = { 75 0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x3B, 0x28, 0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x29, 0 /* "$#0.00;($#0.00)" */ 76 }; 77 static const UChar gLastResortPercentPat[] = { 78 0x23, 0x30, 0x25, 0 /* "#0%" */ 79 }; 80 static const UChar gLastResortScientificPat[] = { 81 0x23, 0x45, 0x30, 0 /* "#E0" */ 82 }; 83 static const UChar gLastResortIsoCurrencyPat[] = { 84 0xA4, 0xA4, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x3B, 0x28, 0xA4, 0xA4, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x29, 0 /* "\u00A4\u00A4#0.00;(\u00A4\u00A4#0.00)" */ 85 }; 86 static const UChar gLastResortPluralCurrencyPat[] = { 87 0x23, 0x30, 0x2E, 0x30, 0x30, 0xA0, 0xA4, 0xA4, 0xA4, 0 /* "#0.00\u00A0\u00A4\u00A4\u00A4*/ 88 }; 89 90 static const UChar gSingleCurrencySign[] = {0xA4, 0}; 91 static const UChar gDoubleCurrencySign[] = {0xA4, 0xA4, 0}; 92 93 static const UChar gSlash = 0x2f; 94 95 // If the maximum base 10 exponent were 4, then the largest number would 96 // be 99,999 which has 5 digits. 97 // On IEEE754 systems gMaxIntegerDigits is 308 + possible denormalized 15 digits + rounding digit 98 // With big decimal, the max exponent is 999,999,999 and the max number of digits is the same, 999,999,999 99 const int32_t icu::NumberFormat::gDefaultMaxIntegerDigits = 2000000000; 100 const int32_t icu::NumberFormat::gDefaultMinIntegerDigits = 127; 101 102 static const UChar * const gLastResortNumberPatterns[UNUM_FORMAT_STYLE_COUNT] = { 103 NULL, // UNUM_PATTERN_DECIMAL 104 gLastResortDecimalPat, // UNUM_DECIMAL 105 gLastResortCurrencyPat, // UNUM_CURRENCY 106 gLastResortPercentPat, // UNUM_PERCENT 107 gLastResortScientificPat, // UNUM_SCIENTIFIC 108 NULL, // UNUM_SPELLOUT 109 NULL, // UNUM_ORDINAL 110 NULL, // UNUM_DURATION 111 NULL, // UNUM_NUMBERING_SYSTEM 112 NULL, // UNUM_PATTERN_RULEBASED 113 gLastResortIsoCurrencyPat, // UNUM_CURRENCY_ISO 114 gLastResortPluralCurrencyPat // UNUM_CURRENCY_PLURAL 115 }; 116 117 // Keys used for accessing resource bundles 118 119 static const char *gNumberElements = "NumberElements"; 120 static const char *gLatn = "latn"; 121 static const char *gPatterns = "patterns"; 122 static const char *gFormatKeys[UNUM_FORMAT_STYLE_COUNT] = { 123 NULL, // UNUM_PATTERN_DECIMAL 124 "decimalFormat", // UNUM_DECIMAL 125 "currencyFormat", // UNUM_CURRENCY 126 "percentFormat", // UNUM_PERCENT 127 "scientificFormat", // UNUM_SCIENTIFIC 128 NULL, // UNUM_SPELLOUT 129 NULL, // UNUM_ORDINAL 130 NULL, // UNUM_DURATION 131 NULL, // UNUM_NUMBERING_SYSTEM 132 NULL, // UNUM_PATTERN_RULEBASED 133 // For UNUM_CURRENCY_ISO and UNUM_CURRENCY_PLURAL, 134 // the pattern is the same as the pattern of UNUM_CURRENCY 135 // except for replacing the single currency sign with 136 // double currency sign or triple currency sign. 137 "currencyFormat", // UNUM_CURRENCY_ISO 138 "currencyFormat" // UNUM_CURRENCY_PLURAL 139 }; 140 141 // Static hashtable cache of NumberingSystem objects used by NumberFormat 142 static UHashtable * NumberingSystem_cache = NULL; 143 static UMutex nscacheMutex = U_MUTEX_INITIALIZER; 144 static icu::UInitOnce gNSCacheInitOnce = U_INITONCE_INITIALIZER; 145 146 #if !UCONFIG_NO_SERVICE 147 static icu::ICULocaleService* gService = NULL; 148 static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER; 149 #endif 150 151 /** 152 * Release all static memory held by Number Format. 153 */ 154 U_CDECL_BEGIN 155 static void U_CALLCONV 156 deleteNumberingSystem(void *obj) { 157 delete (icu::NumberingSystem *)obj; 158 } 159 160 static UBool U_CALLCONV numfmt_cleanup(void) { 161 #if !UCONFIG_NO_SERVICE 162 gServiceInitOnce.reset(); 163 if (gService) { 164 delete gService; 165 gService = NULL; 166 } 167 #endif 168 gNSCacheInitOnce.reset(); 169 if (NumberingSystem_cache) { 170 // delete NumberingSystem_cache; 171 uhash_close(NumberingSystem_cache); 172 NumberingSystem_cache = NULL; 173 } 174 175 return TRUE; 176 } 177 U_CDECL_END 178 179 // ***************************************************************************** 180 // class NumberFormat 181 // ***************************************************************************** 182 183 U_NAMESPACE_BEGIN 184 185 UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(NumberFormat) 186 187 #if !UCONFIG_NO_SERVICE 188 // ------------------------------------- 189 // SimpleNumberFormatFactory implementation 190 NumberFormatFactory::~NumberFormatFactory() {} 191 SimpleNumberFormatFactory::SimpleNumberFormatFactory(const Locale& locale, UBool visible) 192 : _visible(visible) 193 { 194 LocaleUtility::initNameFromLocale(locale, _id); 195 } 196 197 SimpleNumberFormatFactory::~SimpleNumberFormatFactory() {} 198 199 UBool SimpleNumberFormatFactory::visible(void) const { 200 return _visible; 201 } 202 203 const UnicodeString * 204 SimpleNumberFormatFactory::getSupportedIDs(int32_t &count, UErrorCode& status) const 205 { 206 if (U_SUCCESS(status)) { 207 count = 1; 208 return &_id; 209 } 210 count = 0; 211 return NULL; 212 } 213 #endif /* #if !UCONFIG_NO_SERVICE */ 214 215 // ------------------------------------- 216 // default constructor 217 NumberFormat::NumberFormat() 218 : fGroupingUsed(TRUE), 219 fMaxIntegerDigits(gDefaultMaxIntegerDigits), 220 fMinIntegerDigits(1), 221 fMaxFractionDigits(3), // invariant, >= minFractionDigits 222 fMinFractionDigits(0), 223 fParseIntegerOnly(FALSE), 224 fLenient(FALSE) 225 { 226 fCurrency[0] = 0; 227 } 228 229 // ------------------------------------- 230 231 NumberFormat::~NumberFormat() 232 { 233 } 234 235 // ------------------------------------- 236 // copy constructor 237 238 NumberFormat::NumberFormat(const NumberFormat &source) 239 : Format(source) 240 { 241 *this = source; 242 } 243 244 // ------------------------------------- 245 // assignment operator 246 247 NumberFormat& 248 NumberFormat::operator=(const NumberFormat& rhs) 249 { 250 if (this != &rhs) 251 { 252 Format::operator=(rhs); 253 fGroupingUsed = rhs.fGroupingUsed; 254 fMaxIntegerDigits = rhs.fMaxIntegerDigits; 255 fMinIntegerDigits = rhs.fMinIntegerDigits; 256 fMaxFractionDigits = rhs.fMaxFractionDigits; 257 fMinFractionDigits = rhs.fMinFractionDigits; 258 fParseIntegerOnly = rhs.fParseIntegerOnly; 259 u_strncpy(fCurrency, rhs.fCurrency, 4); 260 fLenient = rhs.fLenient; 261 } 262 return *this; 263 } 264 265 // ------------------------------------- 266 267 UBool 268 NumberFormat::operator==(const Format& that) const 269 { 270 // Format::operator== guarantees this cast is safe 271 NumberFormat* other = (NumberFormat*)&that; 272 273 #ifdef FMT_DEBUG 274 // This code makes it easy to determine why two format objects that should 275 // be equal aren't. 276 UBool first = TRUE; 277 if (!Format::operator==(that)) { 278 if (first) { printf("[ "); first = FALSE; } else { printf(", "); } 279 debug("Format::!="); 280 } 281 if (!(fMaxIntegerDigits == other->fMaxIntegerDigits && 282 fMinIntegerDigits == other->fMinIntegerDigits)) { 283 if (first) { printf("[ "); first = FALSE; } else { printf(", "); } 284 debug("Integer digits !="); 285 } 286 if (!(fMaxFractionDigits == other->fMaxFractionDigits && 287 fMinFractionDigits == other->fMinFractionDigits)) { 288 if (first) { printf("[ "); first = FALSE; } else { printf(", "); } 289 debug("Fraction digits !="); 290 } 291 if (!(fGroupingUsed == other->fGroupingUsed)) { 292 if (first) { printf("[ "); first = FALSE; } else { printf(", "); } 293 debug("fGroupingUsed != "); 294 } 295 if (!(fParseIntegerOnly == other->fParseIntegerOnly)) { 296 if (first) { printf("[ "); first = FALSE; } else { printf(", "); } 297 debug("fParseIntegerOnly != "); 298 } 299 if (!(u_strcmp(fCurrency, other->fCurrency) == 0)) { 300 if (first) { printf("[ "); first = FALSE; } else { printf(", "); } 301 debug("fCurrency !="); 302 } 303 if (!(fLenient == other->fLenient)) { 304 if (first) { printf("[ "); first = FALSE; } else { printf(", "); } 305 debug("fLenient != "); 306 } 307 if (!first) { printf(" ]"); } 308 #endif 309 310 return ((this == &that) || 311 ((Format::operator==(that) && 312 fMaxIntegerDigits == other->fMaxIntegerDigits && 313 fMinIntegerDigits == other->fMinIntegerDigits && 314 fMaxFractionDigits == other->fMaxFractionDigits && 315 fMinFractionDigits == other->fMinFractionDigits && 316 fGroupingUsed == other->fGroupingUsed && 317 fParseIntegerOnly == other->fParseIntegerOnly && 318 u_strcmp(fCurrency, other->fCurrency) == 0 && 319 fLenient == other->fLenient))); 320 } 321 322 // ------------------------------------- 323 // Default implementation sets unsupported error; subclasses should 324 // override. 325 326 UnicodeString& 327 NumberFormat::format(double /* unused number */, 328 UnicodeString& toAppendTo, 329 FieldPositionIterator* /* unused posIter */, 330 UErrorCode& status) const 331 { 332 if (!U_FAILURE(status)) { 333 status = U_UNSUPPORTED_ERROR; 334 } 335 return toAppendTo; 336 } 337 338 // ------------------------------------- 339 // Default implementation sets unsupported error; subclasses should 340 // override. 341 342 UnicodeString& 343 NumberFormat::format(int32_t /* unused number */, 344 UnicodeString& toAppendTo, 345 FieldPositionIterator* /* unused posIter */, 346 UErrorCode& status) const 347 { 348 if (!U_FAILURE(status)) { 349 status = U_UNSUPPORTED_ERROR; 350 } 351 return toAppendTo; 352 } 353 354 // ------------------------------------- 355 // Default implementation sets unsupported error; subclasses should 356 // override. 357 358 UnicodeString& 359 NumberFormat::format(int64_t /* unused number */, 360 UnicodeString& toAppendTo, 361 FieldPositionIterator* /* unused posIter */, 362 UErrorCode& status) const 363 { 364 if (!U_FAILURE(status)) { 365 status = U_UNSUPPORTED_ERROR; 366 } 367 return toAppendTo; 368 } 369 370 // ------------------------------------------ 371 // These functions add the status code, just fall back to the non-status versions 372 UnicodeString& 373 NumberFormat::format(double number, 374 UnicodeString& appendTo, 375 FieldPosition& pos, 376 UErrorCode &status) const { 377 if(U_SUCCESS(status)) { 378 return format(number,appendTo,pos); 379 } else { 380 return appendTo; 381 } 382 } 383 384 UnicodeString& 385 NumberFormat::format(int32_t number, 386 UnicodeString& appendTo, 387 FieldPosition& pos, 388 UErrorCode &status) const { 389 if(U_SUCCESS(status)) { 390 return format(number,appendTo,pos); 391 } else { 392 return appendTo; 393 } 394 } 395 396 UnicodeString& 397 NumberFormat::format(int64_t number, 398 UnicodeString& appendTo, 399 FieldPosition& pos, 400 UErrorCode &status) const { 401 if(U_SUCCESS(status)) { 402 return format(number,appendTo,pos); 403 } else { 404 return appendTo; 405 } 406 } 407 408 409 410 // ------------------------------------- 411 // Decimal Number format() default implementation 412 // Subclasses do not normally override this function, but rather the DigitList 413 // formatting functions.. 414 // The expected call chain from here is 415 // this function -> 416 // NumberFormat::format(Formattable -> 417 // DecimalFormat::format(DigitList 418 // 419 // Or, for subclasses of Formattable that do not know about DigitList, 420 // this Function -> 421 // NumberFormat::format(Formattable -> 422 // NumberFormat::format(DigitList -> 423 // XXXFormat::format(double 424 425 UnicodeString& 426 NumberFormat::format(const StringPiece &decimalNum, 427 UnicodeString& toAppendTo, 428 FieldPositionIterator* fpi, 429 UErrorCode& status) const 430 { 431 Formattable f; 432 f.setDecimalNumber(decimalNum, status); 433 format(f, toAppendTo, fpi, status); 434 return toAppendTo; 435 } 436 437 /** 438 * 439 // Formats the number object and save the format 440 // result in the toAppendTo string buffer. 441 442 // utility to save/restore state, used in two overloads 443 // of format(const Formattable&...) below. 444 * 445 * Old purpose of ArgExtractor was to avoid const. Not thread safe! 446 * 447 * keeping it around as a shim. 448 */ 449 class ArgExtractor { 450 const Formattable* num; 451 UChar save[4]; 452 UBool fWasCurrency; 453 454 public: 455 ArgExtractor(const NumberFormat& nf, const Formattable& obj, UErrorCode& status); 456 ~ArgExtractor(); 457 458 const Formattable* number(void) const; 459 const UChar *iso(void) const; 460 UBool wasCurrency(void) const; 461 }; 462 463 inline const Formattable* 464 ArgExtractor::number(void) const { 465 return num; 466 } 467 468 inline UBool 469 ArgExtractor::wasCurrency(void) const { 470 return fWasCurrency; 471 } 472 473 inline const UChar * 474 ArgExtractor::iso(void) const { 475 return save; 476 } 477 478 ArgExtractor::ArgExtractor(const NumberFormat& /*nf*/, const Formattable& obj, UErrorCode& /*status*/) 479 : num(&obj), fWasCurrency(FALSE) { 480 481 const UObject* o = obj.getObject(); // most commonly o==NULL 482 const CurrencyAmount* amt; 483 if (o != NULL && (amt = dynamic_cast<const CurrencyAmount*>(o)) != NULL) { 484 // getISOCurrency() returns a pointer to internal storage, so we 485 // copy it to retain it across the call to setCurrency(). 486 //const UChar* curr = amt->getISOCurrency(); 487 u_strcpy(save, amt->getISOCurrency()); 488 num = &amt->getNumber(); 489 fWasCurrency=TRUE; 490 } else { 491 save[0]=0; 492 } 493 } 494 495 ArgExtractor::~ArgExtractor() { 496 } 497 498 UnicodeString& NumberFormat::format(const DigitList &number, 499 UnicodeString& appendTo, 500 FieldPositionIterator* posIter, 501 UErrorCode& status) const { 502 // DecimalFormat overrides this function, and handles DigitList based big decimals. 503 // Other subclasses (ChoiceFormat, RuleBasedNumberFormat) do not (yet) handle DigitLists, 504 // so this default implementation falls back to formatting decimal numbers as doubles. 505 if (U_FAILURE(status)) { 506 return appendTo; 507 } 508 double dnum = number.getDouble(); 509 format(dnum, appendTo, posIter, status); 510 return appendTo; 511 } 512 513 514 515 UnicodeString& 516 NumberFormat::format(const DigitList &number, 517 UnicodeString& appendTo, 518 FieldPosition& pos, 519 UErrorCode &status) const { 520 // DecimalFormat overrides this function, and handles DigitList based big decimals. 521 // Other subclasses (ChoiceFormat, RuleBasedNumberFormat) do not (yet) handle DigitLists, 522 // so this default implementation falls back to formatting decimal numbers as doubles. 523 if (U_FAILURE(status)) { 524 return appendTo; 525 } 526 double dnum = number.getDouble(); 527 format(dnum, appendTo, pos, status); 528 return appendTo; 529 } 530 531 UnicodeString& 532 NumberFormat::format(const Formattable& obj, 533 UnicodeString& appendTo, 534 FieldPosition& pos, 535 UErrorCode& status) const 536 { 537 if (U_FAILURE(status)) return appendTo; 538 539 ArgExtractor arg(*this, obj, status); 540 const Formattable *n = arg.number(); 541 const UChar *iso = arg.iso(); 542 543 if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) { 544 // trying to format a different currency. 545 // Right now, we clone. 546 LocalPointer<NumberFormat> cloneFmt((NumberFormat*)this->clone()); 547 cloneFmt->setCurrency(iso, status); 548 // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount. 549 return cloneFmt->format(*n, appendTo, pos, status); 550 } 551 552 if (n->isNumeric() && n->getDigitList() != NULL) { 553 // Decimal Number. We will have a DigitList available if the value was 554 // set to a decimal number, or if the value originated with a parse. 555 // 556 // The default implementation for formatting a DigitList converts it 557 // to a double, and formats that, allowing formatting classes that don't 558 // know about DigitList to continue to operate as they had. 559 // 560 // DecimalFormat overrides the DigitList formatting functions. 561 format(*n->getDigitList(), appendTo, pos, status); 562 } else { 563 switch (n->getType()) { 564 case Formattable::kDouble: 565 format(n->getDouble(), appendTo, pos); 566 break; 567 case Formattable::kLong: 568 format(n->getLong(), appendTo, pos); 569 break; 570 case Formattable::kInt64: 571 format(n->getInt64(), appendTo, pos); 572 break; 573 default: 574 status = U_INVALID_FORMAT_ERROR; 575 break; 576 } 577 } 578 579 return appendTo; 580 } 581 582 // -------------------------------------x 583 // Formats the number object and save the format 584 // result in the toAppendTo string buffer. 585 586 UnicodeString& 587 NumberFormat::format(const Formattable& obj, 588 UnicodeString& appendTo, 589 FieldPositionIterator* posIter, 590 UErrorCode& status) const 591 { 592 if (U_FAILURE(status)) return appendTo; 593 594 ArgExtractor arg(*this, obj, status); 595 const Formattable *n = arg.number(); 596 const UChar *iso = arg.iso(); 597 598 if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) { 599 // trying to format a different currency. 600 // Right now, we clone. 601 LocalPointer<NumberFormat> cloneFmt((NumberFormat*)this->clone()); 602 cloneFmt->setCurrency(iso, status); 603 // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount. 604 return cloneFmt->format(*n, appendTo, posIter, status); 605 } 606 607 if (n->isNumeric() && n->getDigitList() != NULL) { 608 // Decimal Number 609 format(*n->getDigitList(), appendTo, posIter, status); 610 } else { 611 switch (n->getType()) { 612 case Formattable::kDouble: 613 format(n->getDouble(), appendTo, posIter, status); 614 break; 615 case Formattable::kLong: 616 format(n->getLong(), appendTo, posIter, status); 617 break; 618 case Formattable::kInt64: 619 format(n->getInt64(), appendTo, posIter, status); 620 break; 621 default: 622 status = U_INVALID_FORMAT_ERROR; 623 break; 624 } 625 } 626 627 return appendTo; 628 } 629 630 // ------------------------------------- 631 632 UnicodeString& 633 NumberFormat::format(int64_t number, 634 UnicodeString& appendTo, 635 FieldPosition& pos) const 636 { 637 // default so we don't introduce a new abstract method 638 return format((int32_t)number, appendTo, pos); 639 } 640 641 // ------------------------------------- 642 // Parses the string and save the result object as well 643 // as the final parsed position. 644 645 void 646 NumberFormat::parseObject(const UnicodeString& source, 647 Formattable& result, 648 ParsePosition& parse_pos) const 649 { 650 parse(source, result, parse_pos); 651 } 652 653 // ------------------------------------- 654 // Formats a double number and save the result in a string. 655 656 UnicodeString& 657 NumberFormat::format(double number, UnicodeString& appendTo) const 658 { 659 FieldPosition pos(0); 660 return format(number, appendTo, pos); 661 } 662 663 // ------------------------------------- 664 // Formats a long number and save the result in a string. 665 666 UnicodeString& 667 NumberFormat::format(int32_t number, UnicodeString& appendTo) const 668 { 669 FieldPosition pos(0); 670 return format(number, appendTo, pos); 671 } 672 673 // ------------------------------------- 674 // Formats a long number and save the result in a string. 675 676 UnicodeString& 677 NumberFormat::format(int64_t number, UnicodeString& appendTo) const 678 { 679 FieldPosition pos(0); 680 return format(number, appendTo, pos); 681 } 682 683 // ------------------------------------- 684 // Parses the text and save the result object. If the returned 685 // parse position is 0, that means the parsing failed, the status 686 // code needs to be set to failure. Ignores the returned parse 687 // position, otherwise. 688 689 void 690 NumberFormat::parse(const UnicodeString& text, 691 Formattable& result, 692 UErrorCode& status) const 693 { 694 if (U_FAILURE(status)) return; 695 696 ParsePosition parsePosition(0); 697 parse(text, result, parsePosition); 698 if (parsePosition.getIndex() == 0) { 699 status = U_INVALID_FORMAT_ERROR; 700 } 701 } 702 703 CurrencyAmount* NumberFormat::parseCurrency(const UnicodeString& text, 704 ParsePosition& pos) const { 705 // Default implementation only -- subclasses should override 706 Formattable parseResult; 707 int32_t start = pos.getIndex(); 708 parse(text, parseResult, pos); 709 if (pos.getIndex() != start) { 710 UChar curr[4]; 711 UErrorCode ec = U_ZERO_ERROR; 712 getEffectiveCurrency(curr, ec); 713 if (U_SUCCESS(ec)) { 714 LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curr, ec)); 715 if (U_FAILURE(ec)) { 716 pos.setIndex(start); // indicate failure 717 } else { 718 return currAmt.orphan(); 719 } 720 } 721 } 722 return NULL; 723 } 724 725 // ------------------------------------- 726 // Sets to only parse integers. 727 728 void 729 NumberFormat::setParseIntegerOnly(UBool value) 730 { 731 fParseIntegerOnly = value; 732 } 733 734 // ------------------------------------- 735 // Sets whether lenient parse is enabled. 736 737 void 738 NumberFormat::setLenient(UBool enable) 739 { 740 fLenient = enable; 741 } 742 743 // ------------------------------------- 744 // Create a number style NumberFormat instance with the default locale. 745 746 NumberFormat* U_EXPORT2 747 NumberFormat::createInstance(UErrorCode& status) 748 { 749 return createInstance(Locale::getDefault(), UNUM_DECIMAL, status); 750 } 751 752 // ------------------------------------- 753 // Create a number style NumberFormat instance with the inLocale locale. 754 755 NumberFormat* U_EXPORT2 756 NumberFormat::createInstance(const Locale& inLocale, UErrorCode& status) 757 { 758 return createInstance(inLocale, UNUM_DECIMAL, status); 759 } 760 761 // ------------------------------------- 762 // Create a currency style NumberFormat instance with the default locale. 763 764 NumberFormat* U_EXPORT2 765 NumberFormat::createCurrencyInstance(UErrorCode& status) 766 { 767 return createCurrencyInstance(Locale::getDefault(), status); 768 } 769 770 // ------------------------------------- 771 // Create a currency style NumberFormat instance with the inLocale locale. 772 773 NumberFormat* U_EXPORT2 774 NumberFormat::createCurrencyInstance(const Locale& inLocale, UErrorCode& status) 775 { 776 return createInstance(inLocale, UNUM_CURRENCY, status); 777 } 778 779 // ------------------------------------- 780 // Create a percent style NumberFormat instance with the default locale. 781 782 NumberFormat* U_EXPORT2 783 NumberFormat::createPercentInstance(UErrorCode& status) 784 { 785 return createInstance(Locale::getDefault(), UNUM_PERCENT, status); 786 } 787 788 // ------------------------------------- 789 // Create a percent style NumberFormat instance with the inLocale locale. 790 791 NumberFormat* U_EXPORT2 792 NumberFormat::createPercentInstance(const Locale& inLocale, UErrorCode& status) 793 { 794 return createInstance(inLocale, UNUM_PERCENT, status); 795 } 796 797 // ------------------------------------- 798 // Create a scientific style NumberFormat instance with the default locale. 799 800 NumberFormat* U_EXPORT2 801 NumberFormat::createScientificInstance(UErrorCode& status) 802 { 803 return createInstance(Locale::getDefault(), UNUM_SCIENTIFIC, status); 804 } 805 806 // ------------------------------------- 807 // Create a scientific style NumberFormat instance with the inLocale locale. 808 809 NumberFormat* U_EXPORT2 810 NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status) 811 { 812 return createInstance(inLocale, UNUM_SCIENTIFIC, status); 813 } 814 815 // ------------------------------------- 816 817 const Locale* U_EXPORT2 818 NumberFormat::getAvailableLocales(int32_t& count) 819 { 820 return Locale::getAvailableLocales(count); 821 } 822 823 // ------------------------------------------ 824 // 825 // Registration 826 // 827 //------------------------------------------- 828 829 #if !UCONFIG_NO_SERVICE 830 831 // ------------------------------------- 832 833 class ICUNumberFormatFactory : public ICUResourceBundleFactory { 834 public: 835 virtual ~ICUNumberFormatFactory(); 836 protected: 837 virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const { 838 return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status); 839 } 840 }; 841 842 ICUNumberFormatFactory::~ICUNumberFormatFactory() {} 843 844 // ------------------------------------- 845 846 class NFFactory : public LocaleKeyFactory { 847 private: 848 NumberFormatFactory* _delegate; 849 Hashtable* _ids; 850 851 public: 852 NFFactory(NumberFormatFactory* delegate) 853 : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE) 854 , _delegate(delegate) 855 , _ids(NULL) 856 { 857 } 858 859 virtual ~NFFactory(); 860 861 virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const 862 { 863 if (handlesKey(key, status)) { 864 const LocaleKey& lkey = (const LocaleKey&)key; 865 Locale loc; 866 lkey.canonicalLocale(loc); 867 int32_t kind = lkey.kind(); 868 869 UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)kind); 870 if (result == NULL) { 871 result = service->getKey((ICUServiceKey&)key /* cast away const */, NULL, this, status); 872 } 873 return result; 874 } 875 return NULL; 876 } 877 878 protected: 879 /** 880 * Return the set of ids that this factory supports (visible or 881 * otherwise). This can be called often and might need to be 882 * cached if it is expensive to create. 883 */ 884 virtual const Hashtable* getSupportedIDs(UErrorCode& status) const 885 { 886 if (U_SUCCESS(status)) { 887 if (!_ids) { 888 int32_t count = 0; 889 const UnicodeString * const idlist = _delegate->getSupportedIDs(count, status); 890 ((NFFactory*)this)->_ids = new Hashtable(status); /* cast away const */ 891 if (_ids) { 892 for (int i = 0; i < count; ++i) { 893 _ids->put(idlist[i], (void*)this, status); 894 } 895 } 896 } 897 return _ids; 898 } 899 return NULL; 900 } 901 }; 902 903 NFFactory::~NFFactory() 904 { 905 delete _delegate; 906 delete _ids; 907 } 908 909 class ICUNumberFormatService : public ICULocaleService { 910 public: 911 ICUNumberFormatService() 912 : ICULocaleService(UNICODE_STRING_SIMPLE("Number Format")) 913 { 914 UErrorCode status = U_ZERO_ERROR; 915 registerFactory(new ICUNumberFormatFactory(), status); 916 } 917 918 virtual ~ICUNumberFormatService(); 919 920 virtual UObject* cloneInstance(UObject* instance) const { 921 return ((NumberFormat*)instance)->clone(); 922 } 923 924 virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /* actualID */, UErrorCode& status) const { 925 LocaleKey& lkey = (LocaleKey&)key; 926 int32_t kind = lkey.kind(); 927 Locale loc; 928 lkey.currentLocale(loc); 929 return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status); 930 } 931 932 virtual UBool isDefault() const { 933 return countFactories() == 1; 934 } 935 }; 936 937 ICUNumberFormatService::~ICUNumberFormatService() {} 938 939 // ------------------------------------- 940 941 static void U_CALLCONV initNumberFormatService() { 942 U_ASSERT(gService == NULL); 943 ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup); 944 gService = new ICUNumberFormatService(); 945 } 946 947 static ICULocaleService* 948 getNumberFormatService(void) 949 { 950 umtx_initOnce(gServiceInitOnce, &initNumberFormatService); 951 return gService; 952 } 953 954 static UBool haveService() { 955 return !gServiceInitOnce.isReset() && (getNumberFormatService() != NULL); 956 } 957 958 // ------------------------------------- 959 960 URegistryKey U_EXPORT2 961 NumberFormat::registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status) 962 { 963 ICULocaleService *service = getNumberFormatService(); 964 if (service) { 965 NFFactory *tempnnf = new NFFactory(toAdopt); 966 if (tempnnf != NULL) { 967 return service->registerFactory(tempnnf, status); 968 } 969 } 970 status = U_MEMORY_ALLOCATION_ERROR; 971 return NULL; 972 } 973 974 // ------------------------------------- 975 976 UBool U_EXPORT2 977 NumberFormat::unregister(URegistryKey key, UErrorCode& status) 978 { 979 if (U_FAILURE(status)) { 980 return FALSE; 981 } 982 if (haveService()) { 983 return gService->unregister(key, status); 984 } else { 985 status = U_ILLEGAL_ARGUMENT_ERROR; 986 return FALSE; 987 } 988 } 989 990 // ------------------------------------- 991 StringEnumeration* U_EXPORT2 992 NumberFormat::getAvailableLocales(void) 993 { 994 ICULocaleService *service = getNumberFormatService(); 995 if (service) { 996 return service->getAvailableLocales(); 997 } 998 return NULL; // no way to return error condition 999 } 1000 #endif /* UCONFIG_NO_SERVICE */ 1001 // ------------------------------------- 1002 1003 NumberFormat* U_EXPORT2 1004 NumberFormat::createInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) { 1005 #if !UCONFIG_NO_SERVICE 1006 if (haveService()) { 1007 return (NumberFormat*)gService->get(loc, kind, status); 1008 } 1009 #endif 1010 return makeInstance(loc, kind, status); 1011 } 1012 1013 1014 // ------------------------------------- 1015 // Checks if the thousand/10 thousand grouping is used in the 1016 // NumberFormat instance. 1017 1018 UBool 1019 NumberFormat::isGroupingUsed() const 1020 { 1021 return fGroupingUsed; 1022 } 1023 1024 // ------------------------------------- 1025 // Sets to use the thousand/10 thousand grouping in the 1026 // NumberFormat instance. 1027 1028 void 1029 NumberFormat::setGroupingUsed(UBool newValue) 1030 { 1031 fGroupingUsed = newValue; 1032 } 1033 1034 // ------------------------------------- 1035 // Gets the maximum number of digits for the integral part for 1036 // this NumberFormat instance. 1037 1038 int32_t NumberFormat::getMaximumIntegerDigits() const 1039 { 1040 return fMaxIntegerDigits; 1041 } 1042 1043 // ------------------------------------- 1044 // Sets the maximum number of digits for the integral part for 1045 // this NumberFormat instance. 1046 1047 void 1048 NumberFormat::setMaximumIntegerDigits(int32_t newValue) 1049 { 1050 fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits)); 1051 if(fMinIntegerDigits > fMaxIntegerDigits) 1052 fMinIntegerDigits = fMaxIntegerDigits; 1053 } 1054 1055 // ------------------------------------- 1056 // Gets the minimum number of digits for the integral part for 1057 // this NumberFormat instance. 1058 1059 int32_t 1060 NumberFormat::getMinimumIntegerDigits() const 1061 { 1062 return fMinIntegerDigits; 1063 } 1064 1065 // ------------------------------------- 1066 // Sets the minimum number of digits for the integral part for 1067 // this NumberFormat instance. 1068 1069 void 1070 NumberFormat::setMinimumIntegerDigits(int32_t newValue) 1071 { 1072 fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits)); 1073 if(fMinIntegerDigits > fMaxIntegerDigits) 1074 fMaxIntegerDigits = fMinIntegerDigits; 1075 } 1076 1077 // ------------------------------------- 1078 // Gets the maximum number of digits for the fractional part for 1079 // this NumberFormat instance. 1080 1081 int32_t 1082 NumberFormat::getMaximumFractionDigits() const 1083 { 1084 return fMaxFractionDigits; 1085 } 1086 1087 // ------------------------------------- 1088 // Sets the maximum number of digits for the fractional part for 1089 // this NumberFormat instance. 1090 1091 void 1092 NumberFormat::setMaximumFractionDigits(int32_t newValue) 1093 { 1094 fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits)); 1095 if(fMaxFractionDigits < fMinFractionDigits) 1096 fMinFractionDigits = fMaxFractionDigits; 1097 } 1098 1099 // ------------------------------------- 1100 // Gets the minimum number of digits for the fractional part for 1101 // this NumberFormat instance. 1102 1103 int32_t 1104 NumberFormat::getMinimumFractionDigits() const 1105 { 1106 return fMinFractionDigits; 1107 } 1108 1109 // ------------------------------------- 1110 // Sets the minimum number of digits for the fractional part for 1111 // this NumberFormat instance. 1112 1113 void 1114 NumberFormat::setMinimumFractionDigits(int32_t newValue) 1115 { 1116 fMinFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits)); 1117 if (fMaxFractionDigits < fMinFractionDigits) 1118 fMaxFractionDigits = fMinFractionDigits; 1119 } 1120 1121 // ------------------------------------- 1122 1123 void NumberFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) { 1124 if (U_FAILURE(ec)) { 1125 return; 1126 } 1127 if (theCurrency) { 1128 u_strncpy(fCurrency, theCurrency, 3); 1129 fCurrency[3] = 0; 1130 } else { 1131 fCurrency[0] = 0; 1132 } 1133 } 1134 1135 const UChar* NumberFormat::getCurrency() const { 1136 return fCurrency; 1137 } 1138 1139 void NumberFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const { 1140 const UChar* c = getCurrency(); 1141 if (*c != 0) { 1142 u_strncpy(result, c, 3); 1143 result[3] = 0; 1144 } else { 1145 const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec); 1146 if (loc == NULL) { 1147 loc = uloc_getDefault(); 1148 } 1149 ucurr_forLocale(loc, result, 4, &ec); 1150 } 1151 } 1152 1153 // ------------------------------------- 1154 // Creates the NumberFormat instance of the specified style (number, currency, 1155 // or percent) for the desired locale. 1156 1157 static void U_CALLCONV nscacheInit() { 1158 U_ASSERT(NumberingSystem_cache == NULL); 1159 ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup); 1160 UErrorCode status = U_ZERO_ERROR; 1161 NumberingSystem_cache = uhash_open(uhash_hashLong, 1162 uhash_compareLong, 1163 NULL, 1164 &status); 1165 if (U_FAILURE(status)) { 1166 // Number Format code will run with no cache if creation fails. 1167 NumberingSystem_cache = NULL; 1168 return; 1169 } 1170 uhash_setValueDeleter(NumberingSystem_cache, deleteNumberingSystem); 1171 } 1172 1173 UBool 1174 NumberFormat::isStyleSupported(UNumberFormatStyle style) { 1175 return gLastResortNumberPatterns[style] != NULL; 1176 } 1177 1178 NumberFormat* 1179 NumberFormat::makeInstance(const Locale& desiredLocale, 1180 UNumberFormatStyle style, 1181 UErrorCode& status) { 1182 return makeInstance(desiredLocale, style, false, status); 1183 } 1184 1185 NumberFormat* 1186 NumberFormat::makeInstance(const Locale& desiredLocale, 1187 UNumberFormatStyle style, 1188 UBool mustBeDecimalFormat, 1189 UErrorCode& status) { 1190 if (U_FAILURE(status)) return NULL; 1191 1192 if (style < 0 || style >= UNUM_FORMAT_STYLE_COUNT) { 1193 status = U_ILLEGAL_ARGUMENT_ERROR; 1194 return NULL; 1195 } 1196 1197 // Some styles are not supported. This is a result of merging 1198 // the @draft ICU 4.2 NumberFormat::EStyles into the long-existing UNumberFormatStyle. 1199 // Ticket #8503 is for reviewing/fixing/merging the two relevant implementations: 1200 // this one and unum_open(). 1201 // The UNUM_PATTERN_ styles are not supported here 1202 // because this method does not take a pattern string. 1203 if (!isStyleSupported(style)) { 1204 status = U_UNSUPPORTED_ERROR; 1205 return NULL; 1206 } 1207 1208 #if U_PLATFORM_USES_ONLY_WIN32_API 1209 if (!mustBeDecimalFormat) { 1210 char buffer[8]; 1211 int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status); 1212 1213 // if the locale has "@compat=host", create a host-specific NumberFormat 1214 if (U_SUCCESS(status) && count > 0 && uprv_strcmp(buffer, "host") == 0) { 1215 Win32NumberFormat *f = NULL; 1216 UBool curr = TRUE; 1217 1218 switch (style) { 1219 case UNUM_DECIMAL: 1220 curr = FALSE; 1221 // fall-through 1222 1223 case UNUM_CURRENCY: 1224 case UNUM_CURRENCY_ISO: // do not support plural formatting here 1225 case UNUM_CURRENCY_PLURAL: 1226 f = new Win32NumberFormat(desiredLocale, curr, status); 1227 1228 if (U_SUCCESS(status)) { 1229 return f; 1230 } 1231 1232 delete f; 1233 break; 1234 default: 1235 break; 1236 } 1237 } 1238 } 1239 #endif 1240 // Use numbering system cache hashtable 1241 umtx_initOnce(gNSCacheInitOnce, &nscacheInit); 1242 1243 // Get cached numbering system 1244 LocalPointer<NumberingSystem> ownedNs; 1245 NumberingSystem *ns = NULL; 1246 if (NumberingSystem_cache != NULL) { 1247 // TODO: Bad hash key usage, see ticket #8504. 1248 int32_t hashKey = desiredLocale.hashCode(); 1249 1250 Mutex lock(&nscacheMutex); 1251 ns = (NumberingSystem *)uhash_iget(NumberingSystem_cache, hashKey); 1252 if (ns == NULL) { 1253 ns = NumberingSystem::createInstance(desiredLocale,status); 1254 uhash_iput(NumberingSystem_cache, hashKey, (void*)ns, &status); 1255 } 1256 } else { 1257 ownedNs.adoptInstead(NumberingSystem::createInstance(desiredLocale,status)); 1258 ns = ownedNs.getAlias(); 1259 } 1260 1261 // check results of getting a numbering system 1262 if (U_FAILURE(status)) { 1263 return NULL; 1264 } 1265 1266 if (mustBeDecimalFormat && ns->isAlgorithmic()) { 1267 status = U_UNSUPPORTED_ERROR; 1268 return NULL; 1269 } 1270 1271 LocalPointer<DecimalFormatSymbols> symbolsToAdopt; 1272 UnicodeString pattern; 1273 LocalUResourceBundlePointer ownedResource(ures_open(NULL, desiredLocale.getName(), &status)); 1274 if (U_FAILURE(status)) { 1275 // We don't appear to have resource data available -- use the last-resort data 1276 status = U_USING_FALLBACK_WARNING; 1277 // When the data is unavailable, and locale isn't passed in, last resort data is used. 1278 symbolsToAdopt.adoptInstead(new DecimalFormatSymbols(status)); 1279 if (symbolsToAdopt.isNull()) { 1280 status = U_MEMORY_ALLOCATION_ERROR; 1281 return NULL; 1282 } 1283 1284 // Creates a DecimalFormat instance with the last resort number patterns. 1285 pattern.setTo(TRUE, gLastResortNumberPatterns[style], -1); 1286 } 1287 else { 1288 // Loads the decimal symbols of the desired locale. 1289 symbolsToAdopt.adoptInstead(new DecimalFormatSymbols(desiredLocale, status)); 1290 if (symbolsToAdopt.isNull()) { 1291 status = U_MEMORY_ALLOCATION_ERROR; 1292 return NULL; 1293 } 1294 1295 UResourceBundle *resource = ownedResource.orphan(); 1296 UResourceBundle *numElements = ures_getByKeyWithFallback(resource, gNumberElements, NULL, &status); 1297 resource = ures_getByKeyWithFallback(numElements, ns->getName(), resource, &status); 1298 resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status); 1299 ownedResource.adoptInstead(resource); 1300 1301 int32_t patLen = 0; 1302 const UChar *patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status); 1303 1304 // Didn't find a pattern specific to the numbering system, so fall back to "latn" 1305 if ( status == U_MISSING_RESOURCE_ERROR && uprv_strcmp(gLatn,ns->getName())) { 1306 status = U_ZERO_ERROR; 1307 resource = ures_getByKeyWithFallback(numElements, gLatn, resource, &status); 1308 resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status); 1309 patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status); 1310 } 1311 1312 ures_close(numElements); 1313 1314 // Creates the specified decimal format style of the desired locale. 1315 pattern.setTo(TRUE, patResStr, patLen); 1316 } 1317 if (U_FAILURE(status)) { 1318 return NULL; 1319 } 1320 if(style==UNUM_CURRENCY || style == UNUM_CURRENCY_ISO){ 1321 const UChar* currPattern = symbolsToAdopt->getCurrencyPattern(); 1322 if(currPattern!=NULL){ 1323 pattern.setTo(currPattern, u_strlen(currPattern)); 1324 } 1325 } 1326 1327 1328 NumberFormat *f; 1329 if (ns->isAlgorithmic()) { 1330 UnicodeString nsDesc; 1331 UnicodeString nsRuleSetGroup; 1332 UnicodeString nsRuleSetName; 1333 Locale nsLoc; 1334 URBNFRuleSetTag desiredRulesType = URBNF_NUMBERING_SYSTEM; 1335 1336 nsDesc.setTo(ns->getDescription()); 1337 int32_t firstSlash = nsDesc.indexOf(gSlash); 1338 int32_t lastSlash = nsDesc.lastIndexOf(gSlash); 1339 if ( lastSlash > firstSlash ) { 1340 CharString nsLocID; 1341 1342 nsLocID.appendInvariantChars(nsDesc.tempSubString(0, firstSlash), status); 1343 nsRuleSetGroup.setTo(nsDesc,firstSlash+1,lastSlash-firstSlash-1); 1344 nsRuleSetName.setTo(nsDesc,lastSlash+1); 1345 1346 nsLoc = Locale::createFromName(nsLocID.data()); 1347 1348 UnicodeString SpelloutRules = UNICODE_STRING_SIMPLE("SpelloutRules"); 1349 if ( nsRuleSetGroup.compare(SpelloutRules) == 0 ) { 1350 desiredRulesType = URBNF_SPELLOUT; 1351 } 1352 } else { 1353 nsLoc = desiredLocale; 1354 nsRuleSetName.setTo(nsDesc); 1355 } 1356 1357 RuleBasedNumberFormat *r = new RuleBasedNumberFormat(desiredRulesType,nsLoc,status); 1358 if (r == NULL) { 1359 status = U_MEMORY_ALLOCATION_ERROR; 1360 return NULL; 1361 } 1362 r->setDefaultRuleSet(nsRuleSetName,status); 1363 f = r; 1364 } else { 1365 // replace single currency sign in the pattern with double currency sign 1366 // if the style is UNUM_CURRENCY_ISO 1367 if (style == UNUM_CURRENCY_ISO) { 1368 pattern.findAndReplace(UnicodeString(TRUE, gSingleCurrencySign, 1), 1369 UnicodeString(TRUE, gDoubleCurrencySign, 2)); 1370 } 1371 1372 // "new DecimalFormat()" does not adopt the symbols if its memory allocation fails. 1373 DecimalFormatSymbols *syms = symbolsToAdopt.orphan(); 1374 f = new DecimalFormat(pattern, syms, style, status); 1375 if (f == NULL) { 1376 delete syms; 1377 status = U_MEMORY_ALLOCATION_ERROR; 1378 return NULL; 1379 } 1380 } 1381 1382 f->setLocaleIDs(ures_getLocaleByType(ownedResource.getAlias(), ULOC_VALID_LOCALE, &status), 1383 ures_getLocaleByType(ownedResource.getAlias(), ULOC_ACTUAL_LOCALE, &status)); 1384 if (U_FAILURE(status)) { 1385 delete f; 1386 return NULL; 1387 } 1388 return f; 1389 } 1390 1391 U_NAMESPACE_END 1392 1393 #endif /* #if !UCONFIG_NO_FORMATTING */ 1394 1395 //eof 1396