Home | History | Annotate | Download | only in i18n 
      1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 /*
      4  * Copyright (C) 2015, International Business Machines
      5  * Corporation and others.  All Rights Reserved.
      6  *
      7  * file name: decimfmtimpl.cpp
      8  */
      9 
     10 #include "unicode/utypes.h"
     11 
     12 #if !UCONFIG_NO_FORMATTING
     13 
     14 #include <math.h>
     15 #include "unicode/numfmt.h"
     16 #include "unicode/plurrule.h"
     17 #include "unicode/ustring.h"
     18 #include "decimalformatpattern.h"
     19 #include "decimalformatpatternimpl.h"
     20 #include "decimfmtimpl.h"
     21 #include "fphdlimp.h"
     22 #include "plurrule_impl.h"
     23 #include "valueformatter.h"
     24 #include "visibledigits.h"
     25 
     26 U_NAMESPACE_BEGIN
     27 
     28 static const int32_t kMaxScientificIntegerDigits = 8;
     29 
     30 static const int32_t kFormattingPosPrefix = (1 << 0);
     31 static const int32_t kFormattingNegPrefix = (1 << 1);
     32 static const int32_t kFormattingPosSuffix = (1 << 2);
     33 static const int32_t kFormattingNegSuffix = (1 << 3);
     34 static const int32_t kFormattingSymbols = (1 << 4);
     35 static const int32_t kFormattingCurrency = (1 << 5);
     36 static const int32_t kFormattingUsesCurrency = (1 << 6);
     37 static const int32_t kFormattingPluralRules = (1 << 7);
     38 static const int32_t kFormattingAffixParser = (1 << 8);
     39 static const int32_t kFormattingCurrencyAffixInfo = (1 << 9);
     40 static const int32_t kFormattingAll = (1 << 10) - 1;
     41 static const int32_t kFormattingAffixes =
     42         kFormattingPosPrefix | kFormattingPosSuffix |
     43         kFormattingNegPrefix | kFormattingNegSuffix;
     44 static const int32_t kFormattingAffixParserWithCurrency =
     45         kFormattingAffixParser | kFormattingCurrencyAffixInfo;
     46 
     47 DecimalFormatImpl::DecimalFormatImpl(
     48         NumberFormat *super,
     49         const Locale &locale,
     50         const UnicodeString &pattern,
     51         UErrorCode &status)
     52         : fSuper(super),
     53           fScale(0),
     54           fRoundingMode(DecimalFormat::kRoundHalfEven),
     55           fSymbols(NULL),
     56           fCurrencyUsage(UCURR_USAGE_STANDARD),
     57           fRules(NULL),
     58           fMonetary(FALSE) {
     59     if (U_FAILURE(status)) {
     60         return;
     61     }
     62     fSymbols = new DecimalFormatSymbols(
     63             locale, status);
     64     if (fSymbols == NULL) {
     65         status = U_MEMORY_ALLOCATION_ERROR;
     66         return;
     67     }
     68     UParseError parseError;
     69     applyPattern(pattern, FALSE, parseError, status);
     70     updateAll(status);
     71 }
     72 
     73 DecimalFormatImpl::DecimalFormatImpl(
     74         NumberFormat *super,
     75         const UnicodeString &pattern,
     76         DecimalFormatSymbols *symbolsToAdopt,
     77         UParseError &parseError,
     78         UErrorCode &status)
     79         : fSuper(super),
     80           fScale(0),
     81           fRoundingMode(DecimalFormat::kRoundHalfEven),
     82           fSymbols(symbolsToAdopt),
     83           fCurrencyUsage(UCURR_USAGE_STANDARD),
     84           fRules(NULL),
     85           fMonetary(FALSE) {
     86     applyPattern(pattern, FALSE, parseError, status);
     87     updateAll(status);
     88 }
     89 
     90 DecimalFormatImpl::DecimalFormatImpl(
     91     NumberFormat *super, const DecimalFormatImpl &other, UErrorCode &status) :
     92           fSuper(super),
     93           fMultiplier(other.fMultiplier),
     94           fScale(other.fScale),
     95           fRoundingMode(other.fRoundingMode),
     96           fMinSigDigits(other.fMinSigDigits),
     97           fMaxSigDigits(other.fMaxSigDigits),
     98           fUseScientific(other.fUseScientific),
     99           fUseSigDigits(other.fUseSigDigits),
    100           fGrouping(other.fGrouping),
    101           fPositivePrefixPattern(other.fPositivePrefixPattern),
    102           fNegativePrefixPattern(other.fNegativePrefixPattern),
    103           fPositiveSuffixPattern(other.fPositiveSuffixPattern),
    104           fNegativeSuffixPattern(other.fNegativeSuffixPattern),
    105           fSymbols(other.fSymbols),
    106           fCurrencyUsage(other.fCurrencyUsage),
    107           fRules(NULL),
    108           fMonetary(other.fMonetary),
    109           fAffixParser(other.fAffixParser),
    110           fCurrencyAffixInfo(other.fCurrencyAffixInfo),
    111           fEffPrecision(other.fEffPrecision),
    112           fEffGrouping(other.fEffGrouping),
    113           fOptions(other.fOptions),
    114           fFormatter(other.fFormatter),
    115           fAffixes(other.fAffixes) {
    116     fSymbols = new DecimalFormatSymbols(*fSymbols);
    117     if (fSymbols == NULL && U_SUCCESS(status)) {
    118         status = U_MEMORY_ALLOCATION_ERROR;
    119     }
    120     if (other.fRules != NULL) {
    121         fRules = new PluralRules(*other.fRules);
    122         if (fRules == NULL && U_SUCCESS(status)) {
    123             status = U_MEMORY_ALLOCATION_ERROR;
    124         }
    125     }
    126 }
    127 
    128 
    129 DecimalFormatImpl &
    130 DecimalFormatImpl::assign(const DecimalFormatImpl &other, UErrorCode &status) {
    131     if (U_FAILURE(status) || this == &other) {
    132         return (*this);
    133     }
    134     UObject::operator=(other);
    135     fMultiplier = other.fMultiplier;
    136     fScale = other.fScale;
    137     fRoundingMode = other.fRoundingMode;
    138     fMinSigDigits = other.fMinSigDigits;
    139     fMaxSigDigits = other.fMaxSigDigits;
    140     fUseScientific = other.fUseScientific;
    141     fUseSigDigits = other.fUseSigDigits;
    142     fGrouping = other.fGrouping;
    143     fPositivePrefixPattern = other.fPositivePrefixPattern;
    144     fNegativePrefixPattern = other.fNegativePrefixPattern;
    145     fPositiveSuffixPattern = other.fPositiveSuffixPattern;
    146     fNegativeSuffixPattern = other.fNegativeSuffixPattern;
    147     fCurrencyUsage = other.fCurrencyUsage;
    148     fMonetary = other.fMonetary;
    149     fAffixParser = other.fAffixParser;
    150     fCurrencyAffixInfo = other.fCurrencyAffixInfo;
    151     fEffPrecision = other.fEffPrecision;
    152     fEffGrouping = other.fEffGrouping;
    153     fOptions = other.fOptions;
    154     fFormatter = other.fFormatter;
    155     fAffixes = other.fAffixes;
    156     *fSymbols = *other.fSymbols;
    157     if (fRules != NULL && other.fRules != NULL) {
    158         *fRules = *other.fRules;
    159     } else {
    160         delete fRules;
    161         fRules = other.fRules;
    162         if (fRules != NULL) {
    163             fRules = new PluralRules(*fRules);
    164             if (fRules == NULL) {
    165                 status = U_MEMORY_ALLOCATION_ERROR;
    166                 return *this;
    167             }
    168         }
    169     }
    170     return *this;
    171 }
    172 
    173 UBool
    174 DecimalFormatImpl::operator==(const DecimalFormatImpl &other) const {
    175     if (this == &other) {
    176         return TRUE;
    177     }
    178     return (fMultiplier == other.fMultiplier)
    179             && (fScale == other.fScale)
    180             && (fRoundingMode == other.fRoundingMode)
    181             && (fMinSigDigits == other.fMinSigDigits)
    182             && (fMaxSigDigits == other.fMaxSigDigits)
    183             && (fUseScientific == other.fUseScientific)
    184             && (fUseSigDigits == other.fUseSigDigits)
    185             && fGrouping.equals(other.fGrouping)
    186             && fPositivePrefixPattern.equals(other.fPositivePrefixPattern)
    187             && fNegativePrefixPattern.equals(other.fNegativePrefixPattern)
    188             && fPositiveSuffixPattern.equals(other.fPositiveSuffixPattern)
    189             && fNegativeSuffixPattern.equals(other.fNegativeSuffixPattern)
    190             && fCurrencyUsage == other.fCurrencyUsage
    191             && fAffixParser.equals(other.fAffixParser)
    192             && fCurrencyAffixInfo.equals(other.fCurrencyAffixInfo)
    193             && fEffPrecision.equals(other.fEffPrecision)
    194             && fEffGrouping.equals(other.fEffGrouping)
    195             && fOptions.equals(other.fOptions)
    196             && fFormatter.equals(other.fFormatter)
    197             && fAffixes.equals(other.fAffixes)
    198             && (*fSymbols == *other.fSymbols)
    199             && ((fRules == other.fRules) || (
    200                     (fRules != NULL) && (other.fRules != NULL)
    201                     && (*fRules == *other.fRules)))
    202             && (fMonetary == other.fMonetary);
    203 }
    204 
    205 DecimalFormatImpl::~DecimalFormatImpl() {
    206     delete fSymbols;
    207     delete fRules;
    208 }
    209 
    210 ValueFormatter &
    211 DecimalFormatImpl::prepareValueFormatter(ValueFormatter &vf) const {
    212     if (fUseScientific) {
    213         vf.prepareScientificFormatting(
    214                 fFormatter, fEffPrecision, fOptions);
    215         return vf;
    216     }
    217     vf.prepareFixedDecimalFormatting(
    218             fFormatter, fEffGrouping, fEffPrecision.fMantissa, fOptions.fMantissa);
    219     return vf;
    220 }
    221 
    222 int32_t
    223 DecimalFormatImpl::getPatternScale() const {
    224     UBool usesPercent = fPositivePrefixPattern.usesPercent() ||
    225             fPositiveSuffixPattern.usesPercent() ||
    226             fNegativePrefixPattern.usesPercent() ||
    227             fNegativeSuffixPattern.usesPercent();
    228     if (usesPercent) {
    229         return 2;
    230     }
    231     UBool usesPermill = fPositivePrefixPattern.usesPermill() ||
    232             fPositiveSuffixPattern.usesPermill() ||
    233             fNegativePrefixPattern.usesPermill() ||
    234             fNegativeSuffixPattern.usesPermill();
    235     if (usesPermill) {
    236         return 3;
    237     }
    238     return 0;
    239 }
    240 
    241 void
    242 DecimalFormatImpl::setMultiplierScale(int32_t scale) {
    243     if (scale == 0) {
    244         // Needed to preserve equality. fMultiplier == 0 means
    245         // multiplier is 1.
    246         fMultiplier.set((int32_t)0);
    247     } else {
    248         fMultiplier.set((int32_t)1);
    249         fMultiplier.shiftDecimalRight(scale);
    250     }
    251 }
    252 
    253 UnicodeString &
    254 DecimalFormatImpl::format(
    255         int32_t number,
    256         UnicodeString &appendTo,
    257         FieldPosition &pos,
    258         UErrorCode &status) const {
    259     FieldPositionOnlyHandler handler(pos);
    260     return formatInt32(number, appendTo, handler, status);
    261 }
    262 
    263 UnicodeString &
    264 DecimalFormatImpl::format(
    265         int32_t number,
    266         UnicodeString &appendTo,
    267         FieldPositionIterator *posIter,
    268         UErrorCode &status) const {
    269     FieldPositionIteratorHandler handler(posIter, status);
    270     return formatInt32(number, appendTo, handler, status);
    271 }
    272 
    273 template<class T>
    274 UBool DecimalFormatImpl::maybeFormatWithDigitList(
    275         T number,
    276         UnicodeString &appendTo,
    277         FieldPositionHandler &handler,
    278         UErrorCode &status) const {
    279     if (!fMultiplier.isZero()) {
    280         DigitList digits;
    281         digits.set(number);
    282         digits.mult(fMultiplier, status);
    283         digits.shiftDecimalRight(fScale);
    284         formatAdjustedDigitList(digits, appendTo, handler, status);
    285         return TRUE;
    286     }
    287     if (fScale != 0) {
    288         DigitList digits;
    289         digits.set(number);
    290         digits.shiftDecimalRight(fScale);
    291         formatAdjustedDigitList(digits, appendTo, handler, status);
    292         return TRUE;
    293     }
    294     return FALSE;
    295 }
    296 
    297 template<class T>
    298 UBool DecimalFormatImpl::maybeInitVisibleDigitsFromDigitList(
    299         T number,
    300         VisibleDigitsWithExponent &visibleDigits,
    301         UErrorCode &status) const {
    302     if (!fMultiplier.isZero()) {
    303         DigitList digits;
    304         digits.set(number);
    305         digits.mult(fMultiplier, status);
    306         digits.shiftDecimalRight(fScale);
    307         initVisibleDigitsFromAdjusted(digits, visibleDigits, status);
    308         return TRUE;
    309     }
    310     if (fScale != 0) {
    311         DigitList digits;
    312         digits.set(number);
    313         digits.shiftDecimalRight(fScale);
    314         initVisibleDigitsFromAdjusted(digits, visibleDigits, status);
    315         return TRUE;
    316     }
    317     return FALSE;
    318 }
    319 
    320 UnicodeString &
    321 DecimalFormatImpl::formatInt32(
    322         int32_t number,
    323         UnicodeString &appendTo,
    324         FieldPositionHandler &handler,
    325         UErrorCode &status) const {
    326     if (maybeFormatWithDigitList(number, appendTo, handler, status)) {
    327         return appendTo;
    328     }
    329     ValueFormatter vf;
    330     return fAffixes.formatInt32(
    331             number,
    332             prepareValueFormatter(vf),
    333             handler,
    334             fRules,
    335             appendTo,
    336             status);
    337 }
    338 
    339 UnicodeString &
    340 DecimalFormatImpl::formatInt64(
    341         int64_t number,
    342         UnicodeString &appendTo,
    343         FieldPositionHandler &handler,
    344         UErrorCode &status) const {
    345     if (number >= INT32_MIN && number <= INT32_MAX) {
    346         return formatInt32((int32_t) number, appendTo, handler, status);
    347     }
    348     VisibleDigitsWithExponent digits;
    349     initVisibleDigitsWithExponent(number, digits, status);
    350     return formatVisibleDigitsWithExponent(
    351             digits, appendTo, handler, status);
    352 }
    353 
    354 UnicodeString &
    355 DecimalFormatImpl::formatDouble(
    356         double number,
    357         UnicodeString &appendTo,
    358         FieldPositionHandler &handler,
    359         UErrorCode &status) const {
    360     VisibleDigitsWithExponent digits;
    361     initVisibleDigitsWithExponent(number, digits, status);
    362     return formatVisibleDigitsWithExponent(
    363             digits, appendTo, handler, status);
    364 }
    365 
    366 UnicodeString &
    367 DecimalFormatImpl::format(
    368         double number,
    369         UnicodeString &appendTo,
    370         FieldPosition &pos,
    371         UErrorCode &status) const {
    372     FieldPositionOnlyHandler handler(pos);
    373     return formatDouble(number, appendTo, handler, status);
    374 }
    375 
    376 UnicodeString &
    377 DecimalFormatImpl::format(
    378         const DigitList &number,
    379         UnicodeString &appendTo,
    380         FieldPosition &pos,
    381         UErrorCode &status) const {
    382     DigitList dl(number);
    383     FieldPositionOnlyHandler handler(pos);
    384     return formatDigitList(dl, appendTo, handler, status);
    385 }
    386 
    387 UnicodeString &
    388 DecimalFormatImpl::format(
    389         int64_t number,
    390         UnicodeString &appendTo,
    391         FieldPosition &pos,
    392         UErrorCode &status) const {
    393     FieldPositionOnlyHandler handler(pos);
    394     return formatInt64(number, appendTo, handler, status);
    395 }
    396 
    397 UnicodeString &
    398 DecimalFormatImpl::format(
    399         int64_t number,
    400         UnicodeString &appendTo,
    401         FieldPositionIterator *posIter,
    402         UErrorCode &status) const {
    403     FieldPositionIteratorHandler handler(posIter, status);
    404     return formatInt64(number, appendTo, handler, status);
    405 }
    406 
    407 UnicodeString &
    408 DecimalFormatImpl::format(
    409         double number,
    410         UnicodeString &appendTo,
    411         FieldPositionIterator *posIter,
    412         UErrorCode &status) const {
    413     FieldPositionIteratorHandler handler(posIter, status);
    414     return formatDouble(number, appendTo, handler, status);
    415 }
    416 
    417 UnicodeString &
    418 DecimalFormatImpl::format(
    419         const DigitList &number,
    420         UnicodeString &appendTo,
    421         FieldPositionIterator *posIter,
    422         UErrorCode &status) const {
    423     DigitList dl(number);
    424     FieldPositionIteratorHandler handler(posIter, status);
    425     return formatDigitList(dl, appendTo, handler, status);
    426 }
    427 
    428 UnicodeString &
    429 DecimalFormatImpl::format(
    430         StringPiece number,
    431         UnicodeString &appendTo,
    432         FieldPositionIterator *posIter,
    433         UErrorCode &status) const {
    434     DigitList dl;
    435     dl.set(number, status);
    436     FieldPositionIteratorHandler handler(posIter, status);
    437     return formatDigitList(dl, appendTo, handler, status);
    438 }
    439 
    440 UnicodeString &
    441 DecimalFormatImpl::format(
    442         const VisibleDigitsWithExponent &digits,
    443         UnicodeString &appendTo,
    444         FieldPosition &pos,
    445         UErrorCode &status) const {
    446     FieldPositionOnlyHandler handler(pos);
    447     return formatVisibleDigitsWithExponent(
    448             digits, appendTo, handler, status);
    449 }
    450 
    451 UnicodeString &
    452 DecimalFormatImpl::format(
    453         const VisibleDigitsWithExponent &digits,
    454         UnicodeString &appendTo,
    455         FieldPositionIterator *posIter,
    456         UErrorCode &status) const {
    457     FieldPositionIteratorHandler handler(posIter, status);
    458     return formatVisibleDigitsWithExponent(
    459             digits, appendTo, handler, status);
    460 }
    461 
    462 DigitList &
    463 DecimalFormatImpl::adjustDigitList(
    464         DigitList &number, UErrorCode &status) const {
    465     number.setRoundingMode(fRoundingMode);
    466     if (!fMultiplier.isZero()) {
    467         number.mult(fMultiplier, status);
    468     }
    469     if (fScale != 0) {
    470         number.shiftDecimalRight(fScale);
    471     }
    472     number.reduce();
    473     return number;
    474 }
    475 
    476 UnicodeString &
    477 DecimalFormatImpl::formatDigitList(
    478         DigitList &number,
    479         UnicodeString &appendTo,
    480         FieldPositionHandler &handler,
    481         UErrorCode &status) const {
    482     VisibleDigitsWithExponent digits;
    483     initVisibleDigitsWithExponent(number, digits, status);
    484     return formatVisibleDigitsWithExponent(
    485             digits, appendTo, handler, status);
    486 }
    487 
    488 UnicodeString &
    489 DecimalFormatImpl::formatAdjustedDigitList(
    490         DigitList &number,
    491         UnicodeString &appendTo,
    492         FieldPositionHandler &handler,
    493         UErrorCode &status) const {
    494     ValueFormatter vf;
    495     return fAffixes.format(
    496             number,
    497             prepareValueFormatter(vf),
    498             handler,
    499             fRules,
    500             appendTo,
    501             status);
    502 }
    503 
    504 UnicodeString &
    505 DecimalFormatImpl::formatVisibleDigitsWithExponent(
    506         const VisibleDigitsWithExponent &digits,
    507         UnicodeString &appendTo,
    508         FieldPositionHandler &handler,
    509         UErrorCode &status) const {
    510     ValueFormatter vf;
    511     return fAffixes.format(
    512             digits,
    513             prepareValueFormatter(vf),
    514             handler,
    515             fRules,
    516             appendTo,
    517             status);
    518 }
    519 
    520 static FixedDecimal &initFixedDecimal(
    521         const VisibleDigits &digits, FixedDecimal &result) {
    522     result.source = 0.0;
    523     result.isNegative = digits.isNegative();
    524     result.isNanOrInfinity = digits.isNaNOrInfinity();
    525     digits.getFixedDecimal(
    526             result.source, result.intValue, result.decimalDigits,
    527             result.decimalDigitsWithoutTrailingZeros,
    528             result.visibleDecimalDigitCount, result.hasIntegerValue);
    529     return result;
    530 }
    531 
    532 FixedDecimal &
    533 DecimalFormatImpl::getFixedDecimal(double number, FixedDecimal &result, UErrorCode &status) const {
    534     if (U_FAILURE(status)) {
    535         return result;
    536     }
    537     VisibleDigits digits;
    538     fEffPrecision.fMantissa.initVisibleDigits(number, digits, status);
    539     return initFixedDecimal(digits, result);
    540 }
    541 
    542 FixedDecimal &
    543 DecimalFormatImpl::getFixedDecimal(
    544         DigitList &number, FixedDecimal &result, UErrorCode &status) const {
    545     if (U_FAILURE(status)) {
    546         return result;
    547     }
    548     VisibleDigits digits;
    549     fEffPrecision.fMantissa.initVisibleDigits(number, digits, status);
    550     return initFixedDecimal(digits, result);
    551 }
    552 
    553 VisibleDigitsWithExponent &
    554 DecimalFormatImpl::initVisibleDigitsWithExponent(
    555         int64_t number,
    556         VisibleDigitsWithExponent &digits,
    557         UErrorCode &status) const {
    558     if (maybeInitVisibleDigitsFromDigitList(
    559             number, digits, status)) {
    560         return digits;
    561     }
    562     if (fUseScientific) {
    563         fEffPrecision.initVisibleDigitsWithExponent(
    564                 number, digits, status);
    565     } else {
    566         fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
    567                 number, digits, status);
    568     }
    569     return digits;
    570 }
    571 
    572 VisibleDigitsWithExponent &
    573 DecimalFormatImpl::initVisibleDigitsWithExponent(
    574         double number,
    575         VisibleDigitsWithExponent &digits,
    576         UErrorCode &status) const {
    577     if (maybeInitVisibleDigitsFromDigitList(
    578             number, digits, status)) {
    579         return digits;
    580     }
    581     if (fUseScientific) {
    582         fEffPrecision.initVisibleDigitsWithExponent(
    583                 number, digits, status);
    584     } else {
    585         fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
    586                 number, digits, status);
    587     }
    588     return digits;
    589 }
    590 
    591 VisibleDigitsWithExponent &
    592 DecimalFormatImpl::initVisibleDigitsWithExponent(
    593         DigitList &number,
    594         VisibleDigitsWithExponent &digits,
    595         UErrorCode &status) const {
    596     adjustDigitList(number, status);
    597     return initVisibleDigitsFromAdjusted(number, digits, status);
    598 }
    599 
    600 VisibleDigitsWithExponent &
    601 DecimalFormatImpl::initVisibleDigitsFromAdjusted(
    602         DigitList &number,
    603         VisibleDigitsWithExponent &digits,
    604         UErrorCode &status) const {
    605     if (fUseScientific) {
    606         fEffPrecision.initVisibleDigitsWithExponent(
    607                 number, digits, status);
    608     } else {
    609         fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
    610                 number, digits, status);
    611     }
    612     return digits;
    613 }
    614 
    615 DigitList &
    616 DecimalFormatImpl::round(
    617         DigitList &number, UErrorCode &status) const {
    618     if (number.isNaN() || number.isInfinite()) {
    619         return number;
    620     }
    621     adjustDigitList(number, status);
    622     ValueFormatter vf;
    623     prepareValueFormatter(vf);
    624     return vf.round(number, status);
    625 }
    626 
    627 void
    628 DecimalFormatImpl::setMinimumSignificantDigits(int32_t newValue) {
    629     fMinSigDigits = newValue;
    630     fUseSigDigits = TRUE; // ticket 9936
    631     updatePrecision();
    632 }
    633 
    634 void
    635 DecimalFormatImpl::setMaximumSignificantDigits(int32_t newValue) {
    636     fMaxSigDigits = newValue;
    637     fUseSigDigits = TRUE; // ticket 9936
    638     updatePrecision();
    639 }
    640 
    641 void
    642 DecimalFormatImpl::setMinMaxSignificantDigits(int32_t min, int32_t max) {
    643     fMinSigDigits = min;
    644     fMaxSigDigits = max;
    645     fUseSigDigits = TRUE; // ticket 9936
    646     updatePrecision();
    647 }
    648 
    649 void
    650 DecimalFormatImpl::setScientificNotation(UBool newValue) {
    651     fUseScientific = newValue;
    652     updatePrecision();
    653 }
    654 
    655 void
    656 DecimalFormatImpl::setSignificantDigitsUsed(UBool newValue) {
    657     fUseSigDigits = newValue;
    658     updatePrecision();
    659 }
    660 
    661 void
    662 DecimalFormatImpl::setGroupingSize(int32_t newValue) {
    663     fGrouping.fGrouping = newValue;
    664     updateGrouping();
    665 }
    666 
    667 void
    668 DecimalFormatImpl::setSecondaryGroupingSize(int32_t newValue) {
    669     fGrouping.fGrouping2 = newValue;
    670     updateGrouping();
    671 }
    672 
    673 void
    674 DecimalFormatImpl::setMinimumGroupingDigits(int32_t newValue) {
    675     fGrouping.fMinGrouping = newValue;
    676     updateGrouping();
    677 }
    678 
    679 void
    680 DecimalFormatImpl::setCurrencyUsage(
    681         UCurrencyUsage currencyUsage, UErrorCode &status) {
    682     fCurrencyUsage = currencyUsage;
    683     updateFormatting(kFormattingCurrency, status);
    684 }
    685 
    686 void
    687 DecimalFormatImpl::setRoundingIncrement(double d) {
    688     if (d > 0.0) {
    689         fEffPrecision.fMantissa.fRoundingIncrement.set(d);
    690     } else {
    691         fEffPrecision.fMantissa.fRoundingIncrement.set(0.0);
    692     }
    693 }
    694 
    695 double
    696 DecimalFormatImpl::getRoundingIncrement() const {
    697     return fEffPrecision.fMantissa.fRoundingIncrement.getDouble();
    698 }
    699 
    700 int32_t
    701 DecimalFormatImpl::getMultiplier() const {
    702     if (fMultiplier.isZero()) {
    703         return 1;
    704     }
    705     return (int32_t) fMultiplier.getDouble();
    706 }
    707 
    708 void
    709 DecimalFormatImpl::setMultiplier(int32_t m) {
    710     if (m == 0 || m == 1) {
    711         fMultiplier.set((int32_t)0);
    712     } else {
    713         fMultiplier.set(m);
    714     }
    715 }
    716 
    717 void
    718 DecimalFormatImpl::setPositivePrefix(const UnicodeString &str) {
    719     fPositivePrefixPattern.remove();
    720     fPositivePrefixPattern.addLiteral(str.getBuffer(), 0, str.length());
    721     UErrorCode status = U_ZERO_ERROR;
    722     updateFormatting(kFormattingPosPrefix, status);
    723 }
    724 
    725 void
    726 DecimalFormatImpl::setPositiveSuffix(const UnicodeString &str) {
    727     fPositiveSuffixPattern.remove();
    728     fPositiveSuffixPattern.addLiteral(str.getBuffer(), 0, str.length());
    729     UErrorCode status = U_ZERO_ERROR;
    730     updateFormatting(kFormattingPosSuffix, status);
    731 }
    732 
    733 void
    734 DecimalFormatImpl::setNegativePrefix(const UnicodeString &str) {
    735     fNegativePrefixPattern.remove();
    736     fNegativePrefixPattern.addLiteral(str.getBuffer(), 0, str.length());
    737     UErrorCode status = U_ZERO_ERROR;
    738     updateFormatting(kFormattingNegPrefix, status);
    739 }
    740 
    741 void
    742 DecimalFormatImpl::setNegativeSuffix(const UnicodeString &str) {
    743     fNegativeSuffixPattern.remove();
    744     fNegativeSuffixPattern.addLiteral(str.getBuffer(), 0, str.length());
    745     UErrorCode status = U_ZERO_ERROR;
    746     updateFormatting(kFormattingNegSuffix, status);
    747 }
    748 
    749 UnicodeString &
    750 DecimalFormatImpl::getPositivePrefix(UnicodeString &result) const {
    751     result = fAffixes.fPositivePrefix.getOtherVariant().toString();
    752     return result;
    753 }
    754 
    755 UnicodeString &
    756 DecimalFormatImpl::getPositiveSuffix(UnicodeString &result) const {
    757     result = fAffixes.fPositiveSuffix.getOtherVariant().toString();
    758     return result;
    759 }
    760 
    761 UnicodeString &
    762 DecimalFormatImpl::getNegativePrefix(UnicodeString &result) const {
    763     result = fAffixes.fNegativePrefix.getOtherVariant().toString();
    764     return result;
    765 }
    766 
    767 UnicodeString &
    768 DecimalFormatImpl::getNegativeSuffix(UnicodeString &result) const {
    769     result = fAffixes.fNegativeSuffix.getOtherVariant().toString();
    770     return result;
    771 }
    772 
    773 void
    774 DecimalFormatImpl::adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt) {
    775     if (symbolsToAdopt == NULL) {
    776         return;
    777     }
    778     delete fSymbols;
    779     fSymbols = symbolsToAdopt;
    780     UErrorCode status = U_ZERO_ERROR;
    781     updateFormatting(kFormattingSymbols, status);
    782 }
    783 
    784 void
    785 DecimalFormatImpl::applyPatternFavorCurrencyPrecision(
    786         const UnicodeString &pattern, UErrorCode &status) {
    787     UParseError perror;
    788     applyPattern(pattern, FALSE, perror, status);
    789     updateForApplyPatternFavorCurrencyPrecision(status);
    790 }
    791 
    792 void
    793 DecimalFormatImpl::applyPattern(
    794         const UnicodeString &pattern, UErrorCode &status) {
    795     UParseError perror;
    796     applyPattern(pattern, FALSE, perror, status);
    797     updateForApplyPattern(status);
    798 }
    799 
    800 void
    801 DecimalFormatImpl::applyPattern(
    802         const UnicodeString &pattern,
    803         UParseError &perror, UErrorCode &status) {
    804     applyPattern(pattern, FALSE, perror, status);
    805     updateForApplyPattern(status);
    806 }
    807 
    808 void
    809 DecimalFormatImpl::applyLocalizedPattern(
    810         const UnicodeString &pattern, UErrorCode &status) {
    811     UParseError perror;
    812     applyPattern(pattern, TRUE, perror, status);
    813     updateForApplyPattern(status);
    814 }
    815 
    816 void
    817 DecimalFormatImpl::applyLocalizedPattern(
    818         const UnicodeString &pattern,
    819         UParseError &perror,  UErrorCode &status) {
    820     applyPattern(pattern, TRUE, perror, status);
    821     updateForApplyPattern(status);
    822 }
    823 
    824 void
    825 DecimalFormatImpl::applyPattern(
    826         const UnicodeString &pattern,
    827         UBool localized, UParseError &perror, UErrorCode &status) {
    828     if (U_FAILURE(status)) {
    829         return;
    830     }
    831     DecimalFormatPatternParser patternParser;
    832     if (localized) {
    833         patternParser.useSymbols(*fSymbols);
    834     }
    835     DecimalFormatPattern out;
    836     patternParser.applyPatternWithoutExpandAffix(
    837             pattern, out, perror, status);
    838     if (U_FAILURE(status)) {
    839         return;
    840     }
    841     fUseScientific = out.fUseExponentialNotation;
    842     fUseSigDigits = out.fUseSignificantDigits;
    843     fSuper->NumberFormat::setMinimumIntegerDigits(out.fMinimumIntegerDigits);
    844     fSuper->NumberFormat::setMaximumIntegerDigits(out.fMaximumIntegerDigits);
    845     fSuper->NumberFormat::setMinimumFractionDigits(out.fMinimumFractionDigits);
    846     fSuper->NumberFormat::setMaximumFractionDigits(out.fMaximumFractionDigits);
    847     fMinSigDigits = out.fMinimumSignificantDigits;
    848     fMaxSigDigits = out.fMaximumSignificantDigits;
    849     fEffPrecision.fMinExponentDigits = out.fMinExponentDigits;
    850     fOptions.fExponent.fAlwaysShowSign = out.fExponentSignAlwaysShown;
    851     fSuper->NumberFormat::setGroupingUsed(out.fGroupingUsed);
    852     fGrouping.fGrouping = out.fGroupingSize;
    853     fGrouping.fGrouping2 = out.fGroupingSize2;
    854     fOptions.fMantissa.fAlwaysShowDecimal = out.fDecimalSeparatorAlwaysShown;
    855     if (out.fRoundingIncrementUsed) {
    856         fEffPrecision.fMantissa.fRoundingIncrement = out.fRoundingIncrement;
    857     } else {
    858         fEffPrecision.fMantissa.fRoundingIncrement.clear();
    859     }
    860     fAffixes.fPadChar = out.fPad;
    861     fNegativePrefixPattern = out.fNegPrefixAffix;
    862     fNegativeSuffixPattern = out.fNegSuffixAffix;
    863     fPositivePrefixPattern = out.fPosPrefixAffix;
    864     fPositiveSuffixPattern = out.fPosSuffixAffix;
    865 
    866     // Work around. Pattern parsing code and DecimalFormat code don't agree
    867     // on the definition of field width, so we have to translate from
    868     // pattern field width to decimal format field width here.
    869     fAffixes.fWidth = out.fFormatWidth == 0 ? 0 :
    870             out.fFormatWidth + fPositivePrefixPattern.countChar32()
    871             + fPositiveSuffixPattern.countChar32();
    872     switch (out.fPadPosition) {
    873     case DecimalFormatPattern::kPadBeforePrefix:
    874         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix;
    875         break;
    876     case DecimalFormatPattern::kPadAfterPrefix:
    877         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix;
    878         break;
    879     case DecimalFormatPattern::kPadBeforeSuffix:
    880         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix;
    881         break;
    882     case DecimalFormatPattern::kPadAfterSuffix:
    883         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix;
    884         break;
    885     default:
    886         break;
    887     }
    888 }
    889 
    890 void
    891 DecimalFormatImpl::updatePrecision() {
    892     if (fUseScientific) {
    893         updatePrecisionForScientific();
    894     } else {
    895         updatePrecisionForFixed();
    896     }
    897 }
    898 
    899 static void updatePrecisionForScientificMinMax(
    900         const DigitInterval &min,
    901         const DigitInterval &max,
    902         DigitInterval &resultMin,
    903         DigitInterval &resultMax,
    904         SignificantDigitInterval &resultSignificant) {
    905     resultMin.setIntDigitCount(0);
    906     resultMin.setFracDigitCount(0);
    907     resultSignificant.clear();
    908     resultMax.clear();
    909 
    910     int32_t maxIntDigitCount = max.getIntDigitCount();
    911     int32_t minIntDigitCount = min.getIntDigitCount();
    912     int32_t maxFracDigitCount = max.getFracDigitCount();
    913     int32_t minFracDigitCount = min.getFracDigitCount();
    914 
    915 
    916     // Not in spec: maxIntDigitCount > 8 assume
    917     // maxIntDigitCount = minIntDigitCount. Current DecimalFormat API has
    918     // no provision for unsetting maxIntDigitCount which would be useful for
    919     // scientific notation. The best we can do is assume that if
    920     // maxIntDigitCount is the default of 2000000000 or is "big enough" then
    921     // user did not intend to explicitly set it. The 8 was derived emperically
    922     // by extensive testing of legacy code.
    923     if (maxIntDigitCount > 8) {
    924         maxIntDigitCount = minIntDigitCount;
    925     }
    926 
    927     // Per the spec, exponent grouping happens if maxIntDigitCount is more
    928     // than 1 and more than minIntDigitCount.
    929     UBool bExponentGrouping = maxIntDigitCount > 1 && minIntDigitCount < maxIntDigitCount;
    930     if (bExponentGrouping) {
    931         resultMax.setIntDigitCount(maxIntDigitCount);
    932 
    933         // For exponent grouping minIntDigits is always treated as 1 even
    934         // if it wasn't set to 1!
    935         resultMin.setIntDigitCount(1);
    936     } else {
    937         // Fixed digit count left of decimal. minIntDigitCount doesn't have
    938         // to equal maxIntDigitCount i.e minIntDigitCount == 0 while
    939         // maxIntDigitCount == 1.
    940         int32_t fixedIntDigitCount = maxIntDigitCount;
    941 
    942         // If fixedIntDigitCount is 0 but
    943         // min or max fraction count is 0 too then use 1. This way we can get
    944         // unlimited precision for X.XXXEX
    945         if (fixedIntDigitCount == 0 && (minFracDigitCount == 0 || maxFracDigitCount == 0)) {
    946             fixedIntDigitCount = 1;
    947         }
    948         resultMax.setIntDigitCount(fixedIntDigitCount);
    949         resultMin.setIntDigitCount(fixedIntDigitCount);
    950     }
    951     // Spec says this is how we compute significant digits. 0 means
    952     // unlimited significant digits.
    953     int32_t maxSigDigits = minIntDigitCount + maxFracDigitCount;
    954     if (maxSigDigits > 0) {
    955         int32_t minSigDigits = minIntDigitCount + minFracDigitCount;
    956         resultSignificant.setMin(minSigDigits);
    957         resultSignificant.setMax(maxSigDigits);
    958     }
    959 }
    960 
    961 void
    962 DecimalFormatImpl::updatePrecisionForScientific() {
    963     FixedPrecision *result = &fEffPrecision.fMantissa;
    964     if (fUseSigDigits) {
    965         result->fMax.setFracDigitCount(-1);
    966         result->fMax.setIntDigitCount(1);
    967         result->fMin.setFracDigitCount(0);
    968         result->fMin.setIntDigitCount(1);
    969         result->fSignificant.clear();
    970         extractSigDigits(result->fSignificant);
    971         return;
    972     }
    973     DigitInterval max;
    974     DigitInterval min;
    975     extractMinMaxDigits(min, max);
    976     updatePrecisionForScientificMinMax(
    977             min, max,
    978             result->fMin, result->fMax, result->fSignificant);
    979 }
    980 
    981 void
    982 DecimalFormatImpl::updatePrecisionForFixed() {
    983     FixedPrecision *result = &fEffPrecision.fMantissa;
    984     if (!fUseSigDigits) {
    985         extractMinMaxDigits(result->fMin, result->fMax);
    986         result->fSignificant.clear();
    987     } else {
    988         extractSigDigits(result->fSignificant);
    989         result->fMin.setIntDigitCount(1);
    990         result->fMin.setFracDigitCount(0);
    991         result->fMax.clear();
    992     }
    993 }
    994 
    995 void
    996  DecimalFormatImpl::extractMinMaxDigits(
    997         DigitInterval &min, DigitInterval &max) const {
    998     min.setIntDigitCount(fSuper->getMinimumIntegerDigits());
    999     max.setIntDigitCount(fSuper->getMaximumIntegerDigits());
   1000     min.setFracDigitCount(fSuper->getMinimumFractionDigits());
   1001     max.setFracDigitCount(fSuper->getMaximumFractionDigits());
   1002 }
   1003 
   1004 void
   1005  DecimalFormatImpl::extractSigDigits(
   1006         SignificantDigitInterval &sig) const {
   1007     sig.setMin(fMinSigDigits < 0 ? 0 : fMinSigDigits);
   1008     sig.setMax(fMaxSigDigits < 0 ? 0 : fMaxSigDigits);
   1009 }
   1010 
   1011 void
   1012 DecimalFormatImpl::updateGrouping() {
   1013     if (fSuper->isGroupingUsed()) {
   1014         fEffGrouping = fGrouping;
   1015     } else {
   1016         fEffGrouping.clear();
   1017     }
   1018 }
   1019 
   1020 void
   1021 DecimalFormatImpl::updateCurrency(UErrorCode &status) {
   1022     updateFormatting(kFormattingCurrency, TRUE, status);
   1023 }
   1024 
   1025 void
   1026 DecimalFormatImpl::updateFormatting(
   1027         int32_t changedFormattingFields,
   1028         UErrorCode &status) {
   1029     updateFormatting(changedFormattingFields, TRUE, status);
   1030 }
   1031 
   1032 void
   1033 DecimalFormatImpl::updateFormatting(
   1034         int32_t changedFormattingFields,
   1035         UBool updatePrecisionBasedOnCurrency,
   1036         UErrorCode &status) {
   1037     if (U_FAILURE(status)) {
   1038         return;
   1039     }
   1040     // Each function updates one field. Order matters. For instance,
   1041     // updatePluralRules comes before updateCurrencyAffixInfo because the
   1042     // fRules field is needed to update the fCurrencyAffixInfo field.
   1043     updateFormattingUsesCurrency(changedFormattingFields);
   1044     updateFormattingFixedPointFormatter(changedFormattingFields);
   1045     updateFormattingAffixParser(changedFormattingFields);
   1046     updateFormattingPluralRules(changedFormattingFields, status);
   1047     updateFormattingCurrencyAffixInfo(
   1048             changedFormattingFields,
   1049             updatePrecisionBasedOnCurrency,
   1050             status);
   1051     updateFormattingLocalizedPositivePrefix(
   1052             changedFormattingFields, status);
   1053     updateFormattingLocalizedPositiveSuffix(
   1054             changedFormattingFields, status);
   1055     updateFormattingLocalizedNegativePrefix(
   1056             changedFormattingFields, status);
   1057     updateFormattingLocalizedNegativeSuffix(
   1058             changedFormattingFields, status);
   1059 }
   1060 
   1061 void
   1062 DecimalFormatImpl::updateFormattingUsesCurrency(
   1063         int32_t &changedFormattingFields) {
   1064     if ((changedFormattingFields & kFormattingAffixes) == 0) {
   1065         // If no affixes changed, don't need to do any work
   1066         return;
   1067     }
   1068     UBool newUsesCurrency =
   1069             fPositivePrefixPattern.usesCurrency() ||
   1070             fPositiveSuffixPattern.usesCurrency() ||
   1071             fNegativePrefixPattern.usesCurrency() ||
   1072             fNegativeSuffixPattern.usesCurrency();
   1073     if (fMonetary != newUsesCurrency) {
   1074         fMonetary = newUsesCurrency;
   1075         changedFormattingFields |= kFormattingUsesCurrency;
   1076     }
   1077 }
   1078 
   1079 void
   1080 DecimalFormatImpl::updateFormattingPluralRules(
   1081         int32_t &changedFormattingFields, UErrorCode &status) {
   1082     if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) {
   1083         // No work to do if both fSymbols and fMonetary
   1084         // fields are unchanged
   1085         return;
   1086     }
   1087     if (U_FAILURE(status)) {
   1088         return;
   1089     }
   1090     PluralRules *newRules = NULL;
   1091     if (fMonetary) {
   1092         newRules = PluralRules::forLocale(fSymbols->getLocale(), status);
   1093         if (U_FAILURE(status)) {
   1094             return;
   1095         }
   1096     }
   1097     // Its ok to say a field has changed when it really hasn't but not
   1098     // the other way around. Here we assume the field changed unless it
   1099     // was NULL before and is still NULL now
   1100     if (fRules != newRules) {
   1101         delete fRules;
   1102         fRules = newRules;
   1103         changedFormattingFields |= kFormattingPluralRules;
   1104     }
   1105 }
   1106 
   1107 void
   1108 DecimalFormatImpl::updateFormattingCurrencyAffixInfo(
   1109         int32_t &changedFormattingFields,
   1110         UBool updatePrecisionBasedOnCurrency,
   1111         UErrorCode &status) {
   1112     if ((changedFormattingFields & (
   1113             kFormattingSymbols | kFormattingCurrency |
   1114             kFormattingUsesCurrency | kFormattingPluralRules)) == 0) {
   1115         // If all these fields are unchanged, no work to do.
   1116         return;
   1117     }
   1118     if (U_FAILURE(status)) {
   1119         return;
   1120     }
   1121     if (!fMonetary) {
   1122         if (fCurrencyAffixInfo.isDefault()) {
   1123             // In this case don't have to do any work
   1124             return;
   1125         }
   1126         fCurrencyAffixInfo.set(NULL, NULL, NULL, status);
   1127         if (U_FAILURE(status)) {
   1128             return;
   1129         }
   1130         changedFormattingFields |= kFormattingCurrencyAffixInfo;
   1131     } else {
   1132         const UChar *currency = fSuper->getCurrency();
   1133         UChar localeCurr[4];
   1134         if (currency[0] == 0) {
   1135             ucurr_forLocale(fSymbols->getLocale().getName(), localeCurr, UPRV_LENGTHOF(localeCurr), &status);
   1136             if (U_SUCCESS(status)) {
   1137                 currency = localeCurr;
   1138                 fSuper->NumberFormat::setCurrency(currency, status);
   1139             } else {
   1140                 currency = NULL;
   1141                 status = U_ZERO_ERROR;
   1142             }
   1143         }
   1144         fCurrencyAffixInfo.set(
   1145                 fSymbols->getLocale().getName(), fRules, currency, status);
   1146         if (U_FAILURE(status)) {
   1147             return;
   1148         }
   1149         UBool customCurrencySymbol = FALSE;
   1150         // If DecimalFormatSymbols has custom currency symbol, prefer
   1151         // that over what we just read from the resource bundles
   1152         if (fSymbols->isCustomCurrencySymbol()) {
   1153             fCurrencyAffixInfo.setSymbol(
   1154                     fSymbols->getConstSymbol(DecimalFormatSymbols::kCurrencySymbol));
   1155             customCurrencySymbol = TRUE;
   1156         }
   1157         if (fSymbols->isCustomIntlCurrencySymbol()) {
   1158             fCurrencyAffixInfo.setISO(
   1159                     fSymbols->getConstSymbol(DecimalFormatSymbols::kIntlCurrencySymbol));
   1160             customCurrencySymbol = TRUE;
   1161         }
   1162         changedFormattingFields |= kFormattingCurrencyAffixInfo;
   1163         if (currency && !customCurrencySymbol && updatePrecisionBasedOnCurrency) {
   1164             FixedPrecision precision;
   1165             CurrencyAffixInfo::adjustPrecision(
   1166                     currency, fCurrencyUsage, precision, status);
   1167             if (U_FAILURE(status)) {
   1168                 return;
   1169             }
   1170             fSuper->NumberFormat::setMinimumFractionDigits(
   1171                     precision.fMin.getFracDigitCount());
   1172             fSuper->NumberFormat::setMaximumFractionDigits(
   1173                     precision.fMax.getFracDigitCount());
   1174             updatePrecision();
   1175             fEffPrecision.fMantissa.fRoundingIncrement =
   1176                     precision.fRoundingIncrement;
   1177         }
   1178 
   1179     }
   1180 }
   1181 
   1182 void
   1183 DecimalFormatImpl::updateFormattingFixedPointFormatter(
   1184         int32_t &changedFormattingFields) {
   1185     if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) {
   1186         // No work to do if fSymbols is unchanged
   1187         return;
   1188     }
   1189     if (fMonetary) {
   1190         fFormatter.setDecimalFormatSymbolsForMonetary(*fSymbols);
   1191     } else {
   1192         fFormatter.setDecimalFormatSymbols(*fSymbols);
   1193     }
   1194 }
   1195 
   1196 void
   1197 DecimalFormatImpl::updateFormattingAffixParser(
   1198         int32_t &changedFormattingFields) {
   1199     if ((changedFormattingFields & kFormattingSymbols) == 0) {
   1200         // No work to do if fSymbols is unchanged
   1201         return;
   1202     }
   1203     fAffixParser.setDecimalFormatSymbols(*fSymbols);
   1204     changedFormattingFields |= kFormattingAffixParser;
   1205 }
   1206 
   1207 void
   1208 DecimalFormatImpl::updateFormattingLocalizedPositivePrefix(
   1209         int32_t &changedFormattingFields, UErrorCode &status) {
   1210     if (U_FAILURE(status)) {
   1211         return;
   1212     }
   1213     if ((changedFormattingFields & (
   1214             kFormattingPosPrefix | kFormattingAffixParserWithCurrency)) == 0) {
   1215         // No work to do
   1216         return;
   1217     }
   1218     fAffixes.fPositivePrefix.remove();
   1219     fAffixParser.parse(
   1220             fPositivePrefixPattern,
   1221             fCurrencyAffixInfo,
   1222             fAffixes.fPositivePrefix,
   1223             status);
   1224 }
   1225 
   1226 void
   1227 DecimalFormatImpl::updateFormattingLocalizedPositiveSuffix(
   1228         int32_t &changedFormattingFields, UErrorCode &status) {
   1229     if (U_FAILURE(status)) {
   1230         return;
   1231     }
   1232     if ((changedFormattingFields & (
   1233             kFormattingPosSuffix | kFormattingAffixParserWithCurrency)) == 0) {
   1234         // No work to do
   1235         return;
   1236     }
   1237     fAffixes.fPositiveSuffix.remove();
   1238     fAffixParser.parse(
   1239             fPositiveSuffixPattern,
   1240             fCurrencyAffixInfo,
   1241             fAffixes.fPositiveSuffix,
   1242             status);
   1243 }
   1244 
   1245 void
   1246 DecimalFormatImpl::updateFormattingLocalizedNegativePrefix(
   1247         int32_t &changedFormattingFields, UErrorCode &status) {
   1248     if (U_FAILURE(status)) {
   1249         return;
   1250     }
   1251     if ((changedFormattingFields & (
   1252             kFormattingNegPrefix | kFormattingAffixParserWithCurrency)) == 0) {
   1253         // No work to do
   1254         return;
   1255     }
   1256     fAffixes.fNegativePrefix.remove();
   1257     fAffixParser.parse(
   1258             fNegativePrefixPattern,
   1259             fCurrencyAffixInfo,
   1260             fAffixes.fNegativePrefix,
   1261             status);
   1262 }
   1263 
   1264 void
   1265 DecimalFormatImpl::updateFormattingLocalizedNegativeSuffix(
   1266         int32_t &changedFormattingFields, UErrorCode &status) {
   1267     if (U_FAILURE(status)) {
   1268         return;
   1269     }
   1270     if ((changedFormattingFields & (
   1271             kFormattingNegSuffix | kFormattingAffixParserWithCurrency)) == 0) {
   1272         // No work to do
   1273         return;
   1274     }
   1275     fAffixes.fNegativeSuffix.remove();
   1276     fAffixParser.parse(
   1277             fNegativeSuffixPattern,
   1278             fCurrencyAffixInfo,
   1279             fAffixes.fNegativeSuffix,
   1280             status);
   1281 }
   1282 
   1283 void
   1284 DecimalFormatImpl::updateForApplyPatternFavorCurrencyPrecision(
   1285         UErrorCode &status) {
   1286     updateAll(kFormattingAll & ~kFormattingSymbols, TRUE, status);
   1287 }
   1288 
   1289 void
   1290 DecimalFormatImpl::updateForApplyPattern(UErrorCode &status) {
   1291     updateAll(kFormattingAll & ~kFormattingSymbols, FALSE, status);
   1292 }
   1293 
   1294 void
   1295 DecimalFormatImpl::updateAll(UErrorCode &status) {
   1296     updateAll(kFormattingAll, TRUE, status);
   1297 }
   1298 
   1299 void
   1300 DecimalFormatImpl::updateAll(
   1301         int32_t formattingFlags,
   1302         UBool updatePrecisionBasedOnCurrency,
   1303         UErrorCode &status) {
   1304     if (U_FAILURE(status)) {
   1305         return;
   1306     }
   1307     updatePrecision();
   1308     updateGrouping();
   1309     updateFormatting(
   1310             formattingFlags, updatePrecisionBasedOnCurrency, status);
   1311     setMultiplierScale(getPatternScale());
   1312 }
   1313 
   1314 
   1315 static int32_t
   1316 getMinimumLengthToDescribeGrouping(const DigitGrouping &grouping) {
   1317     if (grouping.fGrouping <= 0) {
   1318         return 0;
   1319     }
   1320     if (grouping.fGrouping2 <= 0) {
   1321         return grouping.fGrouping + 1;
   1322     }
   1323     return grouping.fGrouping + grouping.fGrouping2 + 1;
   1324 }
   1325 
   1326 /**
   1327  * Given a grouping policy, calculates how many digits are needed left of
   1328  * the decimal point to achieve a desired length left of the
   1329  * decimal point.
   1330  * @param grouping the grouping policy
   1331  * @param desiredLength number of characters needed left of decimal point
   1332  * @param minLeftDigits at least this many digits is returned
   1333  * @param leftDigits the number of digits needed stored here
   1334  *  which is >= minLeftDigits.
   1335  * @return true if a perfect fit or false if having leftDigits would exceed
   1336  *   desiredLength
   1337  */
   1338 static UBool
   1339 getLeftDigitsForLeftLength(
   1340         const DigitGrouping &grouping,
   1341         int32_t desiredLength,
   1342         int32_t minLeftDigits,
   1343         int32_t &leftDigits) {
   1344     leftDigits = minLeftDigits;
   1345     int32_t lengthSoFar = leftDigits + grouping.getSeparatorCount(leftDigits);
   1346     while (lengthSoFar < desiredLength) {
   1347         lengthSoFar += grouping.isSeparatorAt(leftDigits + 1, leftDigits) ? 2 : 1;
   1348         ++leftDigits;
   1349     }
   1350     return (lengthSoFar == desiredLength);
   1351 }
   1352 
   1353 int32_t
   1354 DecimalFormatImpl::computeExponentPatternLength() const {
   1355     if (fUseScientific) {
   1356         return 1 + (fOptions.fExponent.fAlwaysShowSign ? 1 : 0) + fEffPrecision.fMinExponentDigits;
   1357     }
   1358     return 0;
   1359 }
   1360 
   1361 int32_t
   1362 DecimalFormatImpl::countFractionDigitAndDecimalPatternLength(
   1363         int32_t fracDigitCount) const {
   1364     if (!fOptions.fMantissa.fAlwaysShowDecimal && fracDigitCount == 0) {
   1365         return 0;
   1366     }
   1367     return fracDigitCount + 1;
   1368 }
   1369 
   1370 UnicodeString&
   1371 DecimalFormatImpl::toNumberPattern(
   1372         UBool hasPadding, int32_t minimumLength, UnicodeString& result) const {
   1373     // Get a grouping policy like the one in this object that does not
   1374     // have minimum grouping since toPattern doesn't support it.
   1375     DigitGrouping grouping(fEffGrouping);
   1376     grouping.fMinGrouping = 0;
   1377 
   1378     // Only for fixed digits, these are the digits that get 0's.
   1379     DigitInterval minInterval;
   1380 
   1381     // Only for fixed digits, these are the digits that get #'s.
   1382     DigitInterval maxInterval;
   1383 
   1384     // Only for significant digits
   1385     int32_t sigMin;
   1386     int32_t sigMax;
   1387 
   1388     // These are all the digits to be displayed. For significant digits,
   1389     // this interval always starts at the 1's place an extends left.
   1390     DigitInterval fullInterval;
   1391 
   1392     // Digit range of rounding increment. If rounding increment is .025.
   1393     // then roundingIncrementLowerExp = -3 and roundingIncrementUpperExp = -1
   1394     int32_t roundingIncrementLowerExp = 0;
   1395     int32_t roundingIncrementUpperExp = 0;
   1396 
   1397     if (fUseSigDigits) {
   1398         SignificantDigitInterval sigInterval;
   1399         extractSigDigits(sigInterval);
   1400         sigMax = sigInterval.getMax();
   1401         sigMin = sigInterval.getMin();
   1402         fullInterval.setFracDigitCount(0);
   1403         fullInterval.setIntDigitCount(sigMax);
   1404     } else {
   1405         extractMinMaxDigits(minInterval, maxInterval);
   1406         if (fUseScientific) {
   1407            if (maxInterval.getIntDigitCount() > kMaxScientificIntegerDigits) {
   1408                maxInterval.setIntDigitCount(1);
   1409                minInterval.shrinkToFitWithin(maxInterval);
   1410            }
   1411         } else if (hasPadding) {
   1412             // Make max int digits match min int digits for now, we
   1413             // compute necessary padding later.
   1414             maxInterval.setIntDigitCount(minInterval.getIntDigitCount());
   1415         } else {
   1416             // For some reason toPattern adds at least one leading '#'
   1417             maxInterval.setIntDigitCount(minInterval.getIntDigitCount() + 1);
   1418         }
   1419         if (!fEffPrecision.fMantissa.fRoundingIncrement.isZero()) {
   1420             roundingIncrementLowerExp =
   1421                     fEffPrecision.fMantissa.fRoundingIncrement.getLowerExponent();
   1422             roundingIncrementUpperExp =
   1423                     fEffPrecision.fMantissa.fRoundingIncrement.getUpperExponent();
   1424             // We have to include the rounding increment in what we display
   1425             maxInterval.expandToContainDigit(roundingIncrementLowerExp);
   1426             maxInterval.expandToContainDigit(roundingIncrementUpperExp - 1);
   1427         }
   1428         fullInterval = maxInterval;
   1429     }
   1430     // We have to include enough digits to show grouping strategy
   1431     int32_t minLengthToDescribeGrouping =
   1432            getMinimumLengthToDescribeGrouping(grouping);
   1433     if (minLengthToDescribeGrouping > 0) {
   1434         fullInterval.expandToContainDigit(
   1435                 getMinimumLengthToDescribeGrouping(grouping) - 1);
   1436     }
   1437 
   1438     // If we have a minimum length, we have to add digits to the left to
   1439     // depict padding.
   1440     if (hasPadding) {
   1441         // For non scientific notation,
   1442         //  minimumLengthForMantissa = minimumLength
   1443         int32_t minimumLengthForMantissa =
   1444                 minimumLength - computeExponentPatternLength();
   1445         int32_t mininumLengthForMantissaIntPart =
   1446                 minimumLengthForMantissa
   1447                 - countFractionDigitAndDecimalPatternLength(
   1448                         fullInterval.getFracDigitCount());
   1449         // Because of grouping, we may need fewer than expected digits to
   1450         // achieve the length we need.
   1451         int32_t digitsNeeded;
   1452         if (getLeftDigitsForLeftLength(
   1453                 grouping,
   1454                 mininumLengthForMantissaIntPart,
   1455                 fullInterval.getIntDigitCount(),
   1456                 digitsNeeded)) {
   1457 
   1458             // In this case, we achieved the exact length that we want.
   1459             fullInterval.setIntDigitCount(digitsNeeded);
   1460         } else if (digitsNeeded > fullInterval.getIntDigitCount()) {
   1461 
   1462             // Having digitsNeeded digits goes over desired length which
   1463             // means that to have desired length would mean starting on a
   1464             // grouping sepearator e.g ,###,### so add a '#' and use one
   1465             // less digit. This trick gives ####,### but that is the best
   1466             // we can do.
   1467             result.append(kPatternDigit);
   1468             fullInterval.setIntDigitCount(digitsNeeded - 1);
   1469         }
   1470     }
   1471     int32_t maxDigitPos = fullInterval.getMostSignificantExclusive();
   1472     int32_t minDigitPos = fullInterval.getLeastSignificantInclusive();
   1473     for (int32_t i = maxDigitPos - 1; i >= minDigitPos; --i) {
   1474         if (!fOptions.fMantissa.fAlwaysShowDecimal && i == -1) {
   1475             result.append(kPatternDecimalSeparator);
   1476         }
   1477         if (fUseSigDigits) {
   1478             // Use digit symbol
   1479             if (i >= sigMax || i < sigMax - sigMin) {
   1480                 result.append(kPatternDigit);
   1481             } else {
   1482                 result.append(kPatternSignificantDigit);
   1483             }
   1484         } else {
   1485             if (i < roundingIncrementUpperExp && i >= roundingIncrementLowerExp) {
   1486                 result.append((UChar)(fEffPrecision.fMantissa.fRoundingIncrement.getDigitByExponent(i) + kPatternZeroDigit));
   1487             } else if (minInterval.contains(i)) {
   1488                 result.append(kPatternZeroDigit);
   1489             } else {
   1490                 result.append(kPatternDigit);
   1491             }
   1492         }
   1493         if (grouping.isSeparatorAt(i + 1, i)) {
   1494             result.append(kPatternGroupingSeparator);
   1495         }
   1496         if (fOptions.fMantissa.fAlwaysShowDecimal && i == 0) {
   1497             result.append(kPatternDecimalSeparator);
   1498         }
   1499     }
   1500     if (fUseScientific) {
   1501         result.append(kPatternExponent);
   1502         if (fOptions.fExponent.fAlwaysShowSign) {
   1503             result.append(kPatternPlus);
   1504         }
   1505         for (int32_t i = 0; i < 1 || i < fEffPrecision.fMinExponentDigits; ++i) {
   1506             result.append(kPatternZeroDigit);
   1507         }
   1508     }
   1509     return result;
   1510 }
   1511 
   1512 UnicodeString&
   1513 DecimalFormatImpl::toPattern(UnicodeString& result) const {
   1514     result.remove();
   1515     UnicodeString padSpec;
   1516     if (fAffixes.fWidth > 0) {
   1517         padSpec.append(kPatternPadEscape);
   1518         padSpec.append(fAffixes.fPadChar);
   1519     }
   1520     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) {
   1521         result.append(padSpec);
   1522     }
   1523     fPositivePrefixPattern.toUserString(result);
   1524     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) {
   1525         result.append(padSpec);
   1526     }
   1527     toNumberPattern(
   1528             fAffixes.fWidth > 0,
   1529             fAffixes.fWidth - fPositivePrefixPattern.countChar32() - fPositiveSuffixPattern.countChar32(),
   1530             result);
   1531     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) {
   1532         result.append(padSpec);
   1533     }
   1534     fPositiveSuffixPattern.toUserString(result);
   1535     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) {
   1536         result.append(padSpec);
   1537     }
   1538     AffixPattern withNegative;
   1539     withNegative.add(AffixPattern::kNegative);
   1540     withNegative.append(fPositivePrefixPattern);
   1541     if (!fPositiveSuffixPattern.equals(fNegativeSuffixPattern) ||
   1542             !withNegative.equals(fNegativePrefixPattern)) {
   1543         result.append(kPatternSeparator);
   1544         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) {
   1545             result.append(padSpec);
   1546         }
   1547         fNegativePrefixPattern.toUserString(result);
   1548         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) {
   1549             result.append(padSpec);
   1550         }
   1551         toNumberPattern(
   1552                 fAffixes.fWidth > 0,
   1553                 fAffixes.fWidth - fNegativePrefixPattern.countChar32() - fNegativeSuffixPattern.countChar32(),
   1554                 result);
   1555         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) {
   1556             result.append(padSpec);
   1557         }
   1558         fNegativeSuffixPattern.toUserString(result);
   1559         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) {
   1560             result.append(padSpec);
   1561         }
   1562     }
   1563     return result;
   1564 }
   1565 
   1566 int32_t
   1567 DecimalFormatImpl::getOldFormatWidth() const {
   1568     if (fAffixes.fWidth == 0) {
   1569         return 0;
   1570     }
   1571     return fAffixes.fWidth - fPositiveSuffixPattern.countChar32() - fPositivePrefixPattern.countChar32();
   1572 }
   1573 
   1574 const UnicodeString &
   1575 DecimalFormatImpl::getConstSymbol(
   1576         DecimalFormatSymbols::ENumberFormatSymbol symbol) const {
   1577    return fSymbols->getConstSymbol(symbol);
   1578 }
   1579 
   1580 UBool
   1581 DecimalFormatImpl::isParseFastpath() const {
   1582     AffixPattern negative;
   1583     negative.add(AffixPattern::kNegative);
   1584 
   1585     return fAffixes.fWidth == 0 &&
   1586     fPositivePrefixPattern.countChar32() == 0 &&
   1587     fNegativePrefixPattern.equals(negative) &&
   1588     fPositiveSuffixPattern.countChar32() == 0 &&
   1589     fNegativeSuffixPattern.countChar32() == 0;
   1590 }
   1591 
   1592 
   1593 U_NAMESPACE_END
   1594 
   1595 #endif /* #if !UCONFIG_NO_FORMATTING */
   1596 
   1597