icuSources/i18n/rbnf.cpp

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