ICU 56 update step 1

source/i18n/nfrule.cpp

 /*
 ******************************************************************************
-*   Copyright (C) 1997-2014, International Business Machines
+*   Copyright (C) 1997-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 *   file name:  nfrule.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 * Modification history
 * Date        Name      Comments
 * 10/11/2001  Doug      Ported from ICU4J
@@ skipping 10 matching lines @@
 #include "unicode/upluralrules.h"
 #include "unicode/coleitr.h"
 #include "unicode/uchar.h"
 #include "nfrs.h"
 #include "nfrlist.h"
 #include "nfsubs.h"
 #include "patternprops.h"
 
 U_NAMESPACE_BEGIN
 
-NFRule::NFRule(const RuleBasedNumberFormat* _rbnf)
+NFRule::NFRule(const RuleBasedNumberFormat* _rbnf, const UnicodeString &_ruleText, UErrorCode &status)
   : baseValue((int32_t)0)
-  , radix(0)
+  , radix(10)
   , exponent(0)
-  , ruleText()
+  , decimalPoint(0)
+  , ruleText(_ruleText)
   , sub1(NULL)
   , sub2(NULL)
   , formatter(_rbnf)
   , rulePatternFormat(NULL)
 {
+    if (!ruleText.isEmpty()) {
+        parseRuleDescriptor(ruleText, status);
+    }
 }
 
 NFRule::~NFRule()
 {
     if (sub1 != sub2) {
         delete sub2;
+        sub2 = NULL;
     }
     delete sub1;
+    sub1 = NULL;
     delete rulePatternFormat;
+    rulePatternFormat = NULL;
 }
 
 static const UChar gLeftBracket = 0x005b;
 static const UChar gRightBracket = 0x005d;
 static const UChar gColon = 0x003a;
 static const UChar gZero = 0x0030;
 static const UChar gNine = 0x0039;
 static const UChar gSpace = 0x0020;
 static const UChar gSlash = 0x002f;
 static const UChar gGreaterThan = 0x003e;
 static const UChar gLessThan = 0x003c;
 static const UChar gComma = 0x002c;
 static const UChar gDot = 0x002e;
 static const UChar gTick = 0x0027;
 //static const UChar gMinus = 0x002d;
 static const UChar gSemicolon = 0x003b;
+static const UChar gX = 0x0078;
 
 static const UChar gMinusX[] =                  {0x2D, 0x78, 0};    /* "-x" */
-static const UChar gXDotX[] =                   {0x78, 0x2E, 0x78, 0}; /* "x.x" */
-static const UChar gXDotZero[] =                {0x78, 0x2E, 0x30, 0}; /* "x.0" */
-static const UChar gZeroDotX[] =                {0x30, 0x2E, 0x78, 0}; /* "0.x" */
+static const UChar gInf[] =                     {0x49, 0x6E, 0x66, 0}; /* "Inf" */
+static const UChar gNaN[] =                     {0x4E, 0x61, 0x4E, 0}; /* "NaN" */
 
 static const UChar gDollarOpenParenthesis[] =   {0x24, 0x28, 0}; /* "$(" */
 static const UChar gClosedParenthesisDollar[] = {0x29, 0x24, 0}; /* ")$" */
 
 static const UChar gLessLess[] =                {0x3C, 0x3C, 0};    /* "<<" */
 static const UChar gLessPercent[] =             {0x3C, 0x25, 0};    /* "<%" */
 static const UChar gLessHash[] =                {0x3C, 0x23, 0};    /* "<#" */
 static const UChar gLessZero[] =                {0x3C, 0x30, 0};    /* "<0" */
 static const UChar gGreaterGreater[] =          {0x3E, 0x3E, 0};    /* ">>" */
 static const UChar gGreaterPercent[] =          {0x3E, 0x25, 0};    /* ">%" */
 static const UChar gGreaterHash[] =             {0x3E, 0x23, 0};    /* ">#" */
 static const UChar gGreaterZero[] =             {0x3E, 0x30, 0};    /* ">0" */
 static const UChar gEqualPercent[] =            {0x3D, 0x25, 0};    /* "=%" */
 static const UChar gEqualHash[] =               {0x3D, 0x23, 0};    /* "=#" */
 static const UChar gEqualZero[] =               {0x3D, 0x30, 0};    /* "=0" */
 static const UChar gGreaterGreaterGreater[] =   {0x3E, 0x3E, 0x3E, 0}; /* ">>>" */
 
-static const UChar * const tokenStrings[] = {
+static const UChar * const RULE_PREFIXES[] = {
     gLessLess, gLessPercent, gLessHash, gLessZero,
     gGreaterGreater, gGreaterPercent,gGreaterHash, gGreaterZero,
     gEqualPercent, gEqualHash, gEqualZero, NULL
 };
 
 void
 NFRule::makeRules(UnicodeString& description,
-                  const NFRuleSet *ruleSet,
+                  NFRuleSet *owner,
                   const NFRule *predecessor,
                   const RuleBasedNumberFormat *rbnf,
                   NFRuleList& rules,
                   UErrorCode& status)
 {
     // we know we're making at least one rule, so go ahead and
     // new it up and initialize its basevalue and divisor
     // (this also strips the rule descriptor, if any, off the
     // descripton string)
-    NFRule* rule1 = new NFRule(rbnf);
+    NFRule* rule1 = new NFRule(rbnf, description, status);
     /* test for NULL */
     if (rule1 == 0) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
-    rule1->parseRuleDescriptor(description, status);
+    description = rule1->ruleText;
 
     // check the description to see whether there's text enclosed
     // in brackets
     int32_t brack1 = description.indexOf(gLeftBracket);
-    int32_t brack2 = description.indexOf(gRightBracket);
+    int32_t brack2 = brack1 < 0 ? -1 : description.indexOf(gRightBracket);
 
     // if the description doesn't contain a matched pair of brackets,
     // or if it's of a type that doesn't recognize bracketed text,
     // then leave the description alone, initialize the rule's
     // rule text and substitutions, and return that rule
-    if (brack1 == -1 || brack2 == -1 || brack1 > brack2
+    if (brack2 < 0 || brack1 > brack2
         || rule1->getType() == kProperFractionRule
-        || rule1->getType() == kNegativeNumberRule) {
-        rule1->extractSubstitutions(ruleSet, description, predecessor, status);
-        rules.add(rule1);
-    } else {
+        || rule1->getType() == kNegativeNumberRule
+        || rule1->getType() == kInfinityRule
+        || rule1->getType() == kNaNRule)
+    {
+        rule1->extractSubstitutions(owner, description, predecessor, status);
+    }
+    else {
         // if the description does contain a matched pair of brackets,
         // then it's really shorthand for two rules (with one exception)
         NFRule* rule2 = NULL;
         UnicodeString sbuf;
 
         // we'll actually only split the rule into two rules if its
         // base value is an even multiple of its divisor (or it's one
         // of the special rules)
         if ((rule1->baseValue > 0
             && (rule1->baseValue % util64_pow(rule1->radix, rule1->exponent)) == 0)
             || rule1->getType() == kImproperFractionRule
             || rule1->getType() == kMasterRule) {
 
             // if it passes that test, new up the second rule.  If the
             // rule set both rules will belong to is a fraction rule
             // set, they both have the same base value; otherwise,
             // increment the original rule's base value ("rule1" actually
             // goes SECOND in the rule set's rule list)
-            rule2 = new NFRule(rbnf);
+            rule2 = new NFRule(rbnf, UnicodeString(), status);
             /* test for NULL */
             if (rule2 == 0) {
                 status = U_MEMORY_ALLOCATION_ERROR;
                 return;
             }
             if (rule1->baseValue >= 0) {
                 rule2->baseValue = rule1->baseValue;
-                if (!ruleSet->isFractionRuleSet()) {
+                if (!owner->isFractionRuleSet()) {
                     ++rule1->baseValue;
                 }
             }
 
             // if the description began with "x.x" and contains bracketed
             // text, it describes both the improper fraction rule and
             // the proper fraction rule
             else if (rule1->getType() == kImproperFractionRule) {
                 rule2->setType(kProperFractionRule);
             }
@@ skipping 10 matching lines @@
             // same divisor)
             rule2->radix = rule1->radix;
             rule2->exponent = rule1->exponent;
 
             // rule2's rule text omits the stuff in brackets: initalize
             // its rule text and substitutions accordingly
             sbuf.append(description, 0, brack1);
             if (brack2 + 1 < description.length()) {
                 sbuf.append(description, brack2 + 1, description.length() - brack2 - 1);
             }
-            rule2->extractSubstitutions(ruleSet, sbuf, predecessor, status);
+            rule2->extractSubstitutions(owner, sbuf, predecessor, status);
         }
 
         // rule1's text includes the text in the brackets but omits
         // the brackets themselves: initialize _its_ rule text and
         // substitutions accordingly
         sbuf.setTo(description, 0, brack1);
         sbuf.append(description, brack1 + 1, brack2 - brack1 - 1);
         if (brack2 + 1 < description.length()) {
             sbuf.append(description, brack2 + 1, description.length() - brack2 - 1);
         }
-        rule1->extractSubstitutions(ruleSet, sbuf, predecessor, status);
+        rule1->extractSubstitutions(owner, sbuf, predecessor, status);
 
         // if we only have one rule, return it; if we have two, return
         // a two-element array containing them (notice that rule2 goes
         // BEFORE rule1 in the list: in all cases, rule2 OMITS the
         // material in the brackets and rule1 INCLUDES the material
         // in the brackets)
         if (rule2 != NULL) {
-            rules.add(rule2);
+            if (rule2->baseValue >= kNoBase) {
+                rules.add(rule2);
+            }
+            else {
+                owner->setNonNumericalRule(rule2);
+            }
         }
+    }
+    if (rule1->baseValue >= kNoBase) {
         rules.add(rule1);
     }
+    else {
+        owner->setNonNumericalRule(rule1);
+    }
 }
 
 /**
  * This function parses the rule's rule descriptor (i.e., the base
  * value and/or other tokens that precede the rule's rule text
  * in the description) and sets the rule's base value, radix, and
  * exponent according to the descriptor.  (If the description doesn't
  * include a rule descriptor, then this function sets everything to
  * default values and the rule set sets the rule's real base value).
  * @param description The rule's description
  * @return If "description" included a rule descriptor, this is
  * "description" with the descriptor and any trailing whitespace
  * stripped off.  Otherwise; it's "descriptor" unchangd.
  */
 void
 NFRule::parseRuleDescriptor(UnicodeString& description, UErrorCode& status)
 {
     // the description consists of a rule descriptor and a rule body,
     // separated by a colon.  The rule descriptor is optional.  If
     // it's omitted, just set the base value to 0.
     int32_t p = description.indexOf(gColon);
-    if (p == -1) {
-        setBaseValue((int32_t)0, status);
-    } else {
+    if (p != -1) {
         // copy the descriptor out into its own string and strip it,
         // along with any trailing whitespace, out of the original
         // description
         UnicodeString descriptor;
         descriptor.setTo(description, 0, p);
 
         ++p;
         while (p < description.length() && PatternProps::isWhiteSpace(description.charAt(p))) {
             ++p;
         }
         description.removeBetween(0, p);
 
         // check first to see if the rule descriptor matches the token
         // for one of the special rules.  If it does, set the base
-        // value to the correct identfier value
-        if (0 == descriptor.compare(gMinusX, 2)) {
-            setType(kNegativeNumberRule);
-        }
-        else if (0 == descriptor.compare(gXDotX, 3)) {
-            setType(kImproperFractionRule);
-        }
-        else if (0 == descriptor.compare(gZeroDotX, 3)) {
-            setType(kProperFractionRule);
-        }
-        else if (0 == descriptor.compare(gXDotZero, 3)) {
-            setType(kMasterRule);
-        }
-
-        // if the rule descriptor begins with a digit, it's a descriptor
-        // for a normal rule
-        // since we don't have Long.parseLong, and this isn't much work anyway,
-        // just build up the value as we encounter the digits.
-        else if (descriptor.charAt(0) >= gZero && descriptor.charAt(0) <= gNine) {
+        // value to the correct identifier value
+        int descriptorLength = descriptor.length();
+        UChar firstChar = descriptor.charAt(0);
+        UChar lastChar = descriptor.charAt(descriptorLength - 1);
+        if (firstChar >= gZero && firstChar <= gNine && lastChar != gX) {
+            // if the rule descriptor begins with a digit, it's a descriptor
+            // for a normal rule
+            // since we don't have Long.parseLong, and this isn't much work anyway,
+            // just build up the value as we encounter the digits.
             int64_t val = 0;
             p = 0;
             UChar c = gSpace;
 
             // begin parsing the descriptor: copy digits
             // into "tempValue", skip periods, commas, and spaces,
             // stop on a slash or > sign (or at the end of the string),
             // and throw an exception on any other character
             int64_t ll_10 = 10;
-            while (p < descriptor.length()) {
+            while (p < descriptorLength) {
                 c = descriptor.charAt(p);
                 if (c >= gZero && c <= gNine) {
                     val = val * ll_10 + (int32_t)(c - gZero);
                 }
                 else if (c == gSlash || c == gGreaterThan) {
                     break;
                 }
                 else if (PatternProps::isWhiteSpace(c) || c == gComma || c == gDot) {
                 }
                 else {
                     // throw new IllegalArgumentException("Illegal character in rule descriptor");
                     status = U_PARSE_ERROR;
                     return;
                 }
                 ++p;
             }
 
             // we have the base value, so set it
             setBaseValue(val, status);
 
             // if we stopped the previous loop on a slash, we're
             // now parsing the rule's radix.  Again, accumulate digits
             // in tempValue, skip punctuation, stop on a > mark, and
             // throw an exception on anything else
             if (c == gSlash) {
                 val = 0;
                 ++p;
                 int64_t ll_10 = 10;
-                while (p < descriptor.length()) {
+                while (p < descriptorLength) {
                     c = descriptor.charAt(p);
                     if (c >= gZero && c <= gNine) {
                         val = val * ll_10 + (int32_t)(c - gZero);
                     }
                     else if (c == gGreaterThan) {
                         break;
                     }
                     else if (PatternProps::isWhiteSpace(c) || c == gComma || c == gDot) {
                     }
                     else {
@@ skipping 27 matching lines @@
                         --exponent;
                     } else {
                         // throw new IllegalArgumentException("Illegal character in rule descriptor");
                         status = U_PARSE_ERROR;
                         return;
                     }
                     ++p;
                 }
             }
         }
+        else if (0 == descriptor.compare(gMinusX, 2)) {
+            setType(kNegativeNumberRule);
+        }
+        else if (descriptorLength == 3) {
+            if (firstChar == gZero && lastChar == gX) {
+                setBaseValue(kProperFractionRule, status);
+                decimalPoint = descriptor.charAt(1);
+            }
+            else if (firstChar == gX && lastChar == gX) {
+                setBaseValue(kImproperFractionRule, status);
+                decimalPoint = descriptor.charAt(1);
+            }
+            else if (firstChar == gX && lastChar == gZero) {
+                setBaseValue(kMasterRule, status);
+                decimalPoint = descriptor.charAt(1);
+            }
+            else if (descriptor.compare(gNaN, 3) == 0) {
+                setBaseValue(kNaNRule, status);
+            }
+            else if (descriptor.compare(gInf, 3) == 0) {
+                setBaseValue(kInfinityRule, status);
+            }
+        }
     }
+    // else use the default base value for now.
 
     // finally, if the rule body begins with an apostrophe, strip it off
     // (this is generally used to put whitespace at the beginning of
     // a rule's rule text)
     if (description.length() > 0 && description.charAt(0) == gTick) {
         description.removeBetween(0, 1);
     }
 
     // return the description with all the stuff we've just waded through
     // stripped off the front.  It now contains just the rule body.
@@ skipping 11 matching lines @@
 void
 NFRule::extractSubstitutions(const NFRuleSet* ruleSet,
                              const UnicodeString &ruleText,
                              const NFRule* predecessor,
                              UErrorCode& status)
 {
     if (U_FAILURE(status)) {
         return;
     }
     this->ruleText = ruleText;
-    this->rulePatternFormat = NULL;
     sub1 = extractSubstitution(ruleSet, predecessor, status);
-    if (sub1 == NULL || sub1->isNullSubstitution()) {
+    if (sub1 == NULL) {
         // Small optimization. There is no need to create a redundant NullSubstitution.
-        sub2 = sub1;
+        sub2 = NULL;
     }
     else {
         sub2 = extractSubstitution(ruleSet, predecessor, status);
     }
     int32_t pluralRuleStart = this->ruleText.indexOf(gDollarOpenParenthesis, -1, 0);
     int32_t pluralRuleEnd = (pluralRuleStart >= 0 ? this->ruleText.indexOf(gClosedParenthesisDollar, -1, pluralRuleStart) : -1);
     if (pluralRuleEnd >= 0) {
         int32_t endType = this->ruleText.indexOf(gComma, pluralRuleStart);
         if (endType < 0) {
             status = U_PARSE_ERROR;
@@ skipping 30 matching lines @@
 */
 NFSubstitution *
 NFRule::extractSubstitution(const NFRuleSet* ruleSet,
                             const NFRule* predecessor,
                             UErrorCode& status)
 {
     NFSubstitution* result = NULL;
 
     // search the rule's rule text for the first two characters of
     // a substitution token
-    int32_t subStart = indexOfAny(tokenStrings);
+    int32_t subStart = indexOfAnyRulePrefix();
     int32_t subEnd = subStart;
 
     // if we didn't find one, create a null substitution positioned
     // at the end of the rule text
     if (subStart == -1) {
-        return NFSubstitution::makeSubstitution(ruleText.length(), this, predecessor,
-            ruleSet, this->formatter, UnicodeString(), status);
+        return NULL;
     }
 
     // special-case the ">>>" token, since searching for the > at the
     // end will actually find the > in the middle
     if (ruleText.indexOf(gGreaterGreaterGreater, 3, 0) == subStart) {
         subEnd = subStart + 2;
 
         // otherwise the substitution token ends with the same character
         // it began with
     } else {
         UChar c = ruleText.charAt(subStart);
         subEnd = ruleText.indexOf(c, subStart + 1);
         // special case for '<%foo<<'
         if (c == gLessThan && subEnd != -1 && subEnd < ruleText.length() - 1 && ruleText.charAt(subEnd+1) == c) {
             // ordinals use "=#,##0==%abbrev=" as their rule.  Notice that the '==' in the middle
             // occurs because of the juxtaposition of two different rules.  The check for '<' is a hack
             // to get around this.  Having the duplicate at the front would cause problems with
             // rules like "<<%" to format, say, percents...
             ++subEnd;
         }
    }
 
     // if we don't find the end of the token (i.e., if we're on a single,
     // unmatched token character), create a null substitution positioned
     // at the end of the rule
     if (subEnd == -1) {
-        return NFSubstitution::makeSubstitution(ruleText.length(), this, predecessor,
-            ruleSet, this->formatter, UnicodeString(), status);
+        return NULL;
     }
 
     // if we get here, we have a real substitution token (or at least
     // some text bounded by substitution token characters).  Use
     // makeSubstitution() to create the right kind of substitution
     UnicodeString subToken;
     subToken.setTo(ruleText, subStart, subEnd + 1 - subStart);
     result = NFSubstitution::makeSubstitution(subStart, this, predecessor, ruleSet,
         this->formatter, subToken, status);
 
     // remove the substitution from the rule text
     ruleText.removeBetween(subStart, subEnd+1);
 
     return result;
 }
 
 /**
  * Sets the rule's base value, and causes the radix and exponent
  * to be recalculated.  This is used during construction when we
  * don't know the rule's base value until after it's been
  * constructed.  It should be used at any other time.
  * @param The new base value for the rule.
  */
 void
 NFRule::setBaseValue(int64_t newBaseValue, UErrorCode& status)
 {
     // set the base value
     baseValue = newBaseValue;
+    radix = 10;
 
     // if this isn't a special rule, recalculate the radix and exponent
     // (the radix always defaults to 10; if it's supposed to be something
     // else, it's cleaned up by the caller and the exponent is
     // recalculated again-- the only function that does this is
     // NFRule.parseRuleDescriptor() )
     if (baseValue >= 1) {
-        radix = 10;
         exponent = expectedExponent();
 
         // this function gets called on a fully-constructed rule whose
         // description didn't specify a base value.  This means it
         // has substitutions, and some substitutions hold on to copies
         // of the rule's divisor.  Fix their copies of the divisor.
         if (sub1 != NULL) {
             sub1->setDivisor(radix, exponent, status);
         }
         if (sub2 != NULL) {
             sub2->setDivisor(radix, exponent, status);
         }
 
         // if this is a special rule, its radix and exponent are basically
         // ignored.  Set them to "safe" default values
     } else {
-        radix = 10;
         exponent = 0;
     }
 }
 
 /**
 * This calculates the rule's exponent based on its radix and base
 * value.  This will be the highest power the radix can be raised to
 * and still produce a result less than or equal to the base value.
 */
 int16_t
@@ skipping 12 matching lines @@
     int16_t tempResult = (int16_t)(uprv_log((double)baseValue) / uprv_log((double)radix));
     int64_t temp = util64_pow(radix, tempResult + 1);
     if (temp <= baseValue) {
         tempResult += 1;
     }
     return tempResult;
 }
 
 /**
  * Searches the rule's rule text for any of the specified strings.
- * @param strings An array of strings to search the rule's rule
- * text for
  * @return The index of the first match in the rule's rule text
  * (i.e., the first substring in the rule's rule text that matches
  * _any_ of the strings in "strings").  If none of the strings in
  * "strings" is found in the rule's rule text, returns -1.
  */
 int32_t
-NFRule::indexOfAny(const UChar* const strings[]) const
+NFRule::indexOfAnyRulePrefix() const
 {
     int result = -1;
-    for (int i = 0; strings[i]; i++) {
-        int32_t pos = ruleText.indexOf(*strings[i]);
+    for (int i = 0; RULE_PREFIXES[i]; i++) {
+        int32_t pos = ruleText.indexOf(*RULE_PREFIXES[i]);
         if (pos != -1 && (result == -1 || pos < result)) {
             result = pos;
         }
     }
     return result;
 }
 
 //-----------------------------------------------------------------------
 // boilerplate
 //-----------------------------------------------------------------------
 
+static UBool
+util_equalSubstitutions(const NFSubstitution* sub1, const NFSubstitution* sub2)
+{
+    if (sub1) {
+        if (sub2) {
+            return *sub1 == *sub2;
+        }
+    } else if (!sub2) {
+        return TRUE;
+    }
+    return FALSE;
+}
+
 /**
 * Tests two rules for equality.
 * @param that The rule to compare this one against
 * @return True is the two rules are functionally equivalent
 */
 UBool
 NFRule::operator==(const NFRule& rhs) const
 {
     return baseValue == rhs.baseValue
         && radix == rhs.radix
         && exponent == rhs.exponent
         && ruleText == rhs.ruleText
-        && *sub1 == *rhs.sub1
-        && *sub2 == *rhs.sub2;
+        && util_equalSubstitutions(sub1, rhs.sub1)
+        && util_equalSubstitutions(sub2, rhs.sub2);
 }
 
 /**
 * Returns a textual representation of the rule.  This won't
 * necessarily be the same as the description that this rule
 * was created with, but it will produce the same result.
 * @return A textual description of the rule
 */
 static void util_append64(UnicodeString& result, int64_t n)
 {
     UChar buffer[256];
     int32_t len = util64_tou(n, buffer, sizeof(buffer));
     UnicodeString temp(buffer, len);
     result.append(temp);
 }
 
 void
 NFRule::_appendRuleText(UnicodeString& result) const
 {
     switch (getType()) {
     case kNegativeNumberRule: result.append(gMinusX, 2); break;
-    case kImproperFractionRule: result.append(gXDotX, 3); break;
-    case kProperFractionRule: result.append(gZeroDotX, 3); break;
-    case kMasterRule: result.append(gXDotZero, 3); break;
+    case kImproperFractionRule: result.append(gX).append(decimalPoint == 0 ? gDot : decimalPoint).append(gX); break;
+    case kProperFractionRule: result.append(gZero).append(decimalPoint == 0 ? gDot : decimalPoint).append(gX); break;
+    case kMasterRule: result.append(gX).append(decimalPoint == 0 ? gDot : decimalPoint).append(gZero); break;
+    case kInfinityRule: result.append(gInf, 3); break;
+    case kNaNRule: result.append(gNaN, 3); break;
     default:
         // for a normal rule, write out its base value, and if the radix is
         // something other than 10, write out the radix (with the preceding
         // slash, of course).  Then calculate the expected exponent and if
         // if isn't the same as the actual exponent, write an appropriate
         // number of > signs.  Finally, terminate the whole thing with
         // a colon.
         util_append64(result, baseValue);
         if (radix != 10) {
             result.append(gSlash);
             util_append64(result, radix);
         }
         int numCarets = expectedExponent() - exponent;
         for (int i = 0; i < numCarets; i++) {
             result.append(gGreaterThan);
         }
         break;
     }
     result.append(gColon);
     result.append(gSpace);
 
     // if the rule text begins with a space, write an apostrophe
     // (whitespace after the rule descriptor is ignored; the
     // apostrophe is used to make the whitespace significant)
-    if (ruleText.charAt(0) == gSpace && sub1->getPos() != 0) {
+    if (ruleText.charAt(0) == gSpace && (sub1 == NULL || sub1->getPos() != 0)) {
         result.append(gTick);
     }
 
     // now, write the rule's rule text, inserting appropriate
     // substitution tokens in the appropriate places
     UnicodeString ruleTextCopy;
     ruleTextCopy.setTo(ruleText);
 
     UnicodeString temp;
-    sub2->toString(temp);
-    ruleTextCopy.insert(sub2->getPos(), temp);
-    sub1->toString(temp);
-    ruleTextCopy.insert(sub1->getPos(), temp);
+    if (sub2 != NULL) {
+        sub2->toString(temp);
+        ruleTextCopy.insert(sub2->getPos(), temp);
+    }
+    if (sub1 != NULL) {
+        sub1->toString(temp);
+        ruleTextCopy.insert(sub1->getPos(), temp);
+    }
 
     result.append(ruleTextCopy);
 
     // and finally, top the whole thing off with a semicolon and
     // return the result
     result.append(gSemicolon);
 }
 
 //-----------------------------------------------------------------------
 // formatting
 //-----------------------------------------------------------------------
 
 /**
 * Formats the number, and inserts the resulting text into
 * toInsertInto.
 * @param number The number being formatted
 * @param toInsertInto The string where the resultant text should
 * be inserted
 * @param pos The position in toInsertInto where the resultant text
 * should be inserted
 */
 void
-NFRule::doFormat(int64_t number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const
+NFRule::doFormat(int64_t number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const
 {
     // first, insert the rule's rule text into toInsertInto at the
     // specified position, then insert the results of the substitutions
     // into the right places in toInsertInto (notice we do the
     // substitutions in reverse order so that the offsets don't get
     // messed up)
     int32_t pluralRuleStart = ruleText.length();
     int32_t lengthOffset = 0;
     if (!rulePatternFormat) {
         toInsertInto.insert(pos, ruleText);
     }
     else {
         pluralRuleStart = ruleText.indexOf(gDollarOpenParenthesis, -1, 0);
         int pluralRuleEnd = ruleText.indexOf(gClosedParenthesisDollar, -1, pluralRuleStart);
         int initialLength = toInsertInto.length();
         if (pluralRuleEnd < ruleText.length() - 1) {
             toInsertInto.insert(pos, ruleText.tempSubString(pluralRuleEnd + 2));
         }
         toInsertInto.insert(pos,
             rulePatternFormat->format((int32_t)(number/uprv_pow(radix, exponent)), status));
         if (pluralRuleStart > 0) {
             toInsertInto.insert(pos, ruleText.tempSubString(0, pluralRuleStart));
         }
         lengthOffset = ruleText.length() - (toInsertInto.length() - initialLength);
     }
 
-    if (!sub2->isNullSubstitution()) {
-        sub2->doSubstitution(number, toInsertInto, pos - (sub2->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    if (sub2 != NULL) {
+        sub2->doSubstitution(number, toInsertInto, pos - (sub2->getPos() > pluralRuleStart ? lengthOffset : 0), recursionCount, status);
     }
-    if (!sub1->isNullSubstitution()) {
-        sub1->doSubstitution(number, toInsertInto, pos - (sub1->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    if (sub1 != NULL) {
+        sub1->doSubstitution(number, toInsertInto, pos - (sub1->getPos() > pluralRuleStart ? lengthOffset : 0), recursionCount, status);
     }
 }
 
 /**
 * Formats the number, and inserts the resulting text into
 * toInsertInto.
 * @param number The number being formatted
 * @param toInsertInto The string where the resultant text should
 * be inserted
 * @param pos The position in toInsertInto where the resultant text
 * should be inserted
 */
 void
-NFRule::doFormat(double number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const
+NFRule::doFormat(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const
 {
     // first, insert the rule's rule text into toInsertInto at the
     // specified position, then insert the results of the substitutions
     // into the right places in toInsertInto
     // [again, we have two copies of this routine that do the same thing
     // so that we don't sacrifice precision in a long by casting it
     // to a double]
     int32_t pluralRuleStart = ruleText.length();
     int32_t lengthOffset = 0;
     if (!rulePatternFormat) {
         toInsertInto.insert(pos, ruleText);
     }
     else {
         pluralRuleStart = ruleText.indexOf(gDollarOpenParenthesis, -1, 0);
         int pluralRuleEnd = ruleText.indexOf(gClosedParenthesisDollar, -1, pluralRuleStart);
         int initialLength = toInsertInto.length();
         if (pluralRuleEnd < ruleText.length() - 1) {
             toInsertInto.insert(pos, ruleText.tempSubString(pluralRuleEnd + 2));
         }
-        toInsertInto.insert(pos,
-            rulePatternFormat->format((int32_t)(number/uprv_pow(radix, exponent)), status));
+        double pluralVal = number;
+        if (0 <= pluralVal && pluralVal < 1) {
+            // We're in a fractional rule, and we have to match the NumeratorSubstitution behavior.
+            // 2.3 can become 0.2999999999999998 for the fraction due to rounding errors.
+            pluralVal = uprv_round(pluralVal * uprv_pow(radix, exponent));
+        }
+        else {
+            pluralVal = pluralVal / uprv_pow(radix, exponent);
+        }
+        toInsertInto.insert(pos, rulePatternFormat->format((int32_t)(pluralVal), status));
         if (pluralRuleStart > 0) {
             toInsertInto.insert(pos, ruleText.tempSubString(0, pluralRuleStart));
         }
         lengthOffset = ruleText.length() - (toInsertInto.length() - initialLength);
     }
 
-    if (!sub2->isNullSubstitution()) {
-        sub2->doSubstitution(number, toInsertInto, pos - (sub2->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    if (sub2 != NULL) {
+        sub2->doSubstitution(number, toInsertInto, pos - (sub2->getPos() > pluralRuleStart ? lengthOffset : 0), recursionCount, status);
     }
-    if (!sub1->isNullSubstitution()) {
-        sub1->doSubstitution(number, toInsertInto, pos - (sub1->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    if (sub1 != NULL) {
+        sub1->doSubstitution(number, toInsertInto, pos - (sub1->getPos() > pluralRuleStart ? lengthOffset : 0), recursionCount, status);
     }
 }
 
 /**
 * Used by the owning rule set to determine whether to invoke the
 * rollback rule (i.e., whether this rule or the one that precedes
 * it in the rule set's list should be used to format the number)
 * @param The number being formatted
 * @return True if the rule set should use the rule that precedes
 * this one in its list; false if it should use this rule
@@ skipping 10 matching lines @@
     // that expands into
     //    100: << hundred;
     //    101: << hundred >>;
     // internally.  But when we're formatting 200, if we use the rule
     // at 101, which would normally apply, we get "two hundred zero".
     // To prevent this, we roll back and use the rule at 100 instead.
     // This is the logic that makes this happen: the rule at 101 has
     // a modulus substitution, its base value isn't an even multiple
     // of 100, and the value we're trying to format _is_ an even
     // multiple of 100.  This is called the "rollback rule."
-    if ((sub1->isModulusSubstitution()) || (sub2->isModulusSubstitution())) {
+    if ((sub1 != NULL && sub1->isModulusSubstitution()) || (sub2 != NULL && sub2->isModulusSubstitution())) {
         int64_t re = util64_pow(radix, exponent);
         return uprv_fmod(number, (double)re) == 0 && (baseValue % re) != 0;
     }
     return FALSE;
 }
 
 //-----------------------------------------------------------------------
 // parsing
 //-----------------------------------------------------------------------
 
@@ skipping 22 matching lines @@
   int len = us.length();
   char* buf = (char *)uprv_malloc((len+1)*sizeof(char)); //new char[len+1];
   if (buf != NULL) {
           us.extract(0, len, buf);
           buf[len] = 0;
           fprintf(f, "%s", buf);
           uprv_free(buf); //delete[] buf;
   }
 }
 #endif
-
 UBool
 NFRule::doParse(const UnicodeString& text,
                 ParsePosition& parsePosition,
                 UBool isFractionRule,
                 double upperBound,
                 Formattable& resVal) const
 {
     // internally we operate on a copy of the string being parsed
     // (because we're going to change it) and use our own ParsePosition
     ParsePosition pp;
     UnicodeString workText(text);
 
+    int32_t sub1Pos = sub1 != NULL ? sub1->getPos() : ruleText.length();
+    int32_t sub2Pos = sub2 != NULL ? sub2->getPos() : ruleText.length();
+
     // check to see whether the text before the first substitution
     // matches the text at the beginning of the string being
     // parsed.  If it does, strip that off the front of workText;
     // otherwise, dump out with a mismatch
     UnicodeString prefix;
-    prefix.setTo(ruleText, 0, sub1->getPos());
+    prefix.setTo(ruleText, 0, sub1Pos);
 
 #ifdef RBNF_DEBUG
-    fprintf(stderr, "doParse %x ", this);
+    fprintf(stderr, "doParse %p ", this);
     {
         UnicodeString rt;
         _appendRuleText(rt);
         dumpUS(stderr, rt);
     }
 
-    fprintf(stderr, " text: '", this);
+    fprintf(stderr, " text: '");
     dumpUS(stderr, text);
     fprintf(stderr, "' prefix: '");
     dumpUS(stderr, prefix);
 #endif
     stripPrefix(workText, prefix, pp);
     int32_t prefixLength = text.length() - workText.length();
 
 #ifdef RBNF_DEBUG
-    fprintf(stderr, "' pl: %d ppi: %d s1p: %d\n", prefixLength, pp.getIndex(), sub1->getPos());
+    fprintf(stderr, "' pl: %d ppi: %d s1p: %d\n", prefixLength, pp.getIndex(), sub1Pos);
 #endif
 
-    if (pp.getIndex() == 0 && sub1->getPos() != 0) {
+    if (pp.getIndex() == 0 && sub1Pos != 0) {
         // commented out because ParsePosition doesn't have error index in 1.1.x
         // restored for ICU4C port
         parsePosition.setErrorIndex(pp.getErrorIndex());
         resVal.setLong(0);
         return TRUE;
     }
+    if (baseValue == kInfinityRule) {
+        // If you match this, don't try to perform any calculations on it.
+        parsePosition.setIndex(pp.getIndex());
+        resVal.setDouble(uprv_getInfinity());
+        return TRUE;
+    }
+    if (baseValue == kNaNRule) {
+        // If you match this, don't try to perform any calculations on it.
+        parsePosition.setIndex(pp.getIndex());
+        resVal.setDouble(uprv_getNaN());
+        return TRUE;
+    }
 
     // this is the fun part.  The basic guts of the rule-matching
     // logic is matchToDelimiter(), which is called twice.  The first
     // time it searches the input string for the rule text BETWEEN
     // the substitutions and tries to match the intervening text
     // in the input string with the first substitution.  If that
     // succeeds, it then calls it again, this time to look for the
     // rule text after the second substitution and to match the
     // intervening input text against the second substitution.
     //
@@ skipping 23 matching lines @@
     double tempBaseValue = (double)(baseValue <= 0 ? 0 : baseValue);
 
     UnicodeString temp;
     do {
         // our partial parse result starts out as this rule's base
         // value.  If it finds a successful match, matchToDelimiter()
         // will compose this in some way with what it gets back from
         // the substitution, giving us a new partial parse result
         pp.setIndex(0);
 
-        temp.setTo(ruleText, sub1->getPos(), sub2->getPos() - sub1->getPos());
+        temp.setTo(ruleText, sub1Pos, sub2Pos - sub1Pos);
         double partialResult = matchToDelimiter(workText, start, tempBaseValue,
             temp, pp, sub1,
             upperBound);
 
         // if we got a successful match (or were trying to match a
         // null substitution), pp is now pointing at the first unmatched
         // character.  Take note of that, and try matchToDelimiter()
         // on the input text again
-        if (pp.getIndex() != 0 || sub1->isNullSubstitution()) {
+        if (pp.getIndex() != 0 || sub1 == NULL) {
             start = pp.getIndex();
 
             UnicodeString workText2;
             workText2.setTo(workText, pp.getIndex(), workText.length() - pp.getIndex());
             ParsePosition pp2;
 
             // the second matchToDelimiter() will compose our previous
             // partial result with whatever it gets back from its
             // substitution if there's a successful match, giving us
             // a real result
-            temp.setTo(ruleText, sub2->getPos(), ruleText.length() - sub2->getPos());
+            temp.setTo(ruleText, sub2Pos, ruleText.length() - sub2Pos);
             partialResult = matchToDelimiter(workText2, 0, partialResult,
                 temp, pp2, sub2,
                 upperBound);
 
             // if we got a successful match on this second
             // matchToDelimiter() call, update the high-water mark
             // and result (if necessary)
-            if (pp2.getIndex() != 0 || sub2->isNullSubstitution()) {
+            if (pp2.getIndex() != 0 || sub2 == NULL) {
                 if (prefixLength + pp.getIndex() + pp2.getIndex() > highWaterMark) {
                     highWaterMark = prefixLength + pp.getIndex() + pp2.getIndex();
                     result = partialResult;
                 }
             }
-            // commented out because ParsePosition doesn't have error index in 1.1.x
-            // restored for ICU4C port
             else {
-                int32_t temp = pp2.getErrorIndex() + sub1->getPos() + pp.getIndex();
+                // commented out because ParsePosition doesn't have error index in 1.1.x
+                // restored for ICU4C port
+                int32_t temp = pp2.getErrorIndex() + sub1Pos + pp.getIndex();
                 if (temp> parsePosition.getErrorIndex()) {
                     parsePosition.setErrorIndex(temp);
                 }
             }
         }
-        // commented out because ParsePosition doesn't have error index in 1.1.x
-        // restored for ICU4C port
         else {
-            int32_t temp = sub1->getPos() + pp.getErrorIndex();
+            // commented out because ParsePosition doesn't have error index in 1.1.x
+            // restored for ICU4C port
+            int32_t temp = sub1Pos + pp.getErrorIndex();
             if (temp > parsePosition.getErrorIndex()) {
                 parsePosition.setErrorIndex(temp);
             }
         }
         // keep trying to match things until the outer matchToDelimiter()
         // call fails to make a match (each time, it picks up where it
         // left off the previous time)
-    } while (sub1->getPos() != sub2->getPos()
+    } while (sub1Pos != sub2Pos
         && pp.getIndex() > 0
         && pp.getIndex() < workText.length()
         && pp.getIndex() != start);
 
     // update the caller's ParsePosition with our high-water mark
     // (i.e., it now points at the first character this function
     // didn't match-- the ParsePosition is therefore unchanged if
     // we didn't match anything)
     parsePosition.setIndex(highWaterMark);
     // commented out because ParsePosition doesn't have error index in 1.1.x
     // restored for ICU4C port
     if (highWaterMark > 0) {
         parsePosition.setErrorIndex(0);
     }
 
     // this is a hack for one unusual condition: Normally, whether this
     // rule belong to a fraction rule set or not is handled by its
     // substitutions.  But if that rule HAS NO substitutions, then
     // we have to account for it here.  By definition, if the matching
     // rule in a fraction rule set has no substitutions, its numerator
     // is 1, and so the result is the reciprocal of its base value.
-    if (isFractionRule &&
-        highWaterMark > 0 &&
-        sub1->isNullSubstitution()) {
+    if (isFractionRule && highWaterMark > 0 && sub1 == NULL) {
         result = 1 / result;
     }
 
     resVal.setDouble(result);
     return TRUE; // ??? do we need to worry if it is a long or a double?
 }
 
 /**
 * This function is used by parse() to match the text being parsed
 * against a possible prefix string.  This function
@@ skipping 107 matching lines @@
                 // if the substitution could match all the text up to
                 // where we found "delimiter", then this function has
                 // a successful match.  Bump the caller's parse position
                 // to point to the first character after the text
                 // that matches "delimiter", and return the result
                 // we got from parsing the substitution.
                 if (success && tempPP.getIndex() == dPos) {
                     pp.setIndex(dPos + dLen);
                     return result.getDouble();
                 }
-                // commented out because ParsePosition doesn't have error index in 1.1.x
-                // restored for ICU4C port
                 else {
+                    // commented out because ParsePosition doesn't have error index in 1.1.x
+                    // restored for ICU4C port
                     if (tempPP.getErrorIndex() > 0) {
                         pp.setErrorIndex(tempPP.getErrorIndex());
                     } else {
                         pp.setErrorIndex(tempPP.getIndex());
                     }
                 }
             }
 
             // if we didn't match the substitution, search for another
             // copy of "delimiter" in "text" and repeat the loop if
             // we find it
             tempPP.setIndex(0);
             dPos = findText(text, delimiter, dPos + dLen, &dLen);
         }
         // if we make it here, this was an unsuccessful match, and we
         // leave pp unchanged and return 0
         pp.setIndex(0);
         return 0;
 
         // if "delimiter" is empty, or consists only of ignorable characters
         // (i.e., is semantically empty), thwe we obviously can't search
         // for "delimiter".  Instead, just use "sub" to parse as much of
         // "text" as possible.
-    } else {
+    }
+    else if (sub == NULL) {
+        return _baseValue;
+    }
+    else {
         ParsePosition tempPP;
         Formattable result;
 
         // try to match the whole string against the substitution
         UBool success = sub->doParse(text, tempPP, _baseValue, upperBound,
 #if UCONFIG_NO_COLLATION
             FALSE,
 #else
             formatter->isLenient(),
 #endif
             result);
-        if (success && (tempPP.getIndex() != 0 || sub->isNullSubstitution())) {
+        if (success && (tempPP.getIndex() != 0)) {
             // if there's a successful match (or it's a null
             // substitution), update pp to point to the first
             // character we didn't match, and pass the result from
             // sub.doParse() on through to the caller
             pp.setIndex(tempPP.getIndex());
             return result.getDouble();
         }
-        // commented out because ParsePosition doesn't have error index in 1.1.x
-        // restored for ICU4C port
         else {
+            // commented out because ParsePosition doesn't have error index in 1.1.x
+            // restored for ICU4C port
             pp.setErrorIndex(tempPP.getErrorIndex());
         }
 
         // and if we get to here, then nothing matched, so we return
         // 0 and leave pp alone
         return 0;
     }
 }
 
 /**
@@ skipping 324 matching lines @@
 
         return o == CollationElementIterator::NULLORDER;
     }
 #endif
 
     // if lenient parsing is turned off, there is no such thing as
     // an ignorable character: return true only if the string is empty
     return FALSE;
 }
 
+void
+NFRule::setDecimalFormatSymbols(const DecimalFormatSymbols& newSymbols, UErrorCode& status) {
+    if (sub1 != NULL) {
+        sub1->setDecimalFormatSymbols(newSymbols, status);
+    }
+    if (sub2 != NULL) {
+        sub2->setDecimalFormatSymbols(newSymbols, status);
+    }
+}
+
 U_NAMESPACE_END
 
 /* U_HAVE_RBNF */
 #endif