| /* |
| ******************************************************************************* |
| * Copyright (C) 2007-2015, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ******************************************************************************* |
| * |
| * File plurrule.cpp |
| */ |
| |
| #include "starboard/client_porting/poem/assert_poem.h" |
| #include "starboard/client_porting/poem/math_poem.h" |
| #include "starboard/client_porting/poem/stdlib_poem.h" |
| #include "starboard/client_porting/poem/string_poem.h" |
| #if !defined(STARBOARD) |
| #include <math.h> |
| #include <stdio.h> |
| #endif |
| |
| #include "unicode/utypes.h" |
| #include "unicode/localpointer.h" |
| #include "unicode/plurrule.h" |
| |
| // These files must be included after plurrule.h, for the #define in the poems |
| // to work successfully. |
| #include "starboard/client_porting/poem/stdio_poem.h" |
| #include "starboard/client_porting/poem/wchar_poem.h" |
| |
| #include "unicode/upluralrules.h" |
| #include "unicode/ures.h" |
| #include "charstr.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "digitlst.h" |
| #include "hash.h" |
| #include "locutil.h" |
| #include "mutex.h" |
| #include "patternprops.h" |
| #include "plurrule_impl.h" |
| #include "putilimp.h" |
| #include "ucln_in.h" |
| #include "ustrfmt.h" |
| #include "uassert.h" |
| #include "uvectr32.h" |
| #include "sharedpluralrules.h" |
| #include "unifiedcache.h" |
| #include "digitinterval.h" |
| #include "visibledigits.h" |
| |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| U_NAMESPACE_BEGIN |
| |
| #define ARRAY_SIZE(array) (int32_t)(sizeof array / sizeof array[0]) |
| |
| static const UChar PLURAL_KEYWORD_OTHER[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,0}; |
| static const UChar PLURAL_DEFAULT_RULE[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,COLON,SPACE,LOW_N,0}; |
| static const UChar PK_IN[]={LOW_I,LOW_N,0}; |
| static const UChar PK_NOT[]={LOW_N,LOW_O,LOW_T,0}; |
| static const UChar PK_IS[]={LOW_I,LOW_S,0}; |
| static const UChar PK_MOD[]={LOW_M,LOW_O,LOW_D,0}; |
| static const UChar PK_AND[]={LOW_A,LOW_N,LOW_D,0}; |
| static const UChar PK_OR[]={LOW_O,LOW_R,0}; |
| static const UChar PK_VAR_N[]={LOW_N,0}; |
| static const UChar PK_VAR_I[]={LOW_I,0}; |
| static const UChar PK_VAR_F[]={LOW_F,0}; |
| static const UChar PK_VAR_T[]={LOW_T,0}; |
| static const UChar PK_VAR_V[]={LOW_V,0}; |
| static const UChar PK_WITHIN[]={LOW_W,LOW_I,LOW_T,LOW_H,LOW_I,LOW_N,0}; |
| static const UChar PK_DECIMAL[]={LOW_D,LOW_E,LOW_C,LOW_I,LOW_M,LOW_A,LOW_L,0}; |
| static const UChar PK_INTEGER[]={LOW_I,LOW_N,LOW_T,LOW_E,LOW_G,LOW_E,LOW_R,0}; |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralRules) |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralKeywordEnumeration) |
| |
| PluralRules::PluralRules(UErrorCode& /*status*/) |
| : UObject(), |
| mRules(NULL) |
| { |
| } |
| |
| PluralRules::PluralRules(const PluralRules& other) |
| : UObject(other), |
| mRules(NULL) |
| { |
| *this=other; |
| } |
| |
| PluralRules::~PluralRules() { |
| delete mRules; |
| } |
| |
| SharedPluralRules::~SharedPluralRules() { |
| delete ptr; |
| } |
| |
| PluralRules* |
| PluralRules::clone() const { |
| return new PluralRules(*this); |
| } |
| |
| PluralRules& |
| PluralRules::operator=(const PluralRules& other) { |
| if (this != &other) { |
| delete mRules; |
| if (other.mRules==NULL) { |
| mRules = NULL; |
| } |
| else { |
| mRules = new RuleChain(*other.mRules); |
| } |
| } |
| |
| return *this; |
| } |
| |
| StringEnumeration* PluralRules::getAvailableLocales(UErrorCode &status) { |
| StringEnumeration *result = new PluralAvailableLocalesEnumeration(status); |
| if (result == NULL && U_SUCCESS(status)) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| if (U_FAILURE(status)) { |
| delete result; |
| result = NULL; |
| } |
| return result; |
| } |
| |
| |
| PluralRules* U_EXPORT2 |
| PluralRules::createRules(const UnicodeString& description, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| |
| PluralRuleParser parser; |
| PluralRules *newRules = new PluralRules(status); |
| if (U_SUCCESS(status) && newRules == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| parser.parse(description, newRules, status); |
| if (U_FAILURE(status)) { |
| delete newRules; |
| newRules = NULL; |
| } |
| return newRules; |
| } |
| |
| |
| PluralRules* U_EXPORT2 |
| PluralRules::createDefaultRules(UErrorCode& status) { |
| return createRules(UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1), status); |
| } |
| |
| /******************************************************************************/ |
| /* Create PluralRules cache */ |
| |
| template<> U_I18N_API |
| const SharedPluralRules *LocaleCacheKey<SharedPluralRules>::createObject( |
| const void * /*unused*/, UErrorCode &status) const { |
| const char *localeId = fLoc.getName(); |
| PluralRules *pr = PluralRules::internalForLocale( |
| localeId, UPLURAL_TYPE_CARDINAL, status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| SharedPluralRules *result = new SharedPluralRules(pr); |
| if (result == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| delete pr; |
| return NULL; |
| } |
| result->addRef(); |
| return result; |
| } |
| |
| /* end plural rules cache */ |
| /******************************************************************************/ |
| |
| const SharedPluralRules* U_EXPORT2 |
| PluralRules::createSharedInstance( |
| const Locale& locale, UPluralType type, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| if (type != UPLURAL_TYPE_CARDINAL) { |
| status = U_UNSUPPORTED_ERROR; |
| return NULL; |
| } |
| const SharedPluralRules *result = NULL; |
| UnifiedCache::getByLocale(locale, result, status); |
| return result; |
| } |
| |
| PluralRules* U_EXPORT2 |
| PluralRules::forLocale(const Locale& locale, UErrorCode& status) { |
| return forLocale(locale, UPLURAL_TYPE_CARDINAL, status); |
| } |
| |
| PluralRules* U_EXPORT2 |
| PluralRules::forLocale(const Locale& locale, UPluralType type, UErrorCode& status) { |
| if (type != UPLURAL_TYPE_CARDINAL) { |
| return internalForLocale(locale, type, status); |
| } |
| const SharedPluralRules *shared = createSharedInstance( |
| locale, type, status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| PluralRules *result = (*shared)->clone(); |
| shared->removeRef(); |
| if (result == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| return result; |
| } |
| |
| PluralRules* U_EXPORT2 |
| PluralRules::internalForLocale(const Locale& locale, UPluralType type, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| if (type >= UPLURAL_TYPE_COUNT) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| PluralRules *newObj = new PluralRules(status); |
| if (newObj==NULL || U_FAILURE(status)) { |
| delete newObj; |
| return NULL; |
| } |
| UnicodeString locRule = newObj->getRuleFromResource(locale, type, status); |
| // TODO: which errors, if any, should be returned? |
| if (locRule.length() == 0) { |
| // Locales with no specific rules (all numbers have the "other" category |
| // will return a U_MISSING_RESOURCE_ERROR at this point. This is not |
| // an error. |
| locRule = UnicodeString(PLURAL_DEFAULT_RULE); |
| status = U_ZERO_ERROR; |
| } |
| PluralRuleParser parser; |
| parser.parse(locRule, newObj, status); |
| // TODO: should rule parse errors be returned, or |
| // should we silently use default rules? |
| // Original impl used default rules. |
| // Ask the question to ICU Core. |
| |
| return newObj; |
| } |
| |
| UnicodeString |
| PluralRules::select(int32_t number) const { |
| return select(FixedDecimal(number)); |
| } |
| |
| UnicodeString |
| PluralRules::select(double number) const { |
| return select(FixedDecimal(number)); |
| } |
| |
| UnicodeString |
| PluralRules::select(const FixedDecimal &number) const { |
| if (mRules == NULL) { |
| return UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1); |
| } |
| else { |
| return mRules->select(number); |
| } |
| } |
| |
| UnicodeString |
| PluralRules::select(const VisibleDigitsWithExponent &number) const { |
| if (number.getExponent() != NULL) { |
| return UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1); |
| } |
| return select(FixedDecimal(number.getMantissa())); |
| } |
| |
| |
| |
| StringEnumeration* |
| PluralRules::getKeywords(UErrorCode& status) const { |
| if (U_FAILURE(status)) return NULL; |
| StringEnumeration* nameEnumerator = new PluralKeywordEnumeration(mRules, status); |
| if (U_FAILURE(status)) { |
| delete nameEnumerator; |
| return NULL; |
| } |
| |
| return nameEnumerator; |
| } |
| |
| double |
| PluralRules::getUniqueKeywordValue(const UnicodeString& /* keyword */) { |
| // Not Implemented. |
| return UPLRULES_NO_UNIQUE_VALUE; |
| } |
| |
| int32_t |
| PluralRules::getAllKeywordValues(const UnicodeString & /* keyword */, double * /* dest */, |
| int32_t /* destCapacity */, UErrorCode& error) { |
| error = U_UNSUPPORTED_ERROR; |
| return 0; |
| } |
| |
| |
| static double scaleForInt(double d) { |
| double scale = 1.0; |
| while (d != floor(d)) { |
| d = d * 10.0; |
| scale = scale * 10.0; |
| } |
| return scale; |
| } |
| |
| static int32_t |
| getSamplesFromString(const UnicodeString &samples, double *dest, |
| int32_t destCapacity, UErrorCode& status) { |
| int32_t sampleCount = 0; |
| int32_t sampleStartIdx = 0; |
| int32_t sampleEndIdx = 0; |
| |
| //std::string ss; // TODO: debugging. |
| // std::cout << "PluralRules::getSamples(), samples = \"" << samples.toUTF8String(ss) << "\"\n"; |
| for (sampleCount = 0; sampleCount < destCapacity && sampleStartIdx < samples.length(); ) { |
| sampleEndIdx = samples.indexOf(COMMA, sampleStartIdx); |
| if (sampleEndIdx == -1) { |
| sampleEndIdx = samples.length(); |
| } |
| const UnicodeString &sampleRange = samples.tempSubStringBetween(sampleStartIdx, sampleEndIdx); |
| // ss.erase(); |
| // std::cout << "PluralRules::getSamples(), samplesRange = \"" << sampleRange.toUTF8String(ss) << "\"\n"; |
| int32_t tildeIndex = sampleRange.indexOf(TILDE); |
| if (tildeIndex < 0) { |
| FixedDecimal fixed(sampleRange, status); |
| double sampleValue = fixed.source; |
| if (fixed.visibleDecimalDigitCount == 0 || sampleValue != floor(sampleValue)) { |
| dest[sampleCount++] = sampleValue; |
| } |
| } else { |
| |
| FixedDecimal fixedLo(sampleRange.tempSubStringBetween(0, tildeIndex), status); |
| FixedDecimal fixedHi(sampleRange.tempSubStringBetween(tildeIndex+1), status); |
| double rangeLo = fixedLo.source; |
| double rangeHi = fixedHi.source; |
| if (U_FAILURE(status)) { |
| break; |
| } |
| if (rangeHi < rangeLo) { |
| status = U_INVALID_FORMAT_ERROR; |
| break; |
| } |
| |
| // For ranges of samples with fraction decimal digits, scale the number up so that we |
| // are adding one in the units place. Avoids roundoffs from repetitive adds of tenths. |
| |
| double scale = scaleForInt(rangeLo); |
| double t = scaleForInt(rangeHi); |
| if (t > scale) { |
| scale = t; |
| } |
| rangeLo *= scale; |
| rangeHi *= scale; |
| for (double n=rangeLo; n<=rangeHi; n+=1) { |
| // Hack Alert: don't return any decimal samples with integer values that |
| // originated from a format with trailing decimals. |
| // This API is returning doubles, which can't distinguish having displayed |
| // zeros to the right of the decimal. |
| // This results in test failures with values mapping back to a different keyword. |
| double sampleValue = n/scale; |
| if (!(sampleValue == floor(sampleValue) && fixedLo.visibleDecimalDigitCount > 0)) { |
| dest[sampleCount++] = sampleValue; |
| } |
| if (sampleCount >= destCapacity) { |
| break; |
| } |
| } |
| } |
| sampleStartIdx = sampleEndIdx + 1; |
| } |
| return sampleCount; |
| } |
| |
| |
| int32_t |
| PluralRules::getSamples(const UnicodeString &keyword, double *dest, |
| int32_t destCapacity, UErrorCode& status) { |
| RuleChain *rc = rulesForKeyword(keyword); |
| if (rc == NULL || destCapacity == 0 || U_FAILURE(status)) { |
| return 0; |
| } |
| int32_t numSamples = getSamplesFromString(rc->fIntegerSamples, dest, destCapacity, status); |
| if (numSamples == 0) { |
| numSamples = getSamplesFromString(rc->fDecimalSamples, dest, destCapacity, status); |
| } |
| return numSamples; |
| } |
| |
| |
| RuleChain *PluralRules::rulesForKeyword(const UnicodeString &keyword) const { |
| RuleChain *rc; |
| for (rc = mRules; rc != NULL; rc = rc->fNext) { |
| if (rc->fKeyword == keyword) { |
| break; |
| } |
| } |
| return rc; |
| } |
| |
| |
| UBool |
| PluralRules::isKeyword(const UnicodeString& keyword) const { |
| if (0 == keyword.compare(PLURAL_KEYWORD_OTHER, 5)) { |
| return true; |
| } |
| return rulesForKeyword(keyword) != NULL; |
| } |
| |
| UnicodeString |
| PluralRules::getKeywordOther() const { |
| return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5); |
| } |
| |
| UBool |
| PluralRules::operator==(const PluralRules& other) const { |
| const UnicodeString *ptrKeyword; |
| UErrorCode status= U_ZERO_ERROR; |
| |
| if ( this == &other ) { |
| return TRUE; |
| } |
| LocalPointer<StringEnumeration> myKeywordList(getKeywords(status)); |
| LocalPointer<StringEnumeration> otherKeywordList(other.getKeywords(status)); |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| |
| if (myKeywordList->count(status)!=otherKeywordList->count(status)) { |
| return FALSE; |
| } |
| myKeywordList->reset(status); |
| while ((ptrKeyword=myKeywordList->snext(status))!=NULL) { |
| if (!other.isKeyword(*ptrKeyword)) { |
| return FALSE; |
| } |
| } |
| otherKeywordList->reset(status); |
| while ((ptrKeyword=otherKeywordList->snext(status))!=NULL) { |
| if (!this->isKeyword(*ptrKeyword)) { |
| return FALSE; |
| } |
| } |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| void |
| PluralRuleParser::parse(const UnicodeString& ruleData, PluralRules *prules, UErrorCode &status) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| U_ASSERT(ruleIndex == 0); // Parsers are good for a single use only! |
| ruleSrc = &ruleData; |
| |
| while (ruleIndex< ruleSrc->length()) { |
| getNextToken(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| checkSyntax(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| switch (type) { |
| case tAnd: |
| U_ASSERT(curAndConstraint != NULL); |
| curAndConstraint = curAndConstraint->add(); |
| break; |
| case tOr: |
| { |
| U_ASSERT(currentChain != NULL); |
| OrConstraint *orNode=currentChain->ruleHeader; |
| while (orNode->next != NULL) { |
| orNode = orNode->next; |
| } |
| orNode->next= new OrConstraint(); |
| orNode=orNode->next; |
| orNode->next=NULL; |
| curAndConstraint = orNode->add(); |
| } |
| break; |
| case tIs: |
| U_ASSERT(curAndConstraint != NULL); |
| U_ASSERT(curAndConstraint->value == -1); |
| U_ASSERT(curAndConstraint->rangeList == NULL); |
| break; |
| case tNot: |
| U_ASSERT(curAndConstraint != NULL); |
| curAndConstraint->negated=TRUE; |
| break; |
| |
| case tNotEqual: |
| curAndConstraint->negated=TRUE; |
| case tIn: |
| case tWithin: |
| case tEqual: |
| U_ASSERT(curAndConstraint != NULL); |
| curAndConstraint->rangeList = new UVector32(status); |
| curAndConstraint->rangeList->addElement(-1, status); // range Low |
| curAndConstraint->rangeList->addElement(-1, status); // range Hi |
| rangeLowIdx = 0; |
| rangeHiIdx = 1; |
| curAndConstraint->value=PLURAL_RANGE_HIGH; |
| curAndConstraint->integerOnly = (type != tWithin); |
| break; |
| case tNumber: |
| U_ASSERT(curAndConstraint != NULL); |
| if ( (curAndConstraint->op==AndConstraint::MOD)&& |
| (curAndConstraint->opNum == -1 ) ) { |
| curAndConstraint->opNum=getNumberValue(token); |
| } |
| else { |
| if (curAndConstraint->rangeList == NULL) { |
| // this is for an 'is' rule |
| curAndConstraint->value = getNumberValue(token); |
| } else { |
| // this is for an 'in' or 'within' rule |
| if (curAndConstraint->rangeList->elementAti(rangeLowIdx) == -1) { |
| curAndConstraint->rangeList->setElementAt(getNumberValue(token), rangeLowIdx); |
| curAndConstraint->rangeList->setElementAt(getNumberValue(token), rangeHiIdx); |
| } |
| else { |
| curAndConstraint->rangeList->setElementAt(getNumberValue(token), rangeHiIdx); |
| if (curAndConstraint->rangeList->elementAti(rangeLowIdx) > |
| curAndConstraint->rangeList->elementAti(rangeHiIdx)) { |
| // Range Lower bound > Range Upper bound. |
| // U_UNEXPECTED_TOKEN seems a little funny, but it is consistently |
| // used for all plural rule parse errors. |
| status = U_UNEXPECTED_TOKEN; |
| break; |
| } |
| } |
| } |
| } |
| break; |
| case tComma: |
| // TODO: rule syntax checking is inadequate, can happen with badly formed rules. |
| // Catch cases like "n mod 10, is 1" here instead. |
| if (curAndConstraint == NULL || curAndConstraint->rangeList == NULL) { |
| status = U_UNEXPECTED_TOKEN; |
| break; |
| } |
| U_ASSERT(curAndConstraint->rangeList->size() >= 2); |
| rangeLowIdx = curAndConstraint->rangeList->size(); |
| curAndConstraint->rangeList->addElement(-1, status); // range Low |
| rangeHiIdx = curAndConstraint->rangeList->size(); |
| curAndConstraint->rangeList->addElement(-1, status); // range Hi |
| break; |
| case tMod: |
| U_ASSERT(curAndConstraint != NULL); |
| curAndConstraint->op=AndConstraint::MOD; |
| break; |
| case tVariableN: |
| case tVariableI: |
| case tVariableF: |
| case tVariableT: |
| case tVariableV: |
| U_ASSERT(curAndConstraint != NULL); |
| curAndConstraint->digitsType = type; |
| break; |
| case tKeyword: |
| { |
| RuleChain *newChain = new RuleChain; |
| if (newChain == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| break; |
| } |
| newChain->fKeyword = token; |
| if (prules->mRules == NULL) { |
| prules->mRules = newChain; |
| } else { |
| // The new rule chain goes at the end of the linked list of rule chains, |
| // unless there is an "other" keyword & chain. "other" must remain last. |
| RuleChain *insertAfter = prules->mRules; |
| while (insertAfter->fNext!=NULL && |
| insertAfter->fNext->fKeyword.compare(PLURAL_KEYWORD_OTHER, 5) != 0 ){ |
| insertAfter=insertAfter->fNext; |
| } |
| newChain->fNext = insertAfter->fNext; |
| insertAfter->fNext = newChain; |
| } |
| OrConstraint *orNode = new OrConstraint(); |
| newChain->ruleHeader = orNode; |
| curAndConstraint = orNode->add(); |
| currentChain = newChain; |
| } |
| break; |
| |
| case tInteger: |
| for (;;) { |
| getNextToken(status); |
| if (U_FAILURE(status) || type == tSemiColon || type == tEOF || type == tAt) { |
| break; |
| } |
| if (type == tEllipsis) { |
| currentChain->fIntegerSamplesUnbounded = TRUE; |
| continue; |
| } |
| currentChain->fIntegerSamples.append(token); |
| } |
| break; |
| |
| case tDecimal: |
| for (;;) { |
| getNextToken(status); |
| if (U_FAILURE(status) || type == tSemiColon || type == tEOF || type == tAt) { |
| break; |
| } |
| if (type == tEllipsis) { |
| currentChain->fDecimalSamplesUnbounded = TRUE; |
| continue; |
| } |
| currentChain->fDecimalSamples.append(token); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| prevType=type; |
| if (U_FAILURE(status)) { |
| break; |
| } |
| } |
| } |
| |
| UnicodeString |
| PluralRules::getRuleFromResource(const Locale& locale, UPluralType type, UErrorCode& errCode) { |
| UnicodeString emptyStr; |
| |
| if (U_FAILURE(errCode)) { |
| return emptyStr; |
| } |
| LocalUResourceBundlePointer rb(ures_openDirect(NULL, "plurals", &errCode)); |
| if(U_FAILURE(errCode)) { |
| return emptyStr; |
| } |
| const char *typeKey; |
| switch (type) { |
| case UPLURAL_TYPE_CARDINAL: |
| typeKey = "locales"; |
| break; |
| case UPLURAL_TYPE_ORDINAL: |
| typeKey = "locales_ordinals"; |
| break; |
| default: |
| // Must not occur: The caller should have checked for valid types. |
| errCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return emptyStr; |
| } |
| LocalUResourceBundlePointer locRes(ures_getByKey(rb.getAlias(), typeKey, NULL, &errCode)); |
| if(U_FAILURE(errCode)) { |
| return emptyStr; |
| } |
| int32_t resLen=0; |
| const char *curLocaleName=locale.getName(); |
| const UChar* s = ures_getStringByKey(locRes.getAlias(), curLocaleName, &resLen, &errCode); |
| |
| if (s == NULL) { |
| // Check parent locales. |
| UErrorCode status = U_ZERO_ERROR; |
| char parentLocaleName[ULOC_FULLNAME_CAPACITY]; |
| const char *curLocaleName=locale.getName(); |
| uprv_strcpy(parentLocaleName, curLocaleName); |
| |
| while (uloc_getParent(parentLocaleName, parentLocaleName, |
| ULOC_FULLNAME_CAPACITY, &status) > 0) { |
| resLen=0; |
| s = ures_getStringByKey(locRes.getAlias(), parentLocaleName, &resLen, &status); |
| if (s != NULL) { |
| errCode = U_ZERO_ERROR; |
| break; |
| } |
| status = U_ZERO_ERROR; |
| } |
| } |
| if (s==NULL) { |
| return emptyStr; |
| } |
| |
| char setKey[256]; |
| u_UCharsToChars(s, setKey, resLen + 1); |
| // printf("\n PluralRule: %s\n", setKey); |
| |
| LocalUResourceBundlePointer ruleRes(ures_getByKey(rb.getAlias(), "rules", NULL, &errCode)); |
| if(U_FAILURE(errCode)) { |
| return emptyStr; |
| } |
| LocalUResourceBundlePointer setRes(ures_getByKey(ruleRes.getAlias(), setKey, NULL, &errCode)); |
| if (U_FAILURE(errCode)) { |
| return emptyStr; |
| } |
| |
| int32_t numberKeys = ures_getSize(setRes.getAlias()); |
| UnicodeString result; |
| const char *key=NULL; |
| for(int32_t i=0; i<numberKeys; ++i) { // Keys are zero, one, few, ... |
| UnicodeString rules = ures_getNextUnicodeString(setRes.getAlias(), &key, &errCode); |
| UnicodeString uKey(key, -1, US_INV); |
| result.append(uKey); |
| result.append(COLON); |
| result.append(rules); |
| result.append(SEMI_COLON); |
| } |
| return result; |
| } |
| |
| |
| UnicodeString |
| PluralRules::getRules() const { |
| UnicodeString rules; |
| if (mRules != NULL) { |
| mRules->dumpRules(rules); |
| } |
| return rules; |
| } |
| |
| |
| AndConstraint::AndConstraint() { |
| op = AndConstraint::NONE; |
| opNum=-1; |
| value = -1; |
| rangeList = NULL; |
| negated = FALSE; |
| integerOnly = FALSE; |
| digitsType = none; |
| next=NULL; |
| } |
| |
| |
| AndConstraint::AndConstraint(const AndConstraint& other) { |
| this->op = other.op; |
| this->opNum=other.opNum; |
| this->value=other.value; |
| this->rangeList=NULL; |
| if (other.rangeList != NULL) { |
| UErrorCode status = U_ZERO_ERROR; |
| this->rangeList = new UVector32(status); |
| this->rangeList->assign(*other.rangeList, status); |
| } |
| this->integerOnly=other.integerOnly; |
| this->negated=other.negated; |
| this->digitsType = other.digitsType; |
| if (other.next==NULL) { |
| this->next=NULL; |
| } |
| else { |
| this->next = new AndConstraint(*other.next); |
| } |
| } |
| |
| AndConstraint::~AndConstraint() { |
| delete rangeList; |
| if (next!=NULL) { |
| delete next; |
| } |
| } |
| |
| |
| UBool |
| AndConstraint::isFulfilled(const FixedDecimal &number) { |
| UBool result = TRUE; |
| if (digitsType == none) { |
| // An empty AndConstraint, created by a rule with a keyword but no following expression. |
| return TRUE; |
| } |
| double n = number.get(digitsType); // pulls n | i | v | f value for the number. |
| // Will always be positive. |
| // May be non-integer (n option only) |
| do { |
| if (integerOnly && n != uprv_floor(n)) { |
| result = FALSE; |
| break; |
| } |
| |
| if (op == MOD) { |
| n = fmod(n, opNum); |
| } |
| if (rangeList == NULL) { |
| result = value == -1 || // empty rule |
| n == value; // 'is' rule |
| break; |
| } |
| result = FALSE; // 'in' or 'within' rule |
| for (int32_t r=0; r<rangeList->size(); r+=2) { |
| if (rangeList->elementAti(r) <= n && n <= rangeList->elementAti(r+1)) { |
| result = TRUE; |
| break; |
| } |
| } |
| } while (FALSE); |
| |
| if (negated) { |
| result = !result; |
| } |
| return result; |
| } |
| |
| |
| AndConstraint* |
| AndConstraint::add() |
| { |
| this->next = new AndConstraint(); |
| return this->next; |
| } |
| |
| OrConstraint::OrConstraint() { |
| childNode=NULL; |
| next=NULL; |
| } |
| |
| OrConstraint::OrConstraint(const OrConstraint& other) { |
| if ( other.childNode == NULL ) { |
| this->childNode = NULL; |
| } |
| else { |
| this->childNode = new AndConstraint(*(other.childNode)); |
| } |
| if (other.next == NULL ) { |
| this->next = NULL; |
| } |
| else { |
| this->next = new OrConstraint(*(other.next)); |
| } |
| } |
| |
| OrConstraint::~OrConstraint() { |
| if (childNode!=NULL) { |
| delete childNode; |
| } |
| if (next!=NULL) { |
| delete next; |
| } |
| } |
| |
| AndConstraint* |
| OrConstraint::add() |
| { |
| OrConstraint *curOrConstraint=this; |
| { |
| while (curOrConstraint->next!=NULL) { |
| curOrConstraint = curOrConstraint->next; |
| } |
| U_ASSERT(curOrConstraint->childNode == NULL); |
| curOrConstraint->childNode = new AndConstraint(); |
| } |
| return curOrConstraint->childNode; |
| } |
| |
| UBool |
| OrConstraint::isFulfilled(const FixedDecimal &number) { |
| OrConstraint* orRule=this; |
| UBool result=FALSE; |
| |
| while (orRule!=NULL && !result) { |
| result=TRUE; |
| AndConstraint* andRule = orRule->childNode; |
| while (andRule!=NULL && result) { |
| result = andRule->isFulfilled(number); |
| andRule=andRule->next; |
| } |
| orRule = orRule->next; |
| } |
| |
| return result; |
| } |
| |
| |
| RuleChain::RuleChain(): fKeyword(), fNext(NULL), ruleHeader(NULL), fDecimalSamples(), fIntegerSamples(), |
| fDecimalSamplesUnbounded(FALSE), fIntegerSamplesUnbounded(FALSE) { |
| } |
| |
| RuleChain::RuleChain(const RuleChain& other) : |
| fKeyword(other.fKeyword), fNext(NULL), ruleHeader(NULL), fDecimalSamples(other.fDecimalSamples), |
| fIntegerSamples(other.fIntegerSamples), fDecimalSamplesUnbounded(other.fDecimalSamplesUnbounded), |
| fIntegerSamplesUnbounded(other.fIntegerSamplesUnbounded) { |
| if (other.ruleHeader != NULL) { |
| this->ruleHeader = new OrConstraint(*(other.ruleHeader)); |
| } |
| if (other.fNext != NULL ) { |
| this->fNext = new RuleChain(*other.fNext); |
| } |
| } |
| |
| RuleChain::~RuleChain() { |
| delete fNext; |
| delete ruleHeader; |
| } |
| |
| |
| UnicodeString |
| RuleChain::select(const FixedDecimal &number) const { |
| if (!number.isNanOrInfinity) { |
| for (const RuleChain *rules = this; rules != NULL; rules = rules->fNext) { |
| if (rules->ruleHeader->isFulfilled(number)) { |
| return rules->fKeyword; |
| } |
| } |
| } |
| return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5); |
| } |
| |
| static UnicodeString tokenString(tokenType tok) { |
| UnicodeString s; |
| switch (tok) { |
| case tVariableN: |
| s.append(LOW_N); break; |
| case tVariableI: |
| s.append(LOW_I); break; |
| case tVariableF: |
| s.append(LOW_F); break; |
| case tVariableV: |
| s.append(LOW_V); break; |
| case tVariableT: |
| s.append(LOW_T); break; |
| default: |
| s.append(TILDE); |
| } |
| return s; |
| } |
| |
| void |
| RuleChain::dumpRules(UnicodeString& result) { |
| UChar digitString[16]; |
| |
| if ( ruleHeader != NULL ) { |
| result += fKeyword; |
| result += COLON; |
| result += SPACE; |
| OrConstraint* orRule=ruleHeader; |
| while ( orRule != NULL ) { |
| AndConstraint* andRule=orRule->childNode; |
| while ( andRule != NULL ) { |
| if ((andRule->op==AndConstraint::NONE) && (andRule->rangeList==NULL) && (andRule->value == -1)) { |
| // Empty Rules. |
| } else if ( (andRule->op==AndConstraint::NONE) && (andRule->rangeList==NULL) ) { |
| result += tokenString(andRule->digitsType); |
| result += UNICODE_STRING_SIMPLE(" is "); |
| if (andRule->negated) { |
| result += UNICODE_STRING_SIMPLE("not "); |
| } |
| uprv_itou(digitString,16, andRule->value,10,0); |
| result += UnicodeString(digitString); |
| } |
| else { |
| result += tokenString(andRule->digitsType); |
| result += SPACE; |
| if (andRule->op==AndConstraint::MOD) { |
| result += UNICODE_STRING_SIMPLE("mod "); |
| uprv_itou(digitString,16, andRule->opNum,10,0); |
| result += UnicodeString(digitString); |
| } |
| if (andRule->rangeList==NULL) { |
| if (andRule->negated) { |
| result += UNICODE_STRING_SIMPLE(" is not "); |
| uprv_itou(digitString,16, andRule->value,10,0); |
| result += UnicodeString(digitString); |
| } |
| else { |
| result += UNICODE_STRING_SIMPLE(" is "); |
| uprv_itou(digitString,16, andRule->value,10,0); |
| result += UnicodeString(digitString); |
| } |
| } |
| else { |
| if (andRule->negated) { |
| if ( andRule->integerOnly ) { |
| result += UNICODE_STRING_SIMPLE(" not in "); |
| } |
| else { |
| result += UNICODE_STRING_SIMPLE(" not within "); |
| } |
| } |
| else { |
| if ( andRule->integerOnly ) { |
| result += UNICODE_STRING_SIMPLE(" in "); |
| } |
| else { |
| result += UNICODE_STRING_SIMPLE(" within "); |
| } |
| } |
| for (int32_t r=0; r<andRule->rangeList->size(); r+=2) { |
| int32_t rangeLo = andRule->rangeList->elementAti(r); |
| int32_t rangeHi = andRule->rangeList->elementAti(r+1); |
| uprv_itou(digitString,16, rangeLo, 10, 0); |
| result += UnicodeString(digitString); |
| result += UNICODE_STRING_SIMPLE(".."); |
| uprv_itou(digitString,16, rangeHi, 10,0); |
| result += UnicodeString(digitString); |
| if (r+2 < andRule->rangeList->size()) { |
| result += UNICODE_STRING_SIMPLE(", "); |
| } |
| } |
| } |
| } |
| if ( (andRule=andRule->next) != NULL) { |
| result += UNICODE_STRING_SIMPLE(" and "); |
| } |
| } |
| if ( (orRule = orRule->next) != NULL ) { |
| result += UNICODE_STRING_SIMPLE(" or "); |
| } |
| } |
| } |
| if ( fNext != NULL ) { |
| result += UNICODE_STRING_SIMPLE("; "); |
| fNext->dumpRules(result); |
| } |
| } |
| |
| |
| UErrorCode |
| RuleChain::getKeywords(int32_t capacityOfKeywords, UnicodeString* keywords, int32_t& arraySize) const { |
| if ( arraySize < capacityOfKeywords-1 ) { |
| keywords[arraySize++]=fKeyword; |
| } |
| else { |
| return U_BUFFER_OVERFLOW_ERROR; |
| } |
| |
| if ( fNext != NULL ) { |
| return fNext->getKeywords(capacityOfKeywords, keywords, arraySize); |
| } |
| else { |
| return U_ZERO_ERROR; |
| } |
| } |
| |
| UBool |
| RuleChain::isKeyword(const UnicodeString& keywordParam) const { |
| if ( fKeyword == keywordParam ) { |
| return TRUE; |
| } |
| |
| if ( fNext != NULL ) { |
| return fNext->isKeyword(keywordParam); |
| } |
| else { |
| return FALSE; |
| } |
| } |
| |
| |
| PluralRuleParser::PluralRuleParser() : |
| ruleIndex(0), token(), type(none), prevType(none), |
| curAndConstraint(NULL), currentChain(NULL), rangeLowIdx(-1), rangeHiIdx(-1) |
| { |
| } |
| |
| PluralRuleParser::~PluralRuleParser() { |
| } |
| |
| |
| int32_t |
| PluralRuleParser::getNumberValue(const UnicodeString& token) { |
| int32_t i; |
| char digits[128]; |
| |
| i = token.extract(0, token.length(), digits, ARRAY_SIZE(digits), US_INV); |
| digits[i]='\0'; |
| |
| return((int32_t)atoi(digits)); |
| } |
| |
| |
| void |
| PluralRuleParser::checkSyntax(UErrorCode &status) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (!(prevType==none || prevType==tSemiColon)) { |
| type = getKeyType(token, type); // Switch token type from tKeyword if we scanned a reserved word, |
| // and we are not at the start of a rule, where a |
| // keyword is expected. |
| } |
| |
| switch(prevType) { |
| case none: |
| case tSemiColon: |
| if (type!=tKeyword && type != tEOF) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tVariableN: |
| case tVariableI: |
| case tVariableF: |
| case tVariableT: |
| case tVariableV: |
| if (type != tIs && type != tMod && type != tIn && |
| type != tNot && type != tWithin && type != tEqual && type != tNotEqual) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tKeyword: |
| if (type != tColon) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tColon: |
| if (!(type == tVariableN || |
| type == tVariableI || |
| type == tVariableF || |
| type == tVariableT || |
| type == tVariableV || |
| type == tAt)) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tIs: |
| if ( type != tNumber && type != tNot) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tNot: |
| if (type != tNumber && type != tIn && type != tWithin) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tMod: |
| case tDot2: |
| case tIn: |
| case tWithin: |
| case tEqual: |
| case tNotEqual: |
| if (type != tNumber) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tAnd: |
| case tOr: |
| if ( type != tVariableN && |
| type != tVariableI && |
| type != tVariableF && |
| type != tVariableT && |
| type != tVariableV) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tComma: |
| if (type != tNumber) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| case tNumber: |
| if (type != tDot2 && type != tSemiColon && type != tIs && type != tNot && |
| type != tIn && type != tEqual && type != tNotEqual && type != tWithin && |
| type != tAnd && type != tOr && type != tComma && type != tAt && |
| type != tEOF) |
| { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| // TODO: a comma following a number that is not part of a range will be allowed. |
| // It's not the only case of this sort of thing. Parser needs a re-write. |
| break; |
| case tAt: |
| if (type != tDecimal && type != tInteger) { |
| status = U_UNEXPECTED_TOKEN; |
| } |
| break; |
| default: |
| status = U_UNEXPECTED_TOKEN; |
| break; |
| } |
| } |
| |
| |
| /* |
| * Scan the next token from the input rules. |
| * rules and returned token type are in the parser state variables. |
| */ |
| void |
| PluralRuleParser::getNextToken(UErrorCode &status) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| UChar ch; |
| while (ruleIndex < ruleSrc->length()) { |
| ch = ruleSrc->charAt(ruleIndex); |
| type = charType(ch); |
| if (type != tSpace) { |
| break; |
| } |
| ++(ruleIndex); |
| } |
| if (ruleIndex >= ruleSrc->length()) { |
| type = tEOF; |
| return; |
| } |
| int32_t curIndex= ruleIndex; |
| |
| switch (type) { |
| case tColon: |
| case tSemiColon: |
| case tComma: |
| case tEllipsis: |
| case tTilde: // scanned '~' |
| case tAt: // scanned '@' |
| case tEqual: // scanned '=' |
| case tMod: // scanned '%' |
| // Single character tokens. |
| ++curIndex; |
| break; |
| |
| case tNotEqual: // scanned '!' |
| if (ruleSrc->charAt(curIndex+1) == EQUALS) { |
| curIndex += 2; |
| } else { |
| type = none; |
| curIndex += 1; |
| } |
| break; |
| |
| case tKeyword: |
| while (type == tKeyword && ++curIndex < ruleSrc->length()) { |
| ch = ruleSrc->charAt(curIndex); |
| type = charType(ch); |
| } |
| type = tKeyword; |
| break; |
| |
| case tNumber: |
| while (type == tNumber && ++curIndex < ruleSrc->length()) { |
| ch = ruleSrc->charAt(curIndex); |
| type = charType(ch); |
| } |
| type = tNumber; |
| break; |
| |
| case tDot: |
| // We could be looking at either ".." in a range, or "..." at the end of a sample. |
| if (curIndex+1 >= ruleSrc->length() || ruleSrc->charAt(curIndex+1) != DOT) { |
| ++curIndex; |
| break; // Single dot |
| } |
| if (curIndex+2 >= ruleSrc->length() || ruleSrc->charAt(curIndex+2) != DOT) { |
| curIndex += 2; |
| type = tDot2; |
| break; // double dot |
| } |
| type = tEllipsis; |
| curIndex += 3; |
| break; // triple dot |
| |
| default: |
| status = U_UNEXPECTED_TOKEN; |
| ++curIndex; |
| break; |
| } |
| |
| U_ASSERT(ruleIndex <= ruleSrc->length()); |
| U_ASSERT(curIndex <= ruleSrc->length()); |
| token=UnicodeString(*ruleSrc, ruleIndex, curIndex-ruleIndex); |
| ruleIndex = curIndex; |
| } |
| |
| tokenType |
| PluralRuleParser::charType(UChar ch) { |
| if ((ch>=U_ZERO) && (ch<=U_NINE)) { |
| return tNumber; |
| } |
| if (ch>=LOW_A && ch<=LOW_Z) { |
| return tKeyword; |
| } |
| switch (ch) { |
| case COLON: |
| return tColon; |
| case SPACE: |
| return tSpace; |
| case SEMI_COLON: |
| return tSemiColon; |
| case DOT: |
| return tDot; |
| case COMMA: |
| return tComma; |
| case EXCLAMATION: |
| return tNotEqual; |
| case EQUALS: |
| return tEqual; |
| case PERCENT_SIGN: |
| return tMod; |
| case AT: |
| return tAt; |
| case ELLIPSIS: |
| return tEllipsis; |
| case TILDE: |
| return tTilde; |
| default : |
| return none; |
| } |
| } |
| |
| |
| // Set token type for reserved words in the Plural Rule syntax. |
| |
| tokenType |
| PluralRuleParser::getKeyType(const UnicodeString &token, tokenType keyType) |
| { |
| if (keyType != tKeyword) { |
| return keyType; |
| } |
| |
| if (0 == token.compare(PK_VAR_N, 1)) { |
| keyType = tVariableN; |
| } else if (0 == token.compare(PK_VAR_I, 1)) { |
| keyType = tVariableI; |
| } else if (0 == token.compare(PK_VAR_F, 1)) { |
| keyType = tVariableF; |
| } else if (0 == token.compare(PK_VAR_T, 1)) { |
| keyType = tVariableT; |
| } else if (0 == token.compare(PK_VAR_V, 1)) { |
| keyType = tVariableV; |
| } else if (0 == token.compare(PK_IS, 2)) { |
| keyType = tIs; |
| } else if (0 == token.compare(PK_AND, 3)) { |
| keyType = tAnd; |
| } else if (0 == token.compare(PK_IN, 2)) { |
| keyType = tIn; |
| } else if (0 == token.compare(PK_WITHIN, 6)) { |
| keyType = tWithin; |
| } else if (0 == token.compare(PK_NOT, 3)) { |
| keyType = tNot; |
| } else if (0 == token.compare(PK_MOD, 3)) { |
| keyType = tMod; |
| } else if (0 == token.compare(PK_OR, 2)) { |
| keyType = tOr; |
| } else if (0 == token.compare(PK_DECIMAL, 7)) { |
| keyType = tDecimal; |
| } else if (0 == token.compare(PK_INTEGER, 7)) { |
| keyType = tInteger; |
| } |
| return keyType; |
| } |
| |
| |
| PluralKeywordEnumeration::PluralKeywordEnumeration(RuleChain *header, UErrorCode& status) |
| : pos(0), fKeywordNames(status) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fKeywordNames.setDeleter(uprv_deleteUObject); |
| UBool addKeywordOther=TRUE; |
| RuleChain *node=header; |
| while(node!=NULL) { |
| fKeywordNames.addElement(new UnicodeString(node->fKeyword), status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (0 == node->fKeyword.compare(PLURAL_KEYWORD_OTHER, 5)) { |
| addKeywordOther= FALSE; |
| } |
| node=node->fNext; |
| } |
| |
| if (addKeywordOther) { |
| fKeywordNames.addElement(new UnicodeString(PLURAL_KEYWORD_OTHER), status); |
| } |
| } |
| |
| const UnicodeString* |
| PluralKeywordEnumeration::snext(UErrorCode& status) { |
| if (U_SUCCESS(status) && pos < fKeywordNames.size()) { |
| return (const UnicodeString*)fKeywordNames.elementAt(pos++); |
| } |
| return NULL; |
| } |
| |
| void |
| PluralKeywordEnumeration::reset(UErrorCode& /*status*/) { |
| pos=0; |
| } |
| |
| int32_t |
| PluralKeywordEnumeration::count(UErrorCode& /*status*/) const { |
| return fKeywordNames.size(); |
| } |
| |
| PluralKeywordEnumeration::~PluralKeywordEnumeration() { |
| } |
| |
| FixedDecimal::FixedDecimal(const VisibleDigits &digits) { |
| digits.getFixedDecimal( |
| source, intValue, decimalDigits, |
| decimalDigitsWithoutTrailingZeros, |
| visibleDecimalDigitCount, hasIntegerValue); |
| isNegative = digits.isNegative(); |
| isNanOrInfinity = digits.isNaNOrInfinity(); |
| } |
| |
| FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f) { |
| init(n, v, f); |
| // check values. TODO make into unit test. |
| // |
| // long visiblePower = (int) Math.pow(10, v); |
| // if (decimalDigits > visiblePower) { |
| // throw new IllegalArgumentException(); |
| // } |
| // double fraction = intValue + (decimalDigits / (double) visiblePower); |
| // if (fraction != source) { |
| // double diff = Math.abs(fraction - source)/(Math.abs(fraction) + Math.abs(source)); |
| // if (diff > 0.00000001d) { |
| // throw new IllegalArgumentException(); |
| // } |
| // } |
| } |
| |
| FixedDecimal::FixedDecimal(double n, int32_t v) { |
| // Ugly, but for samples we don't care. |
| init(n, v, getFractionalDigits(n, v)); |
| } |
| |
| FixedDecimal::FixedDecimal(double n) { |
| init(n); |
| } |
| |
| FixedDecimal::FixedDecimal() { |
| init(0, 0, 0); |
| } |
| |
| |
| // Create a FixedDecimal from a UnicodeString containing a number. |
| // Inefficient, but only used for samples, so simplicity trumps efficiency. |
| |
| FixedDecimal::FixedDecimal(const UnicodeString &num, UErrorCode &status) { |
| CharString cs; |
| cs.appendInvariantChars(num, status); |
| DigitList dl; |
| dl.set(cs.toStringPiece(), status); |
| if (U_FAILURE(status)) { |
| init(0, 0, 0); |
| return; |
| } |
| int32_t decimalPoint = num.indexOf(DOT); |
| double n = dl.getDouble(); |
| if (decimalPoint == -1) { |
| init(n, 0, 0); |
| } else { |
| int32_t v = num.length() - decimalPoint - 1; |
| init(n, v, getFractionalDigits(n, v)); |
| } |
| } |
| |
| |
| FixedDecimal::FixedDecimal(const FixedDecimal &other) { |
| source = other.source; |
| visibleDecimalDigitCount = other.visibleDecimalDigitCount; |
| decimalDigits = other.decimalDigits; |
| decimalDigitsWithoutTrailingZeros = other.decimalDigitsWithoutTrailingZeros; |
| intValue = other.intValue; |
| hasIntegerValue = other.hasIntegerValue; |
| isNegative = other.isNegative; |
| isNanOrInfinity = other.isNanOrInfinity; |
| } |
| |
| |
| void FixedDecimal::init(double n) { |
| int32_t numFractionDigits = decimals(n); |
| init(n, numFractionDigits, getFractionalDigits(n, numFractionDigits)); |
| } |
| |
| |
| void FixedDecimal::init(double n, int32_t v, int64_t f) { |
| isNegative = n < 0.0; |
| source = fabs(n); |
| isNanOrInfinity = uprv_isNaN(source) || uprv_isPositiveInfinity(source); |
| if (isNanOrInfinity) { |
| v = 0; |
| f = 0; |
| intValue = 0; |
| hasIntegerValue = FALSE; |
| } else { |
| intValue = (int64_t)source; |
| hasIntegerValue = (source == intValue); |
| } |
| |
| visibleDecimalDigitCount = v; |
| decimalDigits = f; |
| if (f == 0) { |
| decimalDigitsWithoutTrailingZeros = 0; |
| } else { |
| int64_t fdwtz = f; |
| while ((fdwtz%10) == 0) { |
| fdwtz /= 10; |
| } |
| decimalDigitsWithoutTrailingZeros = fdwtz; |
| } |
| } |
| |
| |
| // Fast path only exact initialization. Return true if successful. |
| // Note: Do not multiply by 10 each time through loop, rounding cruft can build |
| // up that makes the check for an integer result fail. |
| // A single multiply of the original number works more reliably. |
| static int32_t p10[] = {1, 10, 100, 1000, 10000}; |
| UBool FixedDecimal::quickInit(double n) { |
| UBool success = FALSE; |
| n = fabs(n); |
| int32_t numFractionDigits; |
| for (numFractionDigits = 0; numFractionDigits <= 3; numFractionDigits++) { |
| double scaledN = n * p10[numFractionDigits]; |
| if (scaledN == floor(scaledN)) { |
| success = TRUE; |
| break; |
| } |
| } |
| if (success) { |
| init(n, numFractionDigits, getFractionalDigits(n, numFractionDigits)); |
| } |
| return success; |
| } |
| |
| |
| |
| int32_t FixedDecimal::decimals(double n) { |
| // Count the number of decimal digits in the fraction part of the number, excluding trailing zeros. |
| // fastpath the common cases, integers or fractions with 3 or fewer digits |
| n = fabs(n); |
| for (int ndigits=0; ndigits<=3; ndigits++) { |
| double scaledN = n * p10[ndigits]; |
| if (scaledN == floor(scaledN)) { |
| return ndigits; |
| } |
| } |
| |
| // Slow path, convert with sprintf, parse converted output. |
| char buf[30] = {0}; |
| sprintf(buf, "%1.15e", n); |
| // formatted number looks like this: 1.234567890123457e-01 |
| int exponent = atoi(buf+18); |
| int numFractionDigits = 15; |
| for (int i=16; ; --i) { |
| if (buf[i] != '0') { |
| break; |
| } |
| --numFractionDigits; |
| } |
| numFractionDigits -= exponent; // Fraction part of fixed point representation. |
| return numFractionDigits; |
| } |
| |
| |
| // Get the fraction digits of a double, represented as an integer. |
| // v is the number of visible fraction digits in the displayed form of the number. |
| // Example: n = 1001.234, v = 6, result = 234000 |
| // TODO: need to think through how this is used in the plural rule context. |
| // This function can easily encounter integer overflow, |
| // and can easily return noise digits when the precision of a double is exceeded. |
| |
| int64_t FixedDecimal::getFractionalDigits(double n, int32_t v) { |
| if (v == 0 || n == floor(n) || uprv_isNaN(n) || uprv_isPositiveInfinity(n)) { |
| return 0; |
| } |
| n = fabs(n); |
| double fract = n - floor(n); |
| switch (v) { |
| case 1: return (int64_t)(fract*10.0 + 0.5); |
| case 2: return (int64_t)(fract*100.0 + 0.5); |
| case 3: return (int64_t)(fract*1000.0 + 0.5); |
| default: |
| double scaled = floor(fract * pow(10.0, (double)v) + 0.5); |
| if (scaled > U_INT64_MAX) { |
| return U_INT64_MAX; |
| } else { |
| return (int64_t)scaled; |
| } |
| } |
| } |
| |
| |
| void FixedDecimal::adjustForMinFractionDigits(int32_t minFractionDigits) { |
| int32_t numTrailingFractionZeros = minFractionDigits - visibleDecimalDigitCount; |
| if (numTrailingFractionZeros > 0) { |
| for (int32_t i=0; i<numTrailingFractionZeros; i++) { |
| // Do not let the decimalDigits value overflow if there are many trailing zeros. |
| // Limit the value to 18 digits, the most that a 64 bit int can fully represent. |
| if (decimalDigits >= 100000000000000000LL) { |
| break; |
| } |
| decimalDigits *= 10; |
| } |
| visibleDecimalDigitCount += numTrailingFractionZeros; |
| } |
| } |
| |
| |
| double FixedDecimal::get(tokenType operand) const { |
| switch(operand) { |
| case tVariableN: return source; |
| case tVariableI: return (double)intValue; |
| case tVariableF: return (double)decimalDigits; |
| case tVariableT: return (double)decimalDigitsWithoutTrailingZeros; |
| case tVariableV: return visibleDecimalDigitCount; |
| default: |
| U_ASSERT(FALSE); // unexpected. |
| return source; |
| } |
| } |
| |
| int32_t FixedDecimal::getVisibleFractionDigitCount() const { |
| return visibleDecimalDigitCount; |
| } |
| |
| |
| |
| PluralAvailableLocalesEnumeration::PluralAvailableLocalesEnumeration(UErrorCode &status) { |
| fLocales = NULL; |
| fRes = NULL; |
| fOpenStatus = status; |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fOpenStatus = U_ZERO_ERROR; |
| LocalUResourceBundlePointer rb(ures_openDirect(NULL, "plurals", &fOpenStatus)); |
| fLocales = ures_getByKey(rb.getAlias(), "locales", NULL, &fOpenStatus); |
| } |
| |
| PluralAvailableLocalesEnumeration::~PluralAvailableLocalesEnumeration() { |
| ures_close(fLocales); |
| ures_close(fRes); |
| fLocales = NULL; |
| fRes = NULL; |
| } |
| |
| const char *PluralAvailableLocalesEnumeration::next(int32_t *resultLength, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| if (U_FAILURE(fOpenStatus)) { |
| status = fOpenStatus; |
| return NULL; |
| } |
| fRes = ures_getNextResource(fLocales, fRes, &status); |
| if (fRes == NULL || U_FAILURE(status)) { |
| if (status == U_INDEX_OUTOFBOUNDS_ERROR) { |
| status = U_ZERO_ERROR; |
| } |
| return NULL; |
| } |
| const char *result = ures_getKey(fRes); |
| if (resultLength != NULL) { |
| *resultLength = uprv_strlen(result); |
| } |
| return result; |
| } |
| |
| |
| void PluralAvailableLocalesEnumeration::reset(UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (U_FAILURE(fOpenStatus)) { |
| status = fOpenStatus; |
| return; |
| } |
| ures_resetIterator(fLocales); |
| } |
| |
| int32_t PluralAvailableLocalesEnumeration::count(UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return 0; |
| } |
| if (U_FAILURE(fOpenStatus)) { |
| status = fOpenStatus; |
| return 0; |
| } |
| return ures_getSize(fLocales); |
| } |
| |
| U_NAMESPACE_END |
| |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
| |
| //eof |
