1 // 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 6 * and others. All Rights Reserved. 7 ******************************************************************************* 8 */ 9 10 #include "unicode/utypes.h" 11 #include "utypeinfo.h" // for 'typeid' to work 12 13 #include "unicode/rbnf.h" 14 15 #if U_HAVE_RBNF 16 17 #include "unicode/normlzr.h" 18 #include "unicode/plurfmt.h" 19 #include "unicode/tblcoll.h" 20 #include "unicode/uchar.h" 21 #include "unicode/ucol.h" 22 #include "unicode/uloc.h" 23 #include "unicode/unum.h" 24 #include "unicode/ures.h" 25 #include "unicode/ustring.h" 26 #include "unicode/utf16.h" 27 #include "unicode/udata.h" 28 #include "unicode/udisplaycontext.h" 29 #include "unicode/brkiter.h" 30 #include "unicode/ucasemap.h" 31 32 #include "cmemory.h" 33 #include "cstring.h" 34 #include "patternprops.h" 35 #include "uresimp.h" 36 #include "nfrs.h" 37 #include "number_decimalquantity.h" 38 39 // debugging 40 // #define RBNF_DEBUG 41 42 #ifdef RBNF_DEBUG 43 #include <stdio.h> 44 #endif 45 46 #define U_ICUDATA_RBNF U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "rbnf" 47 48 static const UChar gPercentPercent[] = 49 { 50 0x25, 0x25, 0 51 }; /* "%%" */ 52 53 // All urbnf objects are created through openRules, so we init all of the 54 // Unicode string constants required by rbnf, nfrs, or nfr here. 55 static const UChar gLenientParse[] = 56 { 57 0x25, 0x25, 0x6C, 0x65, 0x6E, 0x69, 0x65, 0x6E, 0x74, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x3A, 0 58 }; /* "%%lenient-parse:" */ 59 static const UChar gSemiColon = 0x003B; 60 static const UChar gSemiPercent[] = 61 { 62 0x3B, 0x25, 0 63 }; /* ";%" */ 64 65 #define kSomeNumberOfBitsDiv2 22 66 #define kHalfMaxDouble (double)(1 << kSomeNumberOfBitsDiv2) 67 #define kMaxDouble (kHalfMaxDouble * kHalfMaxDouble) 68 69 U_NAMESPACE_BEGIN 70 71 using number::impl::DecimalQuantity; 72 73 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedNumberFormat) 74 75 /* 76 This is a utility class. It does not use ICU's RTTI. 77 If ICU's RTTI is needed again, you can uncomment the RTTI code and derive from UObject. 78 Please make sure that intltest passes on Windows in Release mode, 79 since the string pooling per compilation unit will mess up how RTTI works. 80 The RTTI code was also removed due to lack of code coverage. 81 */ 82 class LocalizationInfo : public UMemory { 83 protected: 84 virtual ~LocalizationInfo(); 85 uint32_t refcount; 86 87 public: 88 LocalizationInfo() : refcount(0) {} 89 90 LocalizationInfo* ref(void) { 91 ++refcount; 92 return this; 93 } 94 95 LocalizationInfo* unref(void) { 96 if (refcount && --refcount == 0) { 97 delete this; 98 } 99 return NULL; 100 } 101 102 virtual UBool operator==(const LocalizationInfo* rhs) const; 103 inline UBool operator!=(const LocalizationInfo* rhs) const { return !operator==(rhs); } 104 105 virtual int32_t getNumberOfRuleSets(void) const = 0; 106 virtual const UChar* getRuleSetName(int32_t index) const = 0; 107 virtual int32_t getNumberOfDisplayLocales(void) const = 0; 108 virtual const UChar* getLocaleName(int32_t index) const = 0; 109 virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const = 0; 110 111 virtual int32_t indexForLocale(const UChar* locale) const; 112 virtual int32_t indexForRuleSet(const UChar* ruleset) const; 113 114 // virtual UClassID getDynamicClassID() const = 0; 115 // static UClassID getStaticClassID(void); 116 }; 117 118 LocalizationInfo::~LocalizationInfo() {} 119 120 //UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(LocalizationInfo) 121 122 // if both strings are NULL, this returns TRUE 123 static UBool 124 streq(const UChar* lhs, const UChar* rhs) { 125 if (rhs == lhs) { 126 return TRUE; 127 } 128 if (lhs && rhs) { 129 return u_strcmp(lhs, rhs) == 0; 130 } 131 return FALSE; 132 } 133 134 UBool 135 LocalizationInfo::operator==(const LocalizationInfo* rhs) const { 136 if (rhs) { 137 if (this == rhs) { 138 return TRUE; 139 } 140 141 int32_t rsc = getNumberOfRuleSets(); 142 if (rsc == rhs->getNumberOfRuleSets()) { 143 for (int i = 0; i < rsc; ++i) { 144 if (!streq(getRuleSetName(i), rhs->getRuleSetName(i))) { 145 return FALSE; 146 } 147 } 148 int32_t dlc = getNumberOfDisplayLocales(); 149 if (dlc == rhs->getNumberOfDisplayLocales()) { 150 for (int i = 0; i < dlc; ++i) { 151 const UChar* locale = getLocaleName(i); 152 int32_t ix = rhs->indexForLocale(locale); 153 // if no locale, ix is -1, getLocaleName returns null, so streq returns false 154 if (!streq(locale, rhs->getLocaleName(ix))) { 155 return FALSE; 156 } 157 for (int j = 0; j < rsc; ++j) { 158 if (!streq(getDisplayName(i, j), rhs->getDisplayName(ix, j))) { 159 return FALSE; 160 } 161 } 162 } 163 return TRUE; 164 } 165 } 166 } 167 return FALSE; 168 } 169 170 int32_t 171 LocalizationInfo::indexForLocale(const UChar* locale) const { 172 for (int i = 0; i < getNumberOfDisplayLocales(); ++i) { 173 if (streq(locale, getLocaleName(i))) { 174 return i; 175 } 176 } 177 return -1; 178 } 179 180 int32_t 181 LocalizationInfo::indexForRuleSet(const UChar* ruleset) const { 182 if (ruleset) { 183 for (int i = 0; i < getNumberOfRuleSets(); ++i) { 184 if (streq(ruleset, getRuleSetName(i))) { 185 return i; 186 } 187 } 188 } 189 return -1; 190 } 191 192 193 typedef void (*Fn_Deleter)(void*); 194 195 class VArray { 196 void** buf; 197 int32_t cap; 198 int32_t size; 199 Fn_Deleter deleter; 200 public: 201 VArray() : buf(NULL), cap(0), size(0), deleter(NULL) {} 202 203 VArray(Fn_Deleter del) : buf(NULL), cap(0), size(0), deleter(del) {} 204 205 ~VArray() { 206 if (deleter) { 207 for (int i = 0; i < size; ++i) { 208 (*deleter)(buf[i]); 209 } 210 } 211 uprv_free(buf); 212 } 213 214 int32_t length() { 215 return size; 216 } 217 218 void add(void* elem, UErrorCode& status) { 219 if (U_SUCCESS(status)) { 220 if (size == cap) { 221 if (cap == 0) { 222 cap = 1; 223 } else if (cap < 256) { 224 cap *= 2; 225 } else { 226 cap += 256; 227 } 228 if (buf == NULL) { 229 buf = (void**)uprv_malloc(cap * sizeof(void*)); 230 } else { 231 buf = (void**)uprv_realloc(buf, cap * sizeof(void*)); 232 } 233 if (buf == NULL) { 234 // if we couldn't realloc, we leak the memory we've already allocated, but we're in deep trouble anyway 235 status = U_MEMORY_ALLOCATION_ERROR; 236 return; 237 } 238 void* start = &buf[size]; 239 size_t count = (cap - size) * sizeof(void*); 240 uprv_memset(start, 0, count); // fill with nulls, just because 241 } 242 buf[size++] = elem; 243 } 244 } 245 246 void** release(void) { 247 void** result = buf; 248 buf = NULL; 249 cap = 0; 250 size = 0; 251 return result; 252 } 253 }; 254 255 class LocDataParser; 256 257 class StringLocalizationInfo : public LocalizationInfo { 258 UChar* info; 259 UChar*** data; 260 int32_t numRuleSets; 261 int32_t numLocales; 262 263 friend class LocDataParser; 264 265 StringLocalizationInfo(UChar* i, UChar*** d, int32_t numRS, int32_t numLocs) 266 : info(i), data(d), numRuleSets(numRS), numLocales(numLocs) 267 { 268 } 269 270 public: 271 static StringLocalizationInfo* create(const UnicodeString& info, UParseError& perror, UErrorCode& status); 272 273 virtual ~StringLocalizationInfo(); 274 virtual int32_t getNumberOfRuleSets(void) const { return numRuleSets; } 275 virtual const UChar* getRuleSetName(int32_t index) const; 276 virtual int32_t getNumberOfDisplayLocales(void) const { return numLocales; } 277 virtual const UChar* getLocaleName(int32_t index) const; 278 virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const; 279 280 // virtual UClassID getDynamicClassID() const; 281 // static UClassID getStaticClassID(void); 282 283 private: 284 void init(UErrorCode& status) const; 285 }; 286 287 288 enum { 289 OPEN_ANGLE = 0x003c, /* '<' */ 290 CLOSE_ANGLE = 0x003e, /* '>' */ 291 COMMA = 0x002c, 292 TICK = 0x0027, 293 QUOTE = 0x0022, 294 SPACE = 0x0020 295 }; 296 297 /** 298 * Utility for parsing a localization string and returning a StringLocalizationInfo*. 299 */ 300 class LocDataParser { 301 UChar* data; 302 const UChar* e; 303 UChar* p; 304 UChar ch; 305 UParseError& pe; 306 UErrorCode& ec; 307 308 public: 309 LocDataParser(UParseError& parseError, UErrorCode& status) 310 : data(NULL), e(NULL), p(NULL), ch(0xffff), pe(parseError), ec(status) {} 311 ~LocDataParser() {} 312 313 /* 314 * On a successful parse, return a StringLocalizationInfo*, otherwise delete locData, set perror and status, 315 * and return NULL. The StringLocalizationInfo will adopt locData if it is created. 316 */ 317 StringLocalizationInfo* parse(UChar* data, int32_t len); 318 319 private: 320 321 inline void inc(void) { 322 ++p; 323 ch = 0xffff; 324 } 325 inline UBool checkInc(UChar c) { 326 if (p < e && (ch == c || *p == c)) { 327 inc(); 328 return TRUE; 329 } 330 return FALSE; 331 } 332 inline UBool check(UChar c) { 333 return p < e && (ch == c || *p == c); 334 } 335 inline void skipWhitespace(void) { 336 while (p < e && PatternProps::isWhiteSpace(ch != 0xffff ? ch : *p)) { 337 inc(); 338 } 339 } 340 inline UBool inList(UChar c, const UChar* list) const { 341 if (*list == SPACE && PatternProps::isWhiteSpace(c)) { 342 return TRUE; 343 } 344 while (*list && *list != c) { 345 ++list; 346 } 347 return *list == c; 348 } 349 void parseError(const char* msg); 350 351 StringLocalizationInfo* doParse(void); 352 353 UChar** nextArray(int32_t& requiredLength); 354 UChar* nextString(void); 355 }; 356 357 #ifdef RBNF_DEBUG 358 #define ERROR(msg) parseError(msg); return NULL; 359 #define EXPLANATION_ARG explanationArg 360 #else 361 #define ERROR(msg) parseError(NULL); return NULL; 362 #define EXPLANATION_ARG 363 #endif 364 365 366 static const UChar DQUOTE_STOPLIST[] = { 367 QUOTE, 0 368 }; 369 370 static const UChar SQUOTE_STOPLIST[] = { 371 TICK, 0 372 }; 373 374 static const UChar NOQUOTE_STOPLIST[] = { 375 SPACE, COMMA, CLOSE_ANGLE, OPEN_ANGLE, TICK, QUOTE, 0 376 }; 377 378 static void 379 DeleteFn(void* p) { 380 uprv_free(p); 381 } 382 383 StringLocalizationInfo* 384 LocDataParser::parse(UChar* _data, int32_t len) { 385 if (U_FAILURE(ec)) { 386 if (_data) uprv_free(_data); 387 return NULL; 388 } 389 390 pe.line = 0; 391 pe.offset = -1; 392 pe.postContext[0] = 0; 393 pe.preContext[0] = 0; 394 395 if (_data == NULL) { 396 ec = U_ILLEGAL_ARGUMENT_ERROR; 397 return NULL; 398 } 399 400 if (len <= 0) { 401 ec = U_ILLEGAL_ARGUMENT_ERROR; 402 uprv_free(_data); 403 return NULL; 404 } 405 406 data = _data; 407 e = data + len; 408 p = _data; 409 ch = 0xffff; 410 411 return doParse(); 412 } 413 414 415 StringLocalizationInfo* 416 LocDataParser::doParse(void) { 417 skipWhitespace(); 418 if (!checkInc(OPEN_ANGLE)) { 419 ERROR("Missing open angle"); 420 } else { 421 VArray array(DeleteFn); 422 UBool mightHaveNext = TRUE; 423 int32_t requiredLength = -1; 424 while (mightHaveNext) { 425 mightHaveNext = FALSE; 426 UChar** elem = nextArray(requiredLength); 427 skipWhitespace(); 428 UBool haveComma = check(COMMA); 429 if (elem) { 430 array.add(elem, ec); 431 if (haveComma) { 432 inc(); 433 mightHaveNext = TRUE; 434 } 435 } else if (haveComma) { 436 ERROR("Unexpected character"); 437 } 438 } 439 440 skipWhitespace(); 441 if (!checkInc(CLOSE_ANGLE)) { 442 if (check(OPEN_ANGLE)) { 443 ERROR("Missing comma in outer array"); 444 } else { 445 ERROR("Missing close angle bracket in outer array"); 446 } 447 } 448 449 skipWhitespace(); 450 if (p != e) { 451 ERROR("Extra text after close of localization data"); 452 } 453 454 array.add(NULL, ec); 455 if (U_SUCCESS(ec)) { 456 int32_t numLocs = array.length() - 2; // subtract first, NULL 457 UChar*** result = (UChar***)array.release(); 458 459 return new StringLocalizationInfo(data, result, requiredLength-2, numLocs); // subtract first, NULL 460 } 461 } 462 463 ERROR("Unknown error"); 464 } 465 466 UChar** 467 LocDataParser::nextArray(int32_t& requiredLength) { 468 if (U_FAILURE(ec)) { 469 return NULL; 470 } 471 472 skipWhitespace(); 473 if (!checkInc(OPEN_ANGLE)) { 474 ERROR("Missing open angle"); 475 } 476 477 VArray array; 478 UBool mightHaveNext = TRUE; 479 while (mightHaveNext) { 480 mightHaveNext = FALSE; 481 UChar* elem = nextString(); 482 skipWhitespace(); 483 UBool haveComma = check(COMMA); 484 if (elem) { 485 array.add(elem, ec); 486 if (haveComma) { 487 inc(); 488 mightHaveNext = TRUE; 489 } 490 } else if (haveComma) { 491 ERROR("Unexpected comma"); 492 } 493 } 494 skipWhitespace(); 495 if (!checkInc(CLOSE_ANGLE)) { 496 if (check(OPEN_ANGLE)) { 497 ERROR("Missing close angle bracket in inner array"); 498 } else { 499 ERROR("Missing comma in inner array"); 500 } 501 } 502 503 array.add(NULL, ec); 504 if (U_SUCCESS(ec)) { 505 if (requiredLength == -1) { 506 requiredLength = array.length() + 1; 507 } else if (array.length() != requiredLength) { 508 ec = U_ILLEGAL_ARGUMENT_ERROR; 509 ERROR("Array not of required length"); 510 } 511 512 return (UChar**)array.release(); 513 } 514 ERROR("Unknown Error"); 515 } 516 517 UChar* 518 LocDataParser::nextString() { 519 UChar* result = NULL; 520 521 skipWhitespace(); 522 if (p < e) { 523 const UChar* terminators; 524 UChar c = *p; 525 UBool haveQuote = c == QUOTE || c == TICK; 526 if (haveQuote) { 527 inc(); 528 terminators = c == QUOTE ? DQUOTE_STOPLIST : SQUOTE_STOPLIST; 529 } else { 530 terminators = NOQUOTE_STOPLIST; 531 } 532 UChar* start = p; 533 while (p < e && !inList(*p, terminators)) ++p; 534 if (p == e) { 535 ERROR("Unexpected end of data"); 536 } 537 538 UChar x = *p; 539 if (p > start) { 540 ch = x; 541 *p = 0x0; // terminate by writing to data 542 result = start; // just point into data 543 } 544 if (haveQuote) { 545 if (x != c) { 546 ERROR("Missing matching quote"); 547 } else if (p == start) { 548 ERROR("Empty string"); 549 } 550 inc(); 551 } else if (x == OPEN_ANGLE || x == TICK || x == QUOTE) { 552 ERROR("Unexpected character in string"); 553 } 554 } 555 556 // ok for there to be no next string 557 return result; 558 } 559 560 void LocDataParser::parseError(const char* EXPLANATION_ARG) 561 { 562 if (!data) { 563 return; 564 } 565 566 const UChar* start = p - U_PARSE_CONTEXT_LEN - 1; 567 if (start < data) { 568 start = data; 569 } 570 for (UChar* x = p; --x >= start;) { 571 if (!*x) { 572 start = x+1; 573 break; 574 } 575 } 576 const UChar* limit = p + U_PARSE_CONTEXT_LEN - 1; 577 if (limit > e) { 578 limit = e; 579 } 580 u_strncpy(pe.preContext, start, (int32_t)(p-start)); 581 pe.preContext[p-start] = 0; 582 u_strncpy(pe.postContext, p, (int32_t)(limit-p)); 583 pe.postContext[limit-p] = 0; 584 pe.offset = (int32_t)(p - data); 585 586 #ifdef RBNF_DEBUG 587 fprintf(stderr, "%s at or near character %ld: ", EXPLANATION_ARG, p-data); 588 589 UnicodeString msg; 590 msg.append(start, p - start); 591 msg.append((UChar)0x002f); /* SOLIDUS/SLASH */ 592 msg.append(p, limit-p); 593 msg.append(UNICODE_STRING_SIMPLE("'")); 594 595 char buf[128]; 596 int32_t len = msg.extract(0, msg.length(), buf, 128); 597 if (len >= 128) { 598 buf[127] = 0; 599 } else { 600 buf[len] = 0; 601 } 602 fprintf(stderr, "%s\n", buf); 603 fflush(stderr); 604 #endif 605 606 uprv_free(data); 607 data = NULL; 608 p = NULL; 609 e = NULL; 610 611 if (U_SUCCESS(ec)) { 612 ec = U_PARSE_ERROR; 613 } 614 } 615 616 //UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringLocalizationInfo) 617 618 StringLocalizationInfo* 619 StringLocalizationInfo::create(const UnicodeString& info, UParseError& perror, UErrorCode& status) { 620 if (U_FAILURE(status)) { 621 return NULL; 622 } 623 624 int32_t len = info.length(); 625 if (len == 0) { 626 return NULL; // no error; 627 } 628 629 UChar* p = (UChar*)uprv_malloc(len * sizeof(UChar)); 630 if (!p) { 631 status = U_MEMORY_ALLOCATION_ERROR; 632 return NULL; 633 } 634 info.extract(p, len, status); 635 if (!U_FAILURE(status)) { 636 status = U_ZERO_ERROR; // clear warning about non-termination 637 } 638 639 LocDataParser parser(perror, status); 640 return parser.parse(p, len); 641 } 642 643 StringLocalizationInfo::~StringLocalizationInfo() { 644 for (UChar*** p = (UChar***)data; *p; ++p) { 645 // remaining data is simply pointer into our unicode string data. 646 if (*p) uprv_free(*p); 647 } 648 if (data) uprv_free(data); 649 if (info) uprv_free(info); 650 } 651 652 653 const UChar* 654 StringLocalizationInfo::getRuleSetName(int32_t index) const { 655 if (index >= 0 && index < getNumberOfRuleSets()) { 656 return data[0][index]; 657 } 658 return NULL; 659 } 660 661 const UChar* 662 StringLocalizationInfo::getLocaleName(int32_t index) const { 663 if (index >= 0 && index < getNumberOfDisplayLocales()) { 664 return data[index+1][0]; 665 } 666 return NULL; 667 } 668 669 const UChar* 670 StringLocalizationInfo::getDisplayName(int32_t localeIndex, int32_t ruleIndex) const { 671 if (localeIndex >= 0 && localeIndex < getNumberOfDisplayLocales() && 672 ruleIndex >= 0 && ruleIndex < getNumberOfRuleSets()) { 673 return data[localeIndex+1][ruleIndex+1]; 674 } 675 return NULL; 676 } 677 678 // ---------- 679 680 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 681 const UnicodeString& locs, 682 const Locale& alocale, UParseError& perror, UErrorCode& status) 683 : fRuleSets(NULL) 684 , ruleSetDescriptions(NULL) 685 , numRuleSets(0) 686 , defaultRuleSet(NULL) 687 , locale(alocale) 688 , collator(NULL) 689 , decimalFormatSymbols(NULL) 690 , defaultInfinityRule(NULL) 691 , defaultNaNRule(NULL) 692 , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) 693 , lenient(FALSE) 694 , lenientParseRules(NULL) 695 , localizations(NULL) 696 , capitalizationInfoSet(FALSE) 697 , capitalizationForUIListMenu(FALSE) 698 , capitalizationForStandAlone(FALSE) 699 , capitalizationBrkIter(NULL) 700 { 701 LocalizationInfo* locinfo = StringLocalizationInfo::create(locs, perror, status); 702 init(description, locinfo, perror, status); 703 } 704 705 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 706 const UnicodeString& locs, 707 UParseError& perror, UErrorCode& status) 708 : fRuleSets(NULL) 709 , ruleSetDescriptions(NULL) 710 , numRuleSets(0) 711 , defaultRuleSet(NULL) 712 , locale(Locale::getDefault()) 713 , collator(NULL) 714 , decimalFormatSymbols(NULL) 715 , defaultInfinityRule(NULL) 716 , defaultNaNRule(NULL) 717 , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) 718 , lenient(FALSE) 719 , lenientParseRules(NULL) 720 , localizations(NULL) 721 , capitalizationInfoSet(FALSE) 722 , capitalizationForUIListMenu(FALSE) 723 , capitalizationForStandAlone(FALSE) 724 , capitalizationBrkIter(NULL) 725 { 726 LocalizationInfo* locinfo = StringLocalizationInfo::create(locs, perror, status); 727 init(description, locinfo, perror, status); 728 } 729 730 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 731 LocalizationInfo* info, 732 const Locale& alocale, UParseError& perror, UErrorCode& status) 733 : fRuleSets(NULL) 734 , ruleSetDescriptions(NULL) 735 , numRuleSets(0) 736 , defaultRuleSet(NULL) 737 , locale(alocale) 738 , collator(NULL) 739 , decimalFormatSymbols(NULL) 740 , defaultInfinityRule(NULL) 741 , defaultNaNRule(NULL) 742 , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) 743 , lenient(FALSE) 744 , lenientParseRules(NULL) 745 , localizations(NULL) 746 , capitalizationInfoSet(FALSE) 747 , capitalizationForUIListMenu(FALSE) 748 , capitalizationForStandAlone(FALSE) 749 , capitalizationBrkIter(NULL) 750 { 751 init(description, info, perror, status); 752 } 753 754 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 755 UParseError& perror, 756 UErrorCode& status) 757 : fRuleSets(NULL) 758 , ruleSetDescriptions(NULL) 759 , numRuleSets(0) 760 , defaultRuleSet(NULL) 761 , locale(Locale::getDefault()) 762 , collator(NULL) 763 , decimalFormatSymbols(NULL) 764 , defaultInfinityRule(NULL) 765 , defaultNaNRule(NULL) 766 , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) 767 , lenient(FALSE) 768 , lenientParseRules(NULL) 769 , localizations(NULL) 770 , capitalizationInfoSet(FALSE) 771 , capitalizationForUIListMenu(FALSE) 772 , capitalizationForStandAlone(FALSE) 773 , capitalizationBrkIter(NULL) 774 { 775 init(description, NULL, perror, status); 776 } 777 778 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 779 const Locale& aLocale, 780 UParseError& perror, 781 UErrorCode& status) 782 : fRuleSets(NULL) 783 , ruleSetDescriptions(NULL) 784 , numRuleSets(0) 785 , defaultRuleSet(NULL) 786 , locale(aLocale) 787 , collator(NULL) 788 , decimalFormatSymbols(NULL) 789 , defaultInfinityRule(NULL) 790 , defaultNaNRule(NULL) 791 , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) 792 , lenient(FALSE) 793 , lenientParseRules(NULL) 794 , localizations(NULL) 795 , capitalizationInfoSet(FALSE) 796 , capitalizationForUIListMenu(FALSE) 797 , capitalizationForStandAlone(FALSE) 798 , capitalizationBrkIter(NULL) 799 { 800 init(description, NULL, perror, status); 801 } 802 803 RuleBasedNumberFormat::RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& alocale, UErrorCode& status) 804 : fRuleSets(NULL) 805 , ruleSetDescriptions(NULL) 806 , numRuleSets(0) 807 , defaultRuleSet(NULL) 808 , locale(alocale) 809 , collator(NULL) 810 , decimalFormatSymbols(NULL) 811 , defaultInfinityRule(NULL) 812 , defaultNaNRule(NULL) 813 , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) 814 , lenient(FALSE) 815 , lenientParseRules(NULL) 816 , localizations(NULL) 817 , capitalizationInfoSet(FALSE) 818 , capitalizationForUIListMenu(FALSE) 819 , capitalizationForStandAlone(FALSE) 820 , capitalizationBrkIter(NULL) 821 { 822 if (U_FAILURE(status)) { 823 return; 824 } 825 826 const char* rules_tag = "RBNFRules"; 827 const char* fmt_tag = ""; 828 switch (tag) { 829 case URBNF_SPELLOUT: fmt_tag = "SpelloutRules"; break; 830 case URBNF_ORDINAL: fmt_tag = "OrdinalRules"; break; 831 case URBNF_DURATION: fmt_tag = "DurationRules"; break; 832 case URBNF_NUMBERING_SYSTEM: fmt_tag = "NumberingSystemRules"; break; 833 default: status = U_ILLEGAL_ARGUMENT_ERROR; return; 834 } 835 836 // TODO: read localization info from resource 837 LocalizationInfo* locinfo = NULL; 838 839 UResourceBundle* nfrb = ures_open(U_ICUDATA_RBNF, locale.getName(), &status); 840 if (U_SUCCESS(status)) { 841 setLocaleIDs(ures_getLocaleByType(nfrb, ULOC_VALID_LOCALE, &status), 842 ures_getLocaleByType(nfrb, ULOC_ACTUAL_LOCALE, &status)); 843 844 UResourceBundle* rbnfRules = ures_getByKeyWithFallback(nfrb, rules_tag, NULL, &status); 845 if (U_FAILURE(status)) { 846 ures_close(nfrb); 847 } 848 UResourceBundle* ruleSets = ures_getByKeyWithFallback(rbnfRules, fmt_tag, NULL, &status); 849 if (U_FAILURE(status)) { 850 ures_close(rbnfRules); 851 ures_close(nfrb); 852 return; 853 } 854 855 UnicodeString desc; 856 while (ures_hasNext(ruleSets)) { 857 desc.append(ures_getNextUnicodeString(ruleSets,NULL,&status)); 858 } 859 UParseError perror; 860 861 init(desc, locinfo, perror, status); 862 863 ures_close(ruleSets); 864 ures_close(rbnfRules); 865 } 866 ures_close(nfrb); 867 } 868 869 RuleBasedNumberFormat::RuleBasedNumberFormat(const RuleBasedNumberFormat& rhs) 870 : NumberFormat(rhs) 871 , fRuleSets(NULL) 872 , ruleSetDescriptions(NULL) 873 , numRuleSets(0) 874 , defaultRuleSet(NULL) 875 , locale(rhs.locale) 876 , collator(NULL) 877 , decimalFormatSymbols(NULL) 878 , defaultInfinityRule(NULL) 879 , defaultNaNRule(NULL) 880 , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) 881 , lenient(FALSE) 882 , lenientParseRules(NULL) 883 , localizations(NULL) 884 , capitalizationInfoSet(FALSE) 885 , capitalizationForUIListMenu(FALSE) 886 , capitalizationForStandAlone(FALSE) 887 , capitalizationBrkIter(NULL) 888 { 889 this->operator=(rhs); 890 } 891 892 // -------- 893 894 RuleBasedNumberFormat& 895 RuleBasedNumberFormat::operator=(const RuleBasedNumberFormat& rhs) 896 { 897 if (this == &rhs) { 898 return *this; 899 } 900 NumberFormat::operator=(rhs); 901 UErrorCode status = U_ZERO_ERROR; 902 dispose(); 903 locale = rhs.locale; 904 lenient = rhs.lenient; 905 906 UParseError perror; 907 setDecimalFormatSymbols(*rhs.getDecimalFormatSymbols()); 908 init(rhs.originalDescription, rhs.localizations ? rhs.localizations->ref() : NULL, perror, status); 909 setDefaultRuleSet(rhs.getDefaultRuleSetName(), status); 910 setRoundingMode(rhs.getRoundingMode()); 911 912 capitalizationInfoSet = rhs.capitalizationInfoSet; 913 capitalizationForUIListMenu = rhs.capitalizationForUIListMenu; 914 capitalizationForStandAlone = rhs.capitalizationForStandAlone; 915 #if !UCONFIG_NO_BREAK_ITERATION 916 capitalizationBrkIter = (rhs.capitalizationBrkIter!=NULL)? rhs.capitalizationBrkIter->clone(): NULL; 917 #endif 918 919 return *this; 920 } 921 922 RuleBasedNumberFormat::~RuleBasedNumberFormat() 923 { 924 dispose(); 925 } 926 927 Format* 928 RuleBasedNumberFormat::clone(void) const 929 { 930 return new RuleBasedNumberFormat(*this); 931 } 932 933 UBool 934 RuleBasedNumberFormat::operator==(const Format& other) const 935 { 936 if (this == &other) { 937 return TRUE; 938 } 939 940 if (typeid(*this) == typeid(other)) { 941 const RuleBasedNumberFormat& rhs = (const RuleBasedNumberFormat&)other; 942 // test for capitalization info equality is adequately handled 943 // by the NumberFormat test for fCapitalizationContext equality; 944 // the info here is just derived from that. 945 if (locale == rhs.locale && 946 lenient == rhs.lenient && 947 (localizations == NULL 948 ? rhs.localizations == NULL 949 : (rhs.localizations == NULL 950 ? FALSE 951 : *localizations == rhs.localizations))) { 952 953 NFRuleSet** p = fRuleSets; 954 NFRuleSet** q = rhs.fRuleSets; 955 if (p == NULL) { 956 return q == NULL; 957 } else if (q == NULL) { 958 return FALSE; 959 } 960 while (*p && *q && (**p == **q)) { 961 ++p; 962 ++q; 963 } 964 return *q == NULL && *p == NULL; 965 } 966 } 967 968 return FALSE; 969 } 970 971 UnicodeString 972 RuleBasedNumberFormat::getRules() const 973 { 974 UnicodeString result; 975 if (fRuleSets != NULL) { 976 for (NFRuleSet** p = fRuleSets; *p; ++p) { 977 (*p)->appendRules(result); 978 } 979 } 980 return result; 981 } 982 983 UnicodeString 984 RuleBasedNumberFormat::getRuleSetName(int32_t index) const 985 { 986 if (localizations) { 987 UnicodeString string(TRUE, localizations->getRuleSetName(index), (int32_t)-1); 988 return string; 989 } 990 else if (fRuleSets) { 991 UnicodeString result; 992 for (NFRuleSet** p = fRuleSets; *p; ++p) { 993 NFRuleSet* rs = *p; 994 if (rs->isPublic()) { 995 if (--index == -1) { 996 rs->getName(result); 997 return result; 998 } 999 } 1000 } 1001 } 1002 UnicodeString empty; 1003 return empty; 1004 } 1005 1006 int32_t 1007 RuleBasedNumberFormat::getNumberOfRuleSetNames() const 1008 { 1009 int32_t result = 0; 1010 if (localizations) { 1011 result = localizations->getNumberOfRuleSets(); 1012 } 1013 else if (fRuleSets) { 1014 for (NFRuleSet** p = fRuleSets; *p; ++p) { 1015 if ((**p).isPublic()) { 1016 ++result; 1017 } 1018 } 1019 } 1020 return result; 1021 } 1022 1023 int32_t 1024 RuleBasedNumberFormat::getNumberOfRuleSetDisplayNameLocales(void) const { 1025 if (localizations) { 1026 return localizations->getNumberOfDisplayLocales(); 1027 } 1028 return 0; 1029 } 1030 1031 Locale 1032 RuleBasedNumberFormat::getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const { 1033 if (U_FAILURE(status)) { 1034 return Locale(""); 1035 } 1036 if (localizations && index >= 0 && index < localizations->getNumberOfDisplayLocales()) { 1037 UnicodeString name(TRUE, localizations->getLocaleName(index), -1); 1038 char buffer[64]; 1039 int32_t cap = name.length() + 1; 1040 char* bp = buffer; 1041 if (cap > 64) { 1042 bp = (char *)uprv_malloc(cap); 1043 if (bp == NULL) { 1044 status = U_MEMORY_ALLOCATION_ERROR; 1045 return Locale(""); 1046 } 1047 } 1048 name.extract(0, name.length(), bp, cap, UnicodeString::kInvariant); 1049 Locale retLocale(bp); 1050 if (bp != buffer) { 1051 uprv_free(bp); 1052 } 1053 return retLocale; 1054 } 1055 status = U_ILLEGAL_ARGUMENT_ERROR; 1056 Locale retLocale; 1057 return retLocale; 1058 } 1059 1060 UnicodeString 1061 RuleBasedNumberFormat::getRuleSetDisplayName(int32_t index, const Locale& localeParam) { 1062 if (localizations && index >= 0 && index < localizations->getNumberOfRuleSets()) { 1063 UnicodeString localeName(localeParam.getBaseName(), -1, UnicodeString::kInvariant); 1064 int32_t len = localeName.length(); 1065 UChar* localeStr = localeName.getBuffer(len + 1); 1066 while (len >= 0) { 1067 localeStr[len] = 0; 1068 int32_t ix = localizations->indexForLocale(localeStr); 1069 if (ix >= 0) { 1070 UnicodeString name(TRUE, localizations->getDisplayName(ix, index), -1); 1071 return name; 1072 } 1073 1074 // trim trailing portion, skipping over ommitted sections 1075 do { --len;} while (len > 0 && localeStr[len] != 0x005f); // underscore 1076 while (len > 0 && localeStr[len-1] == 0x005F) --len; 1077 } 1078 UnicodeString name(TRUE, localizations->getRuleSetName(index), -1); 1079 return name; 1080 } 1081 UnicodeString bogus; 1082 bogus.setToBogus(); 1083 return bogus; 1084 } 1085 1086 UnicodeString 1087 RuleBasedNumberFormat::getRuleSetDisplayName(const UnicodeString& ruleSetName, const Locale& localeParam) { 1088 if (localizations) { 1089 UnicodeString rsn(ruleSetName); 1090 int32_t ix = localizations->indexForRuleSet(rsn.getTerminatedBuffer()); 1091 return getRuleSetDisplayName(ix, localeParam); 1092 } 1093 UnicodeString bogus; 1094 bogus.setToBogus(); 1095 return bogus; 1096 } 1097 1098 NFRuleSet* 1099 RuleBasedNumberFormat::findRuleSet(const UnicodeString& name, UErrorCode& status) const 1100 { 1101 if (U_SUCCESS(status) && fRuleSets) { 1102 for (NFRuleSet** p = fRuleSets; *p; ++p) { 1103 NFRuleSet* rs = *p; 1104 if (rs->isNamed(name)) { 1105 return rs; 1106 } 1107 } 1108 status = U_ILLEGAL_ARGUMENT_ERROR; 1109 } 1110 return NULL; 1111 } 1112 1113 UnicodeString& 1114 RuleBasedNumberFormat::format(const DecimalQuantity &number, 1115 UnicodeString &appendTo, 1116 FieldPositionIterator *posIter, 1117 UErrorCode &status) const { 1118 if (U_FAILURE(status)) { 1119 return appendTo; 1120 } 1121 DecimalQuantity copy(number); 1122 if (copy.fitsInLong()) { 1123 format(number.toLong(), appendTo, posIter, status); 1124 } 1125 else { 1126 copy.roundToMagnitude(0, number::impl::RoundingMode::UNUM_ROUND_HALFEVEN, status); 1127 if (copy.fitsInLong()) { 1128 format(number.toDouble(), appendTo, posIter, status); 1129 } 1130 else { 1131 // We're outside of our normal range that this framework can handle. 1132 // The DecimalFormat will provide more accurate results. 1133 1134 // TODO this section should probably be optimized. The DecimalFormat is shared in ICU4J. 1135 LocalPointer<NumberFormat> decimalFormat(NumberFormat::createInstance(locale, UNUM_DECIMAL, status), status); 1136 if (decimalFormat.isNull()) { 1137 return appendTo; 1138 } 1139 Formattable f; 1140 LocalPointer<DecimalQuantity> decimalQuantity(new DecimalQuantity(number), status); 1141 if (decimalQuantity.isNull()) { 1142 return appendTo; 1143 } 1144 f.adoptDecimalQuantity(decimalQuantity.orphan()); // f now owns decimalQuantity. 1145 decimalFormat->format(f, appendTo, posIter, status); 1146 } 1147 } 1148 return appendTo; 1149 } 1150 1151 1152 UnicodeString& 1153 RuleBasedNumberFormat::format(const DecimalQuantity &number, 1154 UnicodeString& appendTo, 1155 FieldPosition& pos, 1156 UErrorCode &status) const { 1157 if (U_FAILURE(status)) { 1158 return appendTo; 1159 } 1160 DecimalQuantity copy(number); 1161 if (copy.fitsInLong()) { 1162 format(number.toLong(), appendTo, pos, status); 1163 } 1164 else { 1165 copy.roundToMagnitude(0, number::impl::RoundingMode::UNUM_ROUND_HALFEVEN, status); 1166 if (copy.fitsInLong()) { 1167 format(number.toDouble(), appendTo, pos, status); 1168 } 1169 else { 1170 // We're outside of our normal range that this framework can handle. 1171 // The DecimalFormat will provide more accurate results. 1172 1173 // TODO this section should probably be optimized. The DecimalFormat is shared in ICU4J. 1174 LocalPointer<NumberFormat> decimalFormat(NumberFormat::createInstance(locale, UNUM_DECIMAL, status), status); 1175 if (decimalFormat.isNull()) { 1176 return appendTo; 1177 } 1178 Formattable f; 1179 LocalPointer<DecimalQuantity> decimalQuantity(new DecimalQuantity(number), status); 1180 if (decimalQuantity.isNull()) { 1181 return appendTo; 1182 } 1183 f.adoptDecimalQuantity(decimalQuantity.orphan()); // f now owns decimalQuantity. 1184 decimalFormat->format(f, appendTo, pos, status); 1185 } 1186 } 1187 return appendTo; 1188 } 1189 1190 UnicodeString& 1191 RuleBasedNumberFormat::format(int32_t number, 1192 UnicodeString& toAppendTo, 1193 FieldPosition& pos) const 1194 { 1195 return format((int64_t)number, toAppendTo, pos); 1196 } 1197 1198 1199 UnicodeString& 1200 RuleBasedNumberFormat::format(int64_t number, 1201 UnicodeString& toAppendTo, 1202 FieldPosition& /* pos */) const 1203 { 1204 if (defaultRuleSet) { 1205 UErrorCode status = U_ZERO_ERROR; 1206 format(number, defaultRuleSet, toAppendTo, status); 1207 } 1208 return toAppendTo; 1209 } 1210 1211 1212 UnicodeString& 1213 RuleBasedNumberFormat::format(double number, 1214 UnicodeString& toAppendTo, 1215 FieldPosition& /* pos */) const 1216 { 1217 UErrorCode status = U_ZERO_ERROR; 1218 if (defaultRuleSet) { 1219 format(number, *defaultRuleSet, toAppendTo, status); 1220 } 1221 return toAppendTo; 1222 } 1223 1224 1225 UnicodeString& 1226 RuleBasedNumberFormat::format(int32_t number, 1227 const UnicodeString& ruleSetName, 1228 UnicodeString& toAppendTo, 1229 FieldPosition& pos, 1230 UErrorCode& status) const 1231 { 1232 return format((int64_t)number, ruleSetName, toAppendTo, pos, status); 1233 } 1234 1235 1236 UnicodeString& 1237 RuleBasedNumberFormat::format(int64_t number, 1238 const UnicodeString& ruleSetName, 1239 UnicodeString& toAppendTo, 1240 FieldPosition& /* pos */, 1241 UErrorCode& status) const 1242 { 1243 if (U_SUCCESS(status)) { 1244 if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) { 1245 // throw new IllegalArgumentException("Can't use internal rule set"); 1246 status = U_ILLEGAL_ARGUMENT_ERROR; 1247 } else { 1248 NFRuleSet *rs = findRuleSet(ruleSetName, status); 1249 if (rs) { 1250 format(number, rs, toAppendTo, status); 1251 } 1252 } 1253 } 1254 return toAppendTo; 1255 } 1256 1257 1258 UnicodeString& 1259 RuleBasedNumberFormat::format(double number, 1260 const UnicodeString& ruleSetName, 1261 UnicodeString& toAppendTo, 1262 FieldPosition& /* pos */, 1263 UErrorCode& status) const 1264 { 1265 if (U_SUCCESS(status)) { 1266 if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) { 1267 // throw new IllegalArgumentException("Can't use internal rule set"); 1268 status = U_ILLEGAL_ARGUMENT_ERROR; 1269 } else { 1270 NFRuleSet *rs = findRuleSet(ruleSetName, status); 1271 if (rs) { 1272 format(number, *rs, toAppendTo, status); 1273 } 1274 } 1275 } 1276 return toAppendTo; 1277 } 1278 1279 void 1280 RuleBasedNumberFormat::format(double number, 1281 NFRuleSet& rs, 1282 UnicodeString& toAppendTo, 1283 UErrorCode& status) const 1284 { 1285 int32_t startPos = toAppendTo.length(); 1286 if (getRoundingMode() != DecimalFormat::ERoundingMode::kRoundUnnecessary && !uprv_isNaN(number) && !uprv_isInfinite(number)) { 1287 DecimalQuantity digitList; 1288 digitList.setToDouble(number); 1289 digitList.roundToMagnitude( 1290 -getMaximumFractionDigits(), 1291 static_cast<UNumberFormatRoundingMode>(getRoundingMode()), 1292 status); 1293 number = digitList.toDouble(); 1294 } 1295 rs.format(number, toAppendTo, toAppendTo.length(), 0, status); 1296 adjustForCapitalizationContext(startPos, toAppendTo, status); 1297 } 1298 1299 /** 1300 * Bottleneck through which all the public format() methods 1301 * that take a long pass. By the time we get here, we know 1302 * which rule set we're using to do the formatting. 1303 * @param number The number to format 1304 * @param ruleSet The rule set to use to format the number 1305 * @return The text that resulted from formatting the number 1306 */ 1307 UnicodeString& 1308 RuleBasedNumberFormat::format(int64_t number, NFRuleSet *ruleSet, UnicodeString& toAppendTo, UErrorCode& status) const 1309 { 1310 // all API format() routines that take a double vector through 1311 // here. We have these two identical functions-- one taking a 1312 // double and one taking a long-- the couple digits of precision 1313 // that long has but double doesn't (both types are 8 bytes long, 1314 // but double has to borrow some of the mantissa bits to hold 1315 // the exponent). 1316 // Create an empty string buffer where the result will 1317 // be built, and pass it to the rule set (along with an insertion 1318 // position of 0 and the number being formatted) to the rule set 1319 // for formatting 1320 1321 if (U_SUCCESS(status)) { 1322 if (number == U_INT64_MIN) { 1323 // We can't handle this value right now. Provide an accurate default value. 1324 1325 // TODO this section should probably be optimized. The DecimalFormat is shared in ICU4J. 1326 NumberFormat *decimalFormat = NumberFormat::createInstance(locale, UNUM_DECIMAL, status); 1327 if (decimalFormat == nullptr) { 1328 return toAppendTo; 1329 } 1330 Formattable f; 1331 FieldPosition pos(FieldPosition::DONT_CARE); 1332 DecimalQuantity *decimalQuantity = new DecimalQuantity(); 1333 if (decimalQuantity == nullptr) { 1334 status = U_MEMORY_ALLOCATION_ERROR; 1335 delete decimalFormat; 1336 return toAppendTo; 1337 } 1338 decimalQuantity->setToLong(number); 1339 f.adoptDecimalQuantity(decimalQuantity); // f now owns decimalQuantity. 1340 decimalFormat->format(f, toAppendTo, pos, status); 1341 delete decimalFormat; 1342 } 1343 else { 1344 int32_t startPos = toAppendTo.length(); 1345 ruleSet->format(number, toAppendTo, toAppendTo.length(), 0, status); 1346 adjustForCapitalizationContext(startPos, toAppendTo, status); 1347 } 1348 } 1349 return toAppendTo; 1350 } 1351 1352 UnicodeString& 1353 RuleBasedNumberFormat::adjustForCapitalizationContext(int32_t startPos, 1354 UnicodeString& currentResult, 1355 UErrorCode& status) const 1356 { 1357 #if !UCONFIG_NO_BREAK_ITERATION 1358 UDisplayContext capitalizationContext = getContext(UDISPCTX_TYPE_CAPITALIZATION, status); 1359 if (capitalizationContext != UDISPCTX_CAPITALIZATION_NONE && startPos == 0 && currentResult.length() > 0) { 1360 // capitalize currentResult according to context 1361 UChar32 ch = currentResult.char32At(0); 1362 if (u_islower(ch) && U_SUCCESS(status) && capitalizationBrkIter != NULL && 1363 ( capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE || 1364 (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU && capitalizationForUIListMenu) || 1365 (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_STANDALONE && capitalizationForStandAlone)) ) { 1366 // titlecase first word of currentResult, here use sentence iterator unlike current implementations 1367 // in LocaleDisplayNamesImpl::adjustForUsageAndContext and RelativeDateFormat::format 1368 currentResult.toTitle(capitalizationBrkIter, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT); 1369 } 1370 } 1371 #endif 1372 return currentResult; 1373 } 1374 1375 1376 void 1377 RuleBasedNumberFormat::parse(const UnicodeString& text, 1378 Formattable& result, 1379 ParsePosition& parsePosition) const 1380 { 1381 if (!fRuleSets) { 1382 parsePosition.setErrorIndex(0); 1383 return; 1384 } 1385 1386 UnicodeString workingText(text, parsePosition.getIndex()); 1387 ParsePosition workingPos(0); 1388 1389 ParsePosition high_pp(0); 1390 Formattable high_result; 1391 1392 for (NFRuleSet** p = fRuleSets; *p; ++p) { 1393 NFRuleSet *rp = *p; 1394 if (rp->isPublic() && rp->isParseable()) { 1395 ParsePosition working_pp(0); 1396 Formattable working_result; 1397 1398 rp->parse(workingText, working_pp, kMaxDouble, 0, working_result); 1399 if (working_pp.getIndex() > high_pp.getIndex()) { 1400 high_pp = working_pp; 1401 high_result = working_result; 1402 1403 if (high_pp.getIndex() == workingText.length()) { 1404 break; 1405 } 1406 } 1407 } 1408 } 1409 1410 int32_t startIndex = parsePosition.getIndex(); 1411 parsePosition.setIndex(startIndex + high_pp.getIndex()); 1412 if (high_pp.getIndex() > 0) { 1413 parsePosition.setErrorIndex(-1); 1414 } else { 1415 int32_t errorIndex = (high_pp.getErrorIndex()>0)? high_pp.getErrorIndex(): 0; 1416 parsePosition.setErrorIndex(startIndex + errorIndex); 1417 } 1418 result = high_result; 1419 if (result.getType() == Formattable::kDouble) { 1420 double d = result.getDouble(); 1421 if (!uprv_isNaN(d) && d == uprv_trunc(d) && INT32_MIN <= d && d <= INT32_MAX) { 1422 // Note: casting a double to an int when the double is too large or small 1423 // to fit the destination is undefined behavior. The explicit range checks, 1424 // above, are required. Just casting and checking the result value is undefined. 1425 result.setLong(static_cast<int32_t>(d)); 1426 } 1427 } 1428 } 1429 1430 #if !UCONFIG_NO_COLLATION 1431 1432 void 1433 RuleBasedNumberFormat::setLenient(UBool enabled) 1434 { 1435 lenient = enabled; 1436 if (!enabled && collator) { 1437 delete collator; 1438 collator = NULL; 1439 } 1440 } 1441 1442 #endif 1443 1444 void 1445 RuleBasedNumberFormat::setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status) { 1446 if (U_SUCCESS(status)) { 1447 if (ruleSetName.isEmpty()) { 1448 if (localizations) { 1449 UnicodeString name(TRUE, localizations->getRuleSetName(0), -1); 1450 defaultRuleSet = findRuleSet(name, status); 1451 } else { 1452 initDefaultRuleSet(); 1453 } 1454 } else if (ruleSetName.startsWith(UNICODE_STRING_SIMPLE("%%"))) { 1455 status = U_ILLEGAL_ARGUMENT_ERROR; 1456 } else { 1457 NFRuleSet* result = findRuleSet(ruleSetName, status); 1458 if (result != NULL) { 1459 defaultRuleSet = result; 1460 } 1461 } 1462 } 1463 } 1464 1465 UnicodeString 1466 RuleBasedNumberFormat::getDefaultRuleSetName() const { 1467 UnicodeString result; 1468 if (defaultRuleSet && defaultRuleSet->isPublic()) { 1469 defaultRuleSet->getName(result); 1470 } else { 1471 result.setToBogus(); 1472 } 1473 return result; 1474 } 1475 1476 void 1477 RuleBasedNumberFormat::initDefaultRuleSet() 1478 { 1479 defaultRuleSet = NULL; 1480 if (!fRuleSets) { 1481 return; 1482 } 1483 1484 const UnicodeString spellout(UNICODE_STRING_SIMPLE("%spellout-numbering")); 1485 const UnicodeString ordinal(UNICODE_STRING_SIMPLE("%digits-ordinal")); 1486 const UnicodeString duration(UNICODE_STRING_SIMPLE("%duration")); 1487 1488 NFRuleSet**p = &fRuleSets[0]; 1489 while (*p) { 1490 if ((*p)->isNamed(spellout) || (*p)->isNamed(ordinal) || (*p)->isNamed(duration)) { 1491 defaultRuleSet = *p; 1492 return; 1493 } else { 1494 ++p; 1495 } 1496 } 1497 1498 defaultRuleSet = *--p; 1499 if (!defaultRuleSet->isPublic()) { 1500 while (p != fRuleSets) { 1501 if ((*--p)->isPublic()) { 1502 defaultRuleSet = *p; 1503 break; 1504 } 1505 } 1506 } 1507 } 1508 1509 1510 void 1511 RuleBasedNumberFormat::init(const UnicodeString& rules, LocalizationInfo* localizationInfos, 1512 UParseError& pErr, UErrorCode& status) 1513 { 1514 // TODO: implement UParseError 1515 uprv_memset(&pErr, 0, sizeof(UParseError)); 1516 // Note: this can leave ruleSets == NULL, so remaining code should check 1517 if (U_FAILURE(status)) { 1518 return; 1519 } 1520 1521 initializeDecimalFormatSymbols(status); 1522 initializeDefaultInfinityRule(status); 1523 initializeDefaultNaNRule(status); 1524 if (U_FAILURE(status)) { 1525 return; 1526 } 1527 1528 this->localizations = localizationInfos == NULL ? NULL : localizationInfos->ref(); 1529 1530 UnicodeString description(rules); 1531 if (!description.length()) { 1532 status = U_MEMORY_ALLOCATION_ERROR; 1533 return; 1534 } 1535 1536 // start by stripping the trailing whitespace from all the rules 1537 // (this is all the whitespace follwing each semicolon in the 1538 // description). This allows us to look for rule-set boundaries 1539 // by searching for ";%" without having to worry about whitespace 1540 // between the ; and the % 1541 stripWhitespace(description); 1542 1543 // check to see if there's a set of lenient-parse rules. If there 1544 // is, pull them out into our temporary holding place for them, 1545 // and delete them from the description before the real desciption- 1546 // parsing code sees them 1547 int32_t lp = description.indexOf(gLenientParse, -1, 0); 1548 if (lp != -1) { 1549 // we've got to make sure we're not in the middle of a rule 1550 // (where "%%lenient-parse" would actually get treated as 1551 // rule text) 1552 if (lp == 0 || description.charAt(lp - 1) == gSemiColon) { 1553 // locate the beginning and end of the actual collation 1554 // rules (there may be whitespace between the name and 1555 // the first token in the description) 1556 int lpEnd = description.indexOf(gSemiPercent, 2, lp); 1557 1558 if (lpEnd == -1) { 1559 lpEnd = description.length() - 1; 1560 } 1561 int lpStart = lp + u_strlen(gLenientParse); 1562 while (PatternProps::isWhiteSpace(description.charAt(lpStart))) { 1563 ++lpStart; 1564 } 1565 1566 // copy out the lenient-parse rules and delete them 1567 // from the description 1568 lenientParseRules = new UnicodeString(); 1569 /* test for NULL */ 1570 if (lenientParseRules == nullptr) { 1571 status = U_MEMORY_ALLOCATION_ERROR; 1572 return; 1573 } 1574 lenientParseRules->setTo(description, lpStart, lpEnd - lpStart); 1575 1576 description.remove(lp, lpEnd + 1 - lp); 1577 } 1578 } 1579 1580 // pre-flight parsing the description and count the number of 1581 // rule sets (";%" marks the end of one rule set and the beginning 1582 // of the next) 1583 numRuleSets = 0; 1584 for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, p)) { 1585 ++numRuleSets; 1586 ++p; 1587 } 1588 ++numRuleSets; 1589 1590 // our rule list is an array of the appropriate size 1591 fRuleSets = (NFRuleSet **)uprv_malloc((numRuleSets + 1) * sizeof(NFRuleSet *)); 1592 /* test for NULL */ 1593 if (fRuleSets == 0) { 1594 status = U_MEMORY_ALLOCATION_ERROR; 1595 return; 1596 } 1597 1598 for (int i = 0; i <= numRuleSets; ++i) { 1599 fRuleSets[i] = NULL; 1600 } 1601 1602 // divide up the descriptions into individual rule-set descriptions 1603 // and store them in a temporary array. At each step, we also 1604 // new up a rule set, but all this does is initialize its name 1605 // and remove it from its description. We can't actually parse 1606 // the rest of the descriptions and finish initializing everything 1607 // because we have to know the names and locations of all the rule 1608 // sets before we can actually set everything up 1609 if(!numRuleSets) { 1610 status = U_ILLEGAL_ARGUMENT_ERROR; 1611 return; 1612 } 1613 1614 ruleSetDescriptions = new UnicodeString[numRuleSets]; 1615 if (ruleSetDescriptions == nullptr) { 1616 status = U_MEMORY_ALLOCATION_ERROR; 1617 return; 1618 } 1619 1620 { 1621 int curRuleSet = 0; 1622 int32_t start = 0; 1623 for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, start)) { 1624 ruleSetDescriptions[curRuleSet].setTo(description, start, p + 1 - start); 1625 fRuleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status); 1626 if (fRuleSets[curRuleSet] == nullptr) { 1627 status = U_MEMORY_ALLOCATION_ERROR; 1628 return; 1629 } 1630 ++curRuleSet; 1631 start = p + 1; 1632 } 1633 ruleSetDescriptions[curRuleSet].setTo(description, start, description.length() - start); 1634 fRuleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status); 1635 if (fRuleSets[curRuleSet] == nullptr) { 1636 status = U_MEMORY_ALLOCATION_ERROR; 1637 return; 1638 } 1639 } 1640 1641 // now we can take note of the formatter's default rule set, which 1642 // is the last public rule set in the description (it's the last 1643 // rather than the first so that a user can create a new formatter 1644 // from an existing formatter and change its default behavior just 1645 // by appending more rule sets to the end) 1646 1647 // {dlf} Initialization of a fraction rule set requires the default rule 1648 // set to be known. For purposes of initialization, this is always the 1649 // last public rule set, no matter what the localization data says. 1650 initDefaultRuleSet(); 1651 1652 // finally, we can go back through the temporary descriptions 1653 // list and finish setting up the substructure (and we throw 1654 // away the temporary descriptions as we go) 1655 { 1656 for (int i = 0; i < numRuleSets; i++) { 1657 fRuleSets[i]->parseRules(ruleSetDescriptions[i], status); 1658 } 1659 } 1660 1661 // Now that the rules are initialized, the 'real' default rule 1662 // set can be adjusted by the localization data. 1663 1664 // The C code keeps the localization array as is, rather than building 1665 // a separate array of the public rule set names, so we have less work 1666 // to do here-- but we still need to check the names. 1667 1668 if (localizationInfos) { 1669 // confirm the names, if any aren't in the rules, that's an error 1670 // it is ok if the rules contain public rule sets that are not in this list 1671 for (int32_t i = 0; i < localizationInfos->getNumberOfRuleSets(); ++i) { 1672 UnicodeString name(TRUE, localizationInfos->getRuleSetName(i), -1); 1673 NFRuleSet* rs = findRuleSet(name, status); 1674 if (rs == NULL) { 1675 break; // error 1676 } 1677 if (i == 0) { 1678 defaultRuleSet = rs; 1679 } 1680 } 1681 } else { 1682 defaultRuleSet = getDefaultRuleSet(); 1683 } 1684 originalDescription = rules; 1685 } 1686 1687 // override the NumberFormat implementation in order to 1688 // lazily initialize relevant items 1689 void 1690 RuleBasedNumberFormat::setContext(UDisplayContext value, UErrorCode& status) 1691 { 1692 NumberFormat::setContext(value, status); 1693 if (U_SUCCESS(status)) { 1694 if (!capitalizationInfoSet && 1695 (value==UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU || value==UDISPCTX_CAPITALIZATION_FOR_STANDALONE)) { 1696 initCapitalizationContextInfo(locale); 1697 capitalizationInfoSet = TRUE; 1698 } 1699 #if !UCONFIG_NO_BREAK_ITERATION 1700 if ( capitalizationBrkIter == NULL && (value==UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE || 1701 (value==UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU && capitalizationForUIListMenu) || 1702 (value==UDISPCTX_CAPITALIZATION_FOR_STANDALONE && capitalizationForStandAlone)) ) { 1703 status = U_ZERO_ERROR; 1704 capitalizationBrkIter = BreakIterator::createSentenceInstance(locale, status); 1705 if (U_FAILURE(status)) { 1706 delete capitalizationBrkIter; 1707 capitalizationBrkIter = NULL; 1708 } 1709 } 1710 #endif 1711 } 1712 } 1713 1714 void 1715 RuleBasedNumberFormat::initCapitalizationContextInfo(const Locale& thelocale) 1716 { 1717 #if !UCONFIG_NO_BREAK_ITERATION 1718 const char * localeID = (thelocale != NULL)? thelocale.getBaseName(): NULL; 1719 UErrorCode status = U_ZERO_ERROR; 1720 UResourceBundle *rb = ures_open(NULL, localeID, &status); 1721 rb = ures_getByKeyWithFallback(rb, "contextTransforms", rb, &status); 1722 rb = ures_getByKeyWithFallback(rb, "number-spellout", rb, &status); 1723 if (U_SUCCESS(status) && rb != NULL) { 1724 int32_t len = 0; 1725 const int32_t * intVector = ures_getIntVector(rb, &len, &status); 1726 if (U_SUCCESS(status) && intVector != NULL && len >= 2) { 1727 capitalizationForUIListMenu = static_cast<UBool>(intVector[0]); 1728 capitalizationForStandAlone = static_cast<UBool>(intVector[1]); 1729 } 1730 } 1731 ures_close(rb); 1732 #endif 1733 } 1734 1735 void 1736 RuleBasedNumberFormat::stripWhitespace(UnicodeString& description) 1737 { 1738 // iterate through the characters... 1739 UnicodeString result; 1740 1741 int start = 0; 1742 while (start != -1 && start < description.length()) { 1743 // seek to the first non-whitespace character... 1744 while (start < description.length() 1745 && PatternProps::isWhiteSpace(description.charAt(start))) { 1746 ++start; 1747 } 1748 1749 // locate the next semicolon in the text and copy the text from 1750 // our current position up to that semicolon into the result 1751 int32_t p = description.indexOf(gSemiColon, start); 1752 if (p == -1) { 1753 // or if we don't find a semicolon, just copy the rest of 1754 // the string into the result 1755 result.append(description, start, description.length() - start); 1756 start = -1; 1757 } 1758 else if (p < description.length()) { 1759 result.append(description, start, p + 1 - start); 1760 start = p + 1; 1761 } 1762 1763 // when we get here, we've seeked off the end of the string, and 1764 // we terminate the loop (we continue until *start* is -1 rather 1765 // than until *p* is -1, because otherwise we'd miss the last 1766 // rule in the description) 1767 else { 1768 start = -1; 1769 } 1770 } 1771 1772 description.setTo(result); 1773 } 1774 1775 1776 void 1777 RuleBasedNumberFormat::dispose() 1778 { 1779 if (fRuleSets) { 1780 for (NFRuleSet** p = fRuleSets; *p; ++p) { 1781 delete *p; 1782 } 1783 uprv_free(fRuleSets); 1784 fRuleSets = NULL; 1785 } 1786 1787 if (ruleSetDescriptions) { 1788 delete [] ruleSetDescriptions; 1789 ruleSetDescriptions = NULL; 1790 } 1791 1792 #if !UCONFIG_NO_COLLATION 1793 delete collator; 1794 #endif 1795 collator = NULL; 1796 1797 delete decimalFormatSymbols; 1798 decimalFormatSymbols = NULL; 1799 1800 delete defaultInfinityRule; 1801 defaultInfinityRule = NULL; 1802 1803 delete defaultNaNRule; 1804 defaultNaNRule = NULL; 1805 1806 delete lenientParseRules; 1807 lenientParseRules = NULL; 1808 1809 #if !UCONFIG_NO_BREAK_ITERATION 1810 delete capitalizationBrkIter; 1811 capitalizationBrkIter = NULL; 1812 #endif 1813 1814 if (localizations) { 1815 localizations = localizations->unref(); 1816 } 1817 } 1818 1819 1820 //----------------------------------------------------------------------- 1821 // package-internal API 1822 //----------------------------------------------------------------------- 1823 1824 /** 1825 * Returns the collator to use for lenient parsing. The collator is lazily created: 1826 * this function creates it the first time it's called. 1827 * @return The collator to use for lenient parsing, or null if lenient parsing 1828 * is turned off. 1829 */ 1830 const RuleBasedCollator* 1831 RuleBasedNumberFormat::getCollator() const 1832 { 1833 #if !UCONFIG_NO_COLLATION 1834 if (!fRuleSets) { 1835 return NULL; 1836 } 1837 1838 // lazy-evaluate the collator 1839 if (collator == NULL && lenient) { 1840 // create a default collator based on the formatter's locale, 1841 // then pull out that collator's rules, append any additional 1842 // rules specified in the description, and create a _new_ 1843 // collator based on the combination of those rules 1844 1845 UErrorCode status = U_ZERO_ERROR; 1846 1847 Collator* temp = Collator::createInstance(locale, status); 1848 RuleBasedCollator* newCollator; 1849 if (U_SUCCESS(status) && (newCollator = dynamic_cast<RuleBasedCollator*>(temp)) != NULL) { 1850 if (lenientParseRules) { 1851 UnicodeString rules(newCollator->getRules()); 1852 rules.append(*lenientParseRules); 1853 1854 newCollator = new RuleBasedCollator(rules, status); 1855 // Exit if newCollator could not be created. 1856 if (newCollator == NULL) { 1857 return NULL; 1858 } 1859 } else { 1860 temp = NULL; 1861 } 1862 if (U_SUCCESS(status)) { 1863 newCollator->setAttribute(UCOL_DECOMPOSITION_MODE, UCOL_ON, status); 1864 // cast away const 1865 ((RuleBasedNumberFormat*)this)->collator = newCollator; 1866 } else { 1867 delete newCollator; 1868 } 1869 } 1870 delete temp; 1871 } 1872 #endif 1873 1874 // if lenient-parse mode is off, this will be null 1875 // (see setLenientParseMode()) 1876 return collator; 1877 } 1878 1879 1880 DecimalFormatSymbols* 1881 RuleBasedNumberFormat::initializeDecimalFormatSymbols(UErrorCode &status) 1882 { 1883 // lazy-evaluate the DecimalFormatSymbols object. This object 1884 // is shared by all DecimalFormat instances belonging to this 1885 // formatter 1886 if (decimalFormatSymbols == nullptr) { 1887 LocalPointer<DecimalFormatSymbols> temp(new DecimalFormatSymbols(locale, status), status); 1888 if (U_SUCCESS(status)) { 1889 decimalFormatSymbols = temp.orphan(); 1890 } 1891 } 1892 return decimalFormatSymbols; 1893 } 1894 1895 /** 1896 * Returns the DecimalFormatSymbols object that should be used by all DecimalFormat 1897 * instances owned by this formatter. 1898 */ 1899 const DecimalFormatSymbols* 1900 RuleBasedNumberFormat::getDecimalFormatSymbols() const 1901 { 1902 return decimalFormatSymbols; 1903 } 1904 1905 NFRule* 1906 RuleBasedNumberFormat::initializeDefaultInfinityRule(UErrorCode &status) 1907 { 1908 if (U_FAILURE(status)) { 1909 return nullptr; 1910 } 1911 if (defaultInfinityRule == NULL) { 1912 UnicodeString rule(UNICODE_STRING_SIMPLE("Inf: ")); 1913 rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kInfinitySymbol)); 1914 LocalPointer<NFRule> temp(new NFRule(this, rule, status), status); 1915 if (U_SUCCESS(status)) { 1916 defaultInfinityRule = temp.orphan(); 1917 } 1918 } 1919 return defaultInfinityRule; 1920 } 1921 1922 const NFRule* 1923 RuleBasedNumberFormat::getDefaultInfinityRule() const 1924 { 1925 return defaultInfinityRule; 1926 } 1927 1928 NFRule* 1929 RuleBasedNumberFormat::initializeDefaultNaNRule(UErrorCode &status) 1930 { 1931 if (U_FAILURE(status)) { 1932 return nullptr; 1933 } 1934 if (defaultNaNRule == nullptr) { 1935 UnicodeString rule(UNICODE_STRING_SIMPLE("NaN: ")); 1936 rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kNaNSymbol)); 1937 LocalPointer<NFRule> temp(new NFRule(this, rule, status), status); 1938 if (U_SUCCESS(status)) { 1939 defaultNaNRule = temp.orphan(); 1940 } 1941 } 1942 return defaultNaNRule; 1943 } 1944 1945 const NFRule* 1946 RuleBasedNumberFormat::getDefaultNaNRule() const 1947 { 1948 return defaultNaNRule; 1949 } 1950 1951 // De-owning the current localized symbols and adopt the new symbols. 1952 void 1953 RuleBasedNumberFormat::adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt) 1954 { 1955 if (symbolsToAdopt == NULL) { 1956 return; // do not allow caller to set decimalFormatSymbols to NULL 1957 } 1958 1959 if (decimalFormatSymbols != NULL) { 1960 delete decimalFormatSymbols; 1961 } 1962 1963 decimalFormatSymbols = symbolsToAdopt; 1964 1965 { 1966 // Apply the new decimalFormatSymbols by reparsing the rulesets 1967 UErrorCode status = U_ZERO_ERROR; 1968 1969 delete defaultInfinityRule; 1970 defaultInfinityRule = NULL; 1971 initializeDefaultInfinityRule(status); // Reset with the new DecimalFormatSymbols 1972 1973 delete defaultNaNRule; 1974 defaultNaNRule = NULL; 1975 initializeDefaultNaNRule(status); // Reset with the new DecimalFormatSymbols 1976 1977 if (fRuleSets) { 1978 for (int32_t i = 0; i < numRuleSets; i++) { 1979 fRuleSets[i]->setDecimalFormatSymbols(*symbolsToAdopt, status); 1980 } 1981 } 1982 } 1983 } 1984 1985 // Setting the symbols is equivalent to adopting a newly created localized symbols. 1986 void 1987 RuleBasedNumberFormat::setDecimalFormatSymbols(const DecimalFormatSymbols& symbols) 1988 { 1989 adoptDecimalFormatSymbols(new DecimalFormatSymbols(symbols)); 1990 } 1991 1992 PluralFormat * 1993 RuleBasedNumberFormat::createPluralFormat(UPluralType pluralType, 1994 const UnicodeString &pattern, 1995 UErrorCode& status) const 1996 { 1997 auto *pf = new PluralFormat(locale, pluralType, pattern, status); 1998 if (pf == nullptr) { 1999 status = U_MEMORY_ALLOCATION_ERROR; 2000 } 2001 return pf; 2002 } 2003 2004 /** 2005 * Get the rounding mode. 2006 * @return A rounding mode 2007 */ 2008 DecimalFormat::ERoundingMode RuleBasedNumberFormat::getRoundingMode() const { 2009 return fRoundingMode; 2010 } 2011 2012 /** 2013 * Set the rounding mode. This has no effect unless the rounding 2014 * increment is greater than zero. 2015 * @param roundingMode A rounding mode 2016 */ 2017 void RuleBasedNumberFormat::setRoundingMode(DecimalFormat::ERoundingMode roundingMode) { 2018 fRoundingMode = roundingMode; 2019 } 2020 2021 U_NAMESPACE_END 2022 2023 /* U_HAVE_RBNF */ 2024 #endif 2025
