/*
*******************************************************************************
-* Copyright (C) 1997-2010, International Business Machines Corporation and *
-* others. All Rights Reserved. *
+* Copyright (C) 1997-2013, International Business Machines Corporation and
+* others. All Rights Reserved.
*******************************************************************************
*
* File NUMFMT.CPP
#include "unicode/curramt.h"
#include "unicode/numsys.h"
#include "unicode/rbnf.h"
+#include "unicode/localpointer.h"
+#include "charstr.h"
#include "winnmfmt.h"
#include "uresimp.h"
#include "uhash.h"
#include "ucln_in.h"
#include "cstring.h"
#include "putilimp.h"
+#include "uassert.h"
#include "umutex.h"
+#include "mutex.h"
#include "digitlst.h"
#include <float.h>
#ifdef FMT_DEBUG
#include <stdio.h>
-static void debugout(UnicodeString s) {
+static inline void debugout(UnicodeString s) {
char buf[2000];
s.extract((int32_t) 0, s.length(), buf);
printf("%s", buf);
// If the maximum base 10 exponent were 4, then the largest number would
// be 99,999 which has 5 digits.
// On IEEE754 systems gMaxIntegerDigits is 308 + possible denormalized 15 digits + rounding digit
-static const int32_t gMaxIntegerDigits = DBL_MAX_10_EXP + DBL_DIG + 1;
-static const int32_t gMinIntegerDigits = 127;
-
-static const UChar * const gLastResortNumberPatterns[] =
-{
- gLastResortDecimalPat,
- gLastResortCurrencyPat,
- gLastResortPercentPat,
- gLastResortScientificPat,
- gLastResortIsoCurrencyPat,
- gLastResortPluralCurrencyPat,
+// With big decimal, the max exponent is 999,999,999 and the max number of digits is the same, 999,999,999
+const int32_t icu::NumberFormat::gDefaultMaxIntegerDigits = 2000000000;
+const int32_t icu::NumberFormat::gDefaultMinIntegerDigits = 127;
+
+static const UChar * const gLastResortNumberPatterns[UNUM_FORMAT_STYLE_COUNT] = {
+ NULL, // UNUM_PATTERN_DECIMAL
+ gLastResortDecimalPat, // UNUM_DECIMAL
+ gLastResortCurrencyPat, // UNUM_CURRENCY
+ gLastResortPercentPat, // UNUM_PERCENT
+ gLastResortScientificPat, // UNUM_SCIENTIFIC
+ NULL, // UNUM_SPELLOUT
+ NULL, // UNUM_ORDINAL
+ NULL, // UNUM_DURATION
+ NULL, // UNUM_NUMBERING_SYSTEM
+ NULL, // UNUM_PATTERN_RULEBASED
+ gLastResortIsoCurrencyPat, // UNUM_CURRENCY_ISO
+ gLastResortPluralCurrencyPat // UNUM_CURRENCY_PLURAL
};
// Keys used for accessing resource bundles
static const char *gNumberElements = "NumberElements";
static const char *gLatn = "latn";
static const char *gPatterns = "patterns";
-static const char *gFormatKeys[] = { "decimalFormat", "currencyFormat", "percentFormat", "scientificFormat" };
+static const char *gFormatKeys[UNUM_FORMAT_STYLE_COUNT] = {
+ NULL, // UNUM_PATTERN_DECIMAL
+ "decimalFormat", // UNUM_DECIMAL
+ "currencyFormat", // UNUM_CURRENCY
+ "percentFormat", // UNUM_PERCENT
+ "scientificFormat", // UNUM_SCIENTIFIC
+ NULL, // UNUM_SPELLOUT
+ NULL, // UNUM_ORDINAL
+ NULL, // UNUM_DURATION
+ NULL, // UNUM_NUMBERING_SYSTEM
+ NULL, // UNUM_PATTERN_RULEBASED
+ // For UNUM_CURRENCY_ISO and UNUM_CURRENCY_PLURAL,
+ // the pattern is the same as the pattern of UNUM_CURRENCY
+ // except for replacing the single currency sign with
+ // double currency sign or triple currency sign.
+ "currencyFormat", // UNUM_CURRENCY_ISO
+ "currencyFormat" // UNUM_CURRENCY_PLURAL
+};
// Static hashtable cache of NumberingSystem objects used by NumberFormat
static UHashtable * NumberingSystem_cache = NULL;
-
-static UMTX nscacheMutex = NULL;
+static UMutex nscacheMutex = U_MUTEX_INITIALIZER;
+static icu::UInitOnce gNSCacheInitOnce = U_INITONCE_INITIALIZER;
#if !UCONFIG_NO_SERVICE
-static U_NAMESPACE_QUALIFIER ICULocaleService* gService = NULL;
+static icu::ICULocaleService* gService = NULL;
+static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
#endif
/**
U_CDECL_BEGIN
static void U_CALLCONV
deleteNumberingSystem(void *obj) {
- delete (U_NAMESPACE_QUALIFIER NumberingSystem *)obj;
+ delete (icu::NumberingSystem *)obj;
}
static UBool U_CALLCONV numfmt_cleanup(void) {
#if !UCONFIG_NO_SERVICE
+ gServiceInitOnce.reset();
if (gService) {
delete gService;
gService = NULL;
}
#endif
+ gNSCacheInitOnce.reset();
if (NumberingSystem_cache) {
// delete NumberingSystem_cache;
uhash_close(NumberingSystem_cache);
// default constructor
NumberFormat::NumberFormat()
: fGroupingUsed(TRUE),
- fMaxIntegerDigits(gMaxIntegerDigits),
+ fMaxIntegerDigits(gDefaultMaxIntegerDigits),
fMinIntegerDigits(1),
fMaxFractionDigits(3), // invariant, >= minFractionDigits
fMinFractionDigits(0),
- fParseIntegerOnly(FALSE)
+ fParseIntegerOnly(FALSE),
+ fLenient(FALSE)
{
fCurrency[0] = 0;
}
fMinFractionDigits = rhs.fMinFractionDigits;
fParseIntegerOnly = rhs.fParseIntegerOnly;
u_strncpy(fCurrency, rhs.fCurrency, 4);
+ fLenient = rhs.fLenient;
}
return *this;
}
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("fCurrency !=");
}
+ if (!(fLenient == other->fLenient)) {
+ if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
+ debug("fLenient != ");
+ }
if (!first) { printf(" ]"); }
#endif
fMinFractionDigits == other->fMinFractionDigits &&
fGroupingUsed == other->fGroupingUsed &&
fParseIntegerOnly == other->fParseIntegerOnly &&
- u_strcmp(fCurrency, other->fCurrency) == 0)));
+ u_strcmp(fCurrency, other->fCurrency) == 0 &&
+ fLenient == other->fLenient)));
}
// -------------------------------------
return toAppendTo;
}
+// ------------------------------------------
+// These functions add the status code, just fall back to the non-status versions
+UnicodeString&
+NumberFormat::format(double number,
+ UnicodeString& appendTo,
+ FieldPosition& pos,
+ UErrorCode &status) const {
+ if(U_SUCCESS(status)) {
+ return format(number,appendTo,pos);
+ } else {
+ return appendTo;
+ }
+}
+
+UnicodeString&
+NumberFormat::format(int32_t number,
+ UnicodeString& appendTo,
+ FieldPosition& pos,
+ UErrorCode &status) const {
+ if(U_SUCCESS(status)) {
+ return format(number,appendTo,pos);
+ } else {
+ return appendTo;
+ }
+}
+
+UnicodeString&
+NumberFormat::format(int64_t number,
+ UnicodeString& appendTo,
+ FieldPosition& pos,
+ UErrorCode &status) const {
+ if(U_SUCCESS(status)) {
+ return format(number,appendTo,pos);
+ } else {
+ return appendTo;
+ }
+}
+
+
+
// -------------------------------------
// Decimal Number format() default implementation
// Subclasses do not normally override this function, but rather the DigitList
return toAppendTo;
}
-// -------------------------------------
+/**
+ *
// Formats the number object and save the format
// result in the toAppendTo string buffer.
// utility to save/restore state, used in two overloads
// of format(const Formattable&...) below.
-
+*
+* Old purpose of ArgExtractor was to avoid const. Not thread safe!
+*
+* keeping it around as a shim.
+*/
class ArgExtractor {
- NumberFormat *ncnf;
const Formattable* num;
- UBool setCurr;
UChar save[4];
+ UBool fWasCurrency;
public:
ArgExtractor(const NumberFormat& nf, const Formattable& obj, UErrorCode& status);
~ArgExtractor();
const Formattable* number(void) const;
+ const UChar *iso(void) const;
+ UBool wasCurrency(void) const;
};
inline const Formattable*
return num;
}
-ArgExtractor::ArgExtractor(const NumberFormat& nf, const Formattable& obj, UErrorCode& status)
- : ncnf((NumberFormat*) &nf), num(&obj), setCurr(FALSE) {
+inline UBool
+ArgExtractor::wasCurrency(void) const {
+ return fWasCurrency;
+}
+
+inline const UChar *
+ArgExtractor::iso(void) const {
+ return save;
+}
+
+ArgExtractor::ArgExtractor(const NumberFormat& /*nf*/, const Formattable& obj, UErrorCode& /*status*/)
+ : num(&obj), fWasCurrency(FALSE) {
const UObject* o = obj.getObject(); // most commonly o==NULL
const CurrencyAmount* amt;
if (o != NULL && (amt = dynamic_cast<const CurrencyAmount*>(o)) != NULL) {
// getISOCurrency() returns a pointer to internal storage, so we
// copy it to retain it across the call to setCurrency().
- const UChar* curr = amt->getISOCurrency();
- u_strcpy(save, nf.getCurrency());
- setCurr = (u_strcmp(curr, save) != 0);
- if (setCurr) {
- ncnf->setCurrency(curr, status);
- }
+ //const UChar* curr = amt->getISOCurrency();
+ u_strcpy(save, amt->getISOCurrency());
num = &amt->getNumber();
+ fWasCurrency=TRUE;
+ } else {
+ save[0]=0;
}
}
ArgExtractor::~ArgExtractor() {
- if (setCurr) {
- UErrorCode ok = U_ZERO_ERROR;
- ncnf->setCurrency(save, ok); // always restore currency
- }
}
UnicodeString& NumberFormat::format(const DigitList &number,
ArgExtractor arg(*this, obj, status);
const Formattable *n = arg.number();
+ const UChar *iso = arg.iso();
+
+ if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) {
+ // trying to format a different currency.
+ // Right now, we clone.
+ LocalPointer<NumberFormat> cloneFmt((NumberFormat*)this->clone());
+ cloneFmt->setCurrency(iso, status);
+ // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount.
+ return cloneFmt->format(*n, appendTo, pos, status);
+ }
if (n->isNumeric() && n->getDigitList() != NULL) {
// Decimal Number. We will have a DigitList available if the value was
ArgExtractor arg(*this, obj, status);
const Formattable *n = arg.number();
+ const UChar *iso = arg.iso();
+
+ if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) {
+ // trying to format a different currency.
+ // Right now, we clone.
+ LocalPointer<NumberFormat> cloneFmt((NumberFormat*)this->clone());
+ cloneFmt->setCurrency(iso, status);
+ // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount.
+ return cloneFmt->format(*n, appendTo, posIter, status);
+ }
if (n->isNumeric() && n->getDigitList() != NULL) {
// Decimal Number
}
}
-Formattable& NumberFormat::parseCurrency(const UnicodeString& text,
- Formattable& result,
- ParsePosition& pos) const {
+CurrencyAmount* NumberFormat::parseCurrency(const UnicodeString& text,
+ ParsePosition& pos) const {
// Default implementation only -- subclasses should override
+ Formattable parseResult;
int32_t start = pos.getIndex();
- parse(text, result, pos);
+ parse(text, parseResult, pos);
if (pos.getIndex() != start) {
UChar curr[4];
UErrorCode ec = U_ZERO_ERROR;
getEffectiveCurrency(curr, ec);
if (U_SUCCESS(ec)) {
- Formattable n(result);
- CurrencyAmount *tempCurAmnt = new CurrencyAmount(n, curr, ec); // Use for null testing.
- if (U_FAILURE(ec) || tempCurAmnt == NULL) {
+ LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curr, ec));
+ if (U_FAILURE(ec)) {
pos.setIndex(start); // indicate failure
} else {
- result.adoptObject(tempCurAmnt);
+ return currAmt.orphan();
}
}
}
- return result;
+ return NULL;
}
// -------------------------------------
}
// -------------------------------------
+// Sets whether lenient parse is enabled.
+
+void
+NumberFormat::setLenient(UBool enable)
+{
+ fLenient = enable;
+}
+
+// -------------------------------------
// Create a number style NumberFormat instance with the default locale.
NumberFormat* U_EXPORT2
NumberFormat::createInstance(UErrorCode& status)
{
- return createInstance(Locale::getDefault(), kNumberStyle, status);
+ return createInstance(Locale::getDefault(), UNUM_DECIMAL, status);
}
// -------------------------------------
NumberFormat* U_EXPORT2
NumberFormat::createInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kNumberStyle, status);
+ return createInstance(inLocale, UNUM_DECIMAL, status);
}
// -------------------------------------
NumberFormat* U_EXPORT2
NumberFormat::createCurrencyInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kCurrencyStyle, status);
+ return createInstance(inLocale, UNUM_CURRENCY, status);
}
// -------------------------------------
NumberFormat* U_EXPORT2
NumberFormat::createPercentInstance(UErrorCode& status)
{
- return createInstance(Locale::getDefault(), kPercentStyle, status);
+ return createInstance(Locale::getDefault(), UNUM_PERCENT, status);
}
// -------------------------------------
NumberFormat* U_EXPORT2
NumberFormat::createPercentInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kPercentStyle, status);
+ return createInstance(inLocale, UNUM_PERCENT, status);
}
// -------------------------------------
NumberFormat* U_EXPORT2
NumberFormat::createScientificInstance(UErrorCode& status)
{
- return createInstance(Locale::getDefault(), kScientificStyle, status);
+ return createInstance(Locale::getDefault(), UNUM_SCIENTIFIC, status);
}
// -------------------------------------
NumberFormat* U_EXPORT2
NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kScientificStyle, status);
+ return createInstance(inLocale, UNUM_SCIENTIFIC, status);
}
// -------------------------------------
// -------------------------------------
class ICUNumberFormatFactory : public ICUResourceBundleFactory {
+public:
+ virtual ~ICUNumberFormatFactory();
protected:
virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const {
- // !!! kind is not an EStyles, need to determine how to handle this
- return NumberFormat::makeInstance(loc, (NumberFormat::EStyles)kind, status);
+ return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
}
};
+ICUNumberFormatFactory::~ICUNumberFormatFactory() {}
+
// -------------------------------------
class NFFactory : public LocaleKeyFactory {
{
}
- virtual ~NFFactory()
- {
- delete _delegate;
- delete _ids;
- }
+ virtual ~NFFactory();
virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const
{
lkey.canonicalLocale(loc);
int32_t kind = lkey.kind();
- UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)(kind+1));
+ UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)kind);
if (result == NULL) {
result = service->getKey((ICUServiceKey&)key /* cast away const */, NULL, this, status);
}
}
};
+NFFactory::~NFFactory()
+{
+ delete _delegate;
+ delete _ids;
+}
+
class ICUNumberFormatService : public ICULocaleService {
public:
ICUNumberFormatService()
registerFactory(new ICUNumberFormatFactory(), status);
}
+ virtual ~ICUNumberFormatService();
+
virtual UObject* cloneInstance(UObject* instance) const {
return ((NumberFormat*)instance)->clone();
}
int32_t kind = lkey.kind();
Locale loc;
lkey.currentLocale(loc);
- return NumberFormat::makeInstance(loc, (NumberFormat::EStyles)kind, status);
+ return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
}
virtual UBool isDefault() const {
}
};
+ICUNumberFormatService::~ICUNumberFormatService() {}
+
// -------------------------------------
+static void U_CALLCONV initNumberFormatService() {
+ U_ASSERT(gService == NULL);
+ ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
+ gService = new ICUNumberFormatService();
+}
+
static ICULocaleService*
getNumberFormatService(void)
{
- UBool needInit;
- UMTX_CHECK(NULL, (UBool)(gService == NULL), needInit);
- if (needInit) {
- ICULocaleService * newservice = new ICUNumberFormatService();
- if (newservice) {
- umtx_lock(NULL);
- if (gService == NULL) {
- gService = newservice;
- newservice = NULL;
- }
- umtx_unlock(NULL);
- }
- if (newservice) {
- delete newservice;
- } else {
- // we won the contention, this thread can register cleanup.
- ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
- }
- }
+ umtx_initOnce(gServiceInitOnce, &initNumberFormatService);
return gService;
}
+static UBool haveService() {
+ return !gServiceInitOnce.isReset() && (getNumberFormatService() != NULL);
+}
+
// -------------------------------------
URegistryKey U_EXPORT2
UBool U_EXPORT2
NumberFormat::unregister(URegistryKey key, UErrorCode& status)
{
- if (U_SUCCESS(status)) {
- UBool haveService;
- UMTX_CHECK(NULL, gService != NULL, haveService);
- if (haveService) {
- return gService->unregister(key, status);
- }
+ if (U_FAILURE(status)) {
+ return FALSE;
+ }
+ if (haveService()) {
+ return gService->unregister(key, status);
+ } else {
status = U_ILLEGAL_ARGUMENT_ERROR;
+ return FALSE;
}
- return FALSE;
}
// -------------------------------------
{
ICULocaleService *service = getNumberFormatService();
if (service) {
- return service->getAvailableLocales();
+ return service->getAvailableLocales();
}
return NULL; // no way to return error condition
}
// -------------------------------------
NumberFormat* U_EXPORT2
-NumberFormat::createInstance(const Locale& loc, EStyles kind, UErrorCode& status)
-{
+NumberFormat::createInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) {
#if !UCONFIG_NO_SERVICE
- UBool haveService;
- UMTX_CHECK(NULL, gService != NULL, haveService);
- if (haveService) {
+ if (haveService()) {
return (NumberFormat*)gService->get(loc, kind, status);
}
- else
#endif
- {
- return makeInstance(loc, kind, status);
- }
+ return makeInstance(loc, kind, status);
}
void
NumberFormat::setMaximumIntegerDigits(int32_t newValue)
{
- fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gMaxIntegerDigits));
+ fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
if(fMinIntegerDigits > fMaxIntegerDigits)
fMinIntegerDigits = fMaxIntegerDigits;
}
void
NumberFormat::setMinimumIntegerDigits(int32_t newValue)
{
- fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gMinIntegerDigits));
+ fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
if(fMinIntegerDigits > fMaxIntegerDigits)
fMaxIntegerDigits = fMinIntegerDigits;
}
void
NumberFormat::setMaximumFractionDigits(int32_t newValue)
{
- fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gMaxIntegerDigits));
+ fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
if(fMaxFractionDigits < fMinFractionDigits)
fMinFractionDigits = fMaxFractionDigits;
}
void
NumberFormat::setMinimumFractionDigits(int32_t newValue)
{
- fMinFractionDigits = uprv_max(0, uprv_min(newValue, gMinIntegerDigits));
+ fMinFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
if (fMaxFractionDigits < fMinFractionDigits)
fMaxFractionDigits = fMinFractionDigits;
}
// Creates the NumberFormat instance of the specified style (number, currency,
// or percent) for the desired locale.
+static void U_CALLCONV nscacheInit() {
+ U_ASSERT(NumberingSystem_cache == NULL);
+ ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
+ UErrorCode status = U_ZERO_ERROR;
+ NumberingSystem_cache = uhash_open(uhash_hashLong,
+ uhash_compareLong,
+ NULL,
+ &status);
+ if (U_FAILURE(status)) {
+ // Number Format code will run with no cache if creation fails.
+ NumberingSystem_cache = NULL;
+ return;
+ }
+ uhash_setValueDeleter(NumberingSystem_cache, deleteNumberingSystem);
+}
+
+UBool
+NumberFormat::isStyleSupported(UNumberFormatStyle style) {
+ return gLastResortNumberPatterns[style] != NULL;
+}
+
NumberFormat*
NumberFormat::makeInstance(const Locale& desiredLocale,
- EStyles style,
- UErrorCode& status)
-{
+ UNumberFormatStyle style,
+ UErrorCode& status) {
+ return makeInstance(desiredLocale, style, false, status);
+}
+
+NumberFormat*
+NumberFormat::makeInstance(const Locale& desiredLocale,
+ UNumberFormatStyle style,
+ UBool mustBeDecimalFormat,
+ UErrorCode& status) {
if (U_FAILURE(status)) return NULL;
- if (style < 0 || style >= kStyleCount) {
+ if (style < 0 || style >= UNUM_FORMAT_STYLE_COUNT) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
-#ifdef U_WINDOWS
- char buffer[8];
- int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status);
+ // Some styles are not supported. This is a result of merging
+ // the @draft ICU 4.2 NumberFormat::EStyles into the long-existing UNumberFormatStyle.
+ // Ticket #8503 is for reviewing/fixing/merging the two relevant implementations:
+ // this one and unum_open().
+ // The UNUM_PATTERN_ styles are not supported here
+ // because this method does not take a pattern string.
+ if (!isStyleSupported(style)) {
+ status = U_UNSUPPORTED_ERROR;
+ return NULL;
+ }
- // if the locale has "@compat=host", create a host-specific NumberFormat
- if (count > 0 && uprv_strcmp(buffer, "host") == 0) {
- Win32NumberFormat *f = NULL;
- UBool curr = TRUE;
+#if U_PLATFORM_USES_ONLY_WIN32_API
+ if (!mustBeDecimalFormat) {
+ char buffer[8];
+ int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status);
- switch (style) {
- case kNumberStyle:
- curr = FALSE;
- // fall-through
+ // if the locale has "@compat=host", create a host-specific NumberFormat
+ if (U_SUCCESS(status) && count > 0 && uprv_strcmp(buffer, "host") == 0) {
+ Win32NumberFormat *f = NULL;
+ UBool curr = TRUE;
- case kCurrencyStyle:
- case kIsoCurrencyStyle: // do not support plural formatting here
- case kPluralCurrencyStyle:
- f = new Win32NumberFormat(desiredLocale, curr, status);
+ switch (style) {
+ case UNUM_DECIMAL:
+ curr = FALSE;
+ // fall-through
- if (U_SUCCESS(status)) {
- return f;
- }
+ case UNUM_CURRENCY:
+ case UNUM_CURRENCY_ISO: // do not support plural formatting here
+ case UNUM_CURRENCY_PLURAL:
+ f = new Win32NumberFormat(desiredLocale, curr, status);
- delete f;
- break;
+ if (U_SUCCESS(status)) {
+ return f;
+ }
- default:
- break;
+ delete f;
+ break;
+ default:
+ break;
+ }
}
}
#endif
+ // Use numbering system cache hashtable
+ umtx_initOnce(gNSCacheInitOnce, &nscacheInit);
- NumberFormat* f = NULL;
- DecimalFormatSymbols* symbolsToAdopt = NULL;
- UnicodeString pattern;
- UResourceBundle *resource = ures_open(NULL, desiredLocale.getName(), &status);
+ // Get cached numbering system
+ LocalPointer<NumberingSystem> ownedNs;
NumberingSystem *ns = NULL;
- UBool deleteSymbols = TRUE;
- UHashtable * cache = NULL;
- int32_t hashKey;
- UBool getCache = FALSE;
- UBool deleteNS = FALSE;
+ if (NumberingSystem_cache != NULL) {
+ // TODO: Bad hash key usage, see ticket #8504.
+ int32_t hashKey = desiredLocale.hashCode();
+
+ Mutex lock(&nscacheMutex);
+ ns = (NumberingSystem *)uhash_iget(NumberingSystem_cache, hashKey);
+ if (ns == NULL) {
+ ns = NumberingSystem::createInstance(desiredLocale,status);
+ uhash_iput(NumberingSystem_cache, hashKey, (void*)ns, &status);
+ }
+ } else {
+ ownedNs.adoptInstead(NumberingSystem::createInstance(desiredLocale,status));
+ ns = ownedNs.getAlias();
+ }
+ // check results of getting a numbering system
+ if (U_FAILURE(status)) {
+ return NULL;
+ }
+
+ if (mustBeDecimalFormat && ns->isAlgorithmic()) {
+ status = U_UNSUPPORTED_ERROR;
+ return NULL;
+ }
+
+ LocalPointer<DecimalFormatSymbols> symbolsToAdopt;
+ UnicodeString pattern;
+ LocalUResourceBundlePointer ownedResource(ures_open(NULL, desiredLocale.getName(), &status));
if (U_FAILURE(status)) {
// We don't appear to have resource data available -- use the last-resort data
status = U_USING_FALLBACK_WARNING;
// When the data is unavailable, and locale isn't passed in, last resort data is used.
- symbolsToAdopt = new DecimalFormatSymbols(status);
+ symbolsToAdopt.adoptInstead(new DecimalFormatSymbols(status));
+ if (symbolsToAdopt.isNull()) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return NULL;
+ }
// Creates a DecimalFormat instance with the last resort number patterns.
pattern.setTo(TRUE, gLastResortNumberPatterns[style], -1);
}
else {
// Loads the decimal symbols of the desired locale.
- symbolsToAdopt = new DecimalFormatSymbols(desiredLocale, status);
-
- int32_t patLen = 0;
+ symbolsToAdopt.adoptInstead(new DecimalFormatSymbols(desiredLocale, status));
+ if (symbolsToAdopt.isNull()) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return NULL;
+ }
- /* for ISOCURRENCYSTYLE and PLURALCURRENCYSTYLE,
- * the pattern is the same as the pattern of CURRENCYSTYLE
- * but by replacing the single currency sign with
- * double currency sign or triple currency sign.
- */
- int styleInNumberPattern = ((style == kIsoCurrencyStyle ||
- style == kPluralCurrencyStyle) ?
- kCurrencyStyle : style);
-
- resource = ures_getByKeyWithFallback(resource, gNumberElements, resource, &status);
- // TODO : Get patterns on a per numbering system basis, for right now assumes "latn" for patterns
- resource = ures_getByKeyWithFallback(resource, gLatn, resource, &status);
+ UResourceBundle *resource = ownedResource.orphan();
+ UResourceBundle *numElements = ures_getByKeyWithFallback(resource, gNumberElements, NULL, &status);
+ resource = ures_getByKeyWithFallback(numElements, ns->getName(), resource, &status);
resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
+ ownedResource.adoptInstead(resource);
- const UChar *patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[styleInNumberPattern], &patLen, &status);
+ int32_t patLen = 0;
+ const UChar *patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
+
+ // Didn't find a pattern specific to the numbering system, so fall back to "latn"
+ if ( status == U_MISSING_RESOURCE_ERROR && uprv_strcmp(gLatn,ns->getName())) {
+ status = U_ZERO_ERROR;
+ resource = ures_getByKeyWithFallback(numElements, gLatn, resource, &status);
+ resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
+ patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
+ }
+
+ ures_close(numElements);
// Creates the specified decimal format style of the desired locale.
pattern.setTo(TRUE, patResStr, patLen);
}
- if (U_FAILURE(status) || symbolsToAdopt == NULL) {
- goto cleanup;
+ if (U_FAILURE(status)) {
+ return NULL;
}
- if(style==kCurrencyStyle || style == kIsoCurrencyStyle){
+ if(style==UNUM_CURRENCY || style == UNUM_CURRENCY_ISO){
const UChar* currPattern = symbolsToAdopt->getCurrencyPattern();
if(currPattern!=NULL){
pattern.setTo(currPattern, u_strlen(currPattern));
}
}
- // Use numbering system cache hashtable
- UMTX_CHECK(&nscacheMutex, (UBool)(cache != NumberingSystem_cache), getCache);
- if (getCache) {
- umtx_lock(&nscacheMutex);
- cache = NumberingSystem_cache;
- umtx_unlock(&nscacheMutex);
- }
-
- // Check cache we got, create if non-existant
- status = U_ZERO_ERROR;
- if (cache == NULL) {
- cache = uhash_open(uhash_hashLong,
- uhash_compareLong,
- NULL,
- &status);
-
- if (cache == NULL || U_FAILURE(status)) {
- // cache not created - out of memory
- cache = NULL;
- }
- else {
- // cache created
- uhash_setValueDeleter(cache, deleteNumberingSystem);
-
- // set final NumberingSystem_cache value
- UHashtable* h = NULL;
-
- UMTX_CHECK(&nscacheMutex, (UBool)(h != NumberingSystem_cache), getCache);
- if (getCache) {
- umtx_lock(&nscacheMutex);
- h = NumberingSystem_cache;
- umtx_unlock(&nscacheMutex);
- }
- if (h == NULL) {
- umtx_lock(&nscacheMutex);
- NumberingSystem_cache = h = cache;
- cache = NULL;
- ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
- umtx_unlock(&nscacheMutex);
- }
-
- if(cache != NULL) {
- uhash_close(cache);
- }
- cache = h;
- }
- }
-
- // Get cached numbering system
- if (cache != NULL) {
- hashKey = desiredLocale.hashCode();
-
- umtx_lock(&nscacheMutex);
- ns = (NumberingSystem *)uhash_iget(cache, hashKey);
- if (ns == NULL) {
- ns = NumberingSystem::createInstance(desiredLocale,status);
- uhash_iput(cache, hashKey, (void*)ns, &status);
- }
- umtx_unlock(&nscacheMutex);
- }
- else {
- ns = NumberingSystem::createInstance(desiredLocale,status);
- deleteNS = TRUE;
- }
-
- // check results of getting a numbering system
- if ((ns == NULL) || (U_FAILURE(status))) {
- goto cleanup;
- }
+ NumberFormat *f;
if (ns->isAlgorithmic()) {
UnicodeString nsDesc;
UnicodeString nsRuleSetGroup;
int32_t firstSlash = nsDesc.indexOf(gSlash);
int32_t lastSlash = nsDesc.lastIndexOf(gSlash);
if ( lastSlash > firstSlash ) {
- char nsLocID[ULOC_FULLNAME_CAPACITY];
+ CharString nsLocID;
- nsDesc.extract(0,firstSlash,nsLocID,ULOC_FULLNAME_CAPACITY,US_INV);
+ nsLocID.appendInvariantChars(nsDesc.tempSubString(0, firstSlash), status);
nsRuleSetGroup.setTo(nsDesc,firstSlash+1,lastSlash-firstSlash-1);
nsRuleSetName.setTo(nsDesc,lastSlash+1);
- nsLoc = Locale::createFromName(nsLocID);
+ nsLoc = Locale::createFromName(nsLocID.data());
UnicodeString SpelloutRules = UNICODE_STRING_SIMPLE("SpelloutRules");
if ( nsRuleSetGroup.compare(SpelloutRules) == 0 ) {
}
RuleBasedNumberFormat *r = new RuleBasedNumberFormat(desiredRulesType,nsLoc,status);
-
- if (U_FAILURE(status) || r == NULL) {
- goto cleanup;
+ if (r == NULL) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return NULL;
}
r->setDefaultRuleSet(nsRuleSetName,status);
- f = (NumberFormat *) r;
-
+ f = r;
} else {
// replace single currency sign in the pattern with double currency sign
- // if the style is kIsoCurrencyStyle
- if (style == kIsoCurrencyStyle) {
- pattern.findAndReplace(gSingleCurrencySign, gDoubleCurrencySign);
+ // if the style is UNUM_CURRENCY_ISO
+ if (style == UNUM_CURRENCY_ISO) {
+ pattern.findAndReplace(UnicodeString(TRUE, gSingleCurrencySign, 1),
+ UnicodeString(TRUE, gDoubleCurrencySign, 2));
}
- f = new DecimalFormat(pattern, symbolsToAdopt, style, status);
- if (U_FAILURE(status) || f == NULL) {
- goto cleanup;
+ // "new DecimalFormat()" does not adopt the symbols if its memory allocation fails.
+ DecimalFormatSymbols *syms = symbolsToAdopt.orphan();
+ f = new DecimalFormat(pattern, syms, style, status);
+ if (f == NULL) {
+ delete syms;
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return NULL;
}
- deleteSymbols = FALSE;
- }
-
- f->setLocaleIDs(ures_getLocaleByType(resource, ULOC_VALID_LOCALE, &status),
- ures_getLocaleByType(resource, ULOC_ACTUAL_LOCALE, &status));
-
-cleanup:
- ures_close(resource);
-
- if (deleteNS && ns) {
- delete ns;
}
+ f->setLocaleIDs(ures_getLocaleByType(ownedResource.getAlias(), ULOC_VALID_LOCALE, &status),
+ ures_getLocaleByType(ownedResource.getAlias(), ULOC_ACTUAL_LOCALE, &status));
if (U_FAILURE(status)) {
- /* If f exists, then it will delete the symbols */
- if (f==NULL) {
- delete symbolsToAdopt;
- }
- else {
- delete f;
- }
+ delete f;
return NULL;
}
- if (f == NULL || symbolsToAdopt == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- f = NULL;
- }
- if (deleteSymbols && symbolsToAdopt != NULL) {
- delete symbolsToAdopt;
- }
return f;
}
projects / platform / framework / web / crosswalk.git / blobdiff