icuSources/i18n/plurrule.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2014, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 *
   7 * File plurrule.cpp
   8 */
   9
  10 #include <math.h>
  11 #include <stdio.h>
  12
  13 #include "unicode/utypes.h"
  14 #include "unicode/localpointer.h"
  15 #include "unicode/plurrule.h"
  16 #include "unicode/upluralrules.h"
  17 #include "unicode/ures.h"
  18 #include "charstr.h"
  19 #include "cmemory.h"
  20 #include "cstring.h"
  21 #include "digitlst.h"
  22 #include "hash.h"
  23 #include "locutil.h"
  24 #include "mutex.h"
  25 #include "patternprops.h"
  26 #include "plurrule_impl.h"
  27 #include "putilimp.h"
  28 #include "ucln_in.h"
  29 #include "ustrfmt.h"
  30 #include "uassert.h"
  31 #include "uvectr32.h"
  32 #include "sharedpluralrules.h"
  33 #include "lrucache.h"
  34
  35 #if !UCONFIG_NO_FORMATTING
  36
  37 static icu::LRUCache *gPluralRulesCache = NULL;
  38 static UMutex gPluralRulesCacheMutex = U_MUTEX_INITIALIZER;
  39 static icu::UInitOnce gPluralRulesCacheInitOnce = U_INITONCE_INITIALIZER;
  40
  41 U_CDECL_BEGIN
  42 static UBool U_CALLCONV plurrules_cleanup(void) {
  43     gPluralRulesCacheInitOnce.reset();
  44     if (gPluralRulesCache) {
  45         delete gPluralRulesCache;
  46         gPluralRulesCache = NULL;
  47     }
  48     return TRUE;
  49 }
  50 U_CDECL_END
  51
  52 U_NAMESPACE_BEGIN
  53
  54 #define ARRAY_SIZE(array) (int32_t)(sizeof array  / sizeof array[0])
  55
  56 static const UChar PLURAL_KEYWORD_OTHER[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,0};
  57 static const UChar PLURAL_DEFAULT_RULE[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,COLON,SPACE,LOW_N,0};
  58 static const UChar PK_IN[]={LOW_I,LOW_N,0};
  59 static const UChar PK_NOT[]={LOW_N,LOW_O,LOW_T,0};
  60 static const UChar PK_IS[]={LOW_I,LOW_S,0};
  61 static const UChar PK_MOD[]={LOW_M,LOW_O,LOW_D,0};
  62 static const UChar PK_AND[]={LOW_A,LOW_N,LOW_D,0};
  63 static const UChar PK_OR[]={LOW_O,LOW_R,0};
  64 static const UChar PK_VAR_N[]={LOW_N,0};
  65 static const UChar PK_VAR_I[]={LOW_I,0};
  66 static const UChar PK_VAR_F[]={LOW_F,0};
  67 static const UChar PK_VAR_T[]={LOW_T,0};
  68 static const UChar PK_VAR_V[]={LOW_V,0};
  69 static const UChar PK_WITHIN[]={LOW_W,LOW_I,LOW_T,LOW_H,LOW_I,LOW_N,0};
  70 static const UChar PK_DECIMAL[]={LOW_D,LOW_E,LOW_C,LOW_I,LOW_M,LOW_A,LOW_L,0};
  71 static const UChar PK_INTEGER[]={LOW_I,LOW_N,LOW_T,LOW_E,LOW_G,LOW_E,LOW_R,0};
  72
  73 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralRules)
  74 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralKeywordEnumeration)
  75
  76 PluralRules::PluralRules(UErrorCode& /*status*/)
  77 :   UObject(),
  78     mRules(NULL)
  79 {
  80 }
  81
  82 PluralRules::PluralRules(const PluralRules& other)
  83 : UObject(other),
  84     mRules(NULL)
  85 {
  86     *this=other;
  87 }
  88
  89 PluralRules::~PluralRules() {
  90     delete mRules;
  91 }
  92
  93 SharedPluralRules::~SharedPluralRules() {
  94     delete ptr;
  95 }
  96
  97 PluralRules*
  98 PluralRules::clone() const {
  99     return new PluralRules(*this);
 100 }
 101
 102 PluralRules&
 103 PluralRules::operator=(const PluralRules& other) {
 104     if (this != &other) {
 105         delete mRules;
 106         if (other.mRules==NULL) {
 107             mRules = NULL;
 108         }
 109         else {
 110             mRules = new RuleChain(*other.mRules);
 111         }
 112     }
 113
 114     return *this;
 115 }
 116
 117 StringEnumeration* PluralRules::getAvailableLocales(UErrorCode &status) {
 118     StringEnumeration *result = new PluralAvailableLocalesEnumeration(status);
 119     if (result == NULL && U_SUCCESS(status)) {
 120         status = U_MEMORY_ALLOCATION_ERROR;
 121     }
 122     if (U_FAILURE(status)) {
 123         delete result;
 124         result = NULL;
 125     }
 126     return result;
 127 }
 128
 129
 130 PluralRules* U_EXPORT2
 131 PluralRules::createRules(const UnicodeString& description, UErrorCode& status) {
 132     if (U_FAILURE(status)) {
 133         return NULL;
 134     }
 135
 136     PluralRuleParser parser;
 137     PluralRules *newRules = new PluralRules(status);
 138     if (U_SUCCESS(status) && newRules == NULL) {
 139         status = U_MEMORY_ALLOCATION_ERROR;
 140     }
 141     parser.parse(description, newRules, status);
 142     if (U_FAILURE(status)) {
 143         delete newRules;
 144         newRules = NULL;
 145     }
 146     return newRules;
 147 }
 148
 149
 150 PluralRules* U_EXPORT2
 151 PluralRules::createDefaultRules(UErrorCode& status) {
 152     return createRules(UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1), status);
 153 }
 154
 155 /******************************************************************************/
 156 /* Create PluralRules cache */
 157
 158 static SharedObject *U_CALLCONV createSharedPluralRules(
 159         const char *localeId, UErrorCode &status) {
 160     if (U_FAILURE(status)) {
 161         return NULL;
 162     }
 163     PluralRules *pr = PluralRules::internalForLocale(
 164             localeId, UPLURAL_TYPE_CARDINAL, status);
 165     if (U_FAILURE(status)) {
 166         return NULL;
 167     }
 168     SharedObject *result = new SharedPluralRules(pr);
 169     if (result == NULL) {
 170         status = U_MEMORY_ALLOCATION_ERROR;
 171         delete pr;
 172         return NULL;
 173     }
 174     return result;
 175 }
 176
 177 static void U_CALLCONV pluralRulesCacheInit(UErrorCode &status) {
 178     U_ASSERT(gPluralRulesCache == NULL);
 179     ucln_i18n_registerCleanup(UCLN_I18N_PLURAL_RULE, plurrules_cleanup);
 180     gPluralRulesCache = new SimpleLRUCache(100, &createSharedPluralRules, status);
 181     if (U_FAILURE(status)) {
 182         delete gPluralRulesCache;
 183         gPluralRulesCache = NULL;
 184     }
 185 }
 186
 187 static void getSharedPluralRulesFromCache(
 188         const char *locale,
 189         const SharedPluralRules *&ptr,
 190         UErrorCode &status) {
 191     umtx_initOnce(gPluralRulesCacheInitOnce, &pluralRulesCacheInit, status);
 192     if (U_FAILURE(status)) {
 193         return;
 194     }
 195     Mutex lock(&gPluralRulesCacheMutex);
 196     gPluralRulesCache->get(locale, ptr, status);
 197 }
 198
 199
 200
 201
 202 /* end plural rules cache */
 203 /******************************************************************************/
 204
 205 const SharedPluralRules* U_EXPORT2
 206 PluralRules::createSharedInstance(
 207         const Locale& locale, UPluralType type, UErrorCode& status) {
 208     if (U_FAILURE(status)) {
 209         return NULL;
 210     }
 211     if (type != UPLURAL_TYPE_CARDINAL) {
 212         status = U_UNSUPPORTED_ERROR;
 213         return NULL;
 214     }
 215     const SharedPluralRules *result = NULL;
 216     getSharedPluralRulesFromCache(locale.getName(), result, status);
 217     return result;
 218 }
 219
 220 PluralRules* U_EXPORT2
 221 PluralRules::forLocale(const Locale& locale, UErrorCode& status) {
 222     return forLocale(locale, UPLURAL_TYPE_CARDINAL, status);
 223 }
 224
 225 PluralRules* U_EXPORT2
 226 PluralRules::forLocale(const Locale& locale, UPluralType type, UErrorCode& status) {
 227     if (type != UPLURAL_TYPE_CARDINAL) {
 228         return internalForLocale(locale, type, status);
 229     }
 230     const SharedPluralRules *shared = createSharedInstance(
 231             locale, type, status);
 232     if (U_FAILURE(status)) {
 233         return NULL;
 234     }
 235     PluralRules *result = (*shared)->clone();
 236     shared->removeRef();
 237     if (result == NULL) {
 238         status = U_MEMORY_ALLOCATION_ERROR;
 239     }
 240     return result;
 241 }
 242
 243 PluralRules* U_EXPORT2
 244 PluralRules::internalForLocale(const Locale& locale, UPluralType type, UErrorCode& status) {
 245     if (U_FAILURE(status)) {
 246         return NULL;
 247     }
 248     if (type >= UPLURAL_TYPE_COUNT) {
 249         status = U_ILLEGAL_ARGUMENT_ERROR;
 250         return NULL;
 251     }
 252     PluralRules *newObj = new PluralRules(status);
 253     if (newObj==NULL || U_FAILURE(status)) {
 254         delete newObj;
 255         return NULL;
 256     }
 257     UnicodeString locRule = newObj->getRuleFromResource(locale, type, status);
 258     // TODO: which errors, if any, should be returned?
 259     if (locRule.length() == 0) {
 260         // Locales with no specific rules (all numbers have the "other" category
 261         //   will return a U_MISSING_RESOURCE_ERROR at this point. This is not
 262         //   an error.
 263         locRule =  UnicodeString(PLURAL_DEFAULT_RULE);
 264         status = U_ZERO_ERROR;
 265     }
 266     PluralRuleParser parser;
 267     parser.parse(locRule, newObj, status);
 268         //  TODO: should rule parse errors be returned, or
 269         //        should we silently use default rules?
 270         //        Original impl used default rules.
 271         //        Ask the question to ICU Core.
 272
 273     return newObj;
 274 }
 275
 276 UnicodeString
 277 PluralRules::select(int32_t number) const {
 278     return select(FixedDecimal(number));
 279 }
 280
 281 UnicodeString
 282 PluralRules::select(double number) const {
 283     return select(FixedDecimal(number));
 284 }
 285
 286 UnicodeString
 287 PluralRules::select(const FixedDecimal &number) const {
 288     if (mRules == NULL) {
 289         return UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1);
 290     }
 291     else {
 292         return mRules->select(number);
 293     }
 294 }
 295
 296 StringEnumeration*
 297 PluralRules::getKeywords(UErrorCode& status) const {
 298     if (U_FAILURE(status))  return NULL;
 299     StringEnumeration* nameEnumerator = new PluralKeywordEnumeration(mRules, status);
 300     if (U_FAILURE(status)) {
 301       delete nameEnumerator;
 302       return NULL;
 303     }
 304
 305     return nameEnumerator;
 306 }
 307
 308 double
 309 PluralRules::getUniqueKeywordValue(const UnicodeString& /* keyword */) {
 310   // Not Implemented.
 311   return UPLRULES_NO_UNIQUE_VALUE;
 312 }
 313
 314 int32_t
 315 PluralRules::getAllKeywordValues(const UnicodeString & /* keyword */, double * /* dest */,
 316                                  int32_t /* destCapacity */, UErrorCode& error) {
 317     error = U_UNSUPPORTED_ERROR;
 318     return 0;
 319 }
 320
 321
 322 static double scaleForInt(double d) {
 323     double scale = 1.0;
 324     while (d != floor(d)) {
 325         d = d * 10.0;
 326         scale = scale * 10.0;
 327     }
 328     return scale;
 329 }
 330
 331 static int32_t
 332 getSamplesFromString(const UnicodeString &samples, double *dest,
 333                         int32_t destCapacity, UErrorCode& status) {
 334     int32_t sampleCount = 0;
 335     int32_t sampleStartIdx = 0;
 336     int32_t sampleEndIdx = 0;
 337
 338     //std::string ss;  // TODO: debugging.
 339     // std::cout << "PluralRules::getSamples(), samples = \"" << samples.toUTF8String(ss) << "\"\n";
 340     for (sampleCount = 0; sampleCount < destCapacity && sampleStartIdx < samples.length(); ) {
 341         sampleEndIdx = samples.indexOf(COMMA, sampleStartIdx);
 342         if (sampleEndIdx == -1) {
 343             sampleEndIdx = samples.length();
 344         }
 345         const UnicodeString &sampleRange = samples.tempSubStringBetween(sampleStartIdx, sampleEndIdx);
 346         // ss.erase();
 347         // std::cout << "PluralRules::getSamples(), samplesRange = \"" << sampleRange.toUTF8String(ss) << "\"\n";
 348         int32_t tildeIndex = sampleRange.indexOf(TILDE);
 349         if (tildeIndex < 0) {
 350             FixedDecimal fixed(sampleRange, status);
 351             double sampleValue = fixed.source;
 352             if (fixed.visibleDecimalDigitCount == 0 || sampleValue != floor(sampleValue)) {
 353                 dest[sampleCount++] = sampleValue;
 354             }
 355         } else {
 356
 357             FixedDecimal fixedLo(sampleRange.tempSubStringBetween(0, tildeIndex), status);
 358             FixedDecimal fixedHi(sampleRange.tempSubStringBetween(tildeIndex+1), status);
 359             double rangeLo = fixedLo.source;
 360             double rangeHi = fixedHi.source;
 361             if (U_FAILURE(status)) {
 362                 break;
 363             }
 364             if (rangeHi < rangeLo) {
 365                 status = U_INVALID_FORMAT_ERROR;
 366                 break;
 367             }
 368
 369             // For ranges of samples with fraction decimal digits, scale the number up so that we
 370             //   are adding one in the units place. Avoids roundoffs from repetitive adds of tenths.
 371
 372             double scale = scaleForInt(rangeLo);
 373             double t = scaleForInt(rangeHi);
 374             if (t > scale) {
 375                 scale = t;
 376             }
 377             rangeLo *= scale;
 378             rangeHi *= scale;
 379             for (double n=rangeLo; n<=rangeHi; n+=1) {
 380                 // Hack Alert: don't return any decimal samples with integer values that
 381                 //    originated from a format with trailing decimals.
 382                 //    This API is returning doubles, which can't distinguish having displayed
 383                 //    zeros to the right of the decimal.
 384                 //    This results in test failures with values mapping back to a different keyword.
 385                 double sampleValue = n/scale;
 386                 if (!(sampleValue == floor(sampleValue) && fixedLo.visibleDecimalDigitCount > 0)) {
 387                     dest[sampleCount++] = sampleValue;
 388                 }
 389                 if (sampleCount >= destCapacity) {
 390                     break;
 391                 }
 392             }
 393         }
 394         sampleStartIdx = sampleEndIdx + 1;
 395     }
 396     return sampleCount;
 397 }
 398
 399
 400 int32_t
 401 PluralRules::getSamples(const UnicodeString &keyword, double *dest,
 402                         int32_t destCapacity, UErrorCode& status) {
 403     RuleChain *rc = rulesForKeyword(keyword);
 404     if (rc == NULL || destCapacity == 0 || U_FAILURE(status)) {
 405         return 0;
 406     }
 407     int32_t numSamples = getSamplesFromString(rc->fIntegerSamples, dest, destCapacity, status);
 408     if (numSamples == 0) {
 409         numSamples = getSamplesFromString(rc->fDecimalSamples, dest, destCapacity, status);
 410     }
 411     return numSamples;
 412 }
 413
 414
 415 RuleChain *PluralRules::rulesForKeyword(const UnicodeString &keyword) const {
 416     RuleChain *rc;
 417     for (rc = mRules; rc != NULL; rc = rc->fNext) {
 418         if (rc->fKeyword == keyword) {
 419             break;
 420         }
 421     }
 422     return rc;
 423 }
 424
 425
 426 UBool
 427 PluralRules::isKeyword(const UnicodeString& keyword) const {
 428     if (0 == keyword.compare(PLURAL_KEYWORD_OTHER, 5)) {
 429         return true;
 430     }
 431     return rulesForKeyword(keyword) != NULL;
 432 }
 433
 434 UnicodeString
 435 PluralRules::getKeywordOther() const {
 436     return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5);
 437 }
 438
 439 UBool
 440 PluralRules::operator==(const PluralRules& other) const  {
 441     const UnicodeString *ptrKeyword;
 442     UErrorCode status= U_ZERO_ERROR;
 443
 444     if ( this == &other ) {
 445         return TRUE;
 446     }
 447     LocalPointer<StringEnumeration> myKeywordList(getKeywords(status));
 448     LocalPointer<StringEnumeration> otherKeywordList(other.getKeywords(status));
 449     if (U_FAILURE(status)) {
 450         return FALSE;
 451     }
 452
 453     if (myKeywordList->count(status)!=otherKeywordList->count(status)) {
 454         return FALSE;
 455     }
 456     myKeywordList->reset(status);
 457     while ((ptrKeyword=myKeywordList->snext(status))!=NULL) {
 458         if (!other.isKeyword(*ptrKeyword)) {
 459             return FALSE;
 460         }
 461     }
 462     otherKeywordList->reset(status);
 463     while ((ptrKeyword=otherKeywordList->snext(status))!=NULL) {
 464         if (!this->isKeyword(*ptrKeyword)) {
 465             return FALSE;
 466         }
 467     }
 468     if (U_FAILURE(status)) {
 469         return FALSE;
 470     }
 471
 472     return TRUE;
 473 }
 474
 475
 476 void
 477 PluralRuleParser::parse(const UnicodeString& ruleData, PluralRules *prules, UErrorCode &status)
 478 {
 479     if (U_FAILURE(status)) {
 480         return;
 481     }
 482     U_ASSERT(ruleIndex == 0);    // Parsers are good for a single use only!
 483     ruleSrc = &ruleData;
 484
 485     while (ruleIndex< ruleSrc->length()) {
 486         getNextToken(status);
 487         if (U_FAILURE(status)) {
 488             return;
 489         }
 490         checkSyntax(status);
 491         if (U_FAILURE(status)) {
 492             return;
 493         }
 494         switch (type) {
 495         case tAnd:
 496             U_ASSERT(curAndConstraint != NULL);
 497             curAndConstraint = curAndConstraint->add();
 498             break;
 499         case tOr:
 500             {
 501                 U_ASSERT(currentChain != NULL);
 502                 OrConstraint *orNode=currentChain->ruleHeader;
 503                 while (orNode->next != NULL) {
 504                     orNode = orNode->next;
 505                 }
 506                 orNode->next= new OrConstraint();
 507                 orNode=orNode->next;
 508                 orNode->next=NULL;
 509                 curAndConstraint = orNode->add();
 510             }
 511             break;
 512         case tIs:
 513             U_ASSERT(curAndConstraint != NULL);
 514             U_ASSERT(curAndConstraint->value == -1);
 515             U_ASSERT(curAndConstraint->rangeList == NULL);
 516             break;
 517         case tNot:
 518             U_ASSERT(curAndConstraint != NULL);
 519             curAndConstraint->negated=TRUE;
 520             break;
 521
 522         case tNotEqual:
 523             curAndConstraint->negated=TRUE;
 524         case tIn:
 525         case tWithin:
 526         case tEqual:
 527             U_ASSERT(curAndConstraint != NULL);
 528             curAndConstraint->rangeList = new UVector32(status);
 529             curAndConstraint->rangeList->addElement(-1, status);  // range Low
 530             curAndConstraint->rangeList->addElement(-1, status);  // range Hi
 531             rangeLowIdx = 0;
 532             rangeHiIdx  = 1;
 533             curAndConstraint->value=PLURAL_RANGE_HIGH;
 534             curAndConstraint->integerOnly = (type != tWithin);
 535             break;
 536         case tNumber:
 537             U_ASSERT(curAndConstraint != NULL);
 538             if ( (curAndConstraint->op==AndConstraint::MOD)&&
 539                  (curAndConstraint->opNum == -1 ) ) {
 540                 curAndConstraint->opNum=getNumberValue(token);
 541             }
 542             else {
 543                 if (curAndConstraint->rangeList == NULL) {
 544                     // this is for an 'is' rule
 545                     curAndConstraint->value = getNumberValue(token);
 546                 } else {
 547                     // this is for an 'in' or 'within' rule
 548                     if (curAndConstraint->rangeList->elementAti(rangeLowIdx) == -1) {
 549                         curAndConstraint->rangeList->setElementAt(getNumberValue(token), rangeLowIdx);
 550                         curAndConstraint->rangeList->setElementAt(getNumberValue(token), rangeHiIdx);
 551                     }
 552                     else {
 553                         curAndConstraint->rangeList->setElementAt(getNumberValue(token), rangeHiIdx);
 554                         if (curAndConstraint->rangeList->elementAti(rangeLowIdx) >
 555                                 curAndConstraint->rangeList->elementAti(rangeHiIdx)) {
 556                             // Range Lower bound > Range Upper bound.
 557                             // U_UNEXPECTED_TOKEN seems a little funny, but it is consistently
 558                             // used for all plural rule parse errors.
 559                             status = U_UNEXPECTED_TOKEN;
 560                             break;
 561                         }
 562                     }
 563                 }
 564             }
 565             break;
 566         case tComma:
 567             // TODO: rule syntax checking is inadequate, can happen with badly formed rules.
 568             //       Catch cases like "n mod 10, is 1" here instead.
 569             if (curAndConstraint == NULL || curAndConstraint->rangeList == NULL) {
 570                 status = U_UNEXPECTED_TOKEN;
 571                 break;
 572             }
 573             U_ASSERT(curAndConstraint->rangeList->size() >= 2);
 574             rangeLowIdx = curAndConstraint->rangeList->size();
 575             curAndConstraint->rangeList->addElement(-1, status);  // range Low
 576             rangeHiIdx = curAndConstraint->rangeList->size();
 577             curAndConstraint->rangeList->addElement(-1, status);  // range Hi
 578             break;
 579         case tMod:
 580             U_ASSERT(curAndConstraint != NULL);
 581             curAndConstraint->op=AndConstraint::MOD;
 582             break;
 583         case tVariableN:
 584         case tVariableI:
 585         case tVariableF:
 586         case tVariableT:
 587         case tVariableV:
 588             U_ASSERT(curAndConstraint != NULL);
 589             curAndConstraint->digitsType = type;
 590             break;
 591         case tKeyword:
 592             {
 593             RuleChain *newChain = new RuleChain;
 594             if (newChain == NULL) {
 595                 status = U_MEMORY_ALLOCATION_ERROR;
 596                 break;
 597             }
 598             newChain->fKeyword = token;
 599             if (prules->mRules == NULL) {
 600                 prules->mRules = newChain;
 601             } else {
 602                 // The new rule chain goes at the end of the linked list of rule chains,
 603                 //   unless there is an "other" keyword & chain. "other" must remain last.
 604                 RuleChain *insertAfter = prules->mRules;
 605                 while (insertAfter->fNext!=NULL &&
 606                        insertAfter->fNext->fKeyword.compare(PLURAL_KEYWORD_OTHER, 5) != 0 ){
 607                     insertAfter=insertAfter->fNext;
 608                 }
 609                 newChain->fNext = insertAfter->fNext;
 610                 insertAfter->fNext = newChain;
 611             }
 612             OrConstraint *orNode = new OrConstraint();
 613             newChain->ruleHeader = orNode;
 614             curAndConstraint = orNode->add();
 615             currentChain = newChain;
 616             }
 617             break;
 618
 619         case tInteger:
 620             for (;;) {
 621                 getNextToken(status);
 622                 if (U_FAILURE(status) || type == tSemiColon || type == tEOF || type == tAt) {
 623                     break;
 624                 }
 625                 if (type == tEllipsis) {
 626                     currentChain->fIntegerSamplesUnbounded = TRUE;
 627                     continue;
 628                 }
 629                 currentChain->fIntegerSamples.append(token);
 630             }
 631             break;
 632
 633         case tDecimal:
 634             for (;;) {
 635                 getNextToken(status);
 636                 if (U_FAILURE(status) || type == tSemiColon || type == tEOF || type == tAt) {
 637                     break;
 638                 }
 639                 if (type == tEllipsis) {
 640                     currentChain->fDecimalSamplesUnbounded = TRUE;
 641                     continue;
 642                 }
 643                 currentChain->fDecimalSamples.append(token);
 644             }
 645             break;
 646
 647         default:
 648             break;
 649         }
 650         prevType=type;
 651         if (U_FAILURE(status)) {
 652             break;
 653         }
 654     }
 655 }
 656
 657 UnicodeString
 658 PluralRules::getRuleFromResource(const Locale& locale, UPluralType type, UErrorCode& errCode) {
 659     UnicodeString emptyStr;
 660
 661     if (U_FAILURE(errCode)) {
 662         return emptyStr;
 663     }
 664     LocalUResourceBundlePointer rb(ures_openDirect(NULL, "plurals", &errCode));
 665     if(U_FAILURE(errCode)) {
 666         return emptyStr;
 667     }
 668     const char *typeKey;
 669     switch (type) {
 670     case UPLURAL_TYPE_CARDINAL:
 671         typeKey = "locales";
 672         break;
 673     case UPLURAL_TYPE_ORDINAL:
 674         typeKey = "locales_ordinals";
 675         break;
 676     default:
 677         // Must not occur: The caller should have checked for valid types.
 678         errCode = U_ILLEGAL_ARGUMENT_ERROR;
 679         return emptyStr;
 680     }
 681     LocalUResourceBundlePointer locRes(ures_getByKey(rb.getAlias(), typeKey, NULL, &errCode));
 682     if(U_FAILURE(errCode)) {
 683         return emptyStr;
 684     }
 685     int32_t resLen=0;
 686     const char *curLocaleName=locale.getName();
 687     const UChar* s = ures_getStringByKey(locRes.getAlias(), curLocaleName, &resLen, &errCode);
 688
 689     if (s == NULL) {
 690         // Check parent locales.
 691         UErrorCode status = U_ZERO_ERROR;
 692         char parentLocaleName[ULOC_FULLNAME_CAPACITY];
 693         const char *curLocaleName=locale.getName();
 694         uprv_strcpy(parentLocaleName, curLocaleName);
 695
 696         while (uloc_getParent(parentLocaleName, parentLocaleName,
 697                                        ULOC_FULLNAME_CAPACITY, &status) > 0) {
 698             resLen=0;
 699             s = ures_getStringByKey(locRes.getAlias(), parentLocaleName, &resLen, &status);
 700             if (s != NULL) {
 701                 errCode = U_ZERO_ERROR;
 702                 break;
 703             }
 704             status = U_ZERO_ERROR;
 705         }
 706     }
 707     if (s==NULL) {
 708         return emptyStr;
 709     }
 710
 711     char setKey[256];
 712     u_UCharsToChars(s, setKey, resLen + 1);
 713     // printf("\n PluralRule: %s\n", setKey);
 714
 715     LocalUResourceBundlePointer ruleRes(ures_getByKey(rb.getAlias(), "rules", NULL, &errCode));
 716     if(U_FAILURE(errCode)) {
 717         return emptyStr;
 718     }
 719     LocalUResourceBundlePointer setRes(ures_getByKey(ruleRes.getAlias(), setKey, NULL, &errCode));
 720     if (U_FAILURE(errCode)) {
 721         return emptyStr;
 722     }
 723
 724     int32_t numberKeys = ures_getSize(setRes.getAlias());
 725     UnicodeString result;
 726     const char *key=NULL;
 727     for(int32_t i=0; i<numberKeys; ++i) {   // Keys are zero, one, few, ...
 728         UnicodeString rules = ures_getNextUnicodeString(setRes.getAlias(), &key, &errCode);
 729         UnicodeString uKey(key, -1, US_INV);
 730         result.append(uKey);
 731         result.append(COLON);
 732         result.append(rules);
 733         result.append(SEMI_COLON);
 734     }
 735     return result;
 736 }
 737
 738
 739 UnicodeString
 740 PluralRules::getRules() const {
 741     UnicodeString rules;
 742     if (mRules != NULL) {
 743         mRules->dumpRules(rules);
 744     }
 745     return rules;
 746 }
 747
 748
 749 AndConstraint::AndConstraint() {
 750     op = AndConstraint::NONE;
 751     opNum=-1;
 752     value = -1;
 753     rangeList = NULL;
 754     negated = FALSE;
 755     integerOnly = FALSE;
 756     digitsType = none;
 757     next=NULL;
 758 }
 759
 760
 761 AndConstraint::AndConstraint(const AndConstraint& other) {
 762     this->op = other.op;
 763     this->opNum=other.opNum;
 764     this->value=other.value;
 765     this->rangeList=NULL;
 766     if (other.rangeList != NULL) {
 767         UErrorCode status = U_ZERO_ERROR;
 768         this->rangeList = new UVector32(status);
 769         this->rangeList->assign(*other.rangeList, status);
 770     }
 771     this->integerOnly=other.integerOnly;
 772     this->negated=other.negated;
 773     this->digitsType = other.digitsType;
 774     if (other.next==NULL) {
 775         this->next=NULL;
 776     }
 777     else {
 778         this->next = new AndConstraint(*other.next);
 779     }
 780 }
 781
 782 AndConstraint::~AndConstraint() {
 783     delete rangeList;
 784     if (next!=NULL) {
 785         delete next;
 786     }
 787 }
 788
 789
 790 UBool
 791 AndConstraint::isFulfilled(const FixedDecimal &number) {
 792     UBool result = TRUE;
 793     if (digitsType == none) {
 794         // An empty AndConstraint, created by a rule with a keyword but no following expression.
 795         return TRUE;
 796     }
 797     double n = number.get(digitsType);  // pulls n | i | v | f value for the number.
 798                                         // Will always be positive.
 799                                         // May be non-integer (n option only)
 800     do {
 801         if (integerOnly && n != uprv_floor(n)) {
 802             result = FALSE;
 803             break;
 804         }
 805
 806         if (op == MOD) {
 807             n = fmod(n, opNum);
 808         }
 809         if (rangeList == NULL) {
 810             result = value == -1 ||    // empty rule
 811                      n == value;       //  'is' rule
 812             break;
 813         }
 814         result = FALSE;                // 'in' or 'within' rule
 815         for (int32_t r=0; r<rangeList->size(); r+=2) {
 816             if (rangeList->elementAti(r) <= n && n <= rangeList->elementAti(r+1)) {
 817                 result = TRUE;
 818                 break;
 819             }
 820         }
 821     } while (FALSE);
 822
 823     if (negated) {
 824         result = !result;
 825     }
 826     return result;
 827 }
 828
 829
 830 AndConstraint*
 831 AndConstraint::add()
 832 {
 833     this->next = new AndConstraint();
 834     return this->next;
 835 }
 836
 837 OrConstraint::OrConstraint() {
 838     childNode=NULL;
 839     next=NULL;
 840 }
 841
 842 OrConstraint::OrConstraint(const OrConstraint& other) {
 843     if ( other.childNode == NULL ) {
 844         this->childNode = NULL;
 845     }
 846     else {
 847         this->childNode = new AndConstraint(*(other.childNode));
 848     }
 849     if (other.next == NULL ) {
 850         this->next = NULL;
 851     }
 852     else {
 853         this->next = new OrConstraint(*(other.next));
 854     }
 855 }
 856
 857 OrConstraint::~OrConstraint() {
 858     if (childNode!=NULL) {
 859         delete childNode;
 860     }
 861     if (next!=NULL) {
 862         delete next;
 863     }
 864 }
 865
 866 AndConstraint*
 867 OrConstraint::add()
 868 {
 869     OrConstraint *curOrConstraint=this;
 870     {
 871         while (curOrConstraint->next!=NULL) {
 872             curOrConstraint = curOrConstraint->next;
 873         }
 874         U_ASSERT(curOrConstraint->childNode == NULL);
 875         curOrConstraint->childNode = new AndConstraint();
 876     }
 877     return curOrConstraint->childNode;
 878 }
 879
 880 UBool
 881 OrConstraint::isFulfilled(const FixedDecimal &number) {
 882     OrConstraint* orRule=this;
 883     UBool result=FALSE;
 884
 885     while (orRule!=NULL && !result) {
 886         result=TRUE;
 887         AndConstraint* andRule = orRule->childNode;
 888         while (andRule!=NULL && result) {
 889             result = andRule->isFulfilled(number);
 890             andRule=andRule->next;
 891         }
 892         orRule = orRule->next;
 893     }
 894
 895     return result;
 896 }
 897
 898
 899 RuleChain::RuleChain(): fKeyword(), fNext(NULL), ruleHeader(NULL), fDecimalSamples(), fIntegerSamples(),
 900                         fDecimalSamplesUnbounded(FALSE), fIntegerSamplesUnbounded(FALSE) {
 901 }
 902
 903 RuleChain::RuleChain(const RuleChain& other) :
 904         fKeyword(other.fKeyword), fNext(NULL), ruleHeader(NULL), fDecimalSamples(other.fDecimalSamples),
 905         fIntegerSamples(other.fIntegerSamples), fDecimalSamplesUnbounded(other.fDecimalSamplesUnbounded),
 906         fIntegerSamplesUnbounded(other.fIntegerSamplesUnbounded) {
 907     if (other.ruleHeader != NULL) {
 908         this->ruleHeader = new OrConstraint(*(other.ruleHeader));
 909     }
 910     if (other.fNext != NULL ) {
 911         this->fNext = new RuleChain(*other.fNext);
 912     }
 913 }
 914
 915 RuleChain::~RuleChain() {
 916     delete fNext;
 917     delete ruleHeader;
 918 }
 919
 920
 921 UnicodeString
 922 RuleChain::select(const FixedDecimal &number) const {
 923     if (!number.isNanOrInfinity) {
 924         for (const RuleChain *rules = this; rules != NULL; rules = rules->fNext) {
 925              if (rules->ruleHeader->isFulfilled(number)) {
 926                  return rules->fKeyword;
 927              }
 928         }
 929     }
 930     return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5);
 931 }
 932
 933 static UnicodeString tokenString(tokenType tok) {
 934     UnicodeString s;
 935     switch (tok) {
 936       case tVariableN:
 937         s.append(LOW_N); break;
 938       case tVariableI:
 939         s.append(LOW_I); break;
 940       case tVariableF:
 941         s.append(LOW_F); break;
 942       case tVariableV:
 943         s.append(LOW_V); break;
 944       case tVariableT:
 945         s.append(LOW_T); break;
 946       default:
 947         s.append(TILDE);
 948     }
 949     return s;
 950 }
 951
 952 void
 953 RuleChain::dumpRules(UnicodeString& result) {
 954     UChar digitString[16];
 955
 956     if ( ruleHeader != NULL ) {
 957         result +=  fKeyword;
 958         result += COLON;
 959         result += SPACE;
 960         OrConstraint* orRule=ruleHeader;
 961         while ( orRule != NULL ) {
 962             AndConstraint* andRule=orRule->childNode;
 963             while ( andRule != NULL ) {
 964                 if ((andRule->op==AndConstraint::NONE) &&  (andRule->rangeList==NULL) && (andRule->value == -1)) {
 965                     // Empty Rules.
 966                 } else if ( (andRule->op==AndConstraint::NONE) && (andRule->rangeList==NULL) ) {
 967                     result += tokenString(andRule->digitsType);
 968                     result += UNICODE_STRING_SIMPLE(" is ");
 969                     if (andRule->negated) {
 970                         result += UNICODE_STRING_SIMPLE("not ");
 971                     }
 972                     uprv_itou(digitString,16, andRule->value,10,0);
 973                     result += UnicodeString(digitString);
 974                 }
 975                 else {
 976                     result += tokenString(andRule->digitsType);
 977                     result += SPACE;
 978                     if (andRule->op==AndConstraint::MOD) {
 979                         result += UNICODE_STRING_SIMPLE("mod ");
 980                         uprv_itou(digitString,16, andRule->opNum,10,0);
 981                         result += UnicodeString(digitString);
 982                     }
 983                     if (andRule->rangeList==NULL) {
 984                         if (andRule->negated) {
 985                             result += UNICODE_STRING_SIMPLE(" is not ");
 986                             uprv_itou(digitString,16, andRule->value,10,0);
 987                             result += UnicodeString(digitString);
 988                         }
 989                         else {
 990                             result += UNICODE_STRING_SIMPLE(" is ");
 991                             uprv_itou(digitString,16, andRule->value,10,0);
 992                             result += UnicodeString(digitString);
 993                         }
 994                     }
 995                     else {
 996                         if (andRule->negated) {
 997                             if ( andRule->integerOnly ) {
 998                                 result += UNICODE_STRING_SIMPLE(" not in ");
 999                             }
1000                             else {
1001                                 result += UNICODE_STRING_SIMPLE(" not within ");
1002                             }
1003                         }
1004                         else {
1005                             if ( andRule->integerOnly ) {
1006                                 result += UNICODE_STRING_SIMPLE(" in ");
1007                             }
1008                             else {
1009                                 result += UNICODE_STRING_SIMPLE(" within ");
1010                             }
1011                         }
1012                         for (int32_t r=0; r<andRule->rangeList->size(); r+=2) {
1013                             int32_t rangeLo = andRule->rangeList->elementAti(r);
1014                             int32_t rangeHi = andRule->rangeList->elementAti(r+1);
1015                             uprv_itou(digitString,16, rangeLo, 10, 0);
1016                             result += UnicodeString(digitString);
1017                             result += UNICODE_STRING_SIMPLE("..");
1018                             uprv_itou(digitString,16, rangeHi, 10,0);
1019                             result += UnicodeString(digitString);
1020                             if (r+2 < andRule->rangeList->size()) {
1021                                 result += UNICODE_STRING_SIMPLE(", ");
1022                             }
1023                         }
1024                     }
1025                 }
1026                 if ( (andRule=andRule->next) != NULL) {
1027                     result += UNICODE_STRING_SIMPLE(" and ");
1028                 }
1029             }
1030             if ( (orRule = orRule->next) != NULL ) {
1031                 result += UNICODE_STRING_SIMPLE(" or ");
1032             }
1033         }
1034     }
1035     if ( fNext != NULL ) {
1036         result += UNICODE_STRING_SIMPLE("; ");
1037         fNext->dumpRules(result);
1038     }
1039 }
1040
1041
1042 UErrorCode
1043 RuleChain::getKeywords(int32_t capacityOfKeywords, UnicodeString* keywords, int32_t& arraySize) const {
1044     if ( arraySize < capacityOfKeywords-1 ) {
1045         keywords[arraySize++]=fKeyword;
1046     }
1047     else {
1048         return U_BUFFER_OVERFLOW_ERROR;
1049     }
1050
1051     if ( fNext != NULL ) {
1052         return fNext->getKeywords(capacityOfKeywords, keywords, arraySize);
1053     }
1054     else {
1055         return U_ZERO_ERROR;
1056     }
1057 }
1058
1059 UBool
1060 RuleChain::isKeyword(const UnicodeString& keywordParam) const {
1061     if ( fKeyword == keywordParam ) {
1062         return TRUE;
1063     }
1064
1065     if ( fNext != NULL ) {
1066         return fNext->isKeyword(keywordParam);
1067     }
1068     else {
1069         return FALSE;
1070     }
1071 }
1072
1073
1074 PluralRuleParser::PluralRuleParser() :
1075         ruleIndex(0), token(), type(none), prevType(none),
1076         curAndConstraint(NULL), currentChain(NULL), rangeLowIdx(-1), rangeHiIdx(-1)
1077 {
1078 }
1079
1080 PluralRuleParser::~PluralRuleParser() {
1081 }
1082
1083
1084 int32_t
1085 PluralRuleParser::getNumberValue(const UnicodeString& token) {
1086     int32_t i;
1087     char digits[128];
1088
1089     i = token.extract(0, token.length(), digits, ARRAY_SIZE(digits), US_INV);
1090     digits[i]='\0';
1091
1092     return((int32_t)atoi(digits));
1093 }
1094
1095
1096 void
1097 PluralRuleParser::checkSyntax(UErrorCode &status)
1098 {
1099     if (U_FAILURE(status)) {
1100         return;
1101     }
1102     if (!(prevType==none || prevType==tSemiColon)) {
1103         type = getKeyType(token, type);  // Switch token type from tKeyword if we scanned a reserved word,
1104                                                //   and we are not at the start of a rule, where a
1105                                                //   keyword is expected.
1106     }
1107
1108     switch(prevType) {
1109     case none:
1110     case tSemiColon:
1111         if (type!=tKeyword && type != tEOF) {
1112             status = U_UNEXPECTED_TOKEN;
1113         }
1114         break;
1115     case tVariableN:
1116     case tVariableI:
1117     case tVariableF:
1118     case tVariableT:
1119     case tVariableV:
1120         if (type != tIs && type != tMod && type != tIn &&
1121             type != tNot && type != tWithin && type != tEqual && type != tNotEqual) {
1122             status = U_UNEXPECTED_TOKEN;
1123         }
1124         break;
1125     case tKeyword:
1126         if (type != tColon) {
1127             status = U_UNEXPECTED_TOKEN;
1128         }
1129         break;
1130     case tColon:
1131         if (!(type == tVariableN ||
1132               type == tVariableI ||
1133               type == tVariableF ||
1134               type == tVariableT ||
1135               type == tVariableV ||
1136               type == tAt)) {
1137             status = U_UNEXPECTED_TOKEN;
1138         }
1139         break;
1140     case tIs:
1141         if ( type != tNumber && type != tNot) {
1142             status = U_UNEXPECTED_TOKEN;
1143         }
1144         break;
1145     case tNot:
1146         if (type != tNumber && type != tIn && type != tWithin) {
1147             status = U_UNEXPECTED_TOKEN;
1148         }
1149         break;
1150     case tMod:
1151     case tDot2:
1152     case tIn:
1153     case tWithin:
1154     case tEqual:
1155     case tNotEqual:
1156         if (type != tNumber) {
1157             status = U_UNEXPECTED_TOKEN;
1158         }
1159         break;
1160     case tAnd:
1161     case tOr:
1162         if ( type != tVariableN &&
1163              type != tVariableI &&
1164              type != tVariableF &&
1165              type != tVariableT &&
1166              type != tVariableV) {
1167             status = U_UNEXPECTED_TOKEN;
1168         }
1169         break;
1170     case tComma:
1171         if (type != tNumber) {
1172             status = U_UNEXPECTED_TOKEN;
1173         }
1174         break;
1175     case tNumber:
1176         if (type != tDot2  && type != tSemiColon && type != tIs       && type != tNot    &&
1177             type != tIn    && type != tEqual     && type != tNotEqual && type != tWithin &&
1178             type != tAnd   && type != tOr        && type != tComma    && type != tAt     &&
1179             type != tEOF)
1180         {
1181             status = U_UNEXPECTED_TOKEN;
1182         }
1183         // TODO: a comma following a number that is not part of a range will be allowed.
1184         //       It's not the only case of this sort of thing. Parser needs a re-write.
1185         break;
1186     case tAt:
1187         if (type != tDecimal && type != tInteger) {
1188             status = U_UNEXPECTED_TOKEN;
1189         }
1190         break;
1191     default:
1192         status = U_UNEXPECTED_TOKEN;
1193         break;
1194     }
1195 }
1196
1197
1198 /*
1199  *  Scan the next token from the input rules.
1200  *     rules and returned token type are in the parser state variables.
1201  */
1202 void
1203 PluralRuleParser::getNextToken(UErrorCode &status)
1204 {
1205     if (U_FAILURE(status)) {
1206         return;
1207     }
1208
1209     UChar ch;
1210     while (ruleIndex < ruleSrc->length()) {
1211         ch = ruleSrc->charAt(ruleIndex);
1212         type = charType(ch);
1213         if (type != tSpace) {
1214             break;
1215         }
1216         ++(ruleIndex);
1217     }
1218     if (ruleIndex >= ruleSrc->length()) {
1219         type = tEOF;
1220         return;
1221     }
1222     int32_t curIndex= ruleIndex;
1223
1224     switch (type) {
1225       case tColon:
1226       case tSemiColon:
1227       case tComma:
1228       case tEllipsis:
1229       case tTilde:   // scanned '~'
1230       case tAt:      // scanned '@'
1231       case tEqual:   // scanned '='
1232       case tMod:     // scanned '%'
1233         // Single character tokens.
1234         ++curIndex;
1235         break;
1236
1237       case tNotEqual:  // scanned '!'
1238         if (ruleSrc->charAt(curIndex+1) == EQUALS) {
1239             curIndex += 2;
1240         } else {
1241             type = none;
1242             curIndex += 1;
1243         }
1244         break;
1245
1246       case tKeyword:
1247          while (type == tKeyword && ++curIndex < ruleSrc->length()) {
1248              ch = ruleSrc->charAt(curIndex);
1249              type = charType(ch);
1250          }
1251          type = tKeyword;
1252          break;
1253
1254       case tNumber:
1255          while (type == tNumber && ++curIndex < ruleSrc->length()) {
1256              ch = ruleSrc->charAt(curIndex);
1257              type = charType(ch);
1258          }
1259          type = tNumber;
1260          break;
1261
1262        case tDot:
1263          // We could be looking at either ".." in a range, or "..." at the end of a sample.
1264          if (curIndex+1 >= ruleSrc->length() || ruleSrc->charAt(curIndex+1) != DOT) {
1265              ++curIndex;
1266              break; // Single dot
1267          }
1268          if (curIndex+2 >= ruleSrc->length() || ruleSrc->charAt(curIndex+2) != DOT) {
1269              curIndex += 2;
1270              type = tDot2;
1271              break; // double dot
1272          }
1273          type = tEllipsis;
1274          curIndex += 3;
1275          break;     // triple dot
1276
1277        default:
1278          status = U_UNEXPECTED_TOKEN;
1279          ++curIndex;
1280          break;
1281     }
1282
1283     U_ASSERT(ruleIndex <= ruleSrc->length());
1284     U_ASSERT(curIndex <= ruleSrc->length());
1285     token=UnicodeString(*ruleSrc, ruleIndex, curIndex-ruleIndex);
1286     ruleIndex = curIndex;
1287 }
1288
1289 tokenType
1290 PluralRuleParser::charType(UChar ch) {
1291     if ((ch>=U_ZERO) && (ch<=U_NINE)) {
1292         return tNumber;
1293     }
1294     if (ch>=LOW_A && ch<=LOW_Z) {
1295         return tKeyword;
1296     }
1297     switch (ch) {
1298     case COLON:
1299         return tColon;
1300     case SPACE:
1301         return tSpace;
1302     case SEMI_COLON:
1303         return tSemiColon;
1304     case DOT:
1305         return tDot;
1306     case COMMA:
1307         return tComma;
1308     case EXCLAMATION:
1309         return tNotEqual;
1310     case EQUALS:
1311         return tEqual;
1312     case PERCENT_SIGN:
1313         return tMod;
1314     case AT:
1315         return tAt;
1316     case ELLIPSIS:
1317         return tEllipsis;
1318     case TILDE:
1319         return tTilde;
1320     default :
1321         return none;
1322     }
1323 }
1324
1325
1326 //  Set token type for reserved words in the Plural Rule syntax.
1327
1328 tokenType
1329 PluralRuleParser::getKeyType(const UnicodeString &token, tokenType keyType)
1330 {
1331     if (keyType != tKeyword) {
1332         return keyType;
1333     }
1334
1335     if (0 == token.compare(PK_VAR_N, 1)) {
1336         keyType = tVariableN;
1337     } else if (0 == token.compare(PK_VAR_I, 1)) {
1338         keyType = tVariableI;
1339     } else if (0 == token.compare(PK_VAR_F, 1)) {
1340         keyType = tVariableF;
1341     } else if (0 == token.compare(PK_VAR_T, 1)) {
1342         keyType = tVariableT;
1343     } else if (0 == token.compare(PK_VAR_V, 1)) {
1344         keyType = tVariableV;
1345     } else if (0 == token.compare(PK_IS, 2)) {
1346         keyType = tIs;
1347     } else if (0 == token.compare(PK_AND, 3)) {
1348         keyType = tAnd;
1349     } else if (0 == token.compare(PK_IN, 2)) {
1350         keyType = tIn;
1351     } else if (0 == token.compare(PK_WITHIN, 6)) {
1352         keyType = tWithin;
1353     } else if (0 == token.compare(PK_NOT, 3)) {
1354         keyType = tNot;
1355     } else if (0 == token.compare(PK_MOD, 3)) {
1356         keyType = tMod;
1357     } else if (0 == token.compare(PK_OR, 2)) {
1358         keyType = tOr;
1359     } else if (0 == token.compare(PK_DECIMAL, 7)) {
1360         keyType = tDecimal;
1361     } else if (0 == token.compare(PK_INTEGER, 7)) {
1362         keyType = tInteger;
1363     }
1364     return keyType;
1365 }
1366
1367
1368 PluralKeywordEnumeration::PluralKeywordEnumeration(RuleChain *header, UErrorCode& status)
1369         : pos(0), fKeywordNames(status) {
1370     if (U_FAILURE(status)) {
1371         return;
1372     }
1373     fKeywordNames.setDeleter(uprv_deleteUObject);
1374     UBool  addKeywordOther=TRUE;
1375     RuleChain *node=header;
1376     while(node!=NULL) {
1377         fKeywordNames.addElement(new UnicodeString(node->fKeyword), status);
1378         if (U_FAILURE(status)) {
1379             return;
1380         }
1381         if (0 == node->fKeyword.compare(PLURAL_KEYWORD_OTHER, 5)) {
1382             addKeywordOther= FALSE;
1383         }
1384         node=node->fNext;
1385     }
1386
1387     if (addKeywordOther) {
1388         fKeywordNames.addElement(new UnicodeString(PLURAL_KEYWORD_OTHER), status);
1389     }
1390 }
1391
1392 const UnicodeString*
1393 PluralKeywordEnumeration::snext(UErrorCode& status) {
1394     if (U_SUCCESS(status) && pos < fKeywordNames.size()) {
1395         return (const UnicodeString*)fKeywordNames.elementAt(pos++);
1396     }
1397     return NULL;
1398 }
1399
1400 void
1401 PluralKeywordEnumeration::reset(UErrorCode& /*status*/) {
1402     pos=0;
1403 }
1404
1405 int32_t
1406 PluralKeywordEnumeration::count(UErrorCode& /*status*/) const {
1407        return fKeywordNames.size();
1408 }
1409
1410 PluralKeywordEnumeration::~PluralKeywordEnumeration() {
1411 }
1412
1413
1414
1415 FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f) {
1416     init(n, v, f);
1417     // check values. TODO make into unit test.
1418     //
1419     //            long visiblePower = (int) Math.pow(10, v);
1420     //            if (decimalDigits > visiblePower) {
1421     //                throw new IllegalArgumentException();
1422     //            }
1423     //            double fraction = intValue + (decimalDigits / (double) visiblePower);
1424     //            if (fraction != source) {
1425     //                double diff = Math.abs(fraction - source)/(Math.abs(fraction) + Math.abs(source));
1426     //                if (diff > 0.00000001d) {
1427     //                    throw new IllegalArgumentException();
1428     //                }
1429     //            }
1430 }
1431
1432 FixedDecimal::FixedDecimal(double n, int32_t v) {
1433     // Ugly, but for samples we don't care.
1434     init(n, v, getFractionalDigits(n, v));
1435 }
1436
1437 FixedDecimal::FixedDecimal(double n) {
1438     init(n);
1439 }
1440
1441 FixedDecimal::FixedDecimal() {
1442     init(0, 0, 0);
1443 }
1444
1445
1446 // Create a FixedDecimal from a UnicodeString containing a number.
1447 //    Inefficient, but only used for samples, so simplicity trumps efficiency.
1448
1449 FixedDecimal::FixedDecimal(const UnicodeString &num, UErrorCode &status) {
1450     CharString cs;
1451     cs.appendInvariantChars(num, status);
1452     DigitList dl;
1453     dl.set(cs.toStringPiece(), status);
1454     if (U_FAILURE(status)) {
1455         init(0, 0, 0);
1456         return;
1457     }
1458     int32_t decimalPoint = num.indexOf(DOT);
1459     double n = dl.getDouble();
1460     if (decimalPoint == -1) {
1461         init(n, 0, 0);
1462     } else {
1463         int32_t v = num.length() - decimalPoint - 1;
1464         init(n, v, getFractionalDigits(n, v));
1465     }
1466 }
1467
1468
1469 FixedDecimal::FixedDecimal(const FixedDecimal &other) {
1470     source = other.source;
1471     visibleDecimalDigitCount = other.visibleDecimalDigitCount;
1472     decimalDigits = other.decimalDigits;
1473     decimalDigitsWithoutTrailingZeros = other.decimalDigitsWithoutTrailingZeros;
1474     intValue = other.intValue;
1475     hasIntegerValue = other.hasIntegerValue;
1476     isNegative = other.isNegative;
1477     isNanOrInfinity = other.isNanOrInfinity;
1478 }
1479
1480
1481 void FixedDecimal::init(double n) {
1482     int32_t numFractionDigits = decimals(n);
1483     init(n, numFractionDigits, getFractionalDigits(n, numFractionDigits));
1484 }
1485
1486
1487 void FixedDecimal::init(double n, int32_t v, int64_t f) {
1488     isNegative = n < 0.0;
1489     source = fabs(n);
1490     isNanOrInfinity = uprv_isNaN(source) || uprv_isPositiveInfinity(source);
1491     if (isNanOrInfinity) {
1492         v = 0;
1493         f = 0;
1494         intValue = 0;
1495         hasIntegerValue = FALSE;
1496     } else {
1497         intValue = (int64_t)source;
1498         hasIntegerValue = (source == intValue);
1499     }
1500
1501     visibleDecimalDigitCount = v;
1502     decimalDigits = f;
1503     if (f == 0) {
1504          decimalDigitsWithoutTrailingZeros = 0;
1505     } else {
1506         int64_t fdwtz = f;
1507         while ((fdwtz%10) == 0) {
1508             fdwtz /= 10;
1509         }
1510         decimalDigitsWithoutTrailingZeros = fdwtz;
1511     }
1512 }
1513
1514
1515 //  Fast path only exact initialization. Return true if successful.
1516 //     Note: Do not multiply by 10 each time through loop, rounding cruft can build
1517 //           up that makes the check for an integer result fail.
1518 //           A single multiply of the original number works more reliably.
1519 static int32_t p10[] = {1, 10, 100, 1000, 10000};
1520 UBool FixedDecimal::quickInit(double n) {
1521     UBool success = FALSE;
1522     n = fabs(n);
1523     int32_t numFractionDigits;
1524     for (numFractionDigits = 0; numFractionDigits <= 3; numFractionDigits++) {
1525         double scaledN = n * p10[numFractionDigits];
1526         if (scaledN == floor(scaledN)) {
1527             success = TRUE;
1528             break;
1529         }
1530     }
1531     if (success) {
1532         init(n, numFractionDigits, getFractionalDigits(n, numFractionDigits));
1533     }
1534     return success;
1535 }
1536
1537
1538
1539 int32_t FixedDecimal::decimals(double n) {
1540     // Count the number of decimal digits in the fraction part of the number, excluding trailing zeros.
1541     // fastpath the common cases, integers or fractions with 3 or fewer digits
1542     n = fabs(n);
1543     for (int ndigits=0; ndigits<=3; ndigits++) {
1544         double scaledN = n * p10[ndigits];
1545         if (scaledN == floor(scaledN)) {
1546             return ndigits;
1547         }
1548     }
1549
1550     // Slow path, convert with sprintf, parse converted output.
1551     char  buf[30] = {0};
1552     sprintf(buf, "%1.15e", n);
1553     // formatted number looks like this: 1.234567890123457e-01
1554     int exponent = atoi(buf+18);
1555     int numFractionDigits = 15;
1556     for (int i=16; ; --i) {
1557         if (buf[i] != '0') {
1558             break;
1559         }
1560         --numFractionDigits;
1561     }
1562     numFractionDigits -= exponent;   // Fraction part of fixed point representation.
1563     return numFractionDigits;
1564 }
1565
1566
1567 // Get the fraction digits of a double, represented as an integer.
1568 //    v is the number of visible fraction digits in the displayed form of the number.
1569 //       Example: n = 1001.234, v = 6, result = 234000
1570 //    TODO: need to think through how this is used in the plural rule context.
1571 //          This function can easily encounter integer overflow,
1572 //          and can easily return noise digits when the precision of a double is exceeded.
1573
1574 int64_t FixedDecimal::getFractionalDigits(double n, int32_t v) {
1575     if (v == 0 || n == floor(n) || uprv_isNaN(n) || uprv_isPositiveInfinity(n)) {
1576         return 0;
1577     }
1578     n = fabs(n);
1579     double fract = n - floor(n);
1580     switch (v) {
1581       case 1: return (int64_t)(fract*10.0 + 0.5);
1582       case 2: return (int64_t)(fract*100.0 + 0.5);
1583       case 3: return (int64_t)(fract*1000.0 + 0.5);
1584       default:
1585           double scaled = floor(fract * pow(10.0, (double)v) + 0.5);
1586           if (scaled > U_INT64_MAX) {
1587               return U_INT64_MAX;
1588           } else {
1589               return (int64_t)scaled;
1590           }
1591       }
1592 }
1593
1594
1595 void FixedDecimal::adjustForMinFractionDigits(int32_t minFractionDigits) {
1596     int32_t numTrailingFractionZeros = minFractionDigits - visibleDecimalDigitCount;
1597     if (numTrailingFractionZeros > 0) {
1598         for (int32_t i=0; i<numTrailingFractionZeros; i++) {
1599             // Do not let the decimalDigits value overflow if there are many trailing zeros.
1600             // Limit the value to 18 digits, the most that a 64 bit int can fully represent.
1601             if (decimalDigits >= 100000000000000000LL) {
1602                 break;
1603             }
1604             decimalDigits *= 10;
1605         }
1606         visibleDecimalDigitCount += numTrailingFractionZeros;
1607     }
1608 }
1609
1610
1611 double FixedDecimal::get(tokenType operand) const {
1612     switch(operand) {
1613         case tVariableN: return source;
1614         case tVariableI: return (double)intValue;
1615         case tVariableF: return (double)decimalDigits;
1616         case tVariableT: return (double)decimalDigitsWithoutTrailingZeros;
1617         case tVariableV: return visibleDecimalDigitCount;
1618         default:
1619              U_ASSERT(FALSE);  // unexpected.
1620              return source;
1621     }
1622 }
1623
1624 int32_t FixedDecimal::getVisibleFractionDigitCount() const {
1625     return visibleDecimalDigitCount;
1626 }
1627
1628
1629
1630 PluralAvailableLocalesEnumeration::PluralAvailableLocalesEnumeration(UErrorCode &status) {
1631     fLocales = NULL;
1632     fRes = NULL;
1633     fOpenStatus = status;
1634     if (U_FAILURE(status)) {
1635         return;
1636     }
1637     fOpenStatus = U_ZERO_ERROR;
1638     LocalUResourceBundlePointer rb(ures_openDirect(NULL, "plurals", &fOpenStatus));
1639     fLocales = ures_getByKey(rb.getAlias(), "locales", NULL, &fOpenStatus);
1640 }
1641
1642 PluralAvailableLocalesEnumeration::~PluralAvailableLocalesEnumeration() {
1643     ures_close(fLocales);
1644     ures_close(fRes);
1645     fLocales = NULL;
1646     fRes = NULL;
1647 }
1648
1649 const char *PluralAvailableLocalesEnumeration::next(int32_t *resultLength, UErrorCode &status) {
1650     if (U_FAILURE(status)) {
1651         return NULL;
1652     }
1653     if (U_FAILURE(fOpenStatus)) {
1654         status = fOpenStatus;
1655         return NULL;
1656     }
1657     fRes = ures_getNextResource(fLocales, fRes, &status);
1658     if (fRes == NULL || U_FAILURE(status)) {
1659         if (status == U_INDEX_OUTOFBOUNDS_ERROR) {
1660             status = U_ZERO_ERROR;
1661         }
1662         return NULL;
1663     }
1664     const char *result = ures_getKey(fRes);
1665     if (resultLength != NULL) {
1666         *resultLength = uprv_strlen(result);
1667     }
1668     return result;
1669 }
1670
1671
1672 void PluralAvailableLocalesEnumeration::reset(UErrorCode &status) {
1673     if (U_FAILURE(status)) {
1674        return;
1675     }
1676     if (U_FAILURE(fOpenStatus)) {
1677         status = fOpenStatus;
1678         return;
1679     }
1680     ures_resetIterator(fLocales);
1681 }
1682
1683 int32_t PluralAvailableLocalesEnumeration::count(UErrorCode &status) const {
1684     if (U_FAILURE(status)) {
1685         return 0;
1686     }
1687     if (U_FAILURE(fOpenStatus)) {
1688         status = fOpenStatus;
1689         return 0;
1690     }
1691     return ures_getSize(fLocales);
1692 }
1693
1694 U_NAMESPACE_END
1695
1696
1697 #endif /* #if !UCONFIG_NO_FORMATTING */
1698
1699 //eof