diff options
Diffstat (limited to 'intl/icu/source/i18n/compactdecimalformat.cpp')
| -rw-r--r-- | intl/icu/source/i18n/compactdecimalformat.cpp | 1004 |
1 files changed, 1004 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/compactdecimalformat.cpp b/intl/icu/source/i18n/compactdecimalformat.cpp new file mode 100644 index 000000000..385b3a513 --- /dev/null +++ b/intl/icu/source/i18n/compactdecimalformat.cpp @@ -0,0 +1,1004 @@ +// Copyright (C) 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. * +******************************************************************************* +* +* File COMPACTDECIMALFORMAT.CPP +* +******************************************************************************** +*/ +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "charstr.h" +#include "cstring.h" +#include "digitlst.h" +#include "mutex.h" +#include "unicode/compactdecimalformat.h" +#include "unicode/numsys.h" +#include "unicode/plurrule.h" +#include "unicode/ures.h" +#include "ucln_in.h" +#include "uhash.h" +#include "umutex.h" +#include "unicode/ures.h" +#include "uresimp.h" + +// Maps locale name to CDFLocaleData struct. +static UHashtable* gCompactDecimalData = NULL; +static UMutex gCompactDecimalMetaLock = U_MUTEX_INITIALIZER; + +U_NAMESPACE_BEGIN + +static const int32_t MAX_DIGITS = 15; +static const char gOther[] = "other"; +static const char gLatnTag[] = "latn"; +static const char gNumberElementsTag[] = "NumberElements"; +static const char gDecimalFormatTag[] = "decimalFormat"; +static const char gPatternsShort[] = "patternsShort"; +static const char gPatternsLong[] = "patternsLong"; +static const char gLatnPath[] = "NumberElements/latn"; + +static const UChar u_0 = 0x30; +static const UChar u_apos = 0x27; + +static const UChar kZero[] = {u_0}; + +// Used to unescape single quotes. +enum QuoteState { + OUTSIDE, + INSIDE_EMPTY, + INSIDE_FULL +}; + +enum FallbackFlags { + ANY = 0, + MUST = 1, + NOT_ROOT = 2 + // Next one will be 4 then 6 etc. +}; + + +// CDFUnit represents a prefix-suffix pair for a particular variant +// and log10 value. +struct CDFUnit : public UMemory { + UnicodeString prefix; + UnicodeString suffix; + inline CDFUnit() : prefix(), suffix() { + prefix.setToBogus(); + } + inline ~CDFUnit() {} + inline UBool isSet() const { + return !prefix.isBogus(); + } + inline void markAsSet() { + prefix.remove(); + } +}; + +// CDFLocaleStyleData contains formatting data for a particular locale +// and style. +class CDFLocaleStyleData : public UMemory { + public: + // What to divide by for each log10 value when formatting. These values + // will be powers of 10. For English, would be: + // 1, 1, 1, 1000, 1000, 1000, 1000000, 1000000, 1000000, 1000000000 ... + double divisors[MAX_DIGITS]; + // Maps plural variants to CDFUnit[MAX_DIGITS] arrays. + // To format a number x, + // first compute log10(x). Compute displayNum = (x / divisors[log10(x)]). + // Compute the plural variant for displayNum + // (e.g zero, one, two, few, many, other). + // Compute cdfUnits = unitsByVariant[pluralVariant]. + // Prefix and suffix to use at cdfUnits[log10(x)] + UHashtable* unitsByVariant; + // A flag for whether or not this CDFLocaleStyleData was loaded from the + // Latin numbering system as a fallback from the locale numbering system. + // This value is meaningless if the object is bogus or empty. + UBool fromFallback; + inline CDFLocaleStyleData() : unitsByVariant(NULL), fromFallback(FALSE) { + uprv_memset(divisors, 0, sizeof(divisors)); + } + ~CDFLocaleStyleData(); + // Init initializes this object. + void Init(UErrorCode& status); + inline UBool isBogus() const { + return unitsByVariant == NULL; + } + void setToBogus(); + UBool isEmpty() { + return unitsByVariant == NULL || unitsByVariant->count == 0; + } + private: + CDFLocaleStyleData(const CDFLocaleStyleData&); + CDFLocaleStyleData& operator=(const CDFLocaleStyleData&); +}; + +// CDFLocaleData contains formatting data for a particular locale. +struct CDFLocaleData : public UMemory { + CDFLocaleStyleData shortData; + CDFLocaleStyleData longData; + inline CDFLocaleData() : shortData(), longData() { } + inline ~CDFLocaleData() { } + // Init initializes this object. + void Init(UErrorCode& status); +}; + +U_NAMESPACE_END + +U_CDECL_BEGIN + +static UBool U_CALLCONV cdf_cleanup(void) { + if (gCompactDecimalData != NULL) { + uhash_close(gCompactDecimalData); + gCompactDecimalData = NULL; + } + return TRUE; +} + +static void U_CALLCONV deleteCDFUnits(void* ptr) { + delete [] (icu::CDFUnit*) ptr; +} + +static void U_CALLCONV deleteCDFLocaleData(void* ptr) { + delete (icu::CDFLocaleData*) ptr; +} + +U_CDECL_END + +U_NAMESPACE_BEGIN + +static UBool divisors_equal(const double* lhs, const double* rhs); +static const CDFLocaleStyleData* getCDFLocaleStyleData(const Locale& inLocale, UNumberCompactStyle style, UErrorCode& status); + +static const CDFLocaleStyleData* extractDataByStyleEnum(const CDFLocaleData& data, UNumberCompactStyle style, UErrorCode& status); +static CDFLocaleData* loadCDFLocaleData(const Locale& inLocale, UErrorCode& status); +static void load(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status); +static int32_t populatePrefixSuffix(const char* variant, int32_t log10Value, const UnicodeString& formatStr, UHashtable* result, UBool overwrite, UErrorCode& status); +static double calculateDivisor(double power10, int32_t numZeros); +static UBool onlySpaces(UnicodeString u); +static void fixQuotes(UnicodeString& s); +static void checkForOtherVariants(CDFLocaleStyleData* result, UErrorCode& status); +static void fillInMissing(CDFLocaleStyleData* result); +static int32_t computeLog10(double x, UBool inRange); +static CDFUnit* createCDFUnit(const char* variant, int32_t log10Value, UHashtable* table, UErrorCode& status); +static const CDFUnit* getCDFUnitFallback(const UHashtable* table, const UnicodeString& variant, int32_t log10Value); + +UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CompactDecimalFormat) + +CompactDecimalFormat::CompactDecimalFormat( + const DecimalFormat& decimalFormat, + const UHashtable* unitsByVariant, + const double* divisors, + PluralRules* pluralRules) + : DecimalFormat(decimalFormat), _unitsByVariant(unitsByVariant), _divisors(divisors), _pluralRules(pluralRules) { +} + +CompactDecimalFormat::CompactDecimalFormat(const CompactDecimalFormat& source) + : DecimalFormat(source), _unitsByVariant(source._unitsByVariant), _divisors(source._divisors), _pluralRules(source._pluralRules->clone()) { +} + +CompactDecimalFormat* U_EXPORT2 +CompactDecimalFormat::createInstance( + const Locale& inLocale, UNumberCompactStyle style, UErrorCode& status) { + LocalPointer<DecimalFormat> decfmt((DecimalFormat*) NumberFormat::makeInstance(inLocale, UNUM_DECIMAL, TRUE, status)); + if (U_FAILURE(status)) { + return NULL; + } + LocalPointer<PluralRules> pluralRules(PluralRules::forLocale(inLocale, status)); + if (U_FAILURE(status)) { + return NULL; + } + const CDFLocaleStyleData* data = getCDFLocaleStyleData(inLocale, style, status); + if (U_FAILURE(status)) { + return NULL; + } + CompactDecimalFormat* result = + new CompactDecimalFormat(*decfmt, data->unitsByVariant, data->divisors, pluralRules.getAlias()); + if (result == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + return NULL; + } + pluralRules.orphan(); + result->setMaximumSignificantDigits(3); + result->setSignificantDigitsUsed(TRUE); + result->setGroupingUsed(FALSE); + return result; +} + +CompactDecimalFormat& +CompactDecimalFormat::operator=(const CompactDecimalFormat& rhs) { + if (this != &rhs) { + DecimalFormat::operator=(rhs); + _unitsByVariant = rhs._unitsByVariant; + _divisors = rhs._divisors; + delete _pluralRules; + _pluralRules = rhs._pluralRules->clone(); + } + return *this; +} + +CompactDecimalFormat::~CompactDecimalFormat() { + delete _pluralRules; +} + + +Format* +CompactDecimalFormat::clone(void) const { + return new CompactDecimalFormat(*this); +} + +UBool +CompactDecimalFormat::operator==(const Format& that) const { + if (this == &that) { + return TRUE; + } + return (DecimalFormat::operator==(that) && eqHelper((const CompactDecimalFormat&) that)); +} + +UBool +CompactDecimalFormat::eqHelper(const CompactDecimalFormat& that) const { + return uhash_equals(_unitsByVariant, that._unitsByVariant) && divisors_equal(_divisors, that._divisors) && (*_pluralRules == *that._pluralRules); +} + +UnicodeString& +CompactDecimalFormat::format( + double number, + UnicodeString& appendTo, + FieldPosition& pos) const { + UErrorCode status = U_ZERO_ERROR; + return format(number, appendTo, pos, status); +} + +UnicodeString& +CompactDecimalFormat::format( + double number, + UnicodeString& appendTo, + FieldPosition& pos, + UErrorCode &status) const { + if (U_FAILURE(status)) { + return appendTo; + } + DigitList orig, rounded; + orig.set(number); + UBool isNegative; + _round(orig, rounded, isNegative, status); + if (U_FAILURE(status)) { + return appendTo; + } + double roundedDouble = rounded.getDouble(); + if (isNegative) { + roundedDouble = -roundedDouble; + } + int32_t baseIdx = computeLog10(roundedDouble, TRUE); + double numberToFormat = roundedDouble / _divisors[baseIdx]; + UnicodeString variant = _pluralRules->select(numberToFormat); + if (isNegative) { + numberToFormat = -numberToFormat; + } + const CDFUnit* unit = getCDFUnitFallback(_unitsByVariant, variant, baseIdx); + appendTo += unit->prefix; + DecimalFormat::format(numberToFormat, appendTo, pos); + appendTo += unit->suffix; + return appendTo; +} + +UnicodeString& +CompactDecimalFormat::format( + double /* number */, + UnicodeString& appendTo, + FieldPositionIterator* /* posIter */, + UErrorCode& status) const { + status = U_UNSUPPORTED_ERROR; + return appendTo; +} + +UnicodeString& +CompactDecimalFormat::format( + int32_t number, + UnicodeString& appendTo, + FieldPosition& pos) const { + return format((double) number, appendTo, pos); +} + +UnicodeString& +CompactDecimalFormat::format( + int32_t number, + UnicodeString& appendTo, + FieldPosition& pos, + UErrorCode &status) const { + return format((double) number, appendTo, pos, status); +} + +UnicodeString& +CompactDecimalFormat::format( + int32_t /* number */, + UnicodeString& appendTo, + FieldPositionIterator* /* posIter */, + UErrorCode& status) const { + status = U_UNSUPPORTED_ERROR; + return appendTo; +} + +UnicodeString& +CompactDecimalFormat::format( + int64_t number, + UnicodeString& appendTo, + FieldPosition& pos) const { + return format((double) number, appendTo, pos); +} + +UnicodeString& +CompactDecimalFormat::format( + int64_t number, + UnicodeString& appendTo, + FieldPosition& pos, + UErrorCode &status) const { + return format((double) number, appendTo, pos, status); +} + +UnicodeString& +CompactDecimalFormat::format( + int64_t /* number */, + UnicodeString& appendTo, + FieldPositionIterator* /* posIter */, + UErrorCode& status) const { + status = U_UNSUPPORTED_ERROR; + return appendTo; +} + +UnicodeString& +CompactDecimalFormat::format( + StringPiece /* number */, + UnicodeString& appendTo, + FieldPositionIterator* /* posIter */, + UErrorCode& status) const { + status = U_UNSUPPORTED_ERROR; + return appendTo; +} + +UnicodeString& +CompactDecimalFormat::format( + const DigitList& /* number */, + UnicodeString& appendTo, + FieldPositionIterator* /* posIter */, + UErrorCode& status) const { + status = U_UNSUPPORTED_ERROR; + return appendTo; +} + +UnicodeString& +CompactDecimalFormat::format(const DigitList& /* number */, + UnicodeString& appendTo, + FieldPosition& /* pos */, + UErrorCode& status) const { + status = U_UNSUPPORTED_ERROR; + return appendTo; +} + +void +CompactDecimalFormat::parse( + const UnicodeString& /* text */, + Formattable& /* result */, + ParsePosition& /* parsePosition */) const { +} + +void +CompactDecimalFormat::parse( + const UnicodeString& /* text */, + Formattable& /* result */, + UErrorCode& status) const { + status = U_UNSUPPORTED_ERROR; +} + +CurrencyAmount* +CompactDecimalFormat::parseCurrency( + const UnicodeString& /* text */, + ParsePosition& /* pos */) const { + return NULL; +} + +void CDFLocaleStyleData::Init(UErrorCode& status) { + if (unitsByVariant != NULL) { + return; + } + unitsByVariant = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status); + if (U_FAILURE(status)) { + return; + } + uhash_setKeyDeleter(unitsByVariant, uprv_free); + uhash_setValueDeleter(unitsByVariant, deleteCDFUnits); +} + +CDFLocaleStyleData::~CDFLocaleStyleData() { + setToBogus(); +} + +void CDFLocaleStyleData::setToBogus() { + if (unitsByVariant != NULL) { + uhash_close(unitsByVariant); + unitsByVariant = NULL; + } +} + +void CDFLocaleData::Init(UErrorCode& status) { + shortData.Init(status); + if (U_FAILURE(status)) { + return; + } + longData.Init(status); +} + +// Helper method for operator= +static UBool divisors_equal(const double* lhs, const double* rhs) { + for (int32_t i = 0; i < MAX_DIGITS; ++i) { + if (lhs[i] != rhs[i]) { + return FALSE; + } + } + return TRUE; +} + +// getCDFLocaleStyleData returns pointer to formatting data for given locale and +// style within the global cache. On cache miss, getCDFLocaleStyleData loads +// the data from CLDR into the global cache before returning the pointer. If a +// UNUM_LONG data is requested for a locale, and that locale does not have +// UNUM_LONG data, getCDFLocaleStyleData will fall back to UNUM_SHORT data for +// that locale. +static const CDFLocaleStyleData* getCDFLocaleStyleData(const Locale& inLocale, UNumberCompactStyle style, UErrorCode& status) { + if (U_FAILURE(status)) { + return NULL; + } + CDFLocaleData* result = NULL; + const char* key = inLocale.getName(); + { + Mutex lock(&gCompactDecimalMetaLock); + if (gCompactDecimalData == NULL) { + gCompactDecimalData = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status); + if (U_FAILURE(status)) { + return NULL; + } + uhash_setKeyDeleter(gCompactDecimalData, uprv_free); + uhash_setValueDeleter(gCompactDecimalData, deleteCDFLocaleData); + ucln_i18n_registerCleanup(UCLN_I18N_CDFINFO, cdf_cleanup); + } else { + result = (CDFLocaleData*) uhash_get(gCompactDecimalData, key); + } + } + if (result != NULL) { + return extractDataByStyleEnum(*result, style, status); + } + + result = loadCDFLocaleData(inLocale, status); + if (U_FAILURE(status)) { + return NULL; + } + + { + Mutex lock(&gCompactDecimalMetaLock); + CDFLocaleData* temp = (CDFLocaleData*) uhash_get(gCompactDecimalData, key); + if (temp != NULL) { + delete result; + result = temp; + } else { + uhash_put(gCompactDecimalData, uprv_strdup(key), (void*) result, &status); + if (U_FAILURE(status)) { + return NULL; + } + } + } + return extractDataByStyleEnum(*result, style, status); +} + +static const CDFLocaleStyleData* extractDataByStyleEnum(const CDFLocaleData& data, UNumberCompactStyle style, UErrorCode& status) { + switch (style) { + case UNUM_SHORT: + return &data.shortData; + case UNUM_LONG: + if (!data.longData.isBogus()) { + return &data.longData; + } + return &data.shortData; + default: + status = U_ILLEGAL_ARGUMENT_ERROR; + return NULL; + } +} + +// loadCDFLocaleData loads formatting data from CLDR for a given locale. The +// caller owns the returned pointer. +static CDFLocaleData* loadCDFLocaleData(const Locale& inLocale, UErrorCode& status) { + if (U_FAILURE(status)) { + return NULL; + } + CDFLocaleData* result = new CDFLocaleData; + if (result == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + return NULL; + } + result->Init(status); + if (U_FAILURE(status)) { + delete result; + return NULL; + } + + load(inLocale, result, status); + + if (U_FAILURE(status)) { + delete result; + return NULL; + } + return result; +} + +namespace { + +struct CmptDecDataSink : public ResourceSink { + + CDFLocaleData& dataBundle; // Where to save values when they are read + UBool isLatin; // Whether or not we are traversing the Latin tree + UBool isFallback; // Whether or not we are traversing the Latin tree as fallback + + enum EPatternsTableKey { PATTERNS_SHORT, PATTERNS_LONG }; + enum EFormatsTableKey { DECIMAL_FORMAT, CURRENCY_FORMAT }; + + /* + * NumberElements{ <-- top (numbering system table) + * latn{ <-- patternsTable (one per numbering system) + * patternsLong{ <-- formatsTable (one per pattern) + * decimalFormat{ <-- powersOfTenTable (one per format) + * 1000{ <-- pluralVariantsTable (one per power of ten) + * one{"0 thousand"} <-- plural variant and template + */ + + CmptDecDataSink(CDFLocaleData& _dataBundle) + : dataBundle(_dataBundle), isLatin(FALSE), isFallback(FALSE) {} + virtual ~CmptDecDataSink(); + + virtual void put(const char *key, ResourceValue &value, UBool isRoot, UErrorCode &errorCode) { + // SPECIAL CASE: Don't consume root in the non-Latin numbering system + if (isRoot && !isLatin) { return; } + + ResourceTable patternsTable = value.getTable(errorCode); + if (U_FAILURE(errorCode)) { return; } + for (int i1 = 0; patternsTable.getKeyAndValue(i1, key, value); ++i1) { + + // Check for patternsShort or patternsLong + EPatternsTableKey patternsTableKey; + if (uprv_strcmp(key, gPatternsShort) == 0) { + patternsTableKey = PATTERNS_SHORT; + } else if (uprv_strcmp(key, gPatternsLong) == 0) { + patternsTableKey = PATTERNS_LONG; + } else { + continue; + } + + // Traverse into the formats table + ResourceTable formatsTable = value.getTable(errorCode); + if (U_FAILURE(errorCode)) { return; } + for (int i2 = 0; formatsTable.getKeyAndValue(i2, key, value); ++i2) { + + // Check for decimalFormat or currencyFormat + EFormatsTableKey formatsTableKey; + if (uprv_strcmp(key, gDecimalFormatTag) == 0) { + formatsTableKey = DECIMAL_FORMAT; + // TODO: Enable this statement when currency support is added + // } else if (uprv_strcmp(key, gCurrencyFormat) == 0) { + // formatsTableKey = CURRENCY_FORMAT; + } else { + continue; + } + + // Set the current style and destination based on the two keys + UNumberCompactStyle style; + CDFLocaleStyleData* destination = NULL; + if (patternsTableKey == PATTERNS_LONG + && formatsTableKey == DECIMAL_FORMAT) { + style = UNUM_LONG; + destination = &dataBundle.longData; + } else if (patternsTableKey == PATTERNS_SHORT + && formatsTableKey == DECIMAL_FORMAT) { + style = UNUM_SHORT; + destination = &dataBundle.shortData; + // TODO: Enable the following statements when currency support is added + // } else if (patternsTableKey == PATTERNS_SHORT + // && formatsTableKey == CURRENCY_FORMAT) { + // style = UNUM_SHORT_CURRENCY; // or whatever the enum gets named + // destination = &dataBundle.shortCurrencyData; + // } else { + // // Silently ignore this case + // continue; + } + + // SPECIAL CASE: RULES FOR WHETHER OR NOT TO CONSUME THIS TABLE: + // 1) Don't consume longData if shortData was consumed from the non-Latin + // locale numbering system + // 2) Don't consume longData for the first time if this is the root bundle and + // shortData is already populated from a more specific locale. Note that if + // both longData and shortData are both only in root, longData will be + // consumed since it is alphabetically before shortData in the bundle. + if (isFallback + && style == UNUM_LONG + && !dataBundle.shortData.isEmpty() + && !dataBundle.shortData.fromFallback) { + continue; + } + if (isRoot + && style == UNUM_LONG + && dataBundle.longData.isEmpty() + && !dataBundle.shortData.isEmpty()) { + continue; + } + + // Set the "fromFallback" flag on the data object + destination->fromFallback = isFallback; + + // Traverse into the powers of ten table + ResourceTable powersOfTenTable = value.getTable(errorCode); + if (U_FAILURE(errorCode)) { return; } + for (int i3 = 0; powersOfTenTable.getKeyAndValue(i3, key, value); ++i3) { + + // The key will always be some even power of 10. e.g 10000. + char* endPtr = NULL; + double power10 = uprv_strtod(key, &endPtr); + if (*endPtr != 0) { + errorCode = U_INTERNAL_PROGRAM_ERROR; + return; + } + int32_t log10Value = computeLog10(power10, FALSE); + + // Silently ignore divisors that are too big. + if (log10Value >= MAX_DIGITS) continue; + + // Iterate over the plural variants ("one", "other", etc) + ResourceTable pluralVariantsTable = value.getTable(errorCode); + if (U_FAILURE(errorCode)) { return; } + for (int i4 = 0; pluralVariantsTable.getKeyAndValue(i4, key, value); ++i4) { + const char* pluralVariant = key; + const UnicodeString formatStr = value.getUnicodeString(errorCode); + + // Copy the data into the in-memory data bundle (do not overwrite + // existing values) + int32_t numZeros = populatePrefixSuffix( + pluralVariant, log10Value, formatStr, + destination->unitsByVariant, FALSE, errorCode); + + // If populatePrefixSuffix returns -1, it means that this key has been + // encountered already. + if (numZeros < 0) { + continue; + } + + // Set the divisor, which is based on the number of zeros in the template + // string. If the divisor from here is different from the one previously + // stored, it means that the number of zeros in different plural variants + // differs; throw an exception. + // TODO: How should I check for floating-point errors here? + // Is there a good reason why "divisor" is double and not long like Java? + double divisor = calculateDivisor(power10, numZeros); + if (destination->divisors[log10Value] != 0.0 + && destination->divisors[log10Value] != divisor) { + errorCode = U_INTERNAL_PROGRAM_ERROR; + return; + } + destination->divisors[log10Value] = divisor; + } + } + } + } + } +}; + +// Virtual destructors must be defined out of line. +CmptDecDataSink::~CmptDecDataSink() {} + +} // namespace + +static void load(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status) { + LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(inLocale, status)); + if (U_FAILURE(status)) { + return; + } + const char* nsName = ns->getName(); + + LocalUResourceBundlePointer resource(ures_open(NULL, inLocale.getName(), &status)); + if (U_FAILURE(status)) { + return; + } + CmptDecDataSink sink(*result); + sink.isFallback = FALSE; + + // First load the number elements data if nsName is not Latin. + if (uprv_strcmp(nsName, gLatnTag) != 0) { + sink.isLatin = FALSE; + CharString path; + path.append(gNumberElementsTag, status) + .append('/', status) + .append(nsName, status); + ures_getAllItemsWithFallback(resource.getAlias(), path.data(), sink, status); + if (status == U_MISSING_RESOURCE_ERROR) { + // Silently ignore and use Latin + status = U_ZERO_ERROR; + } else if (U_FAILURE(status)) { + return; + } + sink.isFallback = TRUE; + } + + // Now load Latin. + sink.isLatin = TRUE; + ures_getAllItemsWithFallback(resource.getAlias(), gLatnPath, sink, status); + if (U_FAILURE(status)) return; + + // If longData is empty, default it to be equal to shortData + if (result->longData.isEmpty()) { + result->longData.setToBogus(); + } + + // Check for "other" variants in each of the three data classes, and resolve missing elements. + + if (!result->longData.isBogus()) { + checkForOtherVariants(&result->longData, status); + if (U_FAILURE(status)) return; + fillInMissing(&result->longData); + } + + checkForOtherVariants(&result->shortData, status); + if (U_FAILURE(status)) return; + fillInMissing(&result->shortData); + + // TODO: Enable this statement when currency support is added + // checkForOtherVariants(&result->shortCurrencyData, status); + // if (U_FAILURE(status)) return; + // fillInMissing(&result->shortCurrencyData); +} + +// populatePrefixSuffix Adds a specific prefix-suffix pair to result for a +// given variant and log10 value. +// variant is 'zero', 'one', 'two', 'few', 'many', or 'other'. +// formatStr is the format string from which the prefix and suffix are +// extracted. It is usually of form 'Pefix 000 suffix'. +// populatePrefixSuffix returns the number of 0's found in formatStr +// before the decimal point. +// In the special case that formatStr contains only spaces for prefix +// and suffix, populatePrefixSuffix returns log10Value + 1. +static int32_t populatePrefixSuffix( + const char* variant, int32_t log10Value, const UnicodeString& formatStr, UHashtable* result, UBool overwrite, UErrorCode& status) { + if (U_FAILURE(status)) { + return 0; + } + int32_t firstIdx = formatStr.indexOf(kZero, UPRV_LENGTHOF(kZero), 0); + // We must have 0's in format string. + if (firstIdx == -1) { + status = U_INTERNAL_PROGRAM_ERROR; + return 0; + } + int32_t lastIdx = formatStr.lastIndexOf(kZero, UPRV_LENGTHOF(kZero), firstIdx); + CDFUnit* unit = createCDFUnit(variant, log10Value, result, status); + if (U_FAILURE(status)) { + return 0; + } + + // Return -1 if we are not overwriting an existing value + if (unit->isSet() && !overwrite) { + return -1; + } + unit->markAsSet(); + + // Everything up to first 0 is the prefix + unit->prefix = formatStr.tempSubString(0, firstIdx); + fixQuotes(unit->prefix); + // Everything beyond the last 0 is the suffix + unit->suffix = formatStr.tempSubString(lastIdx + 1); + fixQuotes(unit->suffix); + + // If there is effectively no prefix or suffix, ignore the actual number of + // 0's and act as if the number of 0's matches the size of the number. + if (onlySpaces(unit->prefix) && onlySpaces(unit->suffix)) { + return log10Value + 1; + } + + // Calculate number of zeros before decimal point + int32_t idx = firstIdx + 1; + while (idx <= lastIdx && formatStr.charAt(idx) == u_0) { + ++idx; + } + return (idx - firstIdx); +} + +// Calculate a divisor based on the magnitude and number of zeros in the +// template string. +static double calculateDivisor(double power10, int32_t numZeros) { + double divisor = power10; + for (int32_t i = 1; i < numZeros; ++i) { + divisor /= 10.0; + } + return divisor; +} + +static UBool onlySpaces(UnicodeString u) { + return u.trim().length() == 0; +} + +// fixQuotes unescapes single quotes. Don''t -> Don't. Letter 'j' -> Letter j. +// Modifies s in place. +static void fixQuotes(UnicodeString& s) { + QuoteState state = OUTSIDE; + int32_t len = s.length(); + int32_t dest = 0; + for (int32_t i = 0; i < len; ++i) { + UChar ch = s.charAt(i); + if (ch == u_apos) { + if (state == INSIDE_EMPTY) { + s.setCharAt(dest, ch); + ++dest; + } + } else { + s.setCharAt(dest, ch); + ++dest; + } + + // Update state + switch (state) { + case OUTSIDE: + state = ch == u_apos ? INSIDE_EMPTY : OUTSIDE; + break; + case INSIDE_EMPTY: + case INSIDE_FULL: + state = ch == u_apos ? OUTSIDE : INSIDE_FULL; + break; + default: + break; + } + } + s.truncate(dest); +} + +// Checks to make sure that an "other" variant is present in all +// powers of 10. +static void checkForOtherVariants(CDFLocaleStyleData* result, + UErrorCode& status) { + if (result == NULL || result->unitsByVariant == NULL) { + return; + } + + const CDFUnit* otherByBase = + (const CDFUnit*) uhash_get(result->unitsByVariant, gOther); + if (otherByBase == NULL) { + status = U_INTERNAL_PROGRAM_ERROR; + return; + } + + // Check all other plural variants, and make sure that if + // any of them are populated, then other is also populated + int32_t pos = UHASH_FIRST; + const UHashElement* element; + while ((element = uhash_nextElement(result->unitsByVariant, &pos)) != NULL) { + CDFUnit* variantsByBase = (CDFUnit*) element->value.pointer; + if (variantsByBase == otherByBase) continue; + for (int32_t log10Value = 0; log10Value < MAX_DIGITS; ++log10Value) { + if (variantsByBase[log10Value].isSet() + && !otherByBase[log10Value].isSet()) { + status = U_INTERNAL_PROGRAM_ERROR; + return; + } + } + } +} + +// fillInMissing ensures that the data in result is complete. +// result data is complete if for each variant in result, there exists +// a prefix-suffix pair for each log10 value and there also exists +// a divisor for each log10 value. +// +// First this function figures out for which log10 values, the other +// variant already had data. These are the same log10 values defined +// in CLDR. +// +// For each log10 value not defined in CLDR, it uses the divisor for +// the last defined log10 value or 1. +// +// Then for each variant, it does the following. For each log10 +// value not defined in CLDR, copy the prefix-suffix pair from the +// previous log10 value. If log10 value is defined in CLDR but is +// missing from given variant, copy the prefix-suffix pair for that +// log10 value from the 'other' variant. +static void fillInMissing(CDFLocaleStyleData* result) { + const CDFUnit* otherUnits = + (const CDFUnit*) uhash_get(result->unitsByVariant, gOther); + UBool definedInCLDR[MAX_DIGITS]; + double lastDivisor = 1.0; + for (int32_t i = 0; i < MAX_DIGITS; ++i) { + if (!otherUnits[i].isSet()) { + result->divisors[i] = lastDivisor; + definedInCLDR[i] = FALSE; + } else { + lastDivisor = result->divisors[i]; + definedInCLDR[i] = TRUE; + } + } + // Iterate over each variant. + int32_t pos = UHASH_FIRST; + const UHashElement* element = uhash_nextElement(result->unitsByVariant, &pos); + for (;element != NULL; element = uhash_nextElement(result->unitsByVariant, &pos)) { + CDFUnit* units = (CDFUnit*) element->value.pointer; + for (int32_t i = 0; i < MAX_DIGITS; ++i) { + if (definedInCLDR[i]) { + if (!units[i].isSet()) { + units[i] = otherUnits[i]; + } + } else { + if (i == 0) { + units[0].markAsSet(); + } else { + units[i] = units[i - 1]; + } + } + } + } +} + +// computeLog10 computes floor(log10(x)). If inRange is TRUE, the biggest +// value computeLog10 will return MAX_DIGITS -1 even for +// numbers > 10^MAX_DIGITS. If inRange is FALSE, computeLog10 will return +// up to MAX_DIGITS. +static int32_t computeLog10(double x, UBool inRange) { + int32_t result = 0; + int32_t max = inRange ? MAX_DIGITS - 1 : MAX_DIGITS; + while (x >= 10.0) { + x /= 10.0; + ++result; + if (result == max) { + break; + } + } + return result; +} + +// createCDFUnit returns a pointer to the prefix-suffix pair for a given +// variant and log10 value within table. If no such prefix-suffix pair is +// stored in table, one is created within table before returning pointer. +static CDFUnit* createCDFUnit(const char* variant, int32_t log10Value, UHashtable* table, UErrorCode& status) { + if (U_FAILURE(status)) { + return NULL; + } + CDFUnit *cdfUnit = (CDFUnit*) uhash_get(table, variant); + if (cdfUnit == NULL) { + cdfUnit = new CDFUnit[MAX_DIGITS]; + if (cdfUnit == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + return NULL; + } + uhash_put(table, uprv_strdup(variant), cdfUnit, &status); + if (U_FAILURE(status)) { + return NULL; + } + } + CDFUnit* result = &cdfUnit[log10Value]; + return result; +} + +// getCDFUnitFallback returns a pointer to the prefix-suffix pair for a given +// variant and log10 value within table. If the given variant doesn't exist, it +// falls back to the OTHER variant. Therefore, this method will always return +// some non-NULL value. +static const CDFUnit* getCDFUnitFallback(const UHashtable* table, const UnicodeString& variant, int32_t log10Value) { + CharString cvariant; + UErrorCode status = U_ZERO_ERROR; + const CDFUnit *cdfUnit = NULL; + cvariant.appendInvariantChars(variant, status); + if (!U_FAILURE(status)) { + cdfUnit = (const CDFUnit*) uhash_get(table, cvariant.data()); + } + if (cdfUnit == NULL) { + cdfUnit = (const CDFUnit*) uhash_get(table, gOther); + } + return &cdfUnit[log10Value]; +} + +U_NAMESPACE_END +#endif |