The Tor Browser / file comparison

comparison: intl/icu/source/i18n/numfmt.cpp

intl/icu/source/i18n/numfmt.cpp

branch
TOR_BUG_3246
changeset 4
fc2d59ddac77
equal deleted inserted replaced
-1:000000000000 0:6543708103a0
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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial