| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * Copyright (C) 1997-2015, International Business Machines Corporation |
| * and others. All Rights Reserved. |
| ******************************************************************************* |
| */ |
| |
| #if defined(STARBOARD) |
| #include "starboard/client_porting/poem/string_poem.h" |
| #endif // defined(STARBOARD) |
| #include "unicode/utypes.h" |
| #include "utypeinfo.h" // for 'typeid' to work |
| |
| #include "unicode/rbnf.h" |
| |
| #if U_HAVE_RBNF |
| |
| #include "unicode/normlzr.h" |
| #include "unicode/plurfmt.h" |
| #include "unicode/tblcoll.h" |
| #include "unicode/uchar.h" |
| #include "unicode/ucol.h" |
| #include "unicode/uloc.h" |
| #include "unicode/unum.h" |
| #include "unicode/ures.h" |
| #include "unicode/ustring.h" |
| #include "unicode/utf16.h" |
| #include "unicode/udata.h" |
| #include "unicode/udisplaycontext.h" |
| #include "unicode/brkiter.h" |
| #include "unicode/ucasemap.h" |
| |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "patternprops.h" |
| #include "uresimp.h" |
| #include "nfrs.h" |
| #include "number_decimalquantity.h" |
| |
| // debugging |
| // #define RBNF_DEBUG |
| |
| #ifdef RBNF_DEBUG |
| #include <stdio.h> |
| #endif |
| |
| #define U_ICUDATA_RBNF U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "rbnf" |
| |
| static const UChar gPercentPercent[] = |
| { |
| 0x25, 0x25, 0 |
| }; /* "%%" */ |
| |
| // All urbnf objects are created through openRules, so we init all of the |
| // Unicode string constants required by rbnf, nfrs, or nfr here. |
| static const UChar gLenientParse[] = |
| { |
| 0x25, 0x25, 0x6C, 0x65, 0x6E, 0x69, 0x65, 0x6E, 0x74, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x3A, 0 |
| }; /* "%%lenient-parse:" */ |
| static const UChar gSemiColon = 0x003B; |
| static const UChar gSemiPercent[] = |
| { |
| 0x3B, 0x25, 0 |
| }; /* ";%" */ |
| |
| #define kSomeNumberOfBitsDiv2 22 |
| #define kHalfMaxDouble (double)(1 << kSomeNumberOfBitsDiv2) |
| #define kMaxDouble (kHalfMaxDouble * kHalfMaxDouble) |
| |
| U_NAMESPACE_BEGIN |
| |
| using number::impl::DecimalQuantity; |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedNumberFormat) |
| |
| /* |
| This is a utility class. It does not use ICU's RTTI. |
| If ICU's RTTI is needed again, you can uncomment the RTTI code and derive from UObject. |
| Please make sure that intltest passes on Windows in Release mode, |
| since the string pooling per compilation unit will mess up how RTTI works. |
| The RTTI code was also removed due to lack of code coverage. |
| */ |
| class LocalizationInfo : public UMemory { |
| protected: |
| virtual ~LocalizationInfo(); |
| uint32_t refcount; |
| |
| public: |
| LocalizationInfo() : refcount(0) {} |
| |
| LocalizationInfo* ref(void) { |
| ++refcount; |
| return this; |
| } |
| |
| LocalizationInfo* unref(void) { |
| if (refcount && --refcount == 0) { |
| delete this; |
| } |
| return NULL; |
| } |
| |
| virtual UBool operator==(const LocalizationInfo* rhs) const; |
| inline UBool operator!=(const LocalizationInfo* rhs) const { return !operator==(rhs); } |
| |
| virtual int32_t getNumberOfRuleSets(void) const = 0; |
| virtual const UChar* getRuleSetName(int32_t index) const = 0; |
| virtual int32_t getNumberOfDisplayLocales(void) const = 0; |
| virtual const UChar* getLocaleName(int32_t index) const = 0; |
| virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const = 0; |
| |
| virtual int32_t indexForLocale(const UChar* locale) const; |
| virtual int32_t indexForRuleSet(const UChar* ruleset) const; |
| |
| // virtual UClassID getDynamicClassID() const = 0; |
| // static UClassID getStaticClassID(void); |
| }; |
| |
| LocalizationInfo::~LocalizationInfo() {} |
| |
| //UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(LocalizationInfo) |
| |
| // if both strings are NULL, this returns TRUE |
| static UBool |
| streq(const UChar* lhs, const UChar* rhs) { |
| if (rhs == lhs) { |
| return TRUE; |
| } |
| if (lhs && rhs) { |
| return u_strcmp(lhs, rhs) == 0; |
| } |
| return FALSE; |
| } |
| |
| UBool |
| LocalizationInfo::operator==(const LocalizationInfo* rhs) const { |
| if (rhs) { |
| if (this == rhs) { |
| return TRUE; |
| } |
| |
| int32_t rsc = getNumberOfRuleSets(); |
| if (rsc == rhs->getNumberOfRuleSets()) { |
| for (int i = 0; i < rsc; ++i) { |
| if (!streq(getRuleSetName(i), rhs->getRuleSetName(i))) { |
| return FALSE; |
| } |
| } |
| int32_t dlc = getNumberOfDisplayLocales(); |
| if (dlc == rhs->getNumberOfDisplayLocales()) { |
| for (int i = 0; i < dlc; ++i) { |
| const UChar* locale = getLocaleName(i); |
| int32_t ix = rhs->indexForLocale(locale); |
| // if no locale, ix is -1, getLocaleName returns null, so streq returns false |
| if (!streq(locale, rhs->getLocaleName(ix))) { |
| return FALSE; |
| } |
| for (int j = 0; j < rsc; ++j) { |
| if (!streq(getDisplayName(i, j), rhs->getDisplayName(ix, j))) { |
| return FALSE; |
| } |
| } |
| } |
| return TRUE; |
| } |
| } |
| } |
| return FALSE; |
| } |
| |
| int32_t |
| LocalizationInfo::indexForLocale(const UChar* locale) const { |
| for (int i = 0; i < getNumberOfDisplayLocales(); ++i) { |
| if (streq(locale, getLocaleName(i))) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| int32_t |
| LocalizationInfo::indexForRuleSet(const UChar* ruleset) const { |
| if (ruleset) { |
| for (int i = 0; i < getNumberOfRuleSets(); ++i) { |
| if (streq(ruleset, getRuleSetName(i))) { |
| return i; |
| } |
| } |
| } |
| return -1; |
| } |
| |
| |
| typedef void (*Fn_Deleter)(void*); |
| |
| class VArray { |
| void** buf; |
| int32_t cap; |
| int32_t size; |
| Fn_Deleter deleter; |
| public: |
| VArray() : buf(NULL), cap(0), size(0), deleter(NULL) {} |
| |
| VArray(Fn_Deleter del) : buf(NULL), cap(0), size(0), deleter(del) {} |
| |
| ~VArray() { |
| if (deleter) { |
| for (int i = 0; i < size; ++i) { |
| (*deleter)(buf[i]); |
| } |
| } |
| uprv_free(buf); |
| } |
| |
| int32_t length() { |
| return size; |
| } |
| |
| void add(void* elem, UErrorCode& status) { |
| if (U_SUCCESS(status)) { |
| if (size == cap) { |
| if (cap == 0) { |
| cap = 1; |
| } else if (cap < 256) { |
| cap *= 2; |
| } else { |
| cap += 256; |
| } |
| if (buf == NULL) { |
| buf = (void**)uprv_malloc(cap * sizeof(void*)); |
| } else { |
| buf = (void**)uprv_realloc(buf, cap * sizeof(void*)); |
| } |
| if (buf == NULL) { |
| // if we couldn't realloc, we leak the memory we've already allocated, but we're in deep trouble anyway |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| void* start = &buf[size]; |
| size_t count = (cap - size) * sizeof(void*); |
| uprv_memset(start, 0, count); // fill with nulls, just because |
| } |
| buf[size++] = elem; |
| } |
| } |
| |
| void** release(void) { |
| void** result = buf; |
| buf = NULL; |
| cap = 0; |
| size = 0; |
| return result; |
| } |
| }; |
| |
| class LocDataParser; |
| |
| class StringLocalizationInfo : public LocalizationInfo { |
| UChar* info; |
| UChar*** data; |
| int32_t numRuleSets; |
| int32_t numLocales; |
| |
| friend class LocDataParser; |
| |
| StringLocalizationInfo(UChar* i, UChar*** d, int32_t numRS, int32_t numLocs) |
| : info(i), data(d), numRuleSets(numRS), numLocales(numLocs) |
| { |
| } |
| |
| public: |
| static StringLocalizationInfo* create(const UnicodeString& info, UParseError& perror, UErrorCode& status); |
| |
| virtual ~StringLocalizationInfo(); |
| virtual int32_t getNumberOfRuleSets(void) const { return numRuleSets; } |
| virtual const UChar* getRuleSetName(int32_t index) const; |
| virtual int32_t getNumberOfDisplayLocales(void) const { return numLocales; } |
| virtual const UChar* getLocaleName(int32_t index) const; |
| virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const; |
| |
| // virtual UClassID getDynamicClassID() const; |
| // static UClassID getStaticClassID(void); |
| |
| private: |
| void init(UErrorCode& status) const; |
| }; |
| |
| |
| enum { |
| OPEN_ANGLE = 0x003c, /* '<' */ |
| CLOSE_ANGLE = 0x003e, /* '>' */ |
| COMMA = 0x002c, |
| TICK = 0x0027, |
| QUOTE = 0x0022, |
| SPACE = 0x0020 |
| }; |
| |
| /** |
| * Utility for parsing a localization string and returning a StringLocalizationInfo*. |
| */ |
| class LocDataParser { |
| UChar* data; |
| const UChar* e; |
| UChar* p; |
| UChar ch; |
| UParseError& pe; |
| UErrorCode& ec; |
| |
| public: |
| LocDataParser(UParseError& parseError, UErrorCode& status) |
| : data(NULL), e(NULL), p(NULL), ch(0xffff), pe(parseError), ec(status) {} |
| ~LocDataParser() {} |
| |
| /* |
| * On a successful parse, return a StringLocalizationInfo*, otherwise delete locData, set perror and status, |
| * and return NULL. The StringLocalizationInfo will adopt locData if it is created. |
| */ |
| StringLocalizationInfo* parse(UChar* data, int32_t len); |
| |
| private: |
| |
| inline void inc(void) { |
| ++p; |
| ch = 0xffff; |
| } |
| inline UBool checkInc(UChar c) { |
| if (p < e && (ch == c || *p == c)) { |
| inc(); |
| return TRUE; |
| } |
| return FALSE; |
| } |
| inline UBool check(UChar c) { |
| return p < e && (ch == c || *p == c); |
| } |
| inline void skipWhitespace(void) { |
| while (p < e && PatternProps::isWhiteSpace(ch != 0xffff ? ch : *p)) { |
| inc(); |
| } |
| } |
| inline UBool inList(UChar c, const UChar* list) const { |
| if (*list == SPACE && PatternProps::isWhiteSpace(c)) { |
| return TRUE; |
| } |
| while (*list && *list != c) { |
| ++list; |
| } |
| return *list == c; |
| } |
| void parseError(const char* msg); |
| |
| StringLocalizationInfo* doParse(void); |
| |
| UChar** nextArray(int32_t& requiredLength); |
| UChar* nextString(void); |
| }; |
| |
| #ifdef RBNF_DEBUG |
| #define ERROR(msg) UPRV_BLOCK_MACRO_BEGIN { \ |
| parseError(msg); \ |
| return NULL; \ |
| } UPRV_BLOCK_MACRO_END |
| #define EXPLANATION_ARG explanationArg |
| #else |
| #define ERROR(msg) UPRV_BLOCK_MACRO_BEGIN { \ |
| parseError(NULL); \ |
| return NULL; \ |
| } UPRV_BLOCK_MACRO_END |
| #define EXPLANATION_ARG |
| #endif |
| |
| |
| static const UChar DQUOTE_STOPLIST[] = { |
| QUOTE, 0 |
| }; |
| |
| static const UChar SQUOTE_STOPLIST[] = { |
| TICK, 0 |
| }; |
| |
| static const UChar NOQUOTE_STOPLIST[] = { |
| SPACE, COMMA, CLOSE_ANGLE, OPEN_ANGLE, TICK, QUOTE, 0 |
| }; |
| |
| static void |
| DeleteFn(void* p) { |
| uprv_free(p); |
| } |
| |
| StringLocalizationInfo* |
| LocDataParser::parse(UChar* _data, int32_t len) { |
| if (U_FAILURE(ec)) { |
| if (_data) uprv_free(_data); |
| return NULL; |
| } |
| |
| pe.line = 0; |
| pe.offset = -1; |
| pe.postContext[0] = 0; |
| pe.preContext[0] = 0; |
| |
| if (_data == NULL) { |
| ec = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| if (len <= 0) { |
| ec = U_ILLEGAL_ARGUMENT_ERROR; |
| uprv_free(_data); |
| return NULL; |
| } |
| |
| data = _data; |
| e = data + len; |
| p = _data; |
| ch = 0xffff; |
| |
| return doParse(); |
| } |
| |
| |
| StringLocalizationInfo* |
| LocDataParser::doParse(void) { |
| skipWhitespace(); |
| if (!checkInc(OPEN_ANGLE)) { |
| ERROR("Missing open angle"); |
| } else { |
| VArray array(DeleteFn); |
| UBool mightHaveNext = TRUE; |
| int32_t requiredLength = -1; |
| while (mightHaveNext) { |
| mightHaveNext = FALSE; |
| UChar** elem = nextArray(requiredLength); |
| skipWhitespace(); |
| UBool haveComma = check(COMMA); |
| if (elem) { |
| array.add(elem, ec); |
| if (haveComma) { |
| inc(); |
| mightHaveNext = TRUE; |
| } |
| } else if (haveComma) { |
| ERROR("Unexpected character"); |
| } |
| } |
| |
| skipWhitespace(); |
| if (!checkInc(CLOSE_ANGLE)) { |
| if (check(OPEN_ANGLE)) { |
| ERROR("Missing comma in outer array"); |
| } else { |
| ERROR("Missing close angle bracket in outer array"); |
| } |
| } |
| |
| skipWhitespace(); |
| if (p != e) { |
| ERROR("Extra text after close of localization data"); |
| } |
| |
| array.add(NULL, ec); |
| if (U_SUCCESS(ec)) { |
| int32_t numLocs = array.length() - 2; // subtract first, NULL |
| UChar*** result = (UChar***)array.release(); |
| |
| return new StringLocalizationInfo(data, result, requiredLength-2, numLocs); // subtract first, NULL |
| } |
| } |
| |
| ERROR("Unknown error"); |
| } |
| |
| UChar** |
| LocDataParser::nextArray(int32_t& requiredLength) { |
| if (U_FAILURE(ec)) { |
| return NULL; |
| } |
| |
| skipWhitespace(); |
| if (!checkInc(OPEN_ANGLE)) { |
| ERROR("Missing open angle"); |
| } |
| |
| VArray array; |
| UBool mightHaveNext = TRUE; |
| while (mightHaveNext) { |
| mightHaveNext = FALSE; |
| UChar* elem = nextString(); |
| skipWhitespace(); |
| UBool haveComma = check(COMMA); |
| if (elem) { |
| array.add(elem, ec); |
| if (haveComma) { |
| inc(); |
| mightHaveNext = TRUE; |
| } |
| } else if (haveComma) { |
| ERROR("Unexpected comma"); |
| } |
| } |
| skipWhitespace(); |
| if (!checkInc(CLOSE_ANGLE)) { |
| if (check(OPEN_ANGLE)) { |
| ERROR("Missing close angle bracket in inner array"); |
| } else { |
| ERROR("Missing comma in inner array"); |
| } |
| } |
| |
| array.add(NULL, ec); |
| if (U_SUCCESS(ec)) { |
| if (requiredLength == -1) { |
| requiredLength = array.length() + 1; |
| } else if (array.length() != requiredLength) { |
| ec = U_ILLEGAL_ARGUMENT_ERROR; |
| ERROR("Array not of required length"); |
| } |
| |
| return (UChar**)array.release(); |
| } |
| ERROR("Unknown Error"); |
| } |
| |
| UChar* |
| LocDataParser::nextString() { |
| UChar* result = NULL; |
| |
| skipWhitespace(); |
| if (p < e) { |
| const UChar* terminators; |
| UChar c = *p; |
| UBool haveQuote = c == QUOTE || c == TICK; |
| if (haveQuote) { |
| inc(); |
| terminators = c == QUOTE ? DQUOTE_STOPLIST : SQUOTE_STOPLIST; |
| } else { |
| terminators = NOQUOTE_STOPLIST; |
| } |
| UChar* start = p; |
| while (p < e && !inList(*p, terminators)) ++p; |
| if (p == e) { |
| ERROR("Unexpected end of data"); |
| } |
| |
| UChar x = *p; |
| if (p > start) { |
| ch = x; |
| *p = 0x0; // terminate by writing to data |
| result = start; // just point into data |
| } |
| if (haveQuote) { |
| if (x != c) { |
| ERROR("Missing matching quote"); |
| } else if (p == start) { |
| ERROR("Empty string"); |
| } |
| inc(); |
| } else if (x == OPEN_ANGLE || x == TICK || x == QUOTE) { |
| ERROR("Unexpected character in string"); |
| } |
| } |
| |
| // ok for there to be no next string |
| return result; |
| } |
| |
| void LocDataParser::parseError(const char* EXPLANATION_ARG) |
| { |
| if (!data) { |
| return; |
| } |
| |
| const UChar* start = p - U_PARSE_CONTEXT_LEN - 1; |
| if (start < data) { |
| start = data; |
| } |
| for (UChar* x = p; --x >= start;) { |
| if (!*x) { |
| start = x+1; |
| break; |
| } |
| } |
| const UChar* limit = p + U_PARSE_CONTEXT_LEN - 1; |
| if (limit > e) { |
| limit = e; |
| } |
| u_strncpy(pe.preContext, start, (int32_t)(p-start)); |
| pe.preContext[p-start] = 0; |
| u_strncpy(pe.postContext, p, (int32_t)(limit-p)); |
| pe.postContext[limit-p] = 0; |
| pe.offset = (int32_t)(p - data); |
| |
| #ifdef RBNF_DEBUG |
| fprintf(stderr, "%s at or near character %ld: ", EXPLANATION_ARG, p-data); |
| |
| UnicodeString msg; |
| msg.append(start, p - start); |
| msg.append((UChar)0x002f); /* SOLIDUS/SLASH */ |
| msg.append(p, limit-p); |
| msg.append(UNICODE_STRING_SIMPLE("'")); |
| |
| char buf[128]; |
| int32_t len = msg.extract(0, msg.length(), buf, 128); |
| if (len >= 128) { |
| buf[127] = 0; |
| } else { |
| buf[len] = 0; |
| } |
| fprintf(stderr, "%s\n", buf); |
| fflush(stderr); |
| #endif |
| |
| uprv_free(data); |
| data = NULL; |
| p = NULL; |
| e = NULL; |
| |
| if (U_SUCCESS(ec)) { |
| ec = U_PARSE_ERROR; |
| } |
| } |
| |
| //UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringLocalizationInfo) |
| |
| StringLocalizationInfo* |
| StringLocalizationInfo::create(const UnicodeString& info, UParseError& perror, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| |
| int32_t len = info.length(); |
| if (len == 0) { |
| return NULL; // no error; |
| } |
| |
| UChar* p = (UChar*)uprv_malloc(len * sizeof(UChar)); |
| if (!p) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| info.extract(p, len, status); |
| if (!U_FAILURE(status)) { |
| status = U_ZERO_ERROR; // clear warning about non-termination |
| } |
| |
| LocDataParser parser(perror, status); |
| return parser.parse(p, len); |
| } |
| |
| StringLocalizationInfo::~StringLocalizationInfo() { |
| for (UChar*** p = (UChar***)data; *p; ++p) { |
| // remaining data is simply pointer into our unicode string data. |
| if (*p) uprv_free(*p); |
| } |
| if (data) uprv_free(data); |
| if (info) uprv_free(info); |
| } |
| |
| |
| const UChar* |
| StringLocalizationInfo::getRuleSetName(int32_t index) const { |
| if (index >= 0 && index < getNumberOfRuleSets()) { |
| return data[0][index]; |
| } |
| return NULL; |
| } |
| |
| const UChar* |
| StringLocalizationInfo::getLocaleName(int32_t index) const { |
| if (index >= 0 && index < getNumberOfDisplayLocales()) { |
| return data[index+1][0]; |
| } |
| return NULL; |
| } |
| |
| const UChar* |
| StringLocalizationInfo::getDisplayName(int32_t localeIndex, int32_t ruleIndex) const { |
| if (localeIndex >= 0 && localeIndex < getNumberOfDisplayLocales() && |
| ruleIndex >= 0 && ruleIndex < getNumberOfRuleSets()) { |
| return data[localeIndex+1][ruleIndex+1]; |
| } |
| return NULL; |
| } |
| |
| // ---------- |
| |
| RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, |
| const UnicodeString& locs, |
| const Locale& alocale, UParseError& perror, UErrorCode& status) |
| : fRuleSets(NULL) |
| , ruleSetDescriptions(NULL) |
| , numRuleSets(0) |
| , defaultRuleSet(NULL) |
| , locale(alocale) |
| , collator(NULL) |
| , decimalFormatSymbols(NULL) |
| , defaultInfinityRule(NULL) |
| , defaultNaNRule(NULL) |
| , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) |
| , lenient(FALSE) |
| , lenientParseRules(NULL) |
| , localizations(NULL) |
| , capitalizationInfoSet(FALSE) |
| , capitalizationForUIListMenu(FALSE) |
| , capitalizationForStandAlone(FALSE) |
| , capitalizationBrkIter(NULL) |
| { |
| LocalizationInfo* locinfo = StringLocalizationInfo::create(locs, perror, status); |
| init(description, locinfo, perror, status); |
| } |
| |
| RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, |
| const UnicodeString& locs, |
| UParseError& perror, UErrorCode& status) |
| : fRuleSets(NULL) |
| , ruleSetDescriptions(NULL) |
| , numRuleSets(0) |
| , defaultRuleSet(NULL) |
| , locale(Locale::getDefault()) |
| , collator(NULL) |
| , decimalFormatSymbols(NULL) |
| , defaultInfinityRule(NULL) |
| , defaultNaNRule(NULL) |
| , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) |
| , lenient(FALSE) |
| , lenientParseRules(NULL) |
| , localizations(NULL) |
| , capitalizationInfoSet(FALSE) |
| , capitalizationForUIListMenu(FALSE) |
| , capitalizationForStandAlone(FALSE) |
| , capitalizationBrkIter(NULL) |
| { |
| LocalizationInfo* locinfo = StringLocalizationInfo::create(locs, perror, status); |
| init(description, locinfo, perror, status); |
| } |
| |
| RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, |
| LocalizationInfo* info, |
| const Locale& alocale, UParseError& perror, UErrorCode& status) |
| : fRuleSets(NULL) |
| , ruleSetDescriptions(NULL) |
| , numRuleSets(0) |
| , defaultRuleSet(NULL) |
| , locale(alocale) |
| , collator(NULL) |
| , decimalFormatSymbols(NULL) |
| , defaultInfinityRule(NULL) |
| , defaultNaNRule(NULL) |
| , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) |
| , lenient(FALSE) |
| , lenientParseRules(NULL) |
| , localizations(NULL) |
| , capitalizationInfoSet(FALSE) |
| , capitalizationForUIListMenu(FALSE) |
| , capitalizationForStandAlone(FALSE) |
| , capitalizationBrkIter(NULL) |
| { |
| init(description, info, perror, status); |
| } |
| |
| RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, |
| UParseError& perror, |
| UErrorCode& status) |
| : fRuleSets(NULL) |
| , ruleSetDescriptions(NULL) |
| , numRuleSets(0) |
| , defaultRuleSet(NULL) |
| , locale(Locale::getDefault()) |
| , collator(NULL) |
| , decimalFormatSymbols(NULL) |
| , defaultInfinityRule(NULL) |
| , defaultNaNRule(NULL) |
| , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) |
| , lenient(FALSE) |
| , lenientParseRules(NULL) |
| , localizations(NULL) |
| , capitalizationInfoSet(FALSE) |
| , capitalizationForUIListMenu(FALSE) |
| , capitalizationForStandAlone(FALSE) |
| , capitalizationBrkIter(NULL) |
| { |
| init(description, NULL, perror, status); |
| } |
| |
| RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, |
| const Locale& aLocale, |
| UParseError& perror, |
| UErrorCode& status) |
| : fRuleSets(NULL) |
| , ruleSetDescriptions(NULL) |
| , numRuleSets(0) |
| , defaultRuleSet(NULL) |
| , locale(aLocale) |
| , collator(NULL) |
| , decimalFormatSymbols(NULL) |
| , defaultInfinityRule(NULL) |
| , defaultNaNRule(NULL) |
| , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) |
| , lenient(FALSE) |
| , lenientParseRules(NULL) |
| , localizations(NULL) |
| , capitalizationInfoSet(FALSE) |
| , capitalizationForUIListMenu(FALSE) |
| , capitalizationForStandAlone(FALSE) |
| , capitalizationBrkIter(NULL) |
| { |
| init(description, NULL, perror, status); |
| } |
| |
| RuleBasedNumberFormat::RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& alocale, UErrorCode& status) |
| : fRuleSets(NULL) |
| , ruleSetDescriptions(NULL) |
| , numRuleSets(0) |
| , defaultRuleSet(NULL) |
| , locale(alocale) |
| , collator(NULL) |
| , decimalFormatSymbols(NULL) |
| , defaultInfinityRule(NULL) |
| , defaultNaNRule(NULL) |
| , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) |
| , lenient(FALSE) |
| , lenientParseRules(NULL) |
| , localizations(NULL) |
| , capitalizationInfoSet(FALSE) |
| , capitalizationForUIListMenu(FALSE) |
| , capitalizationForStandAlone(FALSE) |
| , capitalizationBrkIter(NULL) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| const char* rules_tag = "RBNFRules"; |
| const char* fmt_tag = ""; |
| switch (tag) { |
| case URBNF_SPELLOUT: fmt_tag = "SpelloutRules"; break; |
| case URBNF_ORDINAL: fmt_tag = "OrdinalRules"; break; |
| case URBNF_DURATION: fmt_tag = "DurationRules"; break; |
| case URBNF_NUMBERING_SYSTEM: fmt_tag = "NumberingSystemRules"; break; |
| default: status = U_ILLEGAL_ARGUMENT_ERROR; return; |
| } |
| |
| // TODO: read localization info from resource |
| LocalizationInfo* locinfo = NULL; |
| |
| UResourceBundle* nfrb = ures_open(U_ICUDATA_RBNF, locale.getName(), &status); |
| if (U_SUCCESS(status)) { |
| setLocaleIDs(ures_getLocaleByType(nfrb, ULOC_VALID_LOCALE, &status), |
| ures_getLocaleByType(nfrb, ULOC_ACTUAL_LOCALE, &status)); |
| |
| UResourceBundle* rbnfRules = ures_getByKeyWithFallback(nfrb, rules_tag, NULL, &status); |
| if (U_FAILURE(status)) { |
| ures_close(nfrb); |
| } |
| UResourceBundle* ruleSets = ures_getByKeyWithFallback(rbnfRules, fmt_tag, NULL, &status); |
| if (U_FAILURE(status)) { |
| ures_close(rbnfRules); |
| ures_close(nfrb); |
| return; |
| } |
| |
| UnicodeString desc; |
| while (ures_hasNext(ruleSets)) { |
| desc.append(ures_getNextUnicodeString(ruleSets,NULL,&status)); |
| } |
| UParseError perror; |
| |
| init(desc, locinfo, perror, status); |
| |
| ures_close(ruleSets); |
| ures_close(rbnfRules); |
| } |
| ures_close(nfrb); |
| } |
| |
| RuleBasedNumberFormat::RuleBasedNumberFormat(const RuleBasedNumberFormat& rhs) |
| : NumberFormat(rhs) |
| , fRuleSets(NULL) |
| , ruleSetDescriptions(NULL) |
| , numRuleSets(0) |
| , defaultRuleSet(NULL) |
| , locale(rhs.locale) |
| , collator(NULL) |
| , decimalFormatSymbols(NULL) |
| , defaultInfinityRule(NULL) |
| , defaultNaNRule(NULL) |
| , fRoundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary) |
| , lenient(FALSE) |
| , lenientParseRules(NULL) |
| , localizations(NULL) |
| , capitalizationInfoSet(FALSE) |
| , capitalizationForUIListMenu(FALSE) |
| , capitalizationForStandAlone(FALSE) |
| , capitalizationBrkIter(NULL) |
| { |
| this->operator=(rhs); |
| } |
| |
| // -------- |
| |
| RuleBasedNumberFormat& |
| RuleBasedNumberFormat::operator=(const RuleBasedNumberFormat& rhs) |
| { |
| if (this == &rhs) { |
| return *this; |
| } |
| NumberFormat::operator=(rhs); |
| UErrorCode status = U_ZERO_ERROR; |
| dispose(); |
| locale = rhs.locale; |
| lenient = rhs.lenient; |
| |
| UParseError perror; |
| setDecimalFormatSymbols(*rhs.getDecimalFormatSymbols()); |
| init(rhs.originalDescription, rhs.localizations ? rhs.localizations->ref() : NULL, perror, status); |
| setDefaultRuleSet(rhs.getDefaultRuleSetName(), status); |
| setRoundingMode(rhs.getRoundingMode()); |
| |
| capitalizationInfoSet = rhs.capitalizationInfoSet; |
| capitalizationForUIListMenu = rhs.capitalizationForUIListMenu; |
| capitalizationForStandAlone = rhs.capitalizationForStandAlone; |
| #if !UCONFIG_NO_BREAK_ITERATION |
| capitalizationBrkIter = (rhs.capitalizationBrkIter!=NULL)? rhs.capitalizationBrkIter->clone(): NULL; |
| #endif |
| |
| return *this; |
| } |
| |
| RuleBasedNumberFormat::~RuleBasedNumberFormat() |
| { |
| dispose(); |
| } |
| |
| RuleBasedNumberFormat* |
| RuleBasedNumberFormat::clone() const |
| { |
| return new RuleBasedNumberFormat(*this); |
| } |
| |
| UBool |
| RuleBasedNumberFormat::operator==(const Format& other) const |
| { |
| if (this == &other) { |
| return TRUE; |
| } |
| |
| if (typeid(*this) == typeid(other)) { |
| const RuleBasedNumberFormat& rhs = (const RuleBasedNumberFormat&)other; |
| // test for capitalization info equality is adequately handled |
| // by the NumberFormat test for fCapitalizationContext equality; |
| // the info here is just derived from that. |
| if (locale == rhs.locale && |
| lenient == rhs.lenient && |
| (localizations == NULL |
| ? rhs.localizations == NULL |
| : (rhs.localizations == NULL |
| ? FALSE |
| : *localizations == rhs.localizations))) { |
| |
| NFRuleSet** p = fRuleSets; |
| NFRuleSet** q = rhs.fRuleSets; |
| if (p == NULL) { |
| return q == NULL; |
| } else if (q == NULL) { |
| return FALSE; |
| } |
| while (*p && *q && (**p == **q)) { |
| ++p; |
| ++q; |
| } |
| return *q == NULL && *p == NULL; |
| } |
| } |
| |
| return FALSE; |
| } |
| |
| UnicodeString |
| RuleBasedNumberFormat::getRules() const |
| { |
| UnicodeString result; |
| if (fRuleSets != NULL) { |
| for (NFRuleSet** p = fRuleSets; *p; ++p) { |
| (*p)->appendRules(result); |
| } |
| } |
| return result; |
| } |
| |
| UnicodeString |
| RuleBasedNumberFormat::getRuleSetName(int32_t index) const |
| { |
| if (localizations) { |
| UnicodeString string(TRUE, localizations->getRuleSetName(index), (int32_t)-1); |
| return string; |
| } |
| else if (fRuleSets) { |
| UnicodeString result; |
| for (NFRuleSet** p = fRuleSets; *p; ++p) { |
| NFRuleSet* rs = *p; |
| if (rs->isPublic()) { |
| if (--index == -1) { |
| rs->getName(result); |
| return result; |
| } |
| } |
| } |
| } |
| UnicodeString empty; |
| return empty; |
| } |
| |
| int32_t |
| RuleBasedNumberFormat::getNumberOfRuleSetNames() const |
| { |
| int32_t result = 0; |
| if (localizations) { |
| result = localizations->getNumberOfRuleSets(); |
| } |
| else if (fRuleSets) { |
| for (NFRuleSet** p = fRuleSets; *p; ++p) { |
| if ((**p).isPublic()) { |
| ++result; |
| } |
| } |
| } |
| return result; |
| } |
| |
| int32_t |
| RuleBasedNumberFormat::getNumberOfRuleSetDisplayNameLocales(void) const { |
| if (localizations) { |
| return localizations->getNumberOfDisplayLocales(); |
| } |
| return 0; |
| } |
| |
| Locale |
| RuleBasedNumberFormat::getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const { |
| if (U_FAILURE(status)) { |
| return Locale(""); |
| } |
| if (localizations && index >= 0 && index < localizations->getNumberOfDisplayLocales()) { |
| UnicodeString name(TRUE, localizations->getLocaleName(index), -1); |
| char buffer[64]; |
| int32_t cap = name.length() + 1; |
| char* bp = buffer; |
| if (cap > 64) { |
| bp = (char *)uprv_malloc(cap); |
| if (bp == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return Locale(""); |
| } |
| } |
| name.extract(0, name.length(), bp, cap, UnicodeString::kInvariant); |
| Locale retLocale(bp); |
| if (bp != buffer) { |
| uprv_free(bp); |
| } |
| return retLocale; |
| } |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| Locale retLocale; |
| return retLocale; |
| } |
| |
| UnicodeString |
| RuleBasedNumberFormat::getRuleSetDisplayName(int32_t index, const Locale& localeParam) { |
| if (localizations && index >= 0 && index < localizations->getNumberOfRuleSets()) { |
| UnicodeString localeName(localeParam.getBaseName(), -1, UnicodeString::kInvariant); |
| int32_t len = localeName.length(); |
| UChar* localeStr = localeName.getBuffer(len + 1); |
| while (len >= 0) { |
| localeStr[len] = 0; |
| int32_t ix = localizations->indexForLocale(localeStr); |
| if (ix >= 0) { |
| UnicodeString name(TRUE, localizations->getDisplayName(ix, index), -1); |
| return name; |
| } |
| |
| // trim trailing portion, skipping over ommitted sections |
| do { --len;} while (len > 0 && localeStr[len] != 0x005f); // underscore |
| while (len > 0 && localeStr[len-1] == 0x005F) --len; |
| } |
| UnicodeString name(TRUE, localizations->getRuleSetName(index), -1); |
| return name; |
| } |
| UnicodeString bogus; |
| bogus.setToBogus(); |
| return bogus; |
| } |
| |
| UnicodeString |
| RuleBasedNumberFormat::getRuleSetDisplayName(const UnicodeString& ruleSetName, const Locale& localeParam) { |
| if (localizations) { |
| UnicodeString rsn(ruleSetName); |
| int32_t ix = localizations->indexForRuleSet(rsn.getTerminatedBuffer()); |
| return getRuleSetDisplayName(ix, localeParam); |
| } |
| UnicodeString bogus; |
| bogus.setToBogus(); |
| return bogus; |
| } |
| |
| NFRuleSet* |
| RuleBasedNumberFormat::findRuleSet(const UnicodeString& name, UErrorCode& status) const |
| { |
| if (U_SUCCESS(status) && fRuleSets) { |
| for (NFRuleSet** p = fRuleSets; *p; ++p) { |
| NFRuleSet* rs = *p; |
| if (rs->isNamed(name)) { |
| return rs; |
| } |
| } |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| return NULL; |
| } |
| |
| UnicodeString& |
| RuleBasedNumberFormat::format(const DecimalQuantity &number, |
| UnicodeString& appendTo, |
| FieldPosition& pos, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return appendTo; |
| } |
| DecimalQuantity copy(number); |
| if (copy.fitsInLong()) { |
| format(number.toLong(), appendTo, pos, status); |
| } |
| else { |
| copy.roundToMagnitude(0, number::impl::RoundingMode::UNUM_ROUND_HALFEVEN, status); |
| if (copy.fitsInLong()) { |
| format(number.toDouble(), appendTo, pos, status); |
| } |
| else { |
| // We're outside of our normal range that this framework can handle. |
| // The DecimalFormat will provide more accurate results. |
| |
| // TODO this section should probably be optimized. The DecimalFormat is shared in ICU4J. |
| LocalPointer<NumberFormat> decimalFormat(NumberFormat::createInstance(locale, UNUM_DECIMAL, status), status); |
| if (decimalFormat.isNull()) { |
| return appendTo; |
| } |
| Formattable f; |
| LocalPointer<DecimalQuantity> decimalQuantity(new DecimalQuantity(number), status); |
| if (decimalQuantity.isNull()) { |
| return appendTo; |
| } |
| f.adoptDecimalQuantity(decimalQuantity.orphan()); // f now owns decimalQuantity. |
| decimalFormat->format(f, appendTo, pos, status); |
| } |
| } |
| return appendTo; |
| } |
| |
| UnicodeString& |
| RuleBasedNumberFormat::format(int32_t number, |
| UnicodeString& toAppendTo, |
| FieldPosition& pos) const |
| { |
| return format((int64_t)number, toAppendTo, pos); |
| } |
| |
| |
| UnicodeString& |
| RuleBasedNumberFormat::format(int64_t number, |
| UnicodeString& toAppendTo, |
| FieldPosition& /* pos */) const |
| { |
| if (defaultRuleSet) { |
| UErrorCode status = U_ZERO_ERROR; |
| format(number, defaultRuleSet, toAppendTo, status); |
| } |
| return toAppendTo; |
| } |
| |
| |
| UnicodeString& |
| RuleBasedNumberFormat::format(double number, |
| UnicodeString& toAppendTo, |
| FieldPosition& /* pos */) const |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| if (defaultRuleSet) { |
| format(number, *defaultRuleSet, toAppendTo, status); |
| } |
| return toAppendTo; |
| } |
| |
| |
| UnicodeString& |
| RuleBasedNumberFormat::format(int32_t number, |
| const UnicodeString& ruleSetName, |
| UnicodeString& toAppendTo, |
| FieldPosition& pos, |
| UErrorCode& status) const |
| { |
| return format((int64_t)number, ruleSetName, toAppendTo, pos, status); |
| } |
| |
| |
| UnicodeString& |
| RuleBasedNumberFormat::format(int64_t number, |
| const UnicodeString& ruleSetName, |
| UnicodeString& toAppendTo, |
| FieldPosition& /* pos */, |
| UErrorCode& status) const |
| { |
| if (U_SUCCESS(status)) { |
| if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) { |
| // throw new IllegalArgumentException("Can't use internal rule set"); |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } else { |
| NFRuleSet *rs = findRuleSet(ruleSetName, status); |
| if (rs) { |
| format(number, rs, toAppendTo, status); |
| } |
| } |
| } |
| return toAppendTo; |
| } |
| |
| |
| UnicodeString& |
| RuleBasedNumberFormat::format(double number, |
| const UnicodeString& ruleSetName, |
| UnicodeString& toAppendTo, |
| FieldPosition& /* pos */, |
| UErrorCode& status) const |
| { |
| if (U_SUCCESS(status)) { |
| if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) { |
| // throw new IllegalArgumentException("Can't use internal rule set"); |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } else { |
| NFRuleSet *rs = findRuleSet(ruleSetName, status); |
| if (rs) { |
| format(number, *rs, toAppendTo, status); |
| } |
| } |
| } |
| return toAppendTo; |
| } |
| |
| void |
| RuleBasedNumberFormat::format(double number, |
| NFRuleSet& rs, |
| UnicodeString& toAppendTo, |
| UErrorCode& status) const |
| { |
| int32_t startPos = toAppendTo.length(); |
| if (getRoundingMode() != DecimalFormat::ERoundingMode::kRoundUnnecessary && !uprv_isNaN(number) && !uprv_isInfinite(number)) { |
| DecimalQuantity digitList; |
| digitList.setToDouble(number); |
| digitList.roundToMagnitude( |
| -getMaximumFractionDigits(), |
| static_cast<UNumberFormatRoundingMode>(getRoundingMode()), |
| status); |
| number = digitList.toDouble(); |
| } |
| rs.format(number, toAppendTo, toAppendTo.length(), 0, status); |
| adjustForCapitalizationContext(startPos, toAppendTo, status); |
| } |
| |
| /** |
| * Bottleneck through which all the public format() methods |
| * that take a long pass. By the time we get here, we know |
| * which rule set we're using to do the formatting. |
| * @param number The number to format |
| * @param ruleSet The rule set to use to format the number |
| * @return The text that resulted from formatting the number |
| */ |
| UnicodeString& |
| RuleBasedNumberFormat::format(int64_t number, NFRuleSet *ruleSet, UnicodeString& toAppendTo, UErrorCode& status) const |
| { |
| // all API format() routines that take a double vector through |
| // here. We have these two identical functions-- one taking a |
| // double and one taking a long-- the couple digits of precision |
| // that long has but double doesn't (both types are 8 bytes long, |
| // but double has to borrow some of the mantissa bits to hold |
| // the exponent). |
| // Create an empty string buffer where the result will |
| // be built, and pass it to the rule set (along with an insertion |
| // position of 0 and the number being formatted) to the rule set |
| // for formatting |
| |
| if (U_SUCCESS(status)) { |
| if (number == U_INT64_MIN) { |
| // We can't handle this value right now. Provide an accurate default value. |
| |
| // TODO this section should probably be optimized. The DecimalFormat is shared in ICU4J. |
| NumberFormat *decimalFormat = NumberFormat::createInstance(locale, UNUM_DECIMAL, status); |
| if (decimalFormat == nullptr) { |
| return toAppendTo; |
| } |
| Formattable f; |
| FieldPosition pos(FieldPosition::DONT_CARE); |
| DecimalQuantity *decimalQuantity = new DecimalQuantity(); |
| if (decimalQuantity == nullptr) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| delete decimalFormat; |
| return toAppendTo; |
| } |
| decimalQuantity->setToLong(number); |
| f.adoptDecimalQuantity(decimalQuantity); // f now owns decimalQuantity. |
| decimalFormat->format(f, toAppendTo, pos, status); |
| delete decimalFormat; |
| } |
| else { |
| int32_t startPos = toAppendTo.length(); |
| ruleSet->format(number, toAppendTo, toAppendTo.length(), 0, status); |
| adjustForCapitalizationContext(startPos, toAppendTo, status); |
| } |
| } |
| return toAppendTo; |
| } |
| |
| UnicodeString& |
| RuleBasedNumberFormat::adjustForCapitalizationContext(int32_t startPos, |
| UnicodeString& currentResult, |
| UErrorCode& status) const |
| { |
| #if !UCONFIG_NO_BREAK_ITERATION |
| UDisplayContext capitalizationContext = getContext(UDISPCTX_TYPE_CAPITALIZATION, status); |
| if (capitalizationContext != UDISPCTX_CAPITALIZATION_NONE && startPos == 0 && currentResult.length() > 0) { |
| // capitalize currentResult according to context |
| UChar32 ch = currentResult.char32At(0); |
| if (u_islower(ch) && U_SUCCESS(status) && capitalizationBrkIter != NULL && |
| ( capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE || |
| (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU && capitalizationForUIListMenu) || |
| (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_STANDALONE && capitalizationForStandAlone)) ) { |
| // titlecase first word of currentResult, here use sentence iterator unlike current implementations |
| // in LocaleDisplayNamesImpl::adjustForUsageAndContext and RelativeDateFormat::format |
| currentResult.toTitle(capitalizationBrkIter, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT); |
| } |
| } |
| #endif |
| return currentResult; |
| } |
| |
| |
| void |
| RuleBasedNumberFormat::parse(const UnicodeString& text, |
| Formattable& result, |
| ParsePosition& parsePosition) const |
| { |
| if (!fRuleSets) { |
| parsePosition.setErrorIndex(0); |
| return; |
| } |
| |
| UnicodeString workingText(text, parsePosition.getIndex()); |
| ParsePosition workingPos(0); |
| |
| ParsePosition high_pp(0); |
| Formattable high_result; |
| |
| for (NFRuleSet** p = fRuleSets; *p; ++p) { |
| NFRuleSet *rp = *p; |
| if (rp->isPublic() && rp->isParseable()) { |
| ParsePosition working_pp(0); |
| Formattable working_result; |
| |
| rp->parse(workingText, working_pp, kMaxDouble, 0, working_result); |
| if (working_pp.getIndex() > high_pp.getIndex()) { |
| high_pp = working_pp; |
| high_result = working_result; |
| |
| if (high_pp.getIndex() == workingText.length()) { |
| break; |
| } |
| } |
| } |
| } |
| |
| int32_t startIndex = parsePosition.getIndex(); |
| parsePosition.setIndex(startIndex + high_pp.getIndex()); |
| if (high_pp.getIndex() > 0) { |
| parsePosition.setErrorIndex(-1); |
| } else { |
| int32_t errorIndex = (high_pp.getErrorIndex()>0)? high_pp.getErrorIndex(): 0; |
| parsePosition.setErrorIndex(startIndex + errorIndex); |
| } |
| result = high_result; |
| if (result.getType() == Formattable::kDouble) { |
| double d = result.getDouble(); |
| if (!uprv_isNaN(d) && d == uprv_trunc(d) && INT32_MIN <= d && d <= INT32_MAX) { |
| // Note: casting a double to an int when the double is too large or small |
| // to fit the destination is undefined behavior. The explicit range checks, |
| // above, are required. Just casting and checking the result value is undefined. |
| result.setLong(static_cast<int32_t>(d)); |
| } |
| } |
| } |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| void |
| RuleBasedNumberFormat::setLenient(UBool enabled) |
| { |
| lenient = enabled; |
| if (!enabled && collator) { |
| delete collator; |
| collator = NULL; |
| } |
| } |
| |
| #endif |
| |
| void |
| RuleBasedNumberFormat::setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status) { |
| if (U_SUCCESS(status)) { |
| if (ruleSetName.isEmpty()) { |
| if (localizations) { |
| UnicodeString name(TRUE, localizations->getRuleSetName(0), -1); |
| defaultRuleSet = findRuleSet(name, status); |
| } else { |
| initDefaultRuleSet(); |
| } |
| } else if (ruleSetName.startsWith(UNICODE_STRING_SIMPLE("%%"))) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } else { |
| NFRuleSet* result = findRuleSet(ruleSetName, status); |
| if (result != NULL) { |
| defaultRuleSet = result; |
| } |
| } |
| } |
| } |
| |
| UnicodeString |
| RuleBasedNumberFormat::getDefaultRuleSetName() const { |
| UnicodeString result; |
| if (defaultRuleSet && defaultRuleSet->isPublic()) { |
| defaultRuleSet->getName(result); |
| } else { |
| result.setToBogus(); |
| } |
| return result; |
| } |
| |
| void |
| RuleBasedNumberFormat::initDefaultRuleSet() |
| { |
| defaultRuleSet = NULL; |
| if (!fRuleSets) { |
| return; |
| } |
| |
| const UnicodeString spellout(UNICODE_STRING_SIMPLE("%spellout-numbering")); |
| const UnicodeString ordinal(UNICODE_STRING_SIMPLE("%digits-ordinal")); |
| const UnicodeString duration(UNICODE_STRING_SIMPLE("%duration")); |
| |
| NFRuleSet**p = &fRuleSets[0]; |
| while (*p) { |
| if ((*p)->isNamed(spellout) || (*p)->isNamed(ordinal) || (*p)->isNamed(duration)) { |
| defaultRuleSet = *p; |
| return; |
| } else { |
| ++p; |
| } |
| } |
| |
| defaultRuleSet = *--p; |
| if (!defaultRuleSet->isPublic()) { |
| while (p != fRuleSets) { |
| if ((*--p)->isPublic()) { |
| defaultRuleSet = *p; |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| void |
| RuleBasedNumberFormat::init(const UnicodeString& rules, LocalizationInfo* localizationInfos, |
| UParseError& pErr, UErrorCode& status) |
| { |
| // TODO: implement UParseError |
| uprv_memset(&pErr, 0, sizeof(UParseError)); |
| // Note: this can leave ruleSets == NULL, so remaining code should check |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| initializeDecimalFormatSymbols(status); |
| initializeDefaultInfinityRule(status); |
| initializeDefaultNaNRule(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| this->localizations = localizationInfos == NULL ? NULL : localizationInfos->ref(); |
| |
| UnicodeString description(rules); |
| if (!description.length()) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| |
| // start by stripping the trailing whitespace from all the rules |
| // (this is all the whitespace follwing each semicolon in the |
| // description). This allows us to look for rule-set boundaries |
| // by searching for ";%" without having to worry about whitespace |
| // between the ; and the % |
| stripWhitespace(description); |
| |
| // check to see if there's a set of lenient-parse rules. If there |
| // is, pull them out into our temporary holding place for them, |
| // and delete them from the description before the real desciption- |
| // parsing code sees them |
| int32_t lp = description.indexOf(gLenientParse, -1, 0); |
| if (lp != -1) { |
| // we've got to make sure we're not in the middle of a rule |
| // (where "%%lenient-parse" would actually get treated as |
| // rule text) |
| if (lp == 0 || description.charAt(lp - 1) == gSemiColon) { |
| // locate the beginning and end of the actual collation |
| // rules (there may be whitespace between the name and |
| // the first token in the description) |
| int lpEnd = description.indexOf(gSemiPercent, 2, lp); |
| |
| if (lpEnd == -1) { |
| lpEnd = description.length() - 1; |
| } |
| int lpStart = lp + u_strlen(gLenientParse); |
| while (PatternProps::isWhiteSpace(description.charAt(lpStart))) { |
| ++lpStart; |
| } |
| |
| // copy out the lenient-parse rules and delete them |
| // from the description |
| lenientParseRules = new UnicodeString(); |
| /* test for NULL */ |
| if (lenientParseRules == nullptr) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| lenientParseRules->setTo(description, lpStart, lpEnd - lpStart); |
| |
| description.remove(lp, lpEnd + 1 - lp); |
| } |
| } |
| |
| // pre-flight parsing the description and count the number of |
| // rule sets (";%" marks the end of one rule set and the beginning |
| // of the next) |
| numRuleSets = 0; |
| for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, p)) { |
| ++numRuleSets; |
| ++p; |
| } |
| ++numRuleSets; |
| |
| // our rule list is an array of the appropriate size |
| fRuleSets = (NFRuleSet **)uprv_malloc((numRuleSets + 1) * sizeof(NFRuleSet *)); |
| /* test for NULL */ |
| if (fRuleSets == 0) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| |
| for (int i = 0; i <= numRuleSets; ++i) { |
| fRuleSets[i] = NULL; |
| } |
| |
| // divide up the descriptions into individual rule-set descriptions |
| // and store them in a temporary array. At each step, we also |
| // new up a rule set, but all this does is initialize its name |
| // and remove it from its description. We can't actually parse |
| // the rest of the descriptions and finish initializing everything |
| // because we have to know the names and locations of all the rule |
| // sets before we can actually set everything up |
| if(!numRuleSets) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| ruleSetDescriptions = new UnicodeString[numRuleSets]; |
| if (ruleSetDescriptions == nullptr) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| |
| { |
| int curRuleSet = 0; |
| int32_t start = 0; |
| for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, start)) { |
| ruleSetDescriptions[curRuleSet].setTo(description, start, p + 1 - start); |
| fRuleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status); |
| if (fRuleSets[curRuleSet] == nullptr) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| ++curRuleSet; |
| start = p + 1; |
| } |
| ruleSetDescriptions[curRuleSet].setTo(description, start, description.length() - start); |
| fRuleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status); |
| if (fRuleSets[curRuleSet] == nullptr) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| } |
| |
| // now we can take note of the formatter's default rule set, which |
| // is the last public rule set in the description (it's the last |
| // rather than the first so that a user can create a new formatter |
| // from an existing formatter and change its default behavior just |
| // by appending more rule sets to the end) |
| |
| // {dlf} Initialization of a fraction rule set requires the default rule |
| // set to be known. For purposes of initialization, this is always the |
| // last public rule set, no matter what the localization data says. |
| initDefaultRuleSet(); |
| |
| // finally, we can go back through the temporary descriptions |
| // list and finish setting up the substructure (and we throw |
| // away the temporary descriptions as we go) |
| { |
| for (int i = 0; i < numRuleSets; i++) { |
| fRuleSets[i]->parseRules(ruleSetDescriptions[i], status); |
| } |
| } |
| |
| // Now that the rules are initialized, the 'real' default rule |
| // set can be adjusted by the localization data. |
| |
| // The C code keeps the localization array as is, rather than building |
| // a separate array of the public rule set names, so we have less work |
| // to do here-- but we still need to check the names. |
| |
| if (localizationInfos) { |
| // confirm the names, if any aren't in the rules, that's an error |
| // it is ok if the rules contain public rule sets that are not in this list |
| for (int32_t i = 0; i < localizationInfos->getNumberOfRuleSets(); ++i) { |
| UnicodeString name(TRUE, localizationInfos->getRuleSetName(i), -1); |
| NFRuleSet* rs = findRuleSet(name, status); |
| if (rs == NULL) { |
| break; // error |
| } |
| if (i == 0) { |
| defaultRuleSet = rs; |
| } |
| } |
| } else { |
| defaultRuleSet = getDefaultRuleSet(); |
| } |
| originalDescription = rules; |
| } |
| |
| // override the NumberFormat implementation in order to |
| // lazily initialize relevant items |
| void |
| RuleBasedNumberFormat::setContext(UDisplayContext value, UErrorCode& status) |
| { |
| NumberFormat::setContext(value, status); |
| if (U_SUCCESS(status)) { |
| if (!capitalizationInfoSet && |
| (value==UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU || value==UDISPCTX_CAPITALIZATION_FOR_STANDALONE)) { |
| initCapitalizationContextInfo(locale); |
| capitalizationInfoSet = TRUE; |
| } |
| #if !UCONFIG_NO_BREAK_ITERATION |
| if ( capitalizationBrkIter == NULL && (value==UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE || |
| (value==UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU && capitalizationForUIListMenu) || |
| (value==UDISPCTX_CAPITALIZATION_FOR_STANDALONE && capitalizationForStandAlone)) ) { |
| status = U_ZERO_ERROR; |
| capitalizationBrkIter = BreakIterator::createSentenceInstance(locale, status); |
| if (U_FAILURE(status)) { |
| delete capitalizationBrkIter; |
| capitalizationBrkIter = NULL; |
| } |
| } |
| #endif |
| } |
| } |
| |
| void |
| RuleBasedNumberFormat::initCapitalizationContextInfo(const Locale& thelocale) |
| { |
| #if !UCONFIG_NO_BREAK_ITERATION |
| const char * localeID = (thelocale != NULL)? thelocale.getBaseName(): NULL; |
| UErrorCode status = U_ZERO_ERROR; |
| UResourceBundle *rb = ures_open(NULL, localeID, &status); |
| rb = ures_getByKeyWithFallback(rb, "contextTransforms", rb, &status); |
| rb = ures_getByKeyWithFallback(rb, "number-spellout", rb, &status); |
| if (U_SUCCESS(status) && rb != NULL) { |
| int32_t len = 0; |
| const int32_t * intVector = ures_getIntVector(rb, &len, &status); |
| if (U_SUCCESS(status) && intVector != NULL && len >= 2) { |
| capitalizationForUIListMenu = static_cast<UBool>(intVector[0]); |
| capitalizationForStandAlone = static_cast<UBool>(intVector[1]); |
| } |
| } |
| ures_close(rb); |
| #endif |
| } |
| |
| void |
| RuleBasedNumberFormat::stripWhitespace(UnicodeString& description) |
| { |
| // iterate through the characters... |
| UnicodeString result; |
| |
| int start = 0; |
| while (start != -1 && start < description.length()) { |
| // seek to the first non-whitespace character... |
| while (start < description.length() |
| && PatternProps::isWhiteSpace(description.charAt(start))) { |
| ++start; |
| } |
| |
| // locate the next semicolon in the text and copy the text from |
| // our current position up to that semicolon into the result |
| int32_t p = description.indexOf(gSemiColon, start); |
| if (p == -1) { |
| // or if we don't find a semicolon, just copy the rest of |
| // the string into the result |
| result.append(description, start, description.length() - start); |
| start = -1; |
| } |
| else if (p < description.length()) { |
| result.append(description, start, p + 1 - start); |
| start = p + 1; |
| } |
| |
| // when we get here, we've seeked off the end of the string, and |
| // we terminate the loop (we continue until *start* is -1 rather |
| // than until *p* is -1, because otherwise we'd miss the last |
| // rule in the description) |
| else { |
| start = -1; |
| } |
| } |
| |
| description.setTo(result); |
| } |
| |
| |
| void |
| RuleBasedNumberFormat::dispose() |
| { |
| if (fRuleSets) { |
| for (NFRuleSet** p = fRuleSets; *p; ++p) { |
| delete *p; |
| } |
| uprv_free(fRuleSets); |
| fRuleSets = NULL; |
| } |
| |
| if (ruleSetDescriptions) { |
| delete [] ruleSetDescriptions; |
| ruleSetDescriptions = NULL; |
| } |
| |
| #if !UCONFIG_NO_COLLATION |
| delete collator; |
| #endif |
| collator = NULL; |
| |
| delete decimalFormatSymbols; |
| decimalFormatSymbols = NULL; |
| |
| delete defaultInfinityRule; |
| defaultInfinityRule = NULL; |
| |
| delete defaultNaNRule; |
| defaultNaNRule = NULL; |
| |
| delete lenientParseRules; |
| lenientParseRules = NULL; |
| |
| #if !UCONFIG_NO_BREAK_ITERATION |
| delete capitalizationBrkIter; |
| capitalizationBrkIter = NULL; |
| #endif |
| |
| if (localizations) { |
| localizations = localizations->unref(); |
| } |
| } |
| |
| |
| //----------------------------------------------------------------------- |
| // package-internal API |
| //----------------------------------------------------------------------- |
| |
| /** |
| * Returns the collator to use for lenient parsing. The collator is lazily created: |
| * this function creates it the first time it's called. |
| * @return The collator to use for lenient parsing, or null if lenient parsing |
| * is turned off. |
| */ |
| const RuleBasedCollator* |
| RuleBasedNumberFormat::getCollator() const |
| { |
| #if !UCONFIG_NO_COLLATION |
| if (!fRuleSets) { |
| return NULL; |
| } |
| |
| // lazy-evaluate the collator |
| if (collator == NULL && lenient) { |
| // create a default collator based on the formatter's locale, |
| // then pull out that collator's rules, append any additional |
| // rules specified in the description, and create a _new_ |
| // collator based on the combination of those rules |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| Collator* temp = Collator::createInstance(locale, status); |
| RuleBasedCollator* newCollator; |
| if (U_SUCCESS(status) && (newCollator = dynamic_cast<RuleBasedCollator*>(temp)) != NULL) { |
| if (lenientParseRules) { |
| UnicodeString rules(newCollator->getRules()); |
| rules.append(*lenientParseRules); |
| |
| newCollator = new RuleBasedCollator(rules, status); |
| // Exit if newCollator could not be created. |
| if (newCollator == NULL) { |
| return NULL; |
| } |
| } else { |
| temp = NULL; |
| } |
| if (U_SUCCESS(status)) { |
| newCollator->setAttribute(UCOL_DECOMPOSITION_MODE, UCOL_ON, status); |
| // cast away const |
| ((RuleBasedNumberFormat*)this)->collator = newCollator; |
| } else { |
| delete newCollator; |
| } |
| } |
| delete temp; |
| } |
| #endif |
| |
| // if lenient-parse mode is off, this will be null |
| // (see setLenientParseMode()) |
| return collator; |
| } |
| |
| |
| DecimalFormatSymbols* |
| RuleBasedNumberFormat::initializeDecimalFormatSymbols(UErrorCode &status) |
| { |
| // lazy-evaluate the DecimalFormatSymbols object. This object |
| // is shared by all DecimalFormat instances belonging to this |
| // formatter |
| if (decimalFormatSymbols == nullptr) { |
| LocalPointer<DecimalFormatSymbols> temp(new DecimalFormatSymbols(locale, status), status); |
| if (U_SUCCESS(status)) { |
| decimalFormatSymbols = temp.orphan(); |
| } |
| } |
| return decimalFormatSymbols; |
| } |
| |
| /** |
| * Returns the DecimalFormatSymbols object that should be used by all DecimalFormat |
| * instances owned by this formatter. |
| */ |
| const DecimalFormatSymbols* |
| RuleBasedNumberFormat::getDecimalFormatSymbols() const |
| { |
| return decimalFormatSymbols; |
| } |
| |
| NFRule* |
| RuleBasedNumberFormat::initializeDefaultInfinityRule(UErrorCode &status) |
| { |
| if (U_FAILURE(status)) { |
| return nullptr; |
| } |
| if (defaultInfinityRule == NULL) { |
| UnicodeString rule(UNICODE_STRING_SIMPLE("Inf: ")); |
| rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kInfinitySymbol)); |
| LocalPointer<NFRule> temp(new NFRule(this, rule, status), status); |
| if (U_SUCCESS(status)) { |
| defaultInfinityRule = temp.orphan(); |
| } |
| } |
| return defaultInfinityRule; |
| } |
| |
| const NFRule* |
| RuleBasedNumberFormat::getDefaultInfinityRule() const |
| { |
| return defaultInfinityRule; |
| } |
| |
| NFRule* |
| RuleBasedNumberFormat::initializeDefaultNaNRule(UErrorCode &status) |
| { |
| if (U_FAILURE(status)) { |
| return nullptr; |
| } |
| if (defaultNaNRule == nullptr) { |
| UnicodeString rule(UNICODE_STRING_SIMPLE("NaN: ")); |
| rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kNaNSymbol)); |
| LocalPointer<NFRule> temp(new NFRule(this, rule, status), status); |
| if (U_SUCCESS(status)) { |
| defaultNaNRule = temp.orphan(); |
| } |
| } |
| return defaultNaNRule; |
| } |
| |
| const NFRule* |
| RuleBasedNumberFormat::getDefaultNaNRule() const |
| { |
| return defaultNaNRule; |
| } |
| |
| // De-owning the current localized symbols and adopt the new symbols. |
| void |
| RuleBasedNumberFormat::adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt) |
| { |
| if (symbolsToAdopt == NULL) { |
| return; // do not allow caller to set decimalFormatSymbols to NULL |
| } |
| |
| if (decimalFormatSymbols != NULL) { |
| delete decimalFormatSymbols; |
| } |
| |
| decimalFormatSymbols = symbolsToAdopt; |
| |
| { |
| // Apply the new decimalFormatSymbols by reparsing the rulesets |
| UErrorCode status = U_ZERO_ERROR; |
| |
| delete defaultInfinityRule; |
| defaultInfinityRule = NULL; |
| initializeDefaultInfinityRule(status); // Reset with the new DecimalFormatSymbols |
| |
| delete defaultNaNRule; |
| defaultNaNRule = NULL; |
| initializeDefaultNaNRule(status); // Reset with the new DecimalFormatSymbols |
| |
| if (fRuleSets) { |
| for (int32_t i = 0; i < numRuleSets; i++) { |
| fRuleSets[i]->setDecimalFormatSymbols(*symbolsToAdopt, status); |
| } |
| } |
| } |
| } |
| |
| // Setting the symbols is equivalent to adopting a newly created localized symbols. |
| void |
| RuleBasedNumberFormat::setDecimalFormatSymbols(const DecimalFormatSymbols& symbols) |
| { |
| adoptDecimalFormatSymbols(new DecimalFormatSymbols(symbols)); |
| } |
| |
| PluralFormat * |
| RuleBasedNumberFormat::createPluralFormat(UPluralType pluralType, |
| const UnicodeString &pattern, |
| UErrorCode& status) const |
| { |
| auto *pf = new PluralFormat(locale, pluralType, pattern, status); |
| if (pf == nullptr) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| return pf; |
| } |
| |
| /** |
| * Get the rounding mode. |
| * @return A rounding mode |
| */ |
| DecimalFormat::ERoundingMode RuleBasedNumberFormat::getRoundingMode() const { |
| return fRoundingMode; |
| } |
| |
| /** |
| * Set the rounding mode. This has no effect unless the rounding |
| * increment is greater than zero. |
| * @param roundingMode A rounding mode |
| */ |
| void RuleBasedNumberFormat::setRoundingMode(DecimalFormat::ERoundingMode roundingMode) { |
| fRoundingMode = roundingMode; |
| } |
| |
| U_NAMESPACE_END |
| |
| /* U_HAVE_RBNF */ |
| #endif |
