icuSources/i18n/decimalformatpattern.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 1997-2015, International Business Machines Corporation and    *
   4 * others. All Rights Reserved.                                                *
   5 *******************************************************************************
   6 */
   7
   8 #include "uassert.h"
   9 #include "decimalformatpattern.h"
  10
  11 #if !UCONFIG_NO_FORMATTING
  12
  13 #include "unicode/dcfmtsym.h"
  14 #include "unicode/format.h"
  15 #include "unicode/utf16.h"
  16 #include "decimalformatpatternimpl.h"
  17
  18
  19 #ifdef FMT_DEBUG
  20 #define debug(x) printf("%s:%d: %s\n", __FILE__,__LINE__, x);
  21 #else
  22 #define debug(x)
  23 #endif
  24
  25 U_NAMESPACE_BEGIN
  26
  27 // TODO: Travis Keep: Copied from numfmt.cpp
  28 static int32_t kDoubleIntegerDigits  = 309;
  29 static int32_t kDoubleFractionDigits = 340;
  30
  31
  32 // TODO: Travis Keep: Copied from numfmt.cpp
  33 static int32_t gDefaultMaxIntegerDigits = 2000000000;
  34
  35 // TODO: Travis Keep: This function was copied from format.cpp
  36 static void syntaxError(const UnicodeString& pattern,
  37                          int32_t pos,
  38                          UParseError& parseError) {
  39     parseError.offset = pos;
  40     parseError.line=0;  // we are not using line number
  41
  42     // for pre-context
  43     int32_t start = (pos < U_PARSE_CONTEXT_LEN)? 0 : (pos - (U_PARSE_CONTEXT_LEN-1
  44                                                              /* subtract 1 so that we have room for null*/));
  45     int32_t stop  = pos;
  46     pattern.extract(start,stop-start,parseError.preContext,0);
  47     //null terminate the buffer
  48     parseError.preContext[stop-start] = 0;
  49
  50     //for post-context
  51     start = pos+1;
  52     stop  = ((pos+U_PARSE_CONTEXT_LEN)<=pattern.length()) ? (pos+(U_PARSE_CONTEXT_LEN-1)) :
  53         pattern.length();
  54     pattern.extract(start,stop-start,parseError.postContext,0);
  55     //null terminate the buffer
  56     parseError.postContext[stop-start]= 0;
  57 }
  58
  59 DecimalFormatPattern::DecimalFormatPattern()
  60         : fMinimumIntegerDigits(1),
  61           fMaximumIntegerDigits(gDefaultMaxIntegerDigits),
  62           fMinimumFractionDigits(0),
  63           fMaximumFractionDigits(3),
  64           fUseSignificantDigits(FALSE),
  65           fMinimumSignificantDigits(1),
  66           fMaximumSignificantDigits(6),
  67           fUseExponentialNotation(FALSE),
  68           fMinExponentDigits(0),
  69           fExponentSignAlwaysShown(FALSE),
  70           fCurrencySignCount(fgCurrencySignCountZero),
  71           fGroupingUsed(TRUE),
  72           fGroupingSize(0),
  73           fGroupingSize2(0),
  74           fMultiplier(1),
  75           fDecimalSeparatorAlwaysShown(FALSE),
  76           fFormatWidth(0),
  77           fRoundingIncrementUsed(FALSE),
  78           fRoundingIncrement(),
  79           fPad(kDefaultPad),
  80           fNegPatternsBogus(TRUE),
  81           fPosPatternsBogus(TRUE),
  82           fNegPrefixPattern(),
  83           fNegSuffixPattern(),
  84           fPosPrefixPattern(),
  85           fPosSuffixPattern(),
  86           fPadPosition(DecimalFormatPattern::kPadBeforePrefix) {
  87 }
  88
  89
  90 DecimalFormatPatternParser::DecimalFormatPatternParser() :
  91     fZeroDigit(kPatternZeroDigit),
  92     fSigDigit(kPatternSignificantDigit),
  93     fGroupingSeparator((UChar)kPatternGroupingSeparator),
  94     fDecimalSeparator((UChar)kPatternDecimalSeparator),
  95     fPercent((UChar)kPatternPercent),
  96     fPerMill((UChar)kPatternPerMill),
  97     fDigit((UChar)kPatternDigit),
  98     fSeparator((UChar)kPatternSeparator),
  99     fExponent((UChar)kPatternExponent),
 100     fPlus((UChar)kPatternPlus),
 101     fMinus((UChar)kPatternMinus),
 102     fPadEscape((UChar)kPatternPadEscape) {
 103 }
 104
 105 void DecimalFormatPatternParser::useSymbols(
 106         const DecimalFormatSymbols& symbols) {
 107     fZeroDigit = symbols.getConstSymbol(
 108             DecimalFormatSymbols::kZeroDigitSymbol).char32At(0);
 109     fSigDigit = symbols.getConstSymbol(
 110             DecimalFormatSymbols::kSignificantDigitSymbol).char32At(0);
 111     fGroupingSeparator = symbols.getConstSymbol(
 112             DecimalFormatSymbols::kGroupingSeparatorSymbol);
 113     fDecimalSeparator = symbols.getConstSymbol(
 114             DecimalFormatSymbols::kDecimalSeparatorSymbol);
 115     fPercent = symbols.getConstSymbol(
 116             DecimalFormatSymbols::kPercentSymbol);
 117     fPerMill = symbols.getConstSymbol(
 118             DecimalFormatSymbols::kPerMillSymbol);
 119     fDigit = symbols.getConstSymbol(
 120             DecimalFormatSymbols::kDigitSymbol);
 121     fSeparator = symbols.getConstSymbol(
 122             DecimalFormatSymbols::kPatternSeparatorSymbol);
 123     fExponent = symbols.getConstSymbol(
 124             DecimalFormatSymbols::kExponentialSymbol);
 125     fPlus = symbols.getConstSymbol(
 126             DecimalFormatSymbols::kPlusSignSymbol);
 127     fMinus = symbols.getConstSymbol(
 128             DecimalFormatSymbols::kMinusSignSymbol);
 129     fPadEscape = symbols.getConstSymbol(
 130             DecimalFormatSymbols::kPadEscapeSymbol);
 131 }
 132
 133 void
 134 DecimalFormatPatternParser::applyPatternWithoutExpandAffix(
 135         const UnicodeString& pattern,
 136         DecimalFormatPattern& out,
 137         UParseError& parseError,
 138         UErrorCode& status) {
 139     if (U_FAILURE(status))
 140     {
 141         return;
 142     }
 143     out = DecimalFormatPattern();
 144
 145     // Clear error struct
 146     parseError.offset = -1;
 147     parseError.preContext[0] = parseError.postContext[0] = (UChar)0;
 148
 149     // TODO: Travis Keep: This won't always work.
 150     UChar nineDigit = (UChar)(fZeroDigit + 9);
 151     int32_t digitLen = fDigit.length();
 152     int32_t groupSepLen = fGroupingSeparator.length();
 153     int32_t decimalSepLen = fDecimalSeparator.length();
 154
 155     int32_t pos = 0;
 156     int32_t patLen = pattern.length();
 157     // Part 0 is the positive pattern.  Part 1, if present, is the negative
 158     // pattern.
 159     for (int32_t part=0; part<2 && pos<patLen; ++part) {
 160         // The subpart ranges from 0 to 4: 0=pattern proper, 1=prefix,
 161         // 2=suffix, 3=prefix in quote, 4=suffix in quote.  Subpart 0 is
 162         // between the prefix and suffix, and consists of pattern
 163         // characters.  In the prefix and suffix, percent, perMill, and
 164         // currency symbols are recognized and translated.
 165         int32_t subpart = 1, sub0Start = 0, sub0Limit = 0, sub2Limit = 0;
 166
 167         // It's important that we don't change any fields of this object
 168         // prematurely.  We set the following variables for the multiplier,
 169         // grouping, etc., and then only change the actual object fields if
 170         // everything parses correctly.  This also lets us register
 171         // the data from part 0 and ignore the part 1, except for the
 172         // prefix and suffix.
 173         UnicodeString prefix;
 174         UnicodeString suffix;
 175         int32_t decimalPos = -1;
 176         int32_t multiplier = 1;
 177         int32_t digitLeftCount = 0, zeroDigitCount = 0, digitRightCount = 0, sigDigitCount = 0;
 178         int8_t groupingCount = -1;
 179         int8_t groupingCount2 = -1;
 180         int32_t padPos = -1;
 181         UChar32 padChar = 0;
 182         int32_t roundingPos = -1;
 183         DigitList roundingInc;
 184         int8_t expDigits = -1;
 185         UBool expSignAlways = FALSE;
 186
 187         // The affix is either the prefix or the suffix.
 188         UnicodeString* affix = &prefix;
 189
 190         int32_t start = pos;
 191         UBool isPartDone = FALSE;
 192         UChar32 ch;
 193
 194         for (; !isPartDone && pos < patLen; ) {
 195             // Todo: account for surrogate pairs
 196             ch = pattern.char32At(pos);
 197             switch (subpart) {
 198             case 0: // Pattern proper subpart (between prefix & suffix)
 199                 // Process the digits, decimal, and grouping characters.  We
 200                 // record five pieces of information.  We expect the digits
 201                 // to occur in the pattern ####00.00####, and we record the
 202                 // number of left digits, zero (central) digits, and right
 203                 // digits.  The position of the last grouping character is
 204                 // recorded (should be somewhere within the first two blocks
 205                 // of characters), as is the position of the decimal point,
 206                 // if any (should be in the zero digits).  If there is no
 207                 // decimal point, then there should be no right digits.
 208                 if (pattern.compare(pos, digitLen, fDigit) == 0) {
 209                     if (zeroDigitCount > 0 || sigDigitCount > 0) {
 210                         ++digitRightCount;
 211                     } else {
 212                         ++digitLeftCount;
 213                     }
 214                     if (groupingCount >= 0 && decimalPos < 0) {
 215                         ++groupingCount;
 216                     }
 217                     pos += digitLen;
 218                 } else if ((ch >= fZeroDigit && ch <= nineDigit) ||
 219                            ch == fSigDigit) {
 220                     if (digitRightCount > 0) {
 221                         // Unexpected '0'
 222                         debug("Unexpected '0'")
 223                         status = U_UNEXPECTED_TOKEN;
 224                         syntaxError(pattern,pos,parseError);
 225                         return;
 226                     }
 227                     if (ch == fSigDigit) {
 228                         ++sigDigitCount;
 229                     } else {
 230                         if (ch != fZeroDigit && roundingPos < 0) {
 231                             roundingPos = digitLeftCount + zeroDigitCount;
 232                         }
 233                         if (roundingPos >= 0) {
 234                             roundingInc.append((char)(ch - fZeroDigit + '0'));
 235                         }
 236                         ++zeroDigitCount;
 237                     }
 238                     if (groupingCount >= 0 && decimalPos < 0) {
 239                         ++groupingCount;
 240                     }
 241                     pos += U16_LENGTH(ch);
 242                 } else if (pattern.compare(pos, groupSepLen, fGroupingSeparator) == 0) {
 243                     if (decimalPos >= 0) {
 244                         // Grouping separator after decimal
 245                         debug("Grouping separator after decimal")
 246                         status = U_UNEXPECTED_TOKEN;
 247                         syntaxError(pattern,pos,parseError);
 248                         return;
 249                     }
 250                     groupingCount2 = groupingCount;
 251                     groupingCount = 0;
 252                     pos += groupSepLen;
 253                 } else if (pattern.compare(pos, decimalSepLen, fDecimalSeparator) == 0) {
 254                     if (decimalPos >= 0) {
 255                         // Multiple decimal separators
 256                         debug("Multiple decimal separators")
 257                         status = U_MULTIPLE_DECIMAL_SEPARATORS;
 258                         syntaxError(pattern,pos,parseError);
 259                         return;
 260                     }
 261                     // Intentionally incorporate the digitRightCount,
 262                     // even though it is illegal for this to be > 0
 263                     // at this point.  We check pattern syntax below.
 264                     decimalPos = digitLeftCount + zeroDigitCount + digitRightCount;
 265                     pos += decimalSepLen;
 266                 } else {
 267                     if (pattern.compare(pos, fExponent.length(), fExponent) == 0) {
 268                         if (expDigits >= 0) {
 269                             // Multiple exponential symbols
 270                             debug("Multiple exponential symbols")
 271                             status = U_MULTIPLE_EXPONENTIAL_SYMBOLS;
 272                             syntaxError(pattern,pos,parseError);
 273                             return;
 274                         }
 275                         if (groupingCount >= 0) {
 276                             // Grouping separator in exponential pattern
 277                             debug("Grouping separator in exponential pattern")
 278                             status = U_MALFORMED_EXPONENTIAL_PATTERN;
 279                             syntaxError(pattern,pos,parseError);
 280                             return;
 281                         }
 282                         pos += fExponent.length();
 283                         // Check for positive prefix
 284                         if (pos < patLen
 285                             && pattern.compare(pos, fPlus.length(), fPlus) == 0) {
 286                             expSignAlways = TRUE;
 287                             pos += fPlus.length();
 288                         }
 289                         // Use lookahead to parse out the exponential part of the
 290                         // pattern, then jump into suffix subpart.
 291                         expDigits = 0;
 292                         while (pos < patLen &&
 293                                pattern.char32At(pos) == fZeroDigit) {
 294                             ++expDigits;
 295                             pos += U16_LENGTH(fZeroDigit);
 296                         }
 297
 298                         // 1. Require at least one mantissa pattern digit
 299                         // 2. Disallow "#+ @" in mantissa
 300                         // 3. Require at least one exponent pattern digit
 301                         if (((digitLeftCount + zeroDigitCount) < 1 &&
 302                              (sigDigitCount + digitRightCount) < 1) ||
 303                             (sigDigitCount > 0 && digitLeftCount > 0) ||
 304                             expDigits < 1) {
 305                             // Malformed exponential pattern
 306                             debug("Malformed exponential pattern")
 307                             status = U_MALFORMED_EXPONENTIAL_PATTERN;
 308                             syntaxError(pattern,pos,parseError);
 309                             return;
 310                         }
 311                     }
 312                     // Transition to suffix subpart
 313                     subpart = 2; // suffix subpart
 314                     affix = &suffix;
 315                     sub0Limit = pos;
 316                     continue;
 317                 }
 318                 break;
 319             case 1: // Prefix subpart
 320             case 2: // Suffix subpart
 321                 // Process the prefix / suffix characters
 322                 // Process unquoted characters seen in prefix or suffix
 323                 // subpart.
 324
 325                 // Several syntax characters implicitly begins the
 326                 // next subpart if we are in the prefix; otherwise
 327                 // they are illegal if unquoted.
 328                 if (!pattern.compare(pos, digitLen, fDigit) ||
 329                     !pattern.compare(pos, groupSepLen, fGroupingSeparator) ||
 330                     !pattern.compare(pos, decimalSepLen, fDecimalSeparator) ||
 331                     (ch >= fZeroDigit && ch <= nineDigit) ||
 332                     ch == fSigDigit) {
 333                     if (subpart == 1) { // prefix subpart
 334                         subpart = 0; // pattern proper subpart
 335                         sub0Start = pos; // Reprocess this character
 336                         continue;
 337                     } else {
 338                         status = U_UNQUOTED_SPECIAL;
 339                         syntaxError(pattern,pos,parseError);
 340                         return;
 341                     }
 342                 } else if (ch == kCurrencySign) {
 343                     affix->append(kQuote); // Encode currency
 344                     // Use lookahead to determine if the currency sign is
 345                     // doubled or not.
 346                     U_ASSERT(U16_LENGTH(kCurrencySign) == 1);
 347                     if ((pos+1) < pattern.length() && pattern[pos+1] == kCurrencySign) {
 348                         affix->append(kCurrencySign);
 349                         ++pos; // Skip over the doubled character
 350                         if ((pos+1) < pattern.length() &&
 351                             pattern[pos+1] == kCurrencySign) {
 352                             affix->append(kCurrencySign);
 353                             ++pos; // Skip over the doubled character
 354                             out.fCurrencySignCount = fgCurrencySignCountInPluralFormat;
 355                         } else {
 356                             out.fCurrencySignCount = fgCurrencySignCountInISOFormat;
 357                         }
 358                     } else {
 359                         out.fCurrencySignCount = fgCurrencySignCountInSymbolFormat;
 360                     }
 361                     // Fall through to append(ch)
 362                 } else if (ch == kQuote) {
 363                     // A quote outside quotes indicates either the opening
 364                     // quote or two quotes, which is a quote literal.  That is,
 365                     // we have the first quote in 'do' or o''clock.
 366                     U_ASSERT(U16_LENGTH(kQuote) == 1);
 367                     ++pos;
 368                     if (pos < pattern.length() && pattern[pos] == kQuote) {
 369                         affix->append(kQuote); // Encode quote
 370                         // Fall through to append(ch)
 371                     } else {
 372                         subpart += 2; // open quote
 373                         continue;
 374                     }
 375                 } else if (pattern.compare(pos, fSeparator.length(), fSeparator) == 0) {
 376                     // Don't allow separators in the prefix, and don't allow
 377                     // separators in the second pattern (part == 1).
 378                     if (subpart == 1 || part == 1) {
 379                         // Unexpected separator
 380                         debug("Unexpected separator")
 381                         status = U_UNEXPECTED_TOKEN;
 382                         syntaxError(pattern,pos,parseError);
 383                         return;
 384                     }
 385                     sub2Limit = pos;
 386                     isPartDone = TRUE; // Go to next part
 387                     pos += fSeparator.length();
 388                     break;
 389                 } else if (pattern.compare(pos, fPercent.length(), fPercent) == 0) {
 390                     // Next handle characters which are appended directly.
 391                     if (multiplier != 1) {
 392                         // Too many percent/perMill characters
 393                         debug("Too many percent characters")
 394                         status = U_MULTIPLE_PERCENT_SYMBOLS;
 395                         syntaxError(pattern,pos,parseError);
 396                         return;
 397                     }
 398                     affix->append(kQuote); // Encode percent/perMill
 399                     affix->append(kPatternPercent); // Use unlocalized pattern char
 400                     multiplier = 100;
 401                     pos += fPercent.length();
 402                     break;
 403                 } else if (pattern.compare(pos, fPerMill.length(), fPerMill) == 0) {
 404                     // Next handle characters which are appended directly.
 405                     if (multiplier != 1) {
 406                         // Too many percent/perMill characters
 407                         debug("Too many perMill characters")
 408                         status = U_MULTIPLE_PERMILL_SYMBOLS;
 409                         syntaxError(pattern,pos,parseError);
 410                         return;
 411                     }
 412                     affix->append(kQuote); // Encode percent/perMill
 413                     affix->append(kPatternPerMill); // Use unlocalized pattern char
 414                     multiplier = 1000;
 415                     pos += fPerMill.length();
 416                     break;
 417                 } else if (pattern.compare(pos, fPadEscape.length(), fPadEscape) == 0) {
 418                     if (padPos >= 0 ||               // Multiple pad specifiers
 419                         (pos+1) == pattern.length()) { // Nothing after padEscape
 420                         debug("Multiple pad specifiers")
 421                         status = U_MULTIPLE_PAD_SPECIFIERS;
 422                         syntaxError(pattern,pos,parseError);
 423                         return;
 424                     }
 425                     padPos = pos;
 426                     pos += fPadEscape.length();
 427                     padChar = pattern.char32At(pos);
 428                     pos += U16_LENGTH(padChar);
 429                     break;
 430                 } else if (pattern.compare(pos, fMinus.length(), fMinus) == 0) {
 431                     affix->append(kQuote); // Encode minus
 432                     affix->append(kPatternMinus);
 433                     pos += fMinus.length();
 434                     break;
 435                 } else if (pattern.compare(pos, fPlus.length(), fPlus) == 0) {
 436                     affix->append(kQuote); // Encode plus
 437                     affix->append(kPatternPlus);
 438                     pos += fPlus.length();
 439                     break;
 440                 }
 441                 // Unquoted, non-special characters fall through to here, as
 442                 // well as other code which needs to append something to the
 443                 // affix.
 444                 affix->append(ch);
 445                 pos += U16_LENGTH(ch);
 446                 break;
 447             case 3: // Prefix subpart, in quote
 448             case 4: // Suffix subpart, in quote
 449                 // A quote within quotes indicates either the closing
 450                 // quote or two quotes, which is a quote literal.  That is,
 451                 // we have the second quote in 'do' or 'don''t'.
 452                 if (ch == kQuote) {
 453                     ++pos;
 454                     if (pos < pattern.length() && pattern[pos] == kQuote) {
 455                         affix->append(kQuote); // Encode quote
 456                         // Fall through to append(ch)
 457                     } else {
 458                         subpart -= 2; // close quote
 459                         continue;
 460                     }
 461                 }
 462                 affix->append(ch);
 463                 pos += U16_LENGTH(ch);
 464                 break;
 465             }
 466         }
 467
 468         if (sub0Limit == 0) {
 469             sub0Limit = pattern.length();
 470         }
 471
 472         if (sub2Limit == 0) {
 473             sub2Limit = pattern.length();
 474         }
 475
 476         /* Handle patterns with no '0' pattern character.  These patterns
 477          * are legal, but must be recodified to make sense.  "##.###" ->
 478          * "#0.###".  ".###" -> ".0##".
 479          *
 480          * We allow patterns of the form "####" to produce a zeroDigitCount
 481          * of zero (got that?); although this seems like it might make it
 482          * possible for format() to produce empty strings, format() checks
 483          * for this condition and outputs a zero digit in this situation.
 484          * Having a zeroDigitCount of zero yields a minimum integer digits
 485          * of zero, which allows proper round-trip patterns.  We don't want
 486          * "#" to become "#0" when toPattern() is called (even though that's
 487          * what it really is, semantically).
 488          */
 489         if (zeroDigitCount == 0 && sigDigitCount == 0 &&
 490             digitLeftCount > 0 && decimalPos >= 0) {
 491             // Handle "###.###" and "###." and ".###"
 492             int n = decimalPos;
 493             if (n == 0)
 494                 ++n; // Handle ".###"
 495             digitRightCount = digitLeftCount - n;
 496             digitLeftCount = n - 1;
 497             zeroDigitCount = 1;
 498         }
 499
 500         // Do syntax checking on the digits, decimal points, and quotes.
 501         if ((decimalPos < 0 && digitRightCount > 0 && sigDigitCount == 0) ||
 502             (decimalPos >= 0 &&
 503              (sigDigitCount > 0 ||
 504               decimalPos < digitLeftCount ||
 505               decimalPos > (digitLeftCount + zeroDigitCount))) ||
 506             groupingCount == 0 || groupingCount2 == 0 ||
 507             (sigDigitCount > 0 && zeroDigitCount > 0) ||
 508             subpart > 2)
 509         { // subpart > 2 == unmatched quote
 510             debug("Syntax error")
 511             status = U_PATTERN_SYNTAX_ERROR;
 512             syntaxError(pattern,pos,parseError);
 513             return;
 514         }
 515
 516         // Make sure pad is at legal position before or after affix.
 517         if (padPos >= 0) {
 518             if (padPos == start) {
 519                 padPos = DecimalFormatPattern::kPadBeforePrefix;
 520             } else if (padPos+2 == sub0Start) {
 521                 padPos = DecimalFormatPattern::kPadAfterPrefix;
 522             } else if (padPos == sub0Limit) {
 523                 padPos = DecimalFormatPattern::kPadBeforeSuffix;
 524             } else if (padPos+2 == sub2Limit) {
 525                 padPos = DecimalFormatPattern::kPadAfterSuffix;
 526             } else {
 527                 // Illegal pad position
 528                 debug("Illegal pad position")
 529                 status = U_ILLEGAL_PAD_POSITION;
 530                 syntaxError(pattern,pos,parseError);
 531                 return;
 532             }
 533         }
 534
 535         if (part == 0) {
 536             out.fPosPatternsBogus = FALSE;
 537             out.fPosPrefixPattern = prefix;
 538             out.fPosSuffixPattern = suffix;
 539             out.fNegPatternsBogus = TRUE;
 540             out.fNegPrefixPattern.remove();
 541             out.fNegSuffixPattern.remove();
 542
 543             out.fUseExponentialNotation = (expDigits >= 0);
 544             if (out.fUseExponentialNotation) {
 545               out.fMinExponentDigits = expDigits;
 546             }
 547             out.fExponentSignAlwaysShown = expSignAlways;
 548             int32_t digitTotalCount = digitLeftCount + zeroDigitCount + digitRightCount;
 549             // The effectiveDecimalPos is the position the decimal is at or
 550             // would be at if there is no decimal.  Note that if
 551             // decimalPos<0, then digitTotalCount == digitLeftCount +
 552             // zeroDigitCount.
 553             int32_t effectiveDecimalPos = decimalPos >= 0 ? decimalPos : digitTotalCount;
 554             UBool isSigDig = (sigDigitCount > 0);
 555             out.fUseSignificantDigits = isSigDig;
 556             if (isSigDig) {
 557                 out.fMinimumSignificantDigits = sigDigitCount;
 558                 out.fMaximumSignificantDigits = sigDigitCount + digitRightCount;
 559             } else {
 560                 int32_t minInt = effectiveDecimalPos - digitLeftCount;
 561                 out.fMinimumIntegerDigits = minInt;
 562                 out.fMaximumIntegerDigits = out.fUseExponentialNotation
 563                     ? digitLeftCount + out.fMinimumIntegerDigits
 564                     : gDefaultMaxIntegerDigits;
 565                 out.fMaximumFractionDigits = decimalPos >= 0
 566                     ? (digitTotalCount - decimalPos) : 0;
 567                 out.fMinimumFractionDigits = decimalPos >= 0
 568                     ? (digitLeftCount + zeroDigitCount - decimalPos) : 0;
 569             }
 570             out.fGroupingUsed = groupingCount > 0;
 571             out.fGroupingSize = (groupingCount > 0) ? groupingCount : 0;
 572             out.fGroupingSize2 = (groupingCount2 > 0 && groupingCount2 != groupingCount)
 573                 ? groupingCount2 : 0;
 574             out.fMultiplier = multiplier;
 575             out.fDecimalSeparatorAlwaysShown = decimalPos == 0
 576                     || decimalPos == digitTotalCount;
 577             if (padPos >= 0) {
 578                 out.fPadPosition = (DecimalFormatPattern::EPadPosition) padPos;
 579                 // To compute the format width, first set up sub0Limit -
 580                 // sub0Start.  Add in prefix/suffix length later.
 581
 582                 // fFormatWidth = prefix.length() + suffix.length() +
 583                 //    sub0Limit - sub0Start;
 584                 out.fFormatWidth = sub0Limit - sub0Start;
 585                 out.fPad = padChar;
 586             } else {
 587                 out.fFormatWidth = 0;
 588             }
 589             if (roundingPos >= 0) {
 590                 out.fRoundingIncrementUsed = TRUE;
 591                 roundingInc.setDecimalAt(effectiveDecimalPos - roundingPos);
 592                 out.fRoundingIncrement = roundingInc;
 593             } else {
 594                 out.fRoundingIncrementUsed = FALSE;
 595             }
 596         } else {
 597             out.fNegPatternsBogus = FALSE;
 598             out.fNegPrefixPattern = prefix;
 599             out.fNegSuffixPattern = suffix;
 600         }
 601     }
 602
 603     if (pattern.length() == 0) {
 604         out.fNegPatternsBogus = TRUE;
 605         out.fNegPrefixPattern.remove();
 606         out.fNegSuffixPattern.remove();
 607         out.fPosPatternsBogus = FALSE;
 608         out.fPosPrefixPattern.remove();
 609         out.fPosSuffixPattern.remove();
 610
 611         out.fMinimumIntegerDigits = 0;
 612         out.fMaximumIntegerDigits = kDoubleIntegerDigits;
 613         out.fMinimumFractionDigits = 0;
 614         out.fMaximumFractionDigits = kDoubleFractionDigits;
 615
 616         out.fUseExponentialNotation = FALSE;
 617         out.fCurrencySignCount = fgCurrencySignCountZero;
 618         out.fGroupingUsed = FALSE;
 619         out.fGroupingSize = 0;
 620         out.fGroupingSize2 = 0;
 621         out.fMultiplier = 1;
 622         out.fDecimalSeparatorAlwaysShown = FALSE;
 623         out.fFormatWidth = 0;
 624         out.fRoundingIncrementUsed = FALSE;
 625     }
 626
 627     // If there was no negative pattern, or if the negative pattern is
 628     // identical to the positive pattern, then prepend the minus sign to the
 629     // positive pattern to form the negative pattern.
 630     if (out.fNegPatternsBogus ||
 631         (out.fNegPrefixPattern == out.fPosPrefixPattern
 632          && out.fNegSuffixPattern == out.fPosSuffixPattern)) {
 633         out.fNegPatternsBogus = FALSE;
 634         out.fNegSuffixPattern = out.fPosSuffixPattern;
 635         out.fNegPrefixPattern.remove();
 636         out.fNegPrefixPattern.append(kQuote).append(kPatternMinus)
 637             .append(out.fPosPrefixPattern);
 638     }
 639     // TODO: Deprecate/Remove out.fNegSuffixPattern and 3 other fields.
 640     AffixPattern::parseAffixString(
 641             out.fNegSuffixPattern, out.fNegSuffixAffix, status);
 642     AffixPattern::parseAffixString(
 643             out.fPosSuffixPattern, out.fPosSuffixAffix, status);
 644     AffixPattern::parseAffixString(
 645             out.fNegPrefixPattern, out.fNegPrefixAffix, status);
 646     AffixPattern::parseAffixString(
 647             out.fPosPrefixPattern, out.fPosPrefixAffix, status);
 648 }
 649
 650 U_NAMESPACE_END
 651
 652 #endif /* !UCONFIG_NO_FORMATTING */