Home | History | Annotate | Download | only in i18n 
      1 /*
      2 *******************************************************************************
      3 * Copyright (C) 2007-2012, International Business Machines Corporation and
      4 * others. All Rights Reserved.
      5 *******************************************************************************
      6 *
      7 * File plurrule.cpp
      8 */
      9 
     10 #include "unicode/utypes.h"
     11 #include "unicode/localpointer.h"
     12 #include "unicode/plurrule.h"
     13 #include "unicode/upluralrules.h"
     14 #include "unicode/ures.h"
     15 #include "cmemory.h"
     16 #include "cstring.h"
     17 #include "hash.h"
     18 #include "mutex.h"
     19 #include "patternprops.h"
     20 #include "plurrule_impl.h"
     21 #include "putilimp.h"
     22 #include "ucln_in.h"
     23 #include "ustrfmt.h"
     24 #include "locutil.h"
     25 #include "uassert.h"
     26 
     27 #if !UCONFIG_NO_FORMATTING
     28 
     29 U_NAMESPACE_BEGIN
     30 
     31 // shared by all instances when lazy-initializing samples
     32 static UMutex pluralMutex = U_MUTEX_INITIALIZER;
     33 
     34 #define ARRAY_SIZE(array) (int32_t)(sizeof array  / sizeof array[0])
     35 
     36 static const UChar PLURAL_KEYWORD_OTHER[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,0};
     37 static const UChar PLURAL_DEFAULT_RULE[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,COLON,SPACE,LOW_N,0};
     38 static const UChar PK_IN[]={LOW_I,LOW_N,0};
     39 static const UChar PK_NOT[]={LOW_N,LOW_O,LOW_T,0};
     40 static const UChar PK_IS[]={LOW_I,LOW_S,0};
     41 static const UChar PK_MOD[]={LOW_M,LOW_O,LOW_D,0};
     42 static const UChar PK_AND[]={LOW_A,LOW_N,LOW_D,0};
     43 static const UChar PK_OR[]={LOW_O,LOW_R,0};
     44 static const UChar PK_VAR_N[]={LOW_N,0};
     45 static const UChar PK_WITHIN[]={LOW_W,LOW_I,LOW_T,LOW_H,LOW_I,LOW_N,0};
     46 
     47 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralRules)
     48 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralKeywordEnumeration)
     49 
     50 PluralRules::PluralRules(UErrorCode& status)
     51 :   UObject(),
     52     mRules(NULL),
     53     mParser(NULL),
     54     mSamples(NULL),
     55     mSampleInfo(NULL),
     56     mSampleInfoCount(0)
     57 {
     58     if (U_FAILURE(status)) {
     59         return;
     60     }
     61     mParser = new RuleParser();
     62     if (mParser==NULL) {
     63         status = U_MEMORY_ALLOCATION_ERROR;
     64     }
     65 }
     66 
     67 PluralRules::PluralRules(const PluralRules& other)
     68 : UObject(other),
     69     mRules(NULL),
     70   mParser(NULL),
     71   mSamples(NULL),
     72   mSampleInfo(NULL),
     73   mSampleInfoCount(0)
     74 {
     75     *this=other;
     76 }
     77 
     78 PluralRules::~PluralRules() {
     79     delete mRules;
     80     delete mParser;
     81     uprv_free(mSamples);
     82     uprv_free(mSampleInfo);
     83 }
     84 
     85 PluralRules*
     86 PluralRules::clone() const {
     87     return new PluralRules(*this);
     88 }
     89 
     90 PluralRules&
     91 PluralRules::operator=(const PluralRules& other) {
     92     if (this != &other) {
     93         delete mRules;
     94         if (other.mRules==NULL) {
     95             mRules = NULL;
     96         }
     97         else {
     98             mRules = new RuleChain(*other.mRules);
     99         }
    100         delete mParser;
    101         mParser = new RuleParser();
    102 
    103         uprv_free(mSamples);
    104         mSamples = NULL;
    105 
    106         uprv_free(mSampleInfo);
    107         mSampleInfo = NULL;
    108         mSampleInfoCount = 0;
    109     }
    110 
    111     return *this;
    112 }
    113 
    114 PluralRules* U_EXPORT2
    115 PluralRules::createRules(const UnicodeString& description, UErrorCode& status) {
    116     RuleChain   rules;
    117 
    118     if (U_FAILURE(status)) {
    119         return NULL;
    120     }
    121     PluralRules *newRules = new PluralRules(status);
    122     if ( (newRules != NULL)&& U_SUCCESS(status) ) {
    123         newRules->parseDescription((UnicodeString &)description, rules, status);
    124         if (U_SUCCESS(status)) {
    125             newRules->addRules(rules);
    126         }
    127     }
    128     if (U_FAILURE(status)) {
    129         delete newRules;
    130         return NULL;
    131     }
    132     else {
    133         return newRules;
    134     }
    135 }
    136 
    137 PluralRules* U_EXPORT2
    138 PluralRules::createDefaultRules(UErrorCode& status) {
    139     return createRules(UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1), status);
    140 }
    141 
    142 PluralRules* U_EXPORT2
    143 PluralRules::forLocale(const Locale& locale, UErrorCode& status) {
    144     return forLocale(locale, UPLURAL_TYPE_CARDINAL, status);
    145 }
    146 
    147 PluralRules* U_EXPORT2
    148 PluralRules::forLocale(const Locale& locale, UPluralType type, UErrorCode& status) {
    149     RuleChain   rChain;
    150     if (U_FAILURE(status)) {
    151         return NULL;
    152     }
    153     if (type >= UPLURAL_TYPE_COUNT) {
    154         status = U_ILLEGAL_ARGUMENT_ERROR;
    155         return NULL;
    156     }
    157     PluralRules *newObj = new PluralRules(status);
    158     if (newObj==NULL || U_FAILURE(status)) {
    159         delete newObj;
    160         return NULL;
    161     }
    162     UnicodeString locRule = newObj->getRuleFromResource(locale, type, status);
    163     if ((locRule.length() != 0) && U_SUCCESS(status)) {
    164         newObj->parseDescription(locRule, rChain, status);
    165         if (U_SUCCESS(status)) {
    166             newObj->addRules(rChain);
    167         }
    168     }
    169     if (U_FAILURE(status)||(locRule.length() == 0)) {
    170         // use default plural rule
    171         status = U_ZERO_ERROR;
    172         UnicodeString defRule = UnicodeString(PLURAL_DEFAULT_RULE);
    173         newObj->parseDescription(defRule, rChain, status);
    174         newObj->addRules(rChain);
    175     }
    176 
    177     return newObj;
    178 }
    179 
    180 UnicodeString
    181 PluralRules::select(int32_t number) const {
    182     if (mRules == NULL) {
    183         return UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1);
    184     }
    185     else {
    186         return mRules->select(number);
    187     }
    188 }
    189 
    190 UnicodeString
    191 PluralRules::select(double number) const {
    192     if (mRules == NULL) {
    193         return UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1);
    194     }
    195     else {
    196         return mRules->select(number);
    197     }
    198 }
    199 
    200 StringEnumeration*
    201 PluralRules::getKeywords(UErrorCode& status) const {
    202     if (U_FAILURE(status))  return NULL;
    203     StringEnumeration* nameEnumerator = new PluralKeywordEnumeration(mRules, status);
    204     if (U_FAILURE(status)) {
    205       delete nameEnumerator;
    206       return NULL;
    207     }
    208 
    209     return nameEnumerator;
    210 }
    211 
    212 double
    213 PluralRules::getUniqueKeywordValue(const UnicodeString& keyword) {
    214   double val = 0.0;
    215   UErrorCode status = U_ZERO_ERROR;
    216   int32_t count = getSamplesInternal(keyword, &val, 1, FALSE, status);
    217   return count == 1 ? val : UPLRULES_NO_UNIQUE_VALUE;
    218 }
    219 
    220 int32_t
    221 PluralRules::getAllKeywordValues(const UnicodeString &keyword, double *dest,
    222                                  int32_t destCapacity, UErrorCode& error) {
    223     return getSamplesInternal(keyword, dest, destCapacity, FALSE, error);
    224 }
    225 
    226 int32_t
    227 PluralRules::getSamples(const UnicodeString &keyword, double *dest,
    228                         int32_t destCapacity, UErrorCode& status) {
    229     return getSamplesInternal(keyword, dest, destCapacity, TRUE, status);
    230 }
    231 
    232 int32_t
    233 PluralRules::getSamplesInternal(const UnicodeString &keyword, double *dest,
    234                                 int32_t destCapacity, UBool includeUnlimited,
    235                                 UErrorCode& status) {
    236     initSamples(status);
    237     if (U_FAILURE(status)) {
    238         return -1;
    239     }
    240     if (destCapacity < 0 || (dest == NULL && destCapacity > 0)) {
    241         status = U_ILLEGAL_ARGUMENT_ERROR;
    242         return -1;
    243     }
    244 
    245     int32_t index = getKeywordIndex(keyword, status);
    246     if (index == -1) {
    247         return 0;
    248     }
    249 
    250     const int32_t LIMIT_MASK = 0x1 << 31;
    251 
    252     if (!includeUnlimited) {
    253         if ((mSampleInfo[index] & LIMIT_MASK) == 0) {
    254             return -1;
    255         }
    256     }
    257 
    258     int32_t start = index == 0 ? 0 : mSampleInfo[index - 1] & ~LIMIT_MASK;
    259     int32_t limit = mSampleInfo[index] & ~LIMIT_MASK;
    260     int32_t len = limit - start;
    261     if (len <= destCapacity) {
    262         destCapacity = len;
    263     } else if (includeUnlimited) {
    264         len = destCapacity;  // no overflow, and don't report more than we copy
    265     } else {
    266         status = U_BUFFER_OVERFLOW_ERROR;
    267         return len;
    268     }
    269     for (int32_t i = 0; i < destCapacity; ++i, ++start) {
    270         dest[i] = mSamples[start];
    271     }
    272     return len;
    273 }
    274 
    275 
    276 UBool
    277 PluralRules::isKeyword(const UnicodeString& keyword) const {
    278     if (0 == keyword.compare(PLURAL_KEYWORD_OTHER, 5)) {
    279         return true;
    280     }
    281     else {
    282         if (mRules==NULL) {
    283             return false;
    284         }
    285         else {
    286             return mRules->isKeyword(keyword);
    287         }
    288     }
    289 }
    290 
    291 UnicodeString
    292 PluralRules::getKeywordOther() const {
    293     return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5);
    294 }
    295 
    296 UBool
    297 PluralRules::operator==(const PluralRules& other) const  {
    298     int32_t limit;
    299     const UnicodeString *ptrKeyword;
    300     UErrorCode status= U_ZERO_ERROR;
    301 
    302     if ( this == &other ) {
    303         return TRUE;
    304     }
    305     LocalPointer<StringEnumeration> myKeywordList(getKeywords(status));
    306     LocalPointer<StringEnumeration> otherKeywordList(other.getKeywords(status));
    307     if (U_FAILURE(status)) {
    308         return FALSE;
    309     }
    310 
    311     if (myKeywordList->count(status)!=otherKeywordList->count(status)) {
    312         return FALSE;
    313     }
    314     myKeywordList->reset(status);
    315     while ((ptrKeyword=myKeywordList->snext(status))!=NULL) {
    316         if (!other.isKeyword(*ptrKeyword)) {
    317             return FALSE;
    318         }
    319     }
    320     otherKeywordList->reset(status);
    321     while ((ptrKeyword=otherKeywordList->snext(status))!=NULL) {
    322         if (!this->isKeyword(*ptrKeyword)) {
    323             return FALSE;
    324         }
    325     }
    326     if (U_FAILURE(status)) {
    327         return FALSE;
    328     }
    329 
    330     if ((limit=this->getRepeatLimit()) != other.getRepeatLimit()) {
    331         return FALSE;
    332     }
    333     UnicodeString myKeyword, otherKeyword;
    334     for (int32_t i=0; i<limit; ++i) {
    335         myKeyword = this->select(i);
    336         otherKeyword = other.select(i);
    337         if (myKeyword!=otherKeyword) {
    338             return FALSE;
    339         }
    340     }
    341     return TRUE;
    342 }
    343 
    344 void
    345 PluralRules::parseDescription(UnicodeString& data, RuleChain& rules, UErrorCode &status)
    346 {
    347     int32_t ruleIndex=0;
    348     UnicodeString token;
    349     tokenType type;
    350     tokenType prevType=none;
    351     RuleChain *ruleChain=NULL;
    352     AndConstraint *curAndConstraint=NULL;
    353     OrConstraint *orNode=NULL;
    354     RuleChain *lastChain=NULL;
    355 
    356     if (U_FAILURE(status)) {
    357         return;
    358     }
    359     UnicodeString ruleData = data.toLower("");
    360     while (ruleIndex< ruleData.length()) {
    361         mParser->getNextToken(ruleData, &ruleIndex, token, type, status);
    362         if (U_FAILURE(status)) {
    363             return;
    364         }
    365         mParser->checkSyntax(prevType, type, status);
    366         if (U_FAILURE(status)) {
    367             return;
    368         }
    369         switch (type) {
    370         case tAnd:
    371             U_ASSERT(curAndConstraint != NULL);
    372             curAndConstraint = curAndConstraint->add();
    373             break;
    374         case tOr:
    375             lastChain = &rules;
    376             while (lastChain->next !=NULL) {
    377                 lastChain = lastChain->next;
    378             }
    379             orNode=lastChain->ruleHeader;
    380             while (orNode->next != NULL) {
    381                 orNode = orNode->next;
    382             }
    383             orNode->next= new OrConstraint();
    384             orNode=orNode->next;
    385             orNode->next=NULL;
    386             curAndConstraint = orNode->add();
    387             break;
    388         case tIs:
    389             U_ASSERT(curAndConstraint != NULL);
    390             curAndConstraint->rangeHigh=-1;
    391             break;
    392         case tNot:
    393             U_ASSERT(curAndConstraint != NULL);
    394             curAndConstraint->notIn=TRUE;
    395             break;
    396         case tIn:
    397             U_ASSERT(curAndConstraint != NULL);
    398             curAndConstraint->rangeHigh=PLURAL_RANGE_HIGH;
    399             curAndConstraint->integerOnly = TRUE;
    400             break;
    401         case tWithin:
    402             U_ASSERT(curAndConstraint != NULL);
    403             curAndConstraint->rangeHigh=PLURAL_RANGE_HIGH;
    404             break;
    405         case tNumber:
    406             U_ASSERT(curAndConstraint != NULL);
    407             if ( (curAndConstraint->op==AndConstraint::MOD)&&
    408                  (curAndConstraint->opNum == -1 ) ) {
    409                 curAndConstraint->opNum=getNumberValue(token);
    410             }
    411             else {
    412                 if (curAndConstraint->rangeLow == -1) {
    413                     curAndConstraint->rangeLow=getNumberValue(token);
    414                 }
    415                 else {
    416                     curAndConstraint->rangeHigh=getNumberValue(token);
    417                 }
    418             }
    419             break;
    420         case tMod:
    421             U_ASSERT(curAndConstraint != NULL);
    422             curAndConstraint->op=AndConstraint::MOD;
    423             break;
    424         case tKeyword:
    425             if (ruleChain==NULL) {
    426                 ruleChain = &rules;
    427             }
    428             else {
    429                 while (ruleChain->next!=NULL){
    430                     ruleChain=ruleChain->next;
    431                 }
    432                 ruleChain=ruleChain->next=new RuleChain();
    433             }
    434             if (ruleChain->ruleHeader != NULL) {
    435                 delete ruleChain->ruleHeader;
    436             }
    437             orNode = ruleChain->ruleHeader = new OrConstraint();
    438             curAndConstraint = orNode->add();
    439             ruleChain->keyword = token;
    440             break;
    441         default:
    442             break;
    443         }
    444         prevType=type;
    445     }
    446 }
    447 
    448 int32_t
    449 PluralRules::getNumberValue(const UnicodeString& token) const {
    450     int32_t i;
    451     char digits[128];
    452 
    453     i = token.extract(0, token.length(), digits, ARRAY_SIZE(digits), US_INV);
    454     digits[i]='\0';
    455 
    456     return((int32_t)atoi(digits));
    457 }
    458 
    459 
    460 void
    461 PluralRules::getNextLocale(const UnicodeString& localeData, int32_t* curIndex, UnicodeString& localeName) {
    462     int32_t i=*curIndex;
    463 
    464     localeName.remove();
    465     while (i< localeData.length()) {
    466        if ( (localeData.charAt(i)!= SPACE) && (localeData.charAt(i)!= COMMA) ) {
    467            break;
    468        }
    469        i++;
    470     }
    471 
    472     while (i< localeData.length()) {
    473        if ( (localeData.charAt(i)== SPACE) || (localeData.charAt(i)== COMMA) ) {
    474            break;
    475        }
    476        localeName+=localeData.charAt(i++);
    477     }
    478     *curIndex=i;
    479 }
    480 
    481 
    482 int32_t
    483 PluralRules::getRepeatLimit() const {
    484     if (mRules!=NULL) {
    485         return mRules->getRepeatLimit();
    486     }
    487     else {
    488         return 0;
    489     }
    490 }
    491 
    492 int32_t
    493 PluralRules::getKeywordIndex(const UnicodeString& keyword,
    494                              UErrorCode& status) const {
    495     if (U_SUCCESS(status)) {
    496         int32_t n = 0;
    497         RuleChain* rc = mRules;
    498         while (rc != NULL) {
    499             if (rc->ruleHeader != NULL) {
    500                 if (rc->keyword == keyword) {
    501                     return n;
    502                 }
    503                 ++n;
    504             }
    505             rc = rc->next;
    506         }
    507         if (0 == keyword.compare(PLURAL_KEYWORD_OTHER, 5)) {
    508             return n;
    509         }
    510     }
    511     return -1;
    512 }
    513 
    514 typedef struct SampleRecord {
    515     int32_t ruleIndex;
    516     double  value;
    517 } SampleRecord;
    518 
    519 void
    520 PluralRules::initSamples(UErrorCode& status) {
    521     if (U_FAILURE(status)) {
    522         return;
    523     }
    524     Mutex lock(&pluralMutex);
    525 
    526     if (mSamples) {
    527         return;
    528     }
    529 
    530     // Note, the original design let you have multiple rules with the same keyword.  But
    531     // we don't use that in our data and existing functions in this implementation don't
    532     // fully support it (for example, the returned keywords is a list and not a set).
    533     //
    534     // So I don't support this here either.  If you ask for samples, or for all values,
    535     // you will get information about the first rule with that keyword, not all rules with
    536     // that keyword.
    537 
    538     int32_t maxIndex = 0;
    539     int32_t otherIndex = -1; // the value -1 will indicate we added 'other' at end
    540     RuleChain* rc = mRules;
    541     while (rc != NULL) {
    542         if (rc->ruleHeader != NULL) {
    543             if (otherIndex == -1 && 0 == rc->keyword.compare(PLURAL_KEYWORD_OTHER, 5)) {
    544                 otherIndex = maxIndex;
    545             }
    546             ++maxIndex;
    547         }
    548         rc = rc->next;
    549     }
    550     if (otherIndex == -1) {
    551         ++maxIndex;
    552     }
    553 
    554     LocalMemory<int32_t> newSampleInfo;
    555     if (NULL == newSampleInfo.allocateInsteadAndCopy(maxIndex)) {
    556         status = U_MEMORY_ALLOCATION_ERROR;
    557         return;
    558     }
    559 
    560     const int32_t LIMIT_MASK = 0x1 << 31;
    561 
    562     rc = mRules;
    563     int32_t n = 0;
    564     while (rc != NULL) {
    565         if (rc->ruleHeader != NULL) {
    566             newSampleInfo[n++] = rc->ruleHeader->isLimited() ? LIMIT_MASK : 0;
    567         }
    568         rc = rc->next;
    569     }
    570     if (otherIndex == -1) {
    571         newSampleInfo[maxIndex - 1] = 0; // unlimited
    572     }
    573 
    574     MaybeStackArray<SampleRecord, 10> newSamples;
    575     int32_t sampleCount = 0;
    576 
    577     int32_t limit = getRepeatLimit() * MAX_SAMPLES * 2;
    578     if (limit < 10) {
    579         limit = 10;
    580     }
    581 
    582     for (int i = 0, keywordsRemaining = maxIndex;
    583           keywordsRemaining > 0 && i < limit;
    584           ++i) {
    585         double val = i / 2.0;
    586 
    587         n = 0;
    588         rc = mRules;
    589         int32_t found = -1;
    590         while (rc != NULL) {
    591             if (rc->ruleHeader != NULL) {
    592                 if (rc->ruleHeader->isFulfilled(val)) {
    593                     found = n;
    594                     break;
    595                 }
    596                 ++n;
    597             }
    598             rc = rc->next;
    599         }
    600         if (found == -1) {
    601             // 'other'.  If there is an 'other' rule, the rule set is bad since nothing
    602             // should leak through, but we don't bother to report that here.
    603             found = otherIndex == -1 ? maxIndex - 1 : otherIndex;
    604         }
    605         if (newSampleInfo[found] == MAX_SAMPLES) { // limit flag not set
    606             continue;
    607         }
    608         newSampleInfo[found] += 1; // won't impact limit flag
    609 
    610         if (sampleCount == newSamples.getCapacity()) {
    611             int32_t newCapacity = sampleCount < 20 ? 128 : sampleCount * 2;
    612             if (NULL == newSamples.resize(newCapacity, sampleCount)) {
    613                 status = U_MEMORY_ALLOCATION_ERROR;
    614                 return;
    615             }
    616         }
    617         newSamples[sampleCount].ruleIndex = found;
    618         newSamples[sampleCount].value = val;
    619         ++sampleCount;
    620 
    621         if (newSampleInfo[found] == MAX_SAMPLES) { // limit flag not set
    622             --keywordsRemaining;
    623         }
    624     }
    625 
    626     // sort the values by index, leaving order otherwise unchanged
    627     // this is just a selection sort for simplicity
    628     LocalMemory<double> values;
    629     if (NULL == values.allocateInsteadAndCopy(sampleCount)) {
    630         status = U_MEMORY_ALLOCATION_ERROR;
    631         return;
    632     }
    633     for (int i = 0, j = 0; i < maxIndex; ++i) {
    634         for (int k = 0; k < sampleCount; ++k) {
    635             if (newSamples[k].ruleIndex == i) {
    636                 values[j++] = newSamples[k].value;
    637             }
    638         }
    639     }
    640 
    641     // convert array of mask/lengths to array of mask/limits
    642     limit = 0;
    643     for (int i = 0; i < maxIndex; ++i) {
    644         int32_t info = newSampleInfo[i];
    645         int32_t len = info & ~LIMIT_MASK;
    646         limit += len;
    647         // if a rule is 'unlimited' but has fewer than MAX_SAMPLES samples,
    648         // it's not really unlimited, so mark it as limited
    649         int32_t mask = len < MAX_SAMPLES ? LIMIT_MASK : info & LIMIT_MASK;
    650         newSampleInfo[i] = limit | mask;
    651     }
    652 
    653     // ok, we've got good data
    654     mSamples = values.orphan();
    655     mSampleInfo = newSampleInfo.orphan();
    656     mSampleInfoCount = maxIndex;
    657 }
    658 
    659 void
    660 PluralRules::addRules(RuleChain& rules) {
    661     RuleChain *newRule = new RuleChain(rules);
    662     this->mRules=newRule;
    663     newRule->setRepeatLimit();
    664 }
    665 
    666 UnicodeString
    667 PluralRules::getRuleFromResource(const Locale& locale, UPluralType type, UErrorCode& errCode) {
    668     UnicodeString emptyStr;
    669 
    670     if (U_FAILURE(errCode)) {
    671         return emptyStr;
    672     }
    673     LocalUResourceBundlePointer rb(ures_openDirect(NULL, "plurals", &errCode));
    674     if(U_FAILURE(errCode)) {
    675         return emptyStr;
    676     }
    677     const char *typeKey;
    678     switch (type) {
    679     case UPLURAL_TYPE_CARDINAL:
    680         typeKey = "locales";
    681         break;
    682     case UPLURAL_TYPE_ORDINAL:
    683         typeKey = "locales_ordinals";
    684         break;
    685     default:
    686         // Must not occur: The caller should have checked for valid types.
    687         errCode = U_ILLEGAL_ARGUMENT_ERROR;
    688         return emptyStr;
    689     }
    690     LocalUResourceBundlePointer locRes(ures_getByKey(rb.getAlias(), typeKey, NULL, &errCode));
    691     if(U_FAILURE(errCode)) {
    692         return emptyStr;
    693     }
    694     int32_t resLen=0;
    695     const char *curLocaleName=locale.getName();
    696     const UChar* s = ures_getStringByKey(locRes.getAlias(), curLocaleName, &resLen, &errCode);
    697 
    698     if (s == NULL) {
    699         // Check parent locales.
    700         UErrorCode status = U_ZERO_ERROR;
    701         char parentLocaleName[ULOC_FULLNAME_CAPACITY];
    702         const char *curLocaleName=locale.getName();
    703         uprv_strcpy(parentLocaleName, curLocaleName);
    704 
    705         while (uloc_getParent(parentLocaleName, parentLocaleName,
    706                                        ULOC_FULLNAME_CAPACITY, &status) > 0) {
    707             resLen=0;
    708             s = ures_getStringByKey(locRes.getAlias(), parentLocaleName, &resLen, &status);
    709             if (s != NULL) {
    710                 errCode = U_ZERO_ERROR;
    711                 break;
    712             }
    713             status = U_ZERO_ERROR;
    714         }
    715     }
    716     if (s==NULL) {
    717         return emptyStr;
    718     }
    719 
    720     char setKey[256];
    721     UChar result[256];
    722     u_UCharsToChars(s, setKey, resLen + 1);
    723     // printf("\n PluralRule: %s\n", setKey);
    724 
    725 
    726     LocalUResourceBundlePointer ruleRes(ures_getByKey(rb.getAlias(), "rules", NULL, &errCode));
    727     if(U_FAILURE(errCode)) {
    728         return emptyStr;
    729     }
    730     resLen=0;
    731     LocalUResourceBundlePointer setRes(ures_getByKey(ruleRes.getAlias(), setKey, NULL, &errCode));
    732     if (U_FAILURE(errCode)) {
    733         return emptyStr;
    734     }
    735 
    736     int32_t numberKeys = ures_getSize(setRes.getAlias());
    737     char *key=NULL;
    738     int32_t len=0;
    739     for(int32_t i=0; i<numberKeys; ++i) {
    740         int32_t keyLen;
    741         resLen=0;
    742         s=ures_getNextString(setRes.getAlias(), &resLen, (const char**)&key, &errCode);
    743         keyLen = (int32_t)uprv_strlen(key);
    744         u_charsToUChars(key, result+len, keyLen);
    745         len += keyLen;
    746         result[len++]=COLON;
    747         uprv_memcpy(result+len, s, resLen*sizeof(UChar));
    748         len += resLen;
    749         result[len++]=SEMI_COLON;
    750     }
    751     result[len++]=0;
    752     u_UCharsToChars(result, setKey, len);
    753     // printf(" Rule: %s\n", setKey);
    754 
    755     return UnicodeString(result);
    756 }
    757 
    758 AndConstraint::AndConstraint() {
    759     op = AndConstraint::NONE;
    760     opNum=-1;
    761     rangeLow=-1;
    762     rangeHigh=-1;
    763     notIn=FALSE;
    764     integerOnly=FALSE;
    765     next=NULL;
    766 }
    767 
    768 
    769 AndConstraint::AndConstraint(const AndConstraint& other) {
    770     this->op = other.op;
    771     this->opNum=other.opNum;
    772     this->rangeLow=other.rangeLow;
    773     this->rangeHigh=other.rangeHigh;
    774     this->integerOnly=other.integerOnly;
    775     this->notIn=other.notIn;
    776     if (other.next==NULL) {
    777         this->next=NULL;
    778     }
    779     else {
    780         this->next = new AndConstraint(*other.next);
    781     }
    782 }
    783 
    784 AndConstraint::~AndConstraint() {
    785     if (next!=NULL) {
    786         delete next;
    787     }
    788 }
    789 
    790 
    791 UBool
    792 AndConstraint::isFulfilled(double number) {
    793     UBool result=TRUE;
    794     double value=number;
    795 
    796     // arrrrrrgh
    797     if ((rangeHigh == -1 || integerOnly) && number != uprv_floor(number)) {
    798       return notIn;
    799     }
    800 
    801     if ( op == MOD ) {
    802         value = (int32_t)value % opNum;
    803     }
    804     if ( rangeHigh == -1 ) {
    805         if ( rangeLow == -1 ) {
    806             result = TRUE; // empty rule
    807         }
    808         else {
    809             if ( value == rangeLow ) {
    810                 result = TRUE;
    811             }
    812             else {
    813                 result = FALSE;
    814             }
    815         }
    816     }
    817     else {
    818         if ((rangeLow <= value) && (value <= rangeHigh)) {
    819             if (integerOnly) {
    820                 if ( value != (int32_t)value) {
    821                     result = FALSE;
    822                 }
    823                 else {
    824                     result = TRUE;
    825                 }
    826             }
    827             else {
    828                 result = TRUE;
    829             }
    830         }
    831         else {
    832             result = FALSE;
    833         }
    834     }
    835     if (notIn) {
    836         return !result;
    837     }
    838     else {
    839         return result;
    840     }
    841 }
    842 
    843 UBool
    844 AndConstraint::isLimited() {
    845     return (rangeHigh == -1 || integerOnly) && !notIn && op != MOD;
    846 }
    847 
    848 int32_t
    849 AndConstraint::updateRepeatLimit(int32_t maxLimit) {
    850 
    851     if ( op == MOD ) {
    852         return uprv_max(opNum, maxLimit);
    853     }
    854     else {
    855         if ( rangeHigh == -1 ) {
    856             return uprv_max(rangeLow, maxLimit);
    857         }
    858         else{
    859             return uprv_max(rangeHigh, maxLimit);
    860         }
    861     }
    862 }
    863 
    864 
    865 AndConstraint*
    866 AndConstraint::add()
    867 {
    868     this->next = new AndConstraint();
    869     return this->next;
    870 }
    871 
    872 OrConstraint::OrConstraint() {
    873     childNode=NULL;
    874     next=NULL;
    875 }
    876 
    877 OrConstraint::OrConstraint(const OrConstraint& other) {
    878     if ( other.childNode == NULL ) {
    879         this->childNode = NULL;
    880     }
    881     else {
    882         this->childNode = new AndConstraint(*(other.childNode));
    883     }
    884     if (other.next == NULL ) {
    885         this->next = NULL;
    886     }
    887     else {
    888         this->next = new OrConstraint(*(other.next));
    889     }
    890 }
    891 
    892 OrConstraint::~OrConstraint() {
    893     if (childNode!=NULL) {
    894         delete childNode;
    895     }
    896     if (next!=NULL) {
    897         delete next;
    898     }
    899 }
    900 
    901 AndConstraint*
    902 OrConstraint::add()
    903 {
    904     OrConstraint *curOrConstraint=this;
    905     {
    906         while (curOrConstraint->next!=NULL) {
    907             curOrConstraint = curOrConstraint->next;
    908         }
    909         curOrConstraint->next = NULL;
    910         curOrConstraint->childNode = new AndConstraint();
    911     }
    912     return curOrConstraint->childNode;
    913 }
    914 
    915 UBool
    916 OrConstraint::isFulfilled(double number) {
    917     OrConstraint* orRule=this;
    918     UBool result=FALSE;
    919 
    920     while (orRule!=NULL && !result) {
    921         result=TRUE;
    922         AndConstraint* andRule = orRule->childNode;
    923         while (andRule!=NULL && result) {
    924             result = andRule->isFulfilled(number);
    925             andRule=andRule->next;
    926         }
    927         orRule = orRule->next;
    928     }
    929 
    930     return result;
    931 }
    932 
    933 UBool
    934 OrConstraint::isLimited() {
    935     for (OrConstraint *orc = this; orc != NULL; orc = orc->next) {
    936         UBool result = FALSE;
    937         for (AndConstraint *andc = orc->childNode; andc != NULL; andc = andc->next) {
    938             if (andc->isLimited()) {
    939                 result = TRUE;
    940                 break;
    941             }
    942         }
    943         if (result == FALSE) {
    944             return FALSE;
    945         }
    946     }
    947     return TRUE;
    948 }
    949 
    950 RuleChain::RuleChain() {
    951     ruleHeader=NULL;
    952     next = NULL;
    953     repeatLimit=0;
    954 }
    955 
    956 RuleChain::RuleChain(const RuleChain& other) {
    957     this->repeatLimit = other.repeatLimit;
    958     this->keyword=other.keyword;
    959     if (other.ruleHeader != NULL) {
    960         this->ruleHeader = new OrConstraint(*(other.ruleHeader));
    961     }
    962     else {
    963         this->ruleHeader = NULL;
    964     }
    965     if (other.next != NULL ) {
    966         this->next = new RuleChain(*other.next);
    967     }
    968     else
    969     {
    970         this->next = NULL;
    971     }
    972 }
    973 
    974 RuleChain::~RuleChain() {
    975     if (next != NULL) {
    976         delete next;
    977     }
    978     if ( ruleHeader != NULL ) {
    979         delete ruleHeader;
    980     }
    981 }
    982 
    983 UnicodeString
    984 RuleChain::select(double number) const {
    985 
    986    if ( ruleHeader != NULL ) {
    987        if (ruleHeader->isFulfilled(number)) {
    988            return keyword;
    989        }
    990    }
    991    if ( next != NULL ) {
    992        return next->select(number);
    993    }
    994    else {
    995        return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5);
    996    }
    997 
    998 }
    999 
   1000 void
   1001 RuleChain::dumpRules(UnicodeString& result) {
   1002     UChar digitString[16];
   1003 
   1004     if ( ruleHeader != NULL ) {
   1005         result +=  keyword;
   1006         OrConstraint* orRule=ruleHeader;
   1007         while ( orRule != NULL ) {
   1008             AndConstraint* andRule=orRule->childNode;
   1009             while ( andRule != NULL ) {
   1010                 if ( (andRule->op==AndConstraint::NONE) && (andRule->rangeHigh==-1) ) {
   1011                     result += UNICODE_STRING_SIMPLE(" n is ");
   1012                     if (andRule->notIn) {
   1013                         result += UNICODE_STRING_SIMPLE("not ");
   1014                     }
   1015                     uprv_itou(digitString,16, andRule->rangeLow,10,0);
   1016                     result += UnicodeString(digitString);
   1017                 }
   1018                 else {
   1019                     if (andRule->op==AndConstraint::MOD) {
   1020                         result += UNICODE_STRING_SIMPLE("  n mod ");
   1021                         uprv_itou(digitString,16, andRule->opNum,10,0);
   1022                         result += UnicodeString(digitString);
   1023                     }
   1024                     else {
   1025                         result += UNICODE_STRING_SIMPLE("  n ");
   1026                     }
   1027                     if (andRule->rangeHigh==-1) {
   1028                         if (andRule->notIn) {
   1029                             result += UNICODE_STRING_SIMPLE(" is not ");
   1030                             uprv_itou(digitString,16, andRule->rangeLow,10,0);
   1031                             result += UnicodeString(digitString);
   1032                         }
   1033                         else {
   1034                             result += UNICODE_STRING_SIMPLE(" is ");
   1035                             uprv_itou(digitString,16, andRule->rangeLow,10,0);
   1036                             result += UnicodeString(digitString);
   1037                         }
   1038                     }
   1039                     else {
   1040                         if (andRule->notIn) {
   1041                             if ( andRule->integerOnly ) {
   1042                                 result += UNICODE_STRING_SIMPLE("  not in ");
   1043                             }
   1044                             else {
   1045                                 result += UNICODE_STRING_SIMPLE("  not within ");
   1046                             }
   1047                             uprv_itou(digitString,16, andRule->rangeLow,10,0);
   1048                             result += UnicodeString(digitString);
   1049                             result += UNICODE_STRING_SIMPLE(" .. ");
   1050                             uprv_itou(digitString,16, andRule->rangeHigh,10,0);
   1051                             result += UnicodeString(digitString);
   1052                         }
   1053                         else {
   1054                             if ( andRule->integerOnly ) {
   1055                                 result += UNICODE_STRING_SIMPLE(" in ");
   1056                             }
   1057                             else {
   1058                                 result += UNICODE_STRING_SIMPLE(" within ");
   1059                             }
   1060                             uprv_itou(digitString,16, andRule->rangeLow,10,0);
   1061                             result += UnicodeString(digitString);
   1062                             result += UNICODE_STRING_SIMPLE(" .. ");
   1063                             uprv_itou(digitString,16, andRule->rangeHigh,10,0);
   1064                         }
   1065                     }
   1066                 }
   1067                 if ( (andRule=andRule->next) != NULL) {
   1068                     result.append(PK_AND, 3);
   1069                 }
   1070             }
   1071             if ( (orRule = orRule->next) != NULL ) {
   1072                 result.append(PK_OR, 2);
   1073             }
   1074         }
   1075     }
   1076     if ( next != NULL ) {
   1077         next->dumpRules(result);
   1078     }
   1079 }
   1080 
   1081 int32_t
   1082 RuleChain::getRepeatLimit () {
   1083     return repeatLimit;
   1084 }
   1085 
   1086 void
   1087 RuleChain::setRepeatLimit () {
   1088     int32_t limit=0;
   1089 
   1090     if ( next != NULL ) {
   1091         next->setRepeatLimit();
   1092         limit = next->repeatLimit;
   1093     }
   1094 
   1095     if ( ruleHeader != NULL ) {
   1096         OrConstraint* orRule=ruleHeader;
   1097         while ( orRule != NULL ) {
   1098             AndConstraint* andRule=orRule->childNode;
   1099             while ( andRule != NULL ) {
   1100                 limit = andRule->updateRepeatLimit(limit);
   1101                 andRule = andRule->next;
   1102             }
   1103             orRule = orRule->next;
   1104         }
   1105     }
   1106     repeatLimit = limit;
   1107 }
   1108 
   1109 UErrorCode
   1110 RuleChain::getKeywords(int32_t capacityOfKeywords, UnicodeString* keywords, int32_t& arraySize) const {
   1111     if ( arraySize < capacityOfKeywords-1 ) {
   1112         keywords[arraySize++]=keyword;
   1113     }
   1114     else {
   1115         return U_BUFFER_OVERFLOW_ERROR;
   1116     }
   1117 
   1118     if ( next != NULL ) {
   1119         return next->getKeywords(capacityOfKeywords, keywords, arraySize);
   1120     }
   1121     else {
   1122         return U_ZERO_ERROR;
   1123     }
   1124 }
   1125 
   1126 UBool
   1127 RuleChain::isKeyword(const UnicodeString& keywordParam) const {
   1128     if ( keyword == keywordParam ) {
   1129         return TRUE;
   1130     }
   1131 
   1132     if ( next != NULL ) {
   1133         return next->isKeyword(keywordParam);
   1134     }
   1135     else {
   1136         return FALSE;
   1137     }
   1138 }
   1139 
   1140 
   1141 RuleParser::RuleParser() {
   1142 }
   1143 
   1144 RuleParser::~RuleParser() {
   1145 }
   1146 
   1147 void
   1148 RuleParser::checkSyntax(tokenType prevType, tokenType curType, UErrorCode &status)
   1149 {
   1150     if (U_FAILURE(status)) {
   1151         return;
   1152     }
   1153     switch(prevType) {
   1154     case none:
   1155     case tSemiColon:
   1156         if (curType!=tKeyword) {
   1157             status = U_UNEXPECTED_TOKEN;
   1158         }
   1159         break;
   1160     case tVariableN :
   1161         if (curType != tIs && curType != tMod && curType != tIn &&
   1162             curType != tNot && curType != tWithin) {
   1163             status = U_UNEXPECTED_TOKEN;
   1164         }
   1165         break;
   1166     case tZero:
   1167     case tOne:
   1168     case tTwo:
   1169     case tFew:
   1170     case tMany:
   1171     case tOther:
   1172     case tKeyword:
   1173         if (curType != tColon) {
   1174             status = U_UNEXPECTED_TOKEN;
   1175         }
   1176         break;
   1177     case tColon :
   1178         if (curType != tVariableN) {
   1179             status = U_UNEXPECTED_TOKEN;
   1180         }
   1181         break;
   1182     case tIs:
   1183         if ( curType != tNumber && curType != tNot) {
   1184             status = U_UNEXPECTED_TOKEN;
   1185         }
   1186         break;
   1187     case tNot:
   1188         if (curType != tNumber && curType != tIn && curType != tWithin) {
   1189             status = U_UNEXPECTED_TOKEN;
   1190         }
   1191         break;
   1192     case tMod:
   1193     case tDot:
   1194     case tIn:
   1195     case tWithin:
   1196     case tAnd:
   1197     case tOr:
   1198         if (curType != tNumber && curType != tVariableN) {
   1199             status = U_UNEXPECTED_TOKEN;
   1200         }
   1201         break;
   1202     case tNumber:
   1203         if (curType != tDot && curType != tSemiColon && curType != tIs && curType != tNot &&
   1204             curType != tIn && curType != tWithin && curType != tAnd && curType != tOr)
   1205         {
   1206             status = U_UNEXPECTED_TOKEN;
   1207         }
   1208         break;
   1209     default:
   1210         status = U_UNEXPECTED_TOKEN;
   1211         break;
   1212     }
   1213 }
   1214 
   1215 void
   1216 RuleParser::getNextToken(const UnicodeString& ruleData,
   1217                          int32_t *ruleIndex,
   1218                          UnicodeString& token,
   1219                          tokenType& type,
   1220                          UErrorCode &status)
   1221 {
   1222     int32_t curIndex= *ruleIndex;
   1223     UChar ch;
   1224     tokenType prevType=none;
   1225 
   1226     if (U_FAILURE(status)) {
   1227         return;
   1228     }
   1229     while (curIndex<ruleData.length()) {
   1230         ch = ruleData.charAt(curIndex);
   1231         if ( !inRange(ch, type) ) {
   1232             status = U_ILLEGAL_CHARACTER;
   1233             return;
   1234         }
   1235         switch (type) {
   1236         case tSpace:
   1237             if ( *ruleIndex != curIndex ) { // letter
   1238                 token=UnicodeString(ruleData, *ruleIndex, curIndex-*ruleIndex);
   1239                 *ruleIndex=curIndex;
   1240                 type=prevType;
   1241                 getKeyType(token, type, status);
   1242                 return;
   1243             }
   1244             else {
   1245                 *ruleIndex=*ruleIndex+1;
   1246             }
   1247             break; // consective space
   1248         case tColon:
   1249         case tSemiColon:
   1250             if ( *ruleIndex != curIndex ) {
   1251                 token=UnicodeString(ruleData, *ruleIndex, curIndex-*ruleIndex);
   1252                 *ruleIndex=curIndex;
   1253                 type=prevType;
   1254                 getKeyType(token, type, status);
   1255                 return;
   1256             }
   1257             else {
   1258                 *ruleIndex=curIndex+1;
   1259                 return;
   1260             }
   1261         case tLetter:
   1262              if ((type==prevType)||(prevType==none)) {
   1263                 prevType=type;
   1264                 break;
   1265              }
   1266              break;
   1267         case tNumber:
   1268              if ((type==prevType)||(prevType==none)) {
   1269                 prevType=type;
   1270                 break;
   1271              }
   1272              else {
   1273                 *ruleIndex=curIndex+1;
   1274                 return;
   1275              }
   1276          case tDot:
   1277              if (prevType==none) {  // first dot
   1278                 prevType=type;
   1279                 continue;
   1280              }
   1281              else {
   1282                  if ( *ruleIndex != curIndex ) {
   1283                     token=UnicodeString(ruleData, *ruleIndex, curIndex-*ruleIndex);
   1284                     *ruleIndex=curIndex;  // letter
   1285                     type=prevType;
   1286                     getKeyType(token, type, status);
   1287                     return;
   1288                  }
   1289                  else {  // two consective dots
   1290                     *ruleIndex=curIndex+2;
   1291                     return;
   1292                  }
   1293              }
   1294          default:
   1295              status = U_UNEXPECTED_TOKEN;
   1296              return;
   1297         }
   1298         curIndex++;
   1299     }
   1300     if ( curIndex>=ruleData.length() ) {
   1301         if ( (type == tLetter)||(type == tNumber) ) {
   1302             token=UnicodeString(ruleData, *ruleIndex, curIndex-*ruleIndex);
   1303             getKeyType(token, type, status);
   1304             if (U_FAILURE(status)) {
   1305                 return;
   1306             }
   1307         }
   1308         *ruleIndex = ruleData.length();
   1309     }
   1310 }
   1311 
   1312 UBool
   1313 RuleParser::inRange(UChar ch, tokenType& type) {
   1314     if ((ch>=CAP_A) && (ch<=CAP_Z)) {
   1315         // we assume all characters are in lower case already.
   1316         return FALSE;
   1317     }
   1318     if ((ch>=LOW_A) && (ch<=LOW_Z)) {
   1319         type = tLetter;
   1320         return TRUE;
   1321     }
   1322     if ((ch>=U_ZERO) && (ch<=U_NINE)) {
   1323         type = tNumber;
   1324         return TRUE;
   1325     }
   1326     switch (ch) {
   1327     case COLON:
   1328         type = tColon;
   1329         return TRUE;
   1330     case SPACE:
   1331         type = tSpace;
   1332         return TRUE;
   1333     case SEMI_COLON:
   1334         type = tSemiColon;
   1335         return TRUE;
   1336     case DOT:
   1337         type = tDot;
   1338         return TRUE;
   1339     default :
   1340         type = none;
   1341         return FALSE;
   1342     }
   1343 }
   1344 
   1345 
   1346 void
   1347 RuleParser::getKeyType(const UnicodeString& token, tokenType& keyType, UErrorCode &status)
   1348 {
   1349     if (U_FAILURE(status)) {
   1350         return;
   1351     }
   1352     if ( keyType==tNumber) {
   1353     }
   1354     else if (0 == token.compare(PK_VAR_N, 1)) {
   1355         keyType = tVariableN;
   1356     }
   1357     else if (0 == token.compare(PK_IS, 2)) {
   1358         keyType = tIs;
   1359     }
   1360     else if (0 == token.compare(PK_AND, 3)) {
   1361         keyType = tAnd;
   1362     }
   1363     else if (0 == token.compare(PK_IN, 2)) {
   1364         keyType = tIn;
   1365     }
   1366     else if (0 == token.compare(PK_WITHIN, 6)) {
   1367         keyType = tWithin;
   1368     }
   1369     else if (0 == token.compare(PK_NOT, 3)) {
   1370         keyType = tNot;
   1371     }
   1372     else if (0 == token.compare(PK_MOD, 3)) {
   1373         keyType = tMod;
   1374     }
   1375     else if (0 == token.compare(PK_OR, 2)) {
   1376         keyType = tOr;
   1377     }
   1378     else if ( isValidKeyword(token) ) {
   1379         keyType = tKeyword;
   1380     }
   1381     else {
   1382         status = U_UNEXPECTED_TOKEN;
   1383     }
   1384 }
   1385 
   1386 UBool
   1387 RuleParser::isValidKeyword(const UnicodeString& token) {
   1388     return PatternProps::isIdentifier(token.getBuffer(), token.length());
   1389 }
   1390 
   1391 PluralKeywordEnumeration::PluralKeywordEnumeration(RuleChain *header, UErrorCode& status)
   1392         : pos(0), fKeywordNames(status) {
   1393     if (U_FAILURE(status)) {
   1394         return;
   1395     }
   1396     fKeywordNames.setDeleter(uprv_deleteUObject);
   1397     UBool  addKeywordOther=TRUE;
   1398     RuleChain *node=header;
   1399     while(node!=NULL) {
   1400         fKeywordNames.addElement(new UnicodeString(node->keyword), status);
   1401         if (U_FAILURE(status)) {
   1402             return;
   1403         }
   1404         if (0 == node->keyword.compare(PLURAL_KEYWORD_OTHER, 5)) {
   1405             addKeywordOther= FALSE;
   1406         }
   1407         node=node->next;
   1408     }
   1409 
   1410     if (addKeywordOther) {
   1411         fKeywordNames.addElement(new UnicodeString(PLURAL_KEYWORD_OTHER), status);
   1412     }
   1413 }
   1414 
   1415 const UnicodeString*
   1416 PluralKeywordEnumeration::snext(UErrorCode& status) {
   1417     if (U_SUCCESS(status) && pos < fKeywordNames.size()) {
   1418         return (const UnicodeString*)fKeywordNames.elementAt(pos++);
   1419     }
   1420     return NULL;
   1421 }
   1422 
   1423 void
   1424 PluralKeywordEnumeration::reset(UErrorCode& /*status*/) {
   1425     pos=0;
   1426 }
   1427 
   1428 int32_t
   1429 PluralKeywordEnumeration::count(UErrorCode& /*status*/) const {
   1430        return fKeywordNames.size();
   1431 }
   1432 
   1433 PluralKeywordEnumeration::~PluralKeywordEnumeration() {
   1434 }
   1435 
   1436 U_NAMESPACE_END
   1437 
   1438 
   1439 #endif /* #if !UCONFIG_NO_FORMATTING */
   1440 
   1441 //eof
   1442