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