ICU 56 update step 1

source/i18n/nfrs.cpp

 /*
 ******************************************************************************
-*   Copyright (C) 1997-2014, International Business Machines
+*   Copyright (C) 1997-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 *   file name:  nfrs.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 * Modification history
 * Date        Name      Comments
 * 10/11/2001  Doug      Ported from ICU4J
 */
 
 #include "nfrs.h"
 
 #if U_HAVE_RBNF
 
 #include "unicode/uchar.h"
 #include "nfrule.h"
 #include "nfrlist.h"
 #include "patternprops.h"
 
 #ifdef RBNF_DEBUG
 #include "cmemory.h"
 #endif
 
+enum {
+    /** -x */
+    NEGATIVE_RULE_INDEX = 0,
+    /** x.x */
+    IMPROPER_FRACTION_RULE_INDEX = 1,
+    /** 0.x */
+    PROPER_FRACTION_RULE_INDEX = 2,
+    /** x.0 */
+    MASTER_RULE_INDEX = 3,
+    /** Inf */
+    INFINITY_RULE_INDEX = 4,
+    /** NaN */
+    NAN_RULE_INDEX = 5,
+    NON_NUMERICAL_RULE_LENGTH = 6
+};
+
 U_NAMESPACE_BEGIN
 
 #if 0
 // euclid's algorithm works with doubles
 // note, doubles only get us up to one quadrillion or so, which
 // isn't as much range as we get with longs.  We probably still
 // want either 64-bit math, or BigInteger.
 
 static int64_t
 util_lcm(int64_t x, int64_t y)
@@ skipping 58 matching lines @@
     // x * y == gcd(x, y) * lcm(x, y)
     return x / gcd * y;
 }
 #endif
 
 static const UChar gPercent = 0x0025;
 static const UChar gColon = 0x003a;
 static const UChar gSemicolon = 0x003b;
 static const UChar gLineFeed = 0x000a;
 
-static const UChar gFourSpaces[] =
-{
-    0x20, 0x20, 0x20, 0x20, 0
-}; /* "    " */
 static const UChar gPercentPercent[] =
 {
     0x25, 0x25, 0
 }; /* "%%" */
 
 static const UChar gNoparse[] =
 {
     0x40, 0x6E, 0x6F, 0x70, 0x61, 0x72, 0x73, 0x65, 0
 }; /* "@noparse" */
 
-NFRuleSet::NFRuleSet(UnicodeString* descriptions, int32_t index, UErrorCode& status)
+NFRuleSet::NFRuleSet(RuleBasedNumberFormat *_owner, UnicodeString* descriptions, int32_t index, UErrorCode& status)
   : name()
   , rules(0)
-  , negativeNumberRule(NULL)
+  , owner(_owner)
+  , fractionRules()
   , fIsFractionRuleSet(FALSE)
   , fIsPublic(FALSE)
   , fIsParseable(TRUE)
-  , fRecursionCount(0)
 {
-    for (int i = 0; i < 3; ++i) {
-        fractionRules[i] = NULL;
+    for (int32_t i = 0; i < NON_NUMERICAL_RULE_LENGTH; ++i) {
+        nonNumericalRules[i] = NULL;
     }
 
     if (U_FAILURE(status)) {
         return;
     }
 
     UnicodeString& description = descriptions[index]; // !!! make sure index is valid
 
     if (description.length() == 0) {
         // throw new IllegalArgumentException("Empty rule set description");
@@ skipping 30 matching lines @@
     if ( name.endsWith(gNoparse,8) ) {
         fIsParseable = FALSE;
         name.truncate(name.length()-8); // remove the @noparse from the name
     }
 
     // all of the other members of NFRuleSet are initialized
     // by parseRules()
 }
 
 void
-NFRuleSet::parseRules(UnicodeString& description, const RuleBasedNumberFormat* owner, UErrorCode& status)
+NFRuleSet::parseRules(UnicodeString& description, UErrorCode& status)
 {
     // start by creating a Vector whose elements are Strings containing
     // the descriptions of the rules (one rule per element).  The rules
     // are separated by semicolons (there's no escape facility: ALL
     // semicolons are rule delimiters)
 
     if (U_FAILURE(status)) {
         return;
     }
 
@@ skipping 17 matching lines @@
 
     // for rules that didn't specify a base value, their base values
     // were initialized to 0.  Make another pass through the list and
     // set all those rules' base values.  We also remove any special
     // rules from the list and put them into their own member variables
     int64_t defaultBaseValue = 0;
 
     // (this isn't a for loop because we might be deleting items from
     // the vector-- we want to make sure we only increment i when
     // we _didn't_ delete aything from the vector)
-    uint32_t i = 0;
-    while (i < rules.size()) {
+    int32_t rulesSize = rules.size();
+    for (int32_t i = 0; i < rulesSize; i++) {
         NFRule* rule = rules[i];
+        int64_t baseValue = rule->getBaseValue();
 
-        switch (rule->getType()) {
+        if (baseValue == 0) {
             // if the rule's base value is 0, fill in a default
             // base value (this will be 1 plus the preceding
             // rule's base value for regular rule sets, and the
             // same as the preceding rule's base value in fraction
             // rule sets)
-        case NFRule::kNoBase:
             rule->setBaseValue(defaultBaseValue, status);
-            if (!isFractionRuleSet()) {
-                ++defaultBaseValue;
-            }
-            ++i;
-            break;
-
-            // if it's the negative-number rule, copy it into its own
-            // data member and delete it from the list
-        case NFRule::kNegativeNumberRule:
-            if (negativeNumberRule) {
-                delete negativeNumberRule;
-            }
-            negativeNumberRule = rules.remove(i);
-            break;
-
-            // if it's the improper fraction rule, copy it into the
-            // correct element of fractionRules
-        case NFRule::kImproperFractionRule:
-            if (fractionRules[0]) {
-                delete fractionRules[0];
-            }
-            fractionRules[0] = rules.remove(i);
-            break;
-
-            // if it's the proper fraction rule, copy it into the
-            // correct element of fractionRules
-        case NFRule::kProperFractionRule:
-            if (fractionRules[1]) {
-                delete fractionRules[1];
-            }
-            fractionRules[1] = rules.remove(i);
-            break;
-
-            // if it's the master rule, copy it into the
-            // correct element of fractionRules
-        case NFRule::kMasterRule:
-            if (fractionRules[2]) {
-                delete fractionRules[2];
-            }
-            fractionRules[2] = rules.remove(i);
-            break;
-
+        }
+        else {
             // if it's a regular rule that already knows its base value,
             // check to make sure the rules are in order, and update
             // the default base value for the next rule
-        default:
-            if (rule->getBaseValue() < defaultBaseValue) {
+            if (baseValue < defaultBaseValue) {
                 // throw new IllegalArgumentException("Rules are not in order");
                 status = U_PARSE_ERROR;
                 return;
             }
-            defaultBaseValue = rule->getBaseValue();
-            if (!isFractionRuleSet()) {
-                ++defaultBaseValue;
-            }
-            ++i;
-            break;
+            defaultBaseValue = baseValue;
         }
+        if (!fIsFractionRuleSet) {
+            ++defaultBaseValue;
+        }
+    }
+}
+
+/**
+ * Set one of the non-numerical rules.
+ * @param rule The rule to set.
+ */
+void NFRuleSet::setNonNumericalRule(NFRule *rule) {
+    int64_t baseValue = rule->getBaseValue();
+    if (baseValue == NFRule::kNegativeNumberRule) {
+        delete nonNumericalRules[NEGATIVE_RULE_INDEX];
+        nonNumericalRules[NEGATIVE_RULE_INDEX] = rule;
+    }
+    else if (baseValue == NFRule::kImproperFractionRule) {
+        setBestFractionRule(IMPROPER_FRACTION_RULE_INDEX, rule, TRUE);
+    }
+    else if (baseValue == NFRule::kProperFractionRule) {
+        setBestFractionRule(PROPER_FRACTION_RULE_INDEX, rule, TRUE);
+    }
+    else if (baseValue == NFRule::kMasterRule) {
+        setBestFractionRule(MASTER_RULE_INDEX, rule, TRUE);
+    }
+    else if (baseValue == NFRule::kInfinityRule) {
+        delete nonNumericalRules[INFINITY_RULE_INDEX];
+        nonNumericalRules[INFINITY_RULE_INDEX] = rule;
+    }
+    else if (baseValue == NFRule::kNaNRule) {
+        delete nonNumericalRules[NAN_RULE_INDEX];
+        nonNumericalRules[NAN_RULE_INDEX] = rule;
+    }
+}
+
+/**
+ * Determine the best fraction rule to use. Rules matching the decimal point from
+ * DecimalFormatSymbols become the main set of rules to use.
+ * @param originalIndex The index into nonNumericalRules
+ * @param newRule The new rule to consider
+ * @param rememberRule Should the new rule be added to fractionRules.
+ */
+void NFRuleSet::setBestFractionRule(int32_t originalIndex, NFRule *newRule, UBool rememberRule) {
+    if (rememberRule) {
+        fractionRules.add(newRule);
+    }
+    NFRule *bestResult = nonNumericalRules[originalIndex];
+    if (bestResult == NULL) {
+        nonNumericalRules[originalIndex] = newRule;
+    }
+    else {
+        // We have more than one. Which one is better?
+        const DecimalFormatSymbols *decimalFormatSymbols = owner->getDecimalFormatSymbols();
+        if (decimalFormatSymbols->getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol).charAt(0)
+            == newRule->getDecimalPoint())
+        {
+            nonNumericalRules[originalIndex] = newRule;
+        }
+        // else leave it alone
     }
 }
 
 NFRuleSet::~NFRuleSet()
 {
-    delete negativeNumberRule;
-    delete fractionRules[0];
-    delete fractionRules[1];
-    delete fractionRules[2];
+    for (int i = 0; i < NON_NUMERICAL_RULE_LENGTH; i++) {
+        if (i != IMPROPER_FRACTION_RULE_INDEX
+            && i != PROPER_FRACTION_RULE_INDEX
+            && i != MASTER_RULE_INDEX)
+        {
+            delete nonNumericalRules[i];
+        }
+        // else it will be deleted via NFRuleList fractionRules
+    }
 }
 
 static UBool
 util_equalRules(const NFRule* rule1, const NFRule* rule2)
 {
     if (rule1) {
         if (rule2) {
             return *rule1 == *rule2;
         }
     } else if (!rule2) {
         return TRUE;
     }
     return FALSE;
 }
 
 UBool
 NFRuleSet::operator==(const NFRuleSet& rhs) const
 {
     if (rules.size() == rhs.rules.size() &&
         fIsFractionRuleSet == rhs.fIsFractionRuleSet &&
-        name == rhs.name &&
-        util_equalRules(negativeNumberRule, rhs.negativeNumberRule) &&
-        util_equalRules(fractionRules[0], rhs.fractionRules[0]) &&
-        util_equalRules(fractionRules[1], rhs.fractionRules[1]) &&
-        util_equalRules(fractionRules[2], rhs.fractionRules[2])) {
+        name == rhs.name) {
 
+        // ...then compare the non-numerical rule lists...
+        for (int i = 0; i < NON_NUMERICAL_RULE_LENGTH; i++) {
+            if (!util_equalRules(nonNumericalRules[i], rhs.nonNumericalRules[i])) {
+                return FALSE;
+            }
+        }
+
+        // ...then compare the rule lists...
         for (uint32_t i = 0; i < rules.size(); ++i) {
             if (*rules[i] != *rhs.rules[i]) {
                 return FALSE;
             }
         }
         return TRUE;
     }
     return FALSE;
 }
 
-#define RECURSION_LIMIT 50
+void
+NFRuleSet::setDecimalFormatSymbols(const DecimalFormatSymbols &newSymbols, UErrorCode& status) {
+    for (uint32_t i = 0; i < rules.size(); ++i) {
+        rules[i]->setDecimalFormatSymbols(newSymbols, status);
+    }
+    // Switch the fraction rules to mirror the DecimalFormatSymbols.
+    for (int32_t nonNumericalIdx = IMPROPER_FRACTION_RULE_INDEX; nonNumericalIdx <= MASTER_RULE_INDEX; nonNumericalIdx++) {
+        if (nonNumericalRules[nonNumericalIdx]) {
+            for (uint32_t fIdx = 0; fIdx < fractionRules.size(); fIdx++) {
+                NFRule *fractionRule = fractionRules[fIdx];
+                if (nonNumericalRules[nonNumericalIdx]->getBaseValue() == fractionRule->getBaseValue()) {
+                    setBestFractionRule(nonNumericalIdx, fractionRule, FALSE);
+                }
+            }
+        }
+    }
 
-void
-NFRuleSet::format(int64_t number, UnicodeString& toAppendTo, int32_t pos, UErrorCode& status) const
-{
-    NFRule *rule = findNormalRule(number);
-    if (rule) { // else error, but can't report it
-        NFRuleSet* ncThis = (NFRuleSet*)this;
-        if (ncThis->fRecursionCount++ >= RECURSION_LIMIT) {
-            // stop recursion
-            ncThis->fRecursionCount = 0;
-        } else {
-            rule->doFormat(number, toAppendTo, pos, status);
-            ncThis->fRecursionCount--;
+    for (uint32_t nnrIdx = 0; nnrIdx < NON_NUMERICAL_RULE_LENGTH; nnrIdx++) {
+        NFRule *rule = nonNumericalRules[nnrIdx];
+        if (rule) {
+            rule->setDecimalFormatSymbols(newSymbols, status);
         }
     }
 }
 
+#define RECURSION_LIMIT 64
+
 void
-NFRuleSet::format(double number, UnicodeString& toAppendTo, int32_t pos, UErrorCode& status) const
+NFRuleSet::format(int64_t number, UnicodeString& toAppendTo, int32_t pos, int32_t recursionCount, UErrorCode& status) const
 {
-    NFRule *rule = findDoubleRule(number);
+    if (recursionCount >= RECURSION_LIMIT) {
+        // stop recursion
+        status = U_INVALID_STATE_ERROR;
+        return;
+    }
+    const NFRule *rule = findNormalRule(number);
     if (rule) { // else error, but can't report it
-        NFRuleSet* ncThis = (NFRuleSet*)this;
-        if (ncThis->fRecursionCount++ >= RECURSION_LIMIT) {
-            // stop recursion
-            ncThis->fRecursionCount = 0;
-        } else {
-            rule->doFormat(number, toAppendTo, pos, status);
-            ncThis->fRecursionCount--;
-        }
+        rule->doFormat(number, toAppendTo, pos, ++recursionCount, status);
     }
 }
 
-NFRule*
+void
+NFRuleSet::format(double number, UnicodeString& toAppendTo, int32_t pos, int32_t recursionCount, UErrorCode& status) const
+{
+    if (recursionCount >= RECURSION_LIMIT) {
+        // stop recursion
+        status = U_INVALID_STATE_ERROR;
+        return;
+    }
+    const NFRule *rule = findDoubleRule(number);
+    if (rule) { // else error, but can't report it
+        rule->doFormat(number, toAppendTo, pos, ++recursionCount, status);
+    }
+}
+
+const NFRule*
 NFRuleSet::findDoubleRule(double number) const
 {
     // if this is a fraction rule set, use findFractionRuleSetRule()
     if (isFractionRuleSet()) {
         return findFractionRuleSetRule(number);
     }
 
+    if (uprv_isNaN(number)) {
+        const NFRule *rule = nonNumericalRules[NAN_RULE_INDEX];
+        if (!rule) {
+            rule = owner->getDefaultNaNRule();
+        }
+        return rule;
+    }
+
     // if the number is negative, return the negative number rule
     // (if there isn't a negative-number rule, we pretend it's a
     // positive number)
     if (number < 0) {
-        if (negativeNumberRule) {
-            return  negativeNumberRule;
+        if (nonNumericalRules[NEGATIVE_RULE_INDEX]) {
+            return  nonNumericalRules[NEGATIVE_RULE_INDEX];
         } else {
             number = -number;
         }
     }
 
+    if (uprv_isInfinite(number)) {
+        const NFRule *rule = nonNumericalRules[INFINITY_RULE_INDEX];
+        if (!rule) {
+            rule = owner->getDefaultInfinityRule();
+        }
+        return rule;
+    }
+
     // if the number isn't an integer, we use one of the fraction rules...
     if (number != uprv_floor(number)) {
         // if the number is between 0 and 1, return the proper
         // fraction rule
-        if (number < 1 && fractionRules[1]) {
-            return fractionRules[1];
+        if (number < 1 && nonNumericalRules[PROPER_FRACTION_RULE_INDEX]) {
+            return nonNumericalRules[PROPER_FRACTION_RULE_INDEX];
         }
         // otherwise, return the improper fraction rule
-        else if (fractionRules[0]) {
-            return fractionRules[0];
+        else if (nonNumericalRules[IMPROPER_FRACTION_RULE_INDEX]) {
+            return nonNumericalRules[IMPROPER_FRACTION_RULE_INDEX];
         }
     }
 
     // if there's a master rule, use it to format the number
-    if (fractionRules[2]) {
-        return fractionRules[2];
+    if (nonNumericalRules[MASTER_RULE_INDEX]) {
+        return nonNumericalRules[MASTER_RULE_INDEX];
     }
 
     // and if we haven't yet returned a rule, use findNormalRule()
     // to find the applicable rule
     int64_t r = util64_fromDouble(number + 0.5);
     return findNormalRule(r);
 }
 
-NFRule *
+const NFRule *
 NFRuleSet::findNormalRule(int64_t number) const
 {
     // if this is a fraction rule set, use findFractionRuleSetRule()
     // to find the rule (we should only go into this clause if the
     // value is 0)
     if (fIsFractionRuleSet) {
         return findFractionRuleSetRule((double)number);
     }
 
     // if the number is negative, return the negative-number rule
     // (if there isn't one, pretend the number is positive)
     if (number < 0) {
-        if (negativeNumberRule) {
-            return negativeNumberRule;
+        if (nonNumericalRules[NEGATIVE_RULE_INDEX]) {
+            return nonNumericalRules[NEGATIVE_RULE_INDEX];
         } else {
             number = -number;
         }
     }
 
     // we have to repeat the preceding two checks, even though we
     // do them in findRule(), because the version of format() that
     // takes a long bypasses findRule() and goes straight to this
     // function.  This function does skip the fraction rules since
     // we know the value is an integer (it also skips the master
@@ skipping 36 matching lines @@
         // return
         if (result->shouldRollBack((double)number)) {
             if (hi == 1) { // bad rule set, no prior rule to rollback to from this base
                 return NULL;
             }
             result = rules[hi - 2];
         }
         return result;
     }
     // else use the master rule
-    return fractionRules[2];
+    return nonNumericalRules[MASTER_RULE_INDEX];
 }
 
 /**
  * If this rule is a fraction rule set, this function is used by
  * findRule() to select the most appropriate rule for formatting
  * the number.  Basically, the base value of each rule in the rule
  * set is treated as the denominator of a fraction.  Whichever
  * denominator can produce the fraction closest in value to the
  * number passed in is the result.  If there's a tie, the earlier
  * one in the list wins.  (If there are two rules in a row with the
  * same base value, the first one is used when the numerator of the
  * fraction would be 1, and the second rule is used the rest of the
  * time.
  * @param number The number being formatted (which will always be
  * a number between 0 and 1)
  * @return The rule to use to format this number
  */
-NFRule*
+const NFRule*
 NFRuleSet::findFractionRuleSetRule(double number) const
 {
     // the obvious way to do this (multiply the value being formatted
     // by each rule's base value until you get an integral result)
     // doesn't work because of rounding error.  This method is more
     // accurate
 
     // find the least common multiple of the rules' base values
     // and multiply this by the number being formatted.  This is
     // all the precision we need, and we can do all of the rest
@@ skipping 112 matching lines @@
     ParsePosition workingPos = pos;
 
 #ifdef RBNF_DEBUG
     fprintf(stderr, "<nfrs> %x '", this);
     dumpUS(stderr, name);
     fprintf(stderr, "' text '");
     dumpUS(stderr, text);
     fprintf(stderr, "'\n");
     fprintf(stderr, "  parse negative: %d\n", this, negativeNumberRule != 0);
 #endif
-
-    // start by trying the negative number rule (if there is one)
-    if (negativeNumberRule) {
-        Formattable tempResult;
-#ifdef RBNF_DEBUG
-        fprintf(stderr, "  <nfrs before negative> %x ub: %g\n", negativeNumberRule, upperBound);
-#endif
-        UBool success = negativeNumberRule->doParse(text, workingPos, 0, upperBound, tempResult);
-#ifdef RBNF_DEBUG
-        fprintf(stderr, "  <nfrs after negative> success: %d wpi: %d\n", success, workingPos.getIndex());
-#endif
-        if (success && workingPos.getIndex() > highWaterMark.getIndex()) {
-            result = tempResult;
-            highWaterMark = workingPos;
-        }
-        workingPos = pos;
-    }
-#ifdef RBNF_DEBUG
-    fprintf(stderr, "<nfrs> continue fractional with text '");
-    dumpUS(stderr, text);
-    fprintf(stderr, "' hwm: %d\n", highWaterMark.getIndex());
-#endif
-    // then try each of the fraction rules
-    {
-        for (int i = 0; i < 3; i++) {
-            if (fractionRules[i]) {
-                Formattable tempResult;
-                UBool success = fractionRules[i]->doParse(text, workingPos, 0, upperBound, tempResult);
-                if (success && (workingPos.getIndex() > highWaterMark.getIndex())) {
-                    result = tempResult;
-                    highWaterMark = workingPos;
-                }
-                workingPos = pos;
+    // Try each of the negative rules, fraction rules, infinity rules and NaN rules
+    for (int i = 0; i < NON_NUMERICAL_RULE_LENGTH; i++) {
+        if (nonNumericalRules[i]) {
+            Formattable tempResult;
+            UBool success = nonNumericalRules[i]->doParse(text, workingPos, 0, upperBound, tempResult);
+            if (success && (workingPos.getIndex() > highWaterMark.getIndex())) {
+                result = tempResult;
+                highWaterMark = workingPos;
             }
+            workingPos = pos;
         }
     }
 #ifdef RBNF_DEBUG
     fprintf(stderr, "<nfrs> continue other with text '");
     dumpUS(stderr, text);
     fprintf(stderr, "' hwm: %d\n", highWaterMark.getIndex());
 #endif
 
     // finally, go through the regular rules one at a time.  We start
     // at the end of the list because we want to try matching the most
@@ skipping 35 matching lines @@
     // first character we didn't use, and return the result that
     // corresponds to that string of characters
     pos = highWaterMark;
 
     return 1;
 }
 
 void
 NFRuleSet::appendRules(UnicodeString& result) const
 {
+    uint32_t i;
+
     // the rule set name goes first...
     result.append(name);
     result.append(gColon);
     result.append(gLineFeed);
 
     // followed by the regular rules...
-    for (uint32_t i = 0; i < rules.size(); i++) {
-        result.append(gFourSpaces, 4);
+    for (i = 0; i < rules.size(); i++) {
         rules[i]->_appendRuleText(result);
         result.append(gLineFeed);
     }
 
     // followed by the special rules (if they exist)
-    if (negativeNumberRule) {
-        result.append(gFourSpaces, 4);
-        negativeNumberRule->_appendRuleText(result);
-        result.append(gLineFeed);
-    }
-
-    {
-        for (uint32_t i = 0; i < 3; ++i) {
-            if (fractionRules[i]) {
-                result.append(gFourSpaces, 4);
-                fractionRules[i]->_appendRuleText(result);
+    for (i = 0; i < NON_NUMERICAL_RULE_LENGTH; ++i) {
+        NFRule *rule = nonNumericalRules[i];
+        if (nonNumericalRules[i]) {
+            if (rule->getBaseValue() == NFRule::kImproperFractionRule
+                || rule->getBaseValue() == NFRule::kProperFractionRule
+                || rule->getBaseValue() == NFRule::kMasterRule)
+            {
+                for (uint32_t fIdx = 0; fIdx < fractionRules.size(); fIdx++) {
+                    NFRule *fractionRule = fractionRules[fIdx];
+                    if (fractionRule->getBaseValue() == rule->getBaseValue()) {
+                        fractionRule->_appendRuleText(result);
+                        result.append(gLineFeed);
+                    }
+                }
+            }
+            else {
+                rule->_appendRuleText(result);
                 result.append(gLineFeed);
             }
         }
     }
 }
 
 // utility functions
 
 int64_t util64_fromDouble(double d) {
     int64_t result = 0;
@@ skipping 205 matching lines @@
 
     return len;
 }
 
 
 U_NAMESPACE_END
 
 /* U_HAVE_RBNF */
 #endif