+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
-* Copyright (C) 1997-2012, International Business Machines Corporation
+* Copyright (C) 1997-2015, International Business Machines Corporation
* and others. All Rights Reserved.
*******************************************************************************
*/
+#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/ustring.h"
#include "unicode/utf16.h"
#include "unicode/udata.h"
-#include "nfrs.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 "digitlst.h"
// debugging
-// #define DEBUG
+// #define RBNF_DEBUG
-#ifdef DEBUG
-#include "stdio.h"
+#ifdef RBNF_DEBUG
+#include <stdio.h>
#endif
#define U_ICUDATA_RBNF U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "rbnf"
private:
- void inc(void) { ++p; ch = 0xffff; }
- UBool checkInc(UChar c) { if (p < e && (ch == c || *p == c)) { inc(); return TRUE; } return FALSE; }
- UBool check(UChar c) { return p < e && (ch == c || *p == c); }
- void skipWhitespace(void) { while (p < e && PatternProps::isWhiteSpace(ch != 0xffff ? ch : *p)) inc();}
- UBool inList(UChar c, const UChar* list) const {
- if (*list == SPACE && PatternProps::isWhiteSpace(c)) return TRUE;
- while (*list && *list != c) ++list; return *list == c;
+ 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);
UChar* nextString(void);
};
-#ifdef DEBUG
+#ifdef RBNF_DEBUG
#define ERROR(msg) parseError(msg); return NULL;
+#define EXPLANATION_ARG explanationArg
#else
#define ERROR(msg) parseError(NULL); return NULL;
+#define EXPLANATION_ARG
#endif
return result;
}
-void
-LocDataParser::parseError(const char* /*str*/) {
+void LocDataParser::parseError(const char* EXPLANATION_ARG)
+{
if (!data) {
return;
}
pe.postContext[limit-p] = 0;
pe.offset = (int32_t)(p - data);
-#ifdef DEBUG
- fprintf(stderr, "%s at or near character %d: ", str, 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("'");
+ msg.append(UNICODE_STRING_SIMPLE("'"));
char buf[128];
int32_t len = msg.extract(0, msg.length(), buf, 128);
, locale(alocale)
, collator(NULL)
, decimalFormatSymbols(NULL)
+ , defaultInfinityRule(NULL)
+ , defaultNaNRule(NULL)
+ , roundingMode(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);
, locale(Locale::getDefault())
, collator(NULL)
, decimalFormatSymbols(NULL)
+ , defaultInfinityRule(NULL)
+ , defaultNaNRule(NULL)
+ , roundingMode(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);
, locale(alocale)
, collator(NULL)
, decimalFormatSymbols(NULL)
+ , defaultInfinityRule(NULL)
+ , defaultNaNRule(NULL)
+ , roundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary)
, lenient(FALSE)
, lenientParseRules(NULL)
, localizations(NULL)
+ , capitalizationInfoSet(FALSE)
+ , capitalizationForUIListMenu(FALSE)
+ , capitalizationForStandAlone(FALSE)
+ , capitalizationBrkIter(NULL)
{
init(description, info, perror, status);
}
, locale(Locale::getDefault())
, collator(NULL)
, decimalFormatSymbols(NULL)
+ , defaultInfinityRule(NULL)
+ , defaultNaNRule(NULL)
+ , roundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary)
, lenient(FALSE)
, lenientParseRules(NULL)
, localizations(NULL)
+ , capitalizationInfoSet(FALSE)
+ , capitalizationForUIListMenu(FALSE)
+ , capitalizationForStandAlone(FALSE)
+ , capitalizationBrkIter(NULL)
{
init(description, NULL, perror, status);
}
, locale(aLocale)
, collator(NULL)
, decimalFormatSymbols(NULL)
+ , defaultInfinityRule(NULL)
+ , defaultNaNRule(NULL)
+ , roundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary)
, lenient(FALSE)
, lenientParseRules(NULL)
, localizations(NULL)
+ , capitalizationInfoSet(FALSE)
+ , capitalizationForUIListMenu(FALSE)
+ , capitalizationForStandAlone(FALSE)
+ , capitalizationBrkIter(NULL)
{
init(description, NULL, perror, status);
}
, locale(alocale)
, collator(NULL)
, decimalFormatSymbols(NULL)
+ , defaultInfinityRule(NULL)
+ , defaultNaNRule(NULL)
+ , roundingMode(DecimalFormat::ERoundingMode::kRoundUnnecessary)
, lenient(FALSE)
, lenientParseRules(NULL)
, localizations(NULL)
+ , capitalizationInfoSet(FALSE)
+ , capitalizationForUIListMenu(FALSE)
+ , capitalizationForStandAlone(FALSE)
+ , capitalizationBrkIter(NULL)
{
if (U_FAILURE(status)) {
return;
}
UParseError perror;
- init (desc, locinfo, perror, status);
+ init(desc, locinfo, perror, status);
ures_close(ruleSets);
ures_close(rbnfRules);
, locale(rhs.locale)
, collator(NULL)
, decimalFormatSymbols(NULL)
+ , defaultInfinityRule(NULL)
+ , defaultNaNRule(NULL)
+ , roundingMode(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;
- UnicodeString rules = rhs.getRules();
UParseError perror;
- init(rules, rhs.localizations ? rhs.localizations->ref() : NULL, perror, status);
+ 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;
}
Format*
RuleBasedNumberFormat::clone(void) const
{
- RuleBasedNumberFormat * result = NULL;
- UnicodeString rules = getRules();
- UErrorCode status = U_ZERO_ERROR;
- UParseError perror;
- result = new RuleBasedNumberFormat(rules, localizations, locale, perror, status);
- /* test for NULL */
- if (result == 0) {
- status = U_MEMORY_ALLOCATION_ERROR;
- return 0;
- }
- if (U_FAILURE(status)) {
- delete result;
- result = 0;
- } else {
- result->lenient = lenient;
- }
- return result;
+ return new RuleBasedNumberFormat(*this);
}
UBool
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
RuleBasedNumberFormat::getRuleSetName(int32_t index) const
{
if (localizations) {
- UnicodeString string(TRUE, localizations->getRuleSetName(index), (int32_t)-1);
- return string;
- } else if (ruleSets) {
+ UnicodeString string(TRUE, localizations->getRuleSetName(index), (int32_t)-1);
+ return string;
+ }
+ else if (ruleSets) {
UnicodeString result;
for (NFRuleSet** p = ruleSets; *p; ++p) {
NFRuleSet* rs = *p;
{
int32_t result = 0;
if (localizations) {
- result = localizations->getNumberOfRuleSets();
- } else if (ruleSets) {
+ result = localizations->getNumberOfRuleSets();
+ }
+ else if (ruleSets) {
for (NFRuleSet** p = ruleSets; *p; ++p) {
if ((**p).isPublic()) {
++result;
return NULL;
}
+UnicodeString&
+RuleBasedNumberFormat::format(const DigitList &number,
+ UnicodeString &appendTo,
+ FieldPositionIterator *posIter,
+ UErrorCode &status) const {
+ if (U_FAILURE(status)) {
+ return appendTo;
+ }
+ DigitList copy(number);
+ if (copy.fitsIntoInt64(false)) {
+ format(((DigitList &)number).getInt64(), appendTo, posIter, status);
+ }
+ else {
+ copy.roundAtExponent(0);
+ if (copy.fitsIntoInt64(false)) {
+ format(number.getDouble(), appendTo, posIter, 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.
+ NumberFormat *decimalFormat = NumberFormat::createInstance(locale, UNUM_DECIMAL, status);
+ Formattable f;
+ f.adoptDigitList(new DigitList(number));
+ decimalFormat->format(f, appendTo, posIter, status);
+ delete decimalFormat;
+ }
+ }
+ return appendTo;
+}
+
+
+UnicodeString&
+RuleBasedNumberFormat::format(const DigitList &number,
+ UnicodeString& appendTo,
+ FieldPosition& pos,
+ UErrorCode &status) const {
+ if (U_FAILURE(status)) {
+ return appendTo;
+ }
+ DigitList copy(number);
+ if (copy.fitsIntoInt64(false)) {
+ format(((DigitList &)number).getInt64(), appendTo, pos, status);
+ }
+ else {
+ copy.roundAtExponent(0);
+ if (copy.fitsIntoInt64(false)) {
+ format(number.getDouble(), 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.
+ NumberFormat *decimalFormat = NumberFormat::createInstance(locale, UNUM_DECIMAL, status);
+ Formattable f;
+ f.adoptDigitList(new DigitList(number));
+ decimalFormat->format(f, appendTo, pos, status);
+ delete decimalFormat;
+ }
+ }
+ return appendTo;
+}
+
UnicodeString&
RuleBasedNumberFormat::format(int32_t number,
UnicodeString& toAppendTo,
- FieldPosition& /* pos */) const
+ FieldPosition& pos) const
{
- if (defaultRuleSet) defaultRuleSet->format((int64_t)number, toAppendTo, toAppendTo.length());
- return toAppendTo;
+ return format((int64_t)number, toAppendTo, pos);
}
UnicodeString& toAppendTo,
FieldPosition& /* pos */) const
{
- if (defaultRuleSet) defaultRuleSet->format(number, toAppendTo, toAppendTo.length());
+ if (defaultRuleSet) {
+ UErrorCode status = U_ZERO_ERROR;
+ format(number, defaultRuleSet, toAppendTo, status);
+ }
return toAppendTo;
}
UnicodeString& toAppendTo,
FieldPosition& /* pos */) const
{
- // Special case for NaN; adapted from what DecimalFormat::_format( double number,...) does.
- if (uprv_isNaN(number)) {
- DecimalFormatSymbols* decFmtSyms = getDecimalFormatSymbols(); // RuleBasedNumberFormat internal
- if (decFmtSyms) {
- toAppendTo += decFmtSyms->getConstSymbol(DecimalFormatSymbols::kNaNSymbol);
- }
- } else if (defaultRuleSet) {
- defaultRuleSet->format(number, toAppendTo, toAppendTo.length());
+ 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
{
- // return format((int64_t)number, ruleSetName, toAppendTo, pos, status);
if (U_SUCCESS(status)) {
if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) {
// throw new IllegalArgumentException("Can't use internal rule set");
} else {
NFRuleSet *rs = findRuleSet(ruleSetName, status);
if (rs) {
- rs->format((int64_t)number, toAppendTo, toAppendTo.length());
+ format(number, rs, toAppendTo, status);
}
}
}
UnicodeString&
-RuleBasedNumberFormat::format(int64_t number,
+RuleBasedNumberFormat::format(double number,
const UnicodeString& ruleSetName,
UnicodeString& toAppendTo,
FieldPosition& /* pos */,
} else {
NFRuleSet *rs = findRuleSet(ruleSetName, status);
if (rs) {
- rs->format(number, toAppendTo, toAppendTo.length());
+ format(number, *rs, toAppendTo, status);
}
}
}
return toAppendTo;
}
-
-// make linker happy
-UnicodeString&
-RuleBasedNumberFormat::format(const Formattable& obj,
+void
+RuleBasedNumberFormat::format(double number,
+ NFRuleSet& rs,
UnicodeString& toAppendTo,
- FieldPosition& pos,
UErrorCode& status) const
{
- return NumberFormat::format(obj, toAppendTo, pos, status);
+ int32_t startPos = toAppendTo.length();
+ if (getRoundingMode() != DecimalFormat::ERoundingMode::kRoundUnnecessary && !uprv_isNaN(number) && !uprv_isInfinite(number)) {
+ DigitList digitList;
+ digitList.set(number);
+ digitList.setRoundingMode(getRoundingMode());
+ digitList.roundFixedPoint(getMaximumFractionDigits());
+ number = digitList.getDouble();
+ }
+ 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(double number,
- const UnicodeString& ruleSetName,
- UnicodeString& toAppendTo,
- FieldPosition& /* pos */,
- UErrorCode& status) const
+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 (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) {
- rs->format(number, toAppendTo, toAppendTo.length());
- }
+ 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);
+ Formattable f;
+ FieldPosition pos(FieldPosition::DONT_CARE);
+ DigitList *digitList = new DigitList();
+ digitList->set(number);
+ f.adoptDigitList(digitList);
+ 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 working_pp(0);
Formattable working_result;
- rp->parse(workingText, working_pp, kMaxDouble, working_result, lenient);
+ rp->parse(workingText, working_pp, kMaxDouble, 0, working_result, lenient);
if (working_pp.getIndex() > high_pp.getIndex()) {
high_pp = working_pp;
high_result = working_result;
}
result = high_result;
if (result.getType() == Formattable::kDouble) {
- int32_t r = (int32_t)result.getDouble();
- if ((double)r == result.getDouble()) {
- result.setLong(r);
+ 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));
}
}
}
UnicodeString
RuleBasedNumberFormat::getDefaultRuleSetName() const {
- UnicodeString result;
- if (defaultRuleSet && defaultRuleSet->isPublic()) {
- defaultRuleSet->getName(result);
- } else {
- result.setToBogus();
- }
- return result;
+ UnicodeString result;
+ if (defaultRuleSet && defaultRuleSet->isPublic()) {
+ defaultRuleSet->getName(result);
+ } else {
+ result.setToBogus();
+ }
+ return result;
}
void
{
defaultRuleSet = NULL;
if (!ruleSets) {
- return;
+ return;
}
- const UnicodeString spellout = UNICODE_STRING_SIMPLE("%spellout-numbering");
- const UnicodeString ordinal = UNICODE_STRING_SIMPLE("%digits-ordinal");
- const UnicodeString duration = UNICODE_STRING_SIMPLE("%duration");
+ 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 = &ruleSets[0];
while (*p) {
return;
}
+ initializeDecimalFormatSymbols(status);
+ initializeDefaultInfinityRule(status);
+ initializeDefaultNaNRule(status);
+ if (U_FAILURE(status)) {
+ return;
+ }
+
this->localizations = localizationInfos == NULL ? NULL : localizationInfos->ref();
UnicodeString description(rules);
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);
- ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status);
+ ruleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status);
if (ruleSets[curRuleSet] == 0) {
status = U_MEMORY_ALLOCATION_ERROR;
return;
start = p + 1;
}
ruleSetDescriptions[curRuleSet].setTo(description, start, description.length() - start);
- ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status);
+ ruleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status);
if (ruleSets[curRuleSet] == 0) {
status = U_MEMORY_ALLOCATION_ERROR;
return;
// away the temporary descriptions as we go)
{
for (int i = 0; i < numRuleSets; i++) {
- ruleSets[i]->parseRules(ruleSetDescriptions[i], this, status);
+ ruleSets[i]->parseRules(ruleSetDescriptions[i], status);
}
}
} 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)) ) {
+ UErrorCode 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 = intVector[0];
+ capitalizationForStandAlone = intVector[1];
+ }
+ }
+ ures_close(rb);
+#endif
}
void
if (ruleSetDescriptions) {
delete [] ruleSetDescriptions;
+ ruleSetDescriptions = NULL;
}
#if !UCONFIG_NO_COLLATION
delete decimalFormatSymbols;
decimalFormatSymbols = NULL;
+ delete defaultInfinityRule;
+ defaultInfinityRule = NULL;
+
+ delete defaultNaNRule;
+ defaultNaNRule = NULL;
+
delete lenientParseRules;
lenientParseRules = NULL;
- if (localizations) localizations = localizations->unref();
+#if !UCONFIG_NO_BREAK_ITERATION
+ delete capitalizationBrkIter;
+ capitalizationBrkIter = NULL;
+#endif
+
+ if (localizations) {
+ localizations = localizations->unref();
+ }
}
* @return The collator to use for lenient parsing, or null if lenient parsing
* is turned off.
*/
-Collator*
+const RuleBasedCollator*
RuleBasedNumberFormat::getCollator() const
{
#if !UCONFIG_NO_COLLATION
return NULL;
}
- // lazy-evaulate the collator
+ // 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
newCollator = new RuleBasedCollator(rules, status);
// Exit if newCollator could not be created.
if (newCollator == NULL) {
- return NULL;
+ return NULL;
}
} else {
temp = NULL;
}
-/**
- * Returns the DecimalFormatSymbols object that should be used by all DecimalFormat
- * instances owned by this formatter. This object is lazily created: this function
- * creates it the first time it's called.
- * @return The DecimalFormatSymbols object that should be used by all DecimalFormat
- * instances owned by this formatter.
-*/
DecimalFormatSymbols*
-RuleBasedNumberFormat::getDecimalFormatSymbols() const
+RuleBasedNumberFormat::initializeDecimalFormatSymbols(UErrorCode &status)
{
// lazy-evaluate the DecimalFormatSymbols object. This object
// is shared by all DecimalFormat instances belonging to this
// formatter
if (decimalFormatSymbols == NULL) {
- UErrorCode status = U_ZERO_ERROR;
DecimalFormatSymbols* temp = new DecimalFormatSymbols(locale, status);
if (U_SUCCESS(status)) {
- ((RuleBasedNumberFormat*)this)->decimalFormatSymbols = temp;
- } else {
+ decimalFormatSymbols = temp;
+ }
+ else {
delete temp;
}
}
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 NULL;
+ }
+ if (defaultInfinityRule == NULL) {
+ UnicodeString rule(UNICODE_STRING_SIMPLE("Inf: "));
+ rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kInfinitySymbol));
+ NFRule* temp = new NFRule(this, rule, status);
+ if (U_SUCCESS(status)) {
+ defaultInfinityRule = temp;
+ }
+ else {
+ delete temp;
+ }
+ }
+ return defaultInfinityRule;
+}
+
+const NFRule*
+RuleBasedNumberFormat::getDefaultInfinityRule() const
+{
+ return defaultInfinityRule;
+}
+
+NFRule*
+RuleBasedNumberFormat::initializeDefaultNaNRule(UErrorCode &status)
+{
+ if (U_FAILURE(status)) {
+ return NULL;
+ }
+ if (defaultNaNRule == NULL) {
+ UnicodeString rule(UNICODE_STRING_SIMPLE("NaN: "));
+ rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kNaNSymbol));
+ NFRule* temp = new NFRule(this, rule, status);
+ if (U_SUCCESS(status)) {
+ defaultNaNRule = temp;
+ }
+ else {
+ delete temp;
+ }
+ }
+ 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)
// Apply the new decimalFormatSymbols by reparsing the rulesets
UErrorCode status = U_ZERO_ERROR;
- for (int32_t i = 0; i < numRuleSets; i++) {
- ruleSets[i]->parseRules(ruleSetDescriptions[i], this, status);
+ delete defaultInfinityRule;
+ defaultInfinityRule = NULL;
+ initializeDefaultInfinityRule(status); // Reset with the new DecimalFormatSymbols
+
+ delete defaultNaNRule;
+ defaultNaNRule = NULL;
+ initializeDefaultNaNRule(status); // Reset with the new DecimalFormatSymbols
+
+ if (ruleSets) {
+ for (int32_t i = 0; i < numRuleSets; i++) {
+ ruleSets[i]->setDecimalFormatSymbols(*symbolsToAdopt, status);
+ }
}
}
}
adoptDecimalFormatSymbols(new DecimalFormatSymbols(symbols));
}
+PluralFormat *
+RuleBasedNumberFormat::createPluralFormat(UPluralType pluralType,
+ const UnicodeString &pattern,
+ UErrorCode& status) const
+{
+ return new PluralFormat(locale, pluralType, pattern, status);
+}
+
+/**
+ * Get the rounding mode.
+ * @return A rounding mode
+ */
+DecimalFormat::ERoundingMode RuleBasedNumberFormat::getRoundingMode() const {
+ return roundingMode;
+}
+
+/**
+ * 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) {
+ this->roundingMode = roundingMode;
+}
+
U_NAMESPACE_END
/* U_HAVE_RBNF */
projects / apple / icu.git / blobdiff