1660 lines
49 KiB
C++
1660 lines
49 KiB
C++
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2007-2014, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
*******************************************************************************
|
|
*
|
|
* File plurrule.cpp
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/localpointer.h"
|
|
#include "unicode/plurrule.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"
|
|
|
|
#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);
|
|
}
|
|
}
|
|
|
|
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(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
|