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