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