ICU 56 update step 1

source/i18n/rbnf.cpp

 /*
 *******************************************************************************
-* Copyright (C) 1997-2014, International Business Machines Corporation
+* Copyright (C) 1997-2015, International Business Machines Corporation
 * and others. All Rights Reserved.
 *******************************************************************************
 */
 
 #include "unicode/utypes.h"
 #include "utypeinfo.h"  // for 'typeid' to work
 
 #include "unicode/rbnf.h"
 
 #if U_HAVE_RBNF
@@ skipping 15 matching lines @@
 
 #include "cmemory.h"
 #include "cstring.h"
 #include "patternprops.h"
 #include "uresimp.h"
 
 // debugging
 // #define RBNF_DEBUG
 
 #ifdef RBNF_DEBUG
-#include "stdio.h"
+#include <stdio.h>
 #endif
 
 #define U_ICUDATA_RBNF U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "rbnf"
 
 static const UChar gPercentPercent[] =
 {
     0x25, 0x25, 0
 }; /* "%%" */
 
 // All urbnf objects are created through openRules, so we init all of the
@@ skipping 604 matching lines @@
 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
                                              const UnicodeString& locs,
                                              const Locale& alocale, UParseError& perror, UErrorCode& status)
   : ruleSets(NULL)
   , ruleSetDescriptions(NULL)
   , numRuleSets(0)
   , defaultRuleSet(NULL)
   , locale(alocale)
   , collator(NULL)
   , decimalFormatSymbols(NULL)
+  , defaultInfinityRule(NULL)
+  , defaultNaNRule(NULL)
   , lenient(FALSE)
   , lenientParseRules(NULL)
   , localizations(NULL)
   , capitalizationInfoSet(FALSE)
   , capitalizationForUIListMenu(FALSE)
   , capitalizationForStandAlone(FALSE)
   , capitalizationBrkIter(NULL)
 {
   LocalizationInfo* locinfo = StringLocalizationInfo::create(locs, perror, status);
   init(description, locinfo, perror, status);
 }
 
 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
                                              const UnicodeString& locs,
                                              UParseError& perror, UErrorCode& status)
   : ruleSets(NULL)
   , ruleSetDescriptions(NULL)
   , numRuleSets(0)
   , defaultRuleSet(NULL)
   , locale(Locale::getDefault())
   , collator(NULL)
   , decimalFormatSymbols(NULL)
+  , defaultInfinityRule(NULL)
+  , defaultNaNRule(NULL)
   , lenient(FALSE)
   , lenientParseRules(NULL)
   , localizations(NULL)
   , capitalizationInfoSet(FALSE)
   , capitalizationForUIListMenu(FALSE)
   , capitalizationForStandAlone(FALSE)
   , capitalizationBrkIter(NULL)
 {
   LocalizationInfo* locinfo = StringLocalizationInfo::create(locs, perror, status);
   init(description, locinfo, perror, status);
 }
 
 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
                                              LocalizationInfo* info,
                                              const Locale& alocale, UParseError& perror, UErrorCode& status)
   : ruleSets(NULL)
   , ruleSetDescriptions(NULL)
   , numRuleSets(0)
   , defaultRuleSet(NULL)
   , locale(alocale)
   , collator(NULL)
   , decimalFormatSymbols(NULL)
+  , defaultInfinityRule(NULL)
+  , defaultNaNRule(NULL)
   , lenient(FALSE)
   , lenientParseRules(NULL)
   , localizations(NULL)
   , capitalizationInfoSet(FALSE)
   , capitalizationForUIListMenu(FALSE)
   , capitalizationForStandAlone(FALSE)
   , capitalizationBrkIter(NULL)
 {
   init(description, info, perror, status);
 }
 
 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
                          UParseError& perror, 
                          UErrorCode& status) 
   : ruleSets(NULL)
   , ruleSetDescriptions(NULL)
   , numRuleSets(0)
   , defaultRuleSet(NULL)
   , locale(Locale::getDefault())
   , collator(NULL)
   , decimalFormatSymbols(NULL)
+  , defaultInfinityRule(NULL)
+  , defaultNaNRule(NULL)
   , lenient(FALSE)
   , lenientParseRules(NULL)
   , localizations(NULL)
   , capitalizationInfoSet(FALSE)
   , capitalizationForUIListMenu(FALSE)
   , capitalizationForStandAlone(FALSE)
   , capitalizationBrkIter(NULL)
 {
     init(description, NULL, perror, status);
 }
 
 RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
                          const Locale& aLocale,
                          UParseError& perror, 
                          UErrorCode& status) 
   : ruleSets(NULL)
   , ruleSetDescriptions(NULL)
   , numRuleSets(0)
   , defaultRuleSet(NULL)
   , locale(aLocale)
   , collator(NULL)
   , decimalFormatSymbols(NULL)
+  , defaultInfinityRule(NULL)
+  , defaultNaNRule(NULL)
   , lenient(FALSE)
   , lenientParseRules(NULL)
   , localizations(NULL)
   , capitalizationInfoSet(FALSE)
   , capitalizationForUIListMenu(FALSE)
   , capitalizationForStandAlone(FALSE)
   , capitalizationBrkIter(NULL)
 {
     init(description, NULL, perror, status);
 }
 
 RuleBasedNumberFormat::RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& alocale, UErrorCode& status)
   : ruleSets(NULL)
   , ruleSetDescriptions(NULL)
   , numRuleSets(0)
   , defaultRuleSet(NULL)
   , locale(alocale)
   , collator(NULL)
   , decimalFormatSymbols(NULL)
+  , defaultInfinityRule(NULL)
+  , defaultNaNRule(NULL)
   , lenient(FALSE)
   , lenientParseRules(NULL)
   , localizations(NULL)
   , capitalizationInfoSet(FALSE)
   , capitalizationForUIListMenu(FALSE)
   , capitalizationForStandAlone(FALSE)
   , capitalizationBrkIter(NULL)
 {
     if (U_FAILURE(status)) {
         return;
@@ skipping 27 matching lines @@
             ures_close(nfrb);
             return;
         }
 
         UnicodeString desc;
         while (ures_hasNext(ruleSets)) {
            desc.append(ures_getNextUnicodeString(ruleSets,NULL,&status));
         }
         UParseError perror;
 
-        init (desc, locinfo, perror, status);
+        init(desc, locinfo, perror, status);
 
         ures_close(ruleSets);
         ures_close(rbnfRules);
     }
     ures_close(nfrb);
 }
 
 RuleBasedNumberFormat::RuleBasedNumberFormat(const RuleBasedNumberFormat& rhs)
   : NumberFormat(rhs)
   , ruleSets(NULL)
   , ruleSetDescriptions(NULL)
   , numRuleSets(0)
   , defaultRuleSet(NULL)
   , locale(rhs.locale)
   , collator(NULL)
   , decimalFormatSymbols(NULL)
+  , defaultInfinityRule(NULL)
+  , defaultNaNRule(NULL)
   , lenient(FALSE)
   , lenientParseRules(NULL)
   , localizations(NULL)
   , capitalizationInfoSet(FALSE)
   , capitalizationForUIListMenu(FALSE)
   , capitalizationForStandAlone(FALSE)
   , capitalizationBrkIter(NULL)
 {
     this->operator=(rhs);
 }
 
 // --------
 
 RuleBasedNumberFormat&
 RuleBasedNumberFormat::operator=(const RuleBasedNumberFormat& rhs)
 {
     if (this == &rhs) {
         return *this;
     }
     NumberFormat::operator=(rhs);
     UErrorCode status = U_ZERO_ERROR;
     dispose();
     locale = rhs.locale;
     lenient = rhs.lenient;
 
     UParseError perror;
+    setDecimalFormatSymbols(*rhs.getDecimalFormatSymbols());
     init(rhs.originalDescription, rhs.localizations ? rhs.localizations->ref() : NULL, perror, status);
-    setDecimalFormatSymbols(*rhs.getDecimalFormatSymbols());
     setDefaultRuleSet(rhs.getDefaultRuleSetName(), status);
 
     capitalizationInfoSet = rhs.capitalizationInfoSet;
     capitalizationForUIListMenu = rhs.capitalizationForUIListMenu;
     capitalizationForStandAlone = rhs.capitalizationForStandAlone;
 #if !UCONFIG_NO_BREAK_ITERATION
     capitalizationBrkIter = (rhs.capitalizationBrkIter!=NULL)? rhs.capitalizationBrkIter->clone(): NULL;
 #endif
 
     return *this;
@@ skipping 57 matching lines @@
             (*p)->appendRules(result);
         }
     }
     return result;
 }
 
 UnicodeString
 RuleBasedNumberFormat::getRuleSetName(int32_t index) const
 {
     if (localizations) {
-      UnicodeString string(TRUE, localizations->getRuleSetName(index), (int32_t)-1);
-      return string;
-    } else if (ruleSets) {
+        UnicodeString string(TRUE, localizations->getRuleSetName(index), (int32_t)-1);
+        return string;
+    }
+    else if (ruleSets) {
         UnicodeString result;
         for (NFRuleSet** p = ruleSets; *p; ++p) {
             NFRuleSet* rs = *p;
             if (rs->isPublic()) {
                 if (--index == -1) {
                     rs->getName(result);
                     return result;
                 }
             }
         }
     }
     UnicodeString empty;
     return empty;
 }
 
 int32_t
 RuleBasedNumberFormat::getNumberOfRuleSetNames() const
 {
     int32_t result = 0;
     if (localizations) {
-      result = localizations->getNumberOfRuleSets();
-    } else if (ruleSets) {
+        result = localizations->getNumberOfRuleSets();
+    }
+    else if (ruleSets) {
         for (NFRuleSet** p = ruleSets; *p; ++p) {
             if ((**p).isPublic()) {
                 ++result;
             }
         }
     }
     return result;
 }
 
 int32_t 
@@ skipping 87 matching lines @@
 }
 
 UnicodeString&
 RuleBasedNumberFormat::format(int32_t number,
                               UnicodeString& toAppendTo,
                               FieldPosition& /* pos */) const
 {
     if (defaultRuleSet) {
         UErrorCode status = U_ZERO_ERROR;
         int32_t startPos = toAppendTo.length();
-        defaultRuleSet->format((int64_t)number, toAppendTo, toAppendTo.length(), status);
+        defaultRuleSet->format((int64_t)number, toAppendTo, toAppendTo.length(), 0, status);
         adjustForCapitalizationContext(startPos, toAppendTo);
     }
     return toAppendTo;
 }
 
 
 UnicodeString&
 RuleBasedNumberFormat::format(int64_t number,
                               UnicodeString& toAppendTo,
                               FieldPosition& /* pos */) const
 {
     if (defaultRuleSet) {
         UErrorCode status = U_ZERO_ERROR;
         int32_t startPos = toAppendTo.length();
-        defaultRuleSet->format(number, toAppendTo, toAppendTo.length(), status);
+        defaultRuleSet->format(number, toAppendTo, toAppendTo.length(), 0, status);
         adjustForCapitalizationContext(startPos, toAppendTo);
     }
     return toAppendTo;
 }
 
 
 UnicodeString&
 RuleBasedNumberFormat::format(double number,
                               UnicodeString& toAppendTo,
                               FieldPosition& /* pos */) const
 {
     int32_t startPos = toAppendTo.length();
-    // Special case for NaN; adapted from what DecimalFormat::_format( double number,...) does.
-    if (uprv_isNaN(number)) {
-        DecimalFormatSymbols* decFmtSyms = getDecimalFormatSymbols(); // RuleBasedNumberFormat internal
-        if (decFmtSyms) {
-            toAppendTo += decFmtSyms->getConstSymbol(DecimalFormatSymbols::kNaNSymbol);
-        }
-    } else if (defaultRuleSet) {
+    if (defaultRuleSet) {
         UErrorCode status = U_ZERO_ERROR;
-        defaultRuleSet->format(number, toAppendTo, toAppendTo.length(), status);
+        defaultRuleSet->format(number, toAppendTo, toAppendTo.length(), 0, status);
     }
     return adjustForCapitalizationContext(startPos, toAppendTo);
 }
 
 
 UnicodeString&
 RuleBasedNumberFormat::format(int32_t number,
                               const UnicodeString& ruleSetName,
                               UnicodeString& toAppendTo,
                               FieldPosition& /* pos */,
                               UErrorCode& status) const
 {
     // return format((int64_t)number, ruleSetName, toAppendTo, pos, status);
     if (U_SUCCESS(status)) {
         if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) {
             // throw new IllegalArgumentException("Can't use internal rule set");
             status = U_ILLEGAL_ARGUMENT_ERROR;
         } else {
             NFRuleSet *rs = findRuleSet(ruleSetName, status);
             if (rs) {
                 int32_t startPos = toAppendTo.length();
-                rs->format((int64_t)number, toAppendTo, toAppendTo.length(), status);
+                rs->format((int64_t)number, toAppendTo, toAppendTo.length(), 0, status);
                 adjustForCapitalizationContext(startPos, toAppendTo);
             }
         }
     }
     return toAppendTo;
 }
 
 
 UnicodeString&
 RuleBasedNumberFormat::format(int64_t number,
                               const UnicodeString& ruleSetName,
                               UnicodeString& toAppendTo,
                               FieldPosition& /* pos */,
                               UErrorCode& status) const
 {
     if (U_SUCCESS(status)) {
         if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) {
             // throw new IllegalArgumentException("Can't use internal rule set");
             status = U_ILLEGAL_ARGUMENT_ERROR;
         } else {
             NFRuleSet *rs = findRuleSet(ruleSetName, status);
             if (rs) {
                 int32_t startPos = toAppendTo.length();
-                rs->format(number, toAppendTo, toAppendTo.length(), status);
+                rs->format(number, toAppendTo, toAppendTo.length(), 0, status);
                 adjustForCapitalizationContext(startPos, toAppendTo);
             }
         }
     }
     return toAppendTo;
 }
 
 
 UnicodeString&
 RuleBasedNumberFormat::format(double number,
                               const UnicodeString& ruleSetName,
                               UnicodeString& toAppendTo,
                               FieldPosition& /* pos */,
                               UErrorCode& status) const
 {
     if (U_SUCCESS(status)) {
         if (ruleSetName.indexOf(gPercentPercent, 2, 0) == 0) {
             // throw new IllegalArgumentException("Can't use internal rule set");
             status = U_ILLEGAL_ARGUMENT_ERROR;
         } else {
             NFRuleSet *rs = findRuleSet(ruleSetName, status);
             if (rs) {
                 int32_t startPos = toAppendTo.length();
-                rs->format(number, toAppendTo, toAppendTo.length(), status);
+                rs->format(number, toAppendTo, toAppendTo.length(), 0, status);
                 adjustForCapitalizationContext(startPos, toAppendTo);
             }
         }
     }
     return toAppendTo;
 }
 
 UnicodeString&
 RuleBasedNumberFormat::adjustForCapitalizationContext(int32_t startPos,
                                                       UnicodeString& currentResult) const
@@ skipping 99 matching lines @@
             NFRuleSet* result = findRuleSet(ruleSetName, status);
             if (result != NULL) {
                 defaultRuleSet = result;
             }
         }
     }
 }
 
 UnicodeString
 RuleBasedNumberFormat::getDefaultRuleSetName() const {
-  UnicodeString result;
-  if (defaultRuleSet && defaultRuleSet->isPublic()) {
-    defaultRuleSet->getName(result);
-  } else {
-    result.setToBogus();
-  }
-  return result;
+    UnicodeString result;
+    if (defaultRuleSet && defaultRuleSet->isPublic()) {
+        defaultRuleSet->getName(result);
+    } else {
+        result.setToBogus();
+    }
+    return result;
 }
 
 void 
 RuleBasedNumberFormat::initDefaultRuleSet()
 {
     defaultRuleSet = NULL;
     if (!ruleSets) {
-      return;
+        return;
     }
 
-    const UnicodeString spellout = UNICODE_STRING_SIMPLE("%spellout-numbering");
-    const UnicodeString ordinal = UNICODE_STRING_SIMPLE("%digits-ordinal");
-    const UnicodeString duration = UNICODE_STRING_SIMPLE("%duration");
+    const UnicodeString spellout(UNICODE_STRING_SIMPLE("%spellout-numbering"));
+    const UnicodeString ordinal(UNICODE_STRING_SIMPLE("%digits-ordinal"));
+    const UnicodeString duration(UNICODE_STRING_SIMPLE("%duration"));
 
     NFRuleSet**p = &ruleSets[0];
     while (*p) {
         if ((*p)->isNamed(spellout) || (*p)->isNamed(ordinal) || (*p)->isNamed(duration)) {
             defaultRuleSet = *p;
             return;
         } else {
             ++p;
         }
     }
@@ skipping 14 matching lines @@
 RuleBasedNumberFormat::init(const UnicodeString& rules, LocalizationInfo* localizationInfos,
                             UParseError& pErr, UErrorCode& status)
 {
     // TODO: implement UParseError
     uprv_memset(&pErr, 0, sizeof(UParseError));
     // Note: this can leave ruleSets == NULL, so remaining code should check
     if (U_FAILURE(status)) {
         return;
     }
 
+    initializeDecimalFormatSymbols(status);
+    initializeDefaultInfinityRule(status);
+    initializeDefaultNaNRule(status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+
     this->localizations = localizationInfos == NULL ? NULL : localizationInfos->ref();
 
     UnicodeString description(rules);
     if (!description.length()) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
 
     // start by stripping the trailing whitespace from all the rules
     // (this is all the whitespace follwing each semicolon in the
@@ skipping 77 matching lines @@
     if (ruleSetDescriptions == 0) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
 
     {
         int curRuleSet = 0;
         int32_t start = 0;
         for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, start)) {
             ruleSetDescriptions[curRuleSet].setTo(description, start, p + 1 - start);
-            ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status);
+            ruleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status);
             if (ruleSets[curRuleSet] == 0) {
                 status = U_MEMORY_ALLOCATION_ERROR;
                 return;
             }
             ++curRuleSet;
             start = p + 1;
         }
         ruleSetDescriptions[curRuleSet].setTo(description, start, description.length() - start);
-        ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status);
+        ruleSets[curRuleSet] = new NFRuleSet(this, ruleSetDescriptions, curRuleSet, status);
         if (ruleSets[curRuleSet] == 0) {
             status = U_MEMORY_ALLOCATION_ERROR;
             return;
         }
     }
 
     // now we can take note of the formatter's default rule set, which
     // is the last public rule set in the description (it's the last
     // rather than the first so that a user can create a new formatter
     // from an existing formatter and change its default behavior just
     // by appending more rule sets to the end)
 
     // {dlf} Initialization of a fraction rule set requires the default rule
     // set to be known.  For purposes of initialization, this is always the 
     // last public rule set, no matter what the localization data says.
     initDefaultRuleSet();
 
     // finally, we can go back through the temporary descriptions
     // list and finish seting up the substructure (and we throw
     // away the temporary descriptions as we go)
     {
         for (int i = 0; i < numRuleSets; i++) {
-            ruleSets[i]->parseRules(ruleSetDescriptions[i], this, status);
+            ruleSets[i]->parseRules(ruleSetDescriptions[i], status);
         }
     }
 
     // Now that the rules are initialized, the 'real' default rule
     // set can be adjusted by the localization data.
 
     // The C code keeps the localization array as is, rather than building
     // a separate array of the public rule set names, so we have less work
     // to do here-- but we still need to check the names.
     
@@ skipping 111 matching lines @@
     if (ruleSets) {
         for (NFRuleSet** p = ruleSets; *p; ++p) {
             delete *p;
         }
         uprv_free(ruleSets);
         ruleSets = NULL;
     }
 
     if (ruleSetDescriptions) {
         delete [] ruleSetDescriptions;
+        ruleSetDescriptions = NULL;
     }
 
 #if !UCONFIG_NO_COLLATION
     delete collator;
 #endif
     collator = NULL;
 
     delete decimalFormatSymbols;
     decimalFormatSymbols = NULL;
 
+    delete defaultInfinityRule;
+    defaultInfinityRule = NULL;
+
+    delete defaultNaNRule;
+    defaultNaNRule = NULL;
+
     delete lenientParseRules;
     lenientParseRules = NULL;
 
 #if !UCONFIG_NO_BREAK_ITERATION
-   delete capitalizationBrkIter;
-   capitalizationBrkIter = NULL;
+    delete capitalizationBrkIter;
+    capitalizationBrkIter = NULL;
 #endif
 
-    if (localizations) localizations = localizations->unref();
+    if (localizations) {
+        localizations = localizations->unref();
+    }
 }
 
 
 //-----------------------------------------------------------------------
 // package-internal API
 //-----------------------------------------------------------------------
 
 /**
  * Returns the collator to use for lenient parsing.  The collator is lazily created:
  * this function creates it the first time it's called.
@@ skipping 43 matching lines @@
         delete temp;
     }
 #endif
 
     // if lenient-parse mode is off, this will be null
     // (see setLenientParseMode())
     return collator;
 }
 
 
-/**
- * Returns the DecimalFormatSymbols object that should be used by all DecimalFormat
- * instances owned by this formatter.  This object is lazily created: this function
- * creates it the first time it's called.
- * @return The DecimalFormatSymbols object that should be used by all DecimalFormat
- * instances owned by this formatter.
-*/
 DecimalFormatSymbols*
-RuleBasedNumberFormat::getDecimalFormatSymbols() const
+RuleBasedNumberFormat::initializeDecimalFormatSymbols(UErrorCode &status)
 {
     // lazy-evaluate the DecimalFormatSymbols object.  This object
     // is shared by all DecimalFormat instances belonging to this
     // formatter
     if (decimalFormatSymbols == NULL) {
-        UErrorCode status = U_ZERO_ERROR;
         DecimalFormatSymbols* temp = new DecimalFormatSymbols(locale, status);
         if (U_SUCCESS(status)) {
-            ((RuleBasedNumberFormat*)this)->decimalFormatSymbols = temp;
-        } else {
+            decimalFormatSymbols = temp;
+        }
+        else {
             delete temp;
         }
     }
     return decimalFormatSymbols;
 }
 
+/**
+ * Returns the DecimalFormatSymbols object that should be used by all DecimalFormat
+ * instances owned by this formatter.
+*/
+const DecimalFormatSymbols*
+RuleBasedNumberFormat::getDecimalFormatSymbols() const
+{
+    return decimalFormatSymbols;
+}
+
+NFRule*
+RuleBasedNumberFormat::initializeDefaultInfinityRule(UErrorCode &status)
+{
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    if (defaultInfinityRule == NULL) {
+        UnicodeString rule(UNICODE_STRING_SIMPLE("Inf: "));
+        rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kInfinitySymbol));
+        NFRule* temp = new NFRule(this, rule, status);
+        if (U_SUCCESS(status)) {
+            defaultInfinityRule = temp;
+        }
+        else {
+            delete temp;
+        }
+    }
+    return defaultInfinityRule;
+}
+
+const NFRule*
+RuleBasedNumberFormat::getDefaultInfinityRule() const
+{
+    return defaultInfinityRule;
+}
+
+NFRule*
+RuleBasedNumberFormat::initializeDefaultNaNRule(UErrorCode &status)
+{
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    if (defaultNaNRule == NULL) {
+        UnicodeString rule(UNICODE_STRING_SIMPLE("NaN: "));
+        rule.append(getDecimalFormatSymbols()->getSymbol(DecimalFormatSymbols::kNaNSymbol));
+        NFRule* temp = new NFRule(this, rule, status);
+        if (U_SUCCESS(status)) {
+            defaultNaNRule = temp;
+        }
+        else {
+            delete temp;
+        }
+    }
+    return defaultNaNRule;
+}
+
+const NFRule*
+RuleBasedNumberFormat::getDefaultNaNRule() const
+{
+    return defaultNaNRule;
+}
+
 // De-owning the current localized symbols and adopt the new symbols.
 void
 RuleBasedNumberFormat::adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt)
 {
     if (symbolsToAdopt == NULL) {
         return; // do not allow caller to set decimalFormatSymbols to NULL
     }
 
     if (decimalFormatSymbols != NULL) {
         delete decimalFormatSymbols;
     }
 
     decimalFormatSymbols = symbolsToAdopt;
 
     {
         // Apply the new decimalFormatSymbols by reparsing the rulesets
         UErrorCode status = U_ZERO_ERROR;
 
-        for (int32_t i = 0; i < numRuleSets; i++) {
-            ruleSets[i]->parseRules(ruleSetDescriptions[i], this, status);
+        delete defaultInfinityRule;
+        defaultInfinityRule = NULL;
+        initializeDefaultInfinityRule(status); // Reset with the new DecimalFormatSymbols
+
+        delete defaultNaNRule;
+        defaultNaNRule = NULL;
+        initializeDefaultNaNRule(status); // Reset with the new DecimalFormatSymbols
+
+        if (ruleSets) {
+            for (int32_t i = 0; i < numRuleSets; i++) {
+                ruleSets[i]->setDecimalFormatSymbols(*symbolsToAdopt, status);
+            }
         }
     }
 }
 
 // Setting the symbols is equlivalent to adopting a newly created localized symbols.
 void
 RuleBasedNumberFormat::setDecimalFormatSymbols(const DecimalFormatSymbols& symbols)
 {
     adoptDecimalFormatSymbols(new DecimalFormatSymbols(symbols));
 }
 
 PluralFormat *
 RuleBasedNumberFormat::createPluralFormat(UPluralType pluralType,
                                           const UnicodeString &pattern,
                                           UErrorCode& status) const
 {
     return new PluralFormat(locale, pluralType, pattern, status);
 }
 
 U_NAMESPACE_END
 
 /* U_HAVE_RBNF */
 #endif