Check in the pristine copy of ICU 4.6...

icu46/source/i18n/rbnf.cpp

+/*
+*******************************************************************************
+* Copyright (C) 1997-2010, International Business Machines Corporation
+* and others. All Rights Reserved.
+*******************************************************************************
+*/
+
+#include <typeinfo>  // for 'typeid' to work
+
+#include "unicode/rbnf.h"
+
+#if U_HAVE_RBNF
+
+#include "unicode/normlzr.h"
+#include "unicode/tblcoll.h"
+#include "unicode/uchar.h"
+#include "unicode/ucol.h"
+#include "unicode/uloc.h"
+#include "unicode/unum.h"
+#include "unicode/ures.h"
+#include "unicode/ustring.h"
+#include "unicode/utf16.h"
+#include "unicode/udata.h"
+#include "nfrs.h"
+
+#include "cmemory.h"
+#include "cstring.h"
+#include "util.h"
+#include "uresimp.h"
+
+// debugging
+// #define DEBUG
+
+#ifdef DEBUG
+#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
+// Unicode string constants required by rbnf, nfrs, or nfr here.
+static const UChar gLenientParse[] =
+{
+    0x25, 0x25, 0x6C, 0x65, 0x6E, 0x69, 0x65, 0x6E, 0x74, 0x2D, 0x70, 0x61, 0x72, 0x73, 0x65, 0x3A, 0
+}; /* "%%lenient-parse:" */
+static const UChar gSemiColon = 0x003B;
+static const UChar gSemiPercent[] =
+{
+    0x3B, 0x25, 0
+}; /* ";%" */
+
+#define kSomeNumberOfBitsDiv2 22
+#define kHalfMaxDouble (double)(1 << kSomeNumberOfBitsDiv2)
+#define kMaxDouble (kHalfMaxDouble * kHalfMaxDouble)
+
+// Temporary workaround - when noParse is true, do noting in parse.
+// TODO: We need a real fix - see #6895/#6896
+static const char *NO_SPELLOUT_PARSE_LANGUAGES[] = { "ga", NULL };
+
+U_NAMESPACE_BEGIN
+
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedNumberFormat)
+
+/*
+This is a utility class. It does not use ICU's RTTI.
+If ICU's RTTI is needed again, you can uncomment the RTTI code and derive from UObject.
+Please make sure that intltest passes on Windows in Release mode,
+since the string pooling per compilation unit will mess up how RTTI works.
+The RTTI code was also removed due to lack of code coverage.
+*/
+class LocalizationInfo : public UMemory {
+protected:
+    virtual ~LocalizationInfo() {};
+    uint32_t refcount;
+    
+public:
+    LocalizationInfo() : refcount(0) {}
+    
+    LocalizationInfo* ref(void) {
+        ++refcount;
+        return this;
+    }
+    
+    LocalizationInfo* unref(void) {
+        if (refcount && --refcount == 0) {
+            delete this;
+        }
+        return NULL;
+    }
+    
+    virtual UBool operator==(const LocalizationInfo* rhs) const;
+    inline  UBool operator!=(const LocalizationInfo* rhs) const { return !operator==(rhs); }
+    
+    virtual int32_t getNumberOfRuleSets(void) const = 0;
+    virtual const UChar* getRuleSetName(int32_t index) const = 0;
+    virtual int32_t getNumberOfDisplayLocales(void) const = 0;
+    virtual const UChar* getLocaleName(int32_t index) const = 0;
+    virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const = 0;
+    
+    virtual int32_t indexForLocale(const UChar* locale) const;
+    virtual int32_t indexForRuleSet(const UChar* ruleset) const;
+    
+//    virtual UClassID getDynamicClassID() const = 0;
+//    static UClassID getStaticClassID(void);
+};
+
+//UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(LocalizationInfo)
+
+// if both strings are NULL, this returns TRUE
+static UBool 
+streq(const UChar* lhs, const UChar* rhs) {
+    if (rhs == lhs) {
+        return TRUE;
+    }
+    if (lhs && rhs) {
+        return u_strcmp(lhs, rhs) == 0;
+    }
+    return FALSE;
+}
+
+UBool
+LocalizationInfo::operator==(const LocalizationInfo* rhs) const {
+    if (rhs) {
+        if (this == rhs) {
+            return TRUE;
+        }
+        
+        int32_t rsc = getNumberOfRuleSets();
+        if (rsc == rhs->getNumberOfRuleSets()) {
+            for (int i = 0; i < rsc; ++i) {
+                if (!streq(getRuleSetName(i), rhs->getRuleSetName(i))) {
+                    return FALSE;
+                }
+            }
+            int32_t dlc = getNumberOfDisplayLocales();
+            if (dlc == rhs->getNumberOfDisplayLocales()) {
+                for (int i = 0; i < dlc; ++i) {
+                    const UChar* locale = getLocaleName(i);
+                    int32_t ix = rhs->indexForLocale(locale);
+                    // if no locale, ix is -1, getLocaleName returns null, so streq returns false
+                    if (!streq(locale, rhs->getLocaleName(ix))) {
+                        return FALSE;
+                    }
+                    for (int j = 0; j < rsc; ++j) {
+                        if (!streq(getDisplayName(i, j), rhs->getDisplayName(ix, j))) {
+                            return FALSE;
+                        }
+                    }
+                }
+                return TRUE;
+            }
+        }
+    }
+    return FALSE;
+}
+
+int32_t
+LocalizationInfo::indexForLocale(const UChar* locale) const {
+    for (int i = 0; i < getNumberOfDisplayLocales(); ++i) {
+        if (streq(locale, getLocaleName(i))) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+int32_t
+LocalizationInfo::indexForRuleSet(const UChar* ruleset) const {
+    if (ruleset) {
+        for (int i = 0; i < getNumberOfRuleSets(); ++i) {
+            if (streq(ruleset, getRuleSetName(i))) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+
+
+typedef void (*Fn_Deleter)(void*);
+
+class VArray {
+    void** buf;
+    int32_t cap;
+    int32_t size;
+    Fn_Deleter deleter;
+public:
+    VArray() : buf(NULL), cap(0), size(0), deleter(NULL) {}
+    
+    VArray(Fn_Deleter del) : buf(NULL), cap(0), size(0), deleter(del) {}
+    
+    ~VArray() {
+        if (deleter) {
+            for (int i = 0; i < size; ++i) {
+                (*deleter)(buf[i]);
+            }
+        }
+        uprv_free(buf); 
+    }
+    
+    int32_t length() {
+        return size;
+    }
+    
+    void add(void* elem, UErrorCode& status) {
+        if (U_SUCCESS(status)) {
+            if (size == cap) {
+                if (cap == 0) {
+                    cap = 1;
+                } else if (cap < 256) {
+                    cap *= 2;
+                } else {
+                    cap += 256;
+                }
+                if (buf == NULL) {
+                    buf = (void**)uprv_malloc(cap * sizeof(void*));
+                } else {
+                    buf = (void**)uprv_realloc(buf, cap * sizeof(void*));
+                }
+                if (buf == NULL) {
+                    // if we couldn't realloc, we leak the memory we've already allocated, but we're in deep trouble anyway
+                    status = U_MEMORY_ALLOCATION_ERROR;
+                    return;
+                }
+                void* start = &buf[size];
+                size_t count = (cap - size) * sizeof(void*);
+                uprv_memset(start, 0, count); // fill with nulls, just because
+            }
+            buf[size++] = elem;
+        }
+    }
+    
+    void** release(void) {
+        void** result = buf;
+        buf = NULL;
+        cap = 0;
+        size = 0;
+        return result;
+    }
+};
+
+class LocDataParser;
+
+class StringLocalizationInfo : public LocalizationInfo {
+    UChar* info;
+    UChar*** data;
+    int32_t numRuleSets;
+    int32_t numLocales;
+
+friend class LocDataParser;
+
+    StringLocalizationInfo(UChar* i, UChar*** d, int32_t numRS, int32_t numLocs)
+        : info(i), data(d), numRuleSets(numRS), numLocales(numLocs)
+    {
+    }
+    
+public:
+    static StringLocalizationInfo* create(const UnicodeString& info, UParseError& perror, UErrorCode& status);
+    
+    virtual ~StringLocalizationInfo();
+    virtual int32_t getNumberOfRuleSets(void) const { return numRuleSets; }
+    virtual const UChar* getRuleSetName(int32_t index) const;
+    virtual int32_t getNumberOfDisplayLocales(void) const { return numLocales; }
+    virtual const UChar* getLocaleName(int32_t index) const;
+    virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const;
+    
+//    virtual UClassID getDynamicClassID() const;
+//    static UClassID getStaticClassID(void);
+    
+private:
+    void init(UErrorCode& status) const;
+};
+
+
+enum {
+    OPEN_ANGLE = 0x003c, /* '<' */
+    CLOSE_ANGLE = 0x003e, /* '>' */
+    COMMA = 0x002c,
+    TICK = 0x0027,
+    QUOTE = 0x0022,
+    SPACE = 0x0020
+};
+
+/**
+ * Utility for parsing a localization string and returning a StringLocalizationInfo*.
+ */
+class LocDataParser {
+    UChar* data;
+    const UChar* e;
+    UChar* p;
+    UChar ch;
+    UParseError& pe;
+    UErrorCode& ec;
+    
+public:
+    LocDataParser(UParseError& parseError, UErrorCode& status) 
+        : data(NULL), e(NULL), p(NULL), ch(0xffff), pe(parseError), ec(status) {}
+    ~LocDataParser() {}
+    
+    /*
+    * On a successful parse, return a StringLocalizationInfo*, otherwise delete locData, set perror and status,
+    * and return NULL.  The StringLocalizationInfo will adopt locData if it is created.
+    */
+    StringLocalizationInfo* parse(UChar* data, int32_t len);
+    
+private:
+    
+    void inc(void) { ++p; ch = 0xffff; }
+    UBool checkInc(UChar c) { if (p < e && (ch == c || *p == c)) { inc(); return TRUE; } return FALSE; }
+    UBool check(UChar c) { return p < e && (ch == c || *p == c); }
+    void skipWhitespace(void) { while (p < e && uprv_isRuleWhiteSpace(ch != 0xffff ? ch : *p)) inc();}
+    UBool inList(UChar c, const UChar* list) const {
+        if (*list == SPACE && uprv_isRuleWhiteSpace(c)) return TRUE;
+        while (*list && *list != c) ++list; return *list == c;
+    }
+    void parseError(const char* msg);
+    
+    StringLocalizationInfo* doParse(void);
+        
+    UChar** nextArray(int32_t& requiredLength);
+    UChar*  nextString(void);
+};
+
+#ifdef DEBUG
+#define ERROR(msg) parseError(msg); return NULL;
+#else
+#define ERROR(msg) parseError(NULL); return NULL;
+#endif
+        
+
+static const UChar DQUOTE_STOPLIST[] = { 
+    QUOTE, 0
+};
+
+static const UChar SQUOTE_STOPLIST[] = { 
+    TICK, 0
+};
+
+static const UChar NOQUOTE_STOPLIST[] = { 
+    SPACE, COMMA, CLOSE_ANGLE, OPEN_ANGLE, TICK, QUOTE, 0
+};
+
+static void
+DeleteFn(void* p) {
+  uprv_free(p);
+}
+
+StringLocalizationInfo*
+LocDataParser::parse(UChar* _data, int32_t len) {
+    if (U_FAILURE(ec)) {
+        if (_data) uprv_free(_data);
+        return NULL;
+    }
+
+    pe.line = 0;
+    pe.offset = -1;
+    pe.postContext[0] = 0;
+    pe.preContext[0] = 0;
+
+    if (_data == NULL) {
+        ec = U_ILLEGAL_ARGUMENT_ERROR;
+        return NULL;
+    }
+
+    if (len <= 0) {
+        ec = U_ILLEGAL_ARGUMENT_ERROR;
+        uprv_free(_data);
+        return NULL;
+    }
+
+    data = _data;
+    e = data + len;
+    p = _data;
+    ch = 0xffff;
+
+    return doParse();
+}
+
+
+StringLocalizationInfo*
+LocDataParser::doParse(void) {
+    skipWhitespace();
+    if (!checkInc(OPEN_ANGLE)) {
+        ERROR("Missing open angle");
+    } else {
+        VArray array(DeleteFn);
+        UBool mightHaveNext = TRUE;
+        int32_t requiredLength = -1;
+        while (mightHaveNext) {
+            mightHaveNext = FALSE;
+            UChar** elem = nextArray(requiredLength);
+            skipWhitespace();
+            UBool haveComma = check(COMMA);
+            if (elem) {
+                array.add(elem, ec);
+                if (haveComma) {
+                    inc();
+                    mightHaveNext = TRUE;
+                }
+            } else if (haveComma) {
+                ERROR("Unexpected character");
+            }
+        }
+
+        skipWhitespace();
+        if (!checkInc(CLOSE_ANGLE)) {
+            if (check(OPEN_ANGLE)) {
+                ERROR("Missing comma in outer array");
+            } else {
+                ERROR("Missing close angle bracket in outer array");
+            }
+        }
+
+        skipWhitespace();
+        if (p != e) {
+            ERROR("Extra text after close of localization data");
+        }
+
+        array.add(NULL, ec);
+        if (U_SUCCESS(ec)) {
+            int32_t numLocs = array.length() - 2; // subtract first, NULL
+            UChar*** result = (UChar***)array.release();
+            
+            return new StringLocalizationInfo(data, result, requiredLength-2, numLocs); // subtract first, NULL
+        }
+    }
+  
+    ERROR("Unknown error");
+}
+
+UChar**
+LocDataParser::nextArray(int32_t& requiredLength) {
+    if (U_FAILURE(ec)) {
+        return NULL;
+    }
+    
+    skipWhitespace();
+    if (!checkInc(OPEN_ANGLE)) {
+        ERROR("Missing open angle");
+    }
+
+    VArray array;
+    UBool mightHaveNext = TRUE;
+    while (mightHaveNext) {
+        mightHaveNext = FALSE;
+        UChar* elem = nextString();
+        skipWhitespace();
+        UBool haveComma = check(COMMA);
+        if (elem) {
+            array.add(elem, ec);
+            if (haveComma) {
+                inc();
+                mightHaveNext = TRUE;
+            }
+        } else if (haveComma) {
+            ERROR("Unexpected comma");
+        }
+    }
+    skipWhitespace();
+    if (!checkInc(CLOSE_ANGLE)) {
+        if (check(OPEN_ANGLE)) {
+            ERROR("Missing close angle bracket in inner array");
+        } else {
+            ERROR("Missing comma in inner array");
+        }
+    }
+
+    array.add(NULL, ec);
+    if (U_SUCCESS(ec)) {
+        if (requiredLength == -1) {
+            requiredLength = array.length() + 1;
+        } else if (array.length() != requiredLength) {
+            ec = U_ILLEGAL_ARGUMENT_ERROR;
+            ERROR("Array not of required length");
+        }
+        
+        return (UChar**)array.release();
+    }
+    ERROR("Unknown Error");
+}
+
+UChar*
+LocDataParser::nextString() {
+    UChar* result = NULL;
+    
+    skipWhitespace();
+    if (p < e) {
+        const UChar* terminators;
+        UChar c = *p;
+        UBool haveQuote = c == QUOTE || c == TICK;
+        if (haveQuote) {
+            inc();
+            terminators = c == QUOTE ? DQUOTE_STOPLIST : SQUOTE_STOPLIST;
+        } else {
+            terminators = NOQUOTE_STOPLIST;
+        }
+        UChar* start = p;
+        while (p < e && !inList(*p, terminators)) ++p;
+        if (p == e) {
+            ERROR("Unexpected end of data");
+        }
+        
+        UChar x = *p;
+        if (p > start) {
+            ch = x;
+            *p = 0x0; // terminate by writing to data
+            result = start; // just point into data
+        }
+        if (haveQuote) {
+            if (x != c) {
+                ERROR("Missing matching quote");
+            } else if (p == start) {
+                ERROR("Empty string");
+            }
+            inc();
+        } else if (x == OPEN_ANGLE || x == TICK || x == QUOTE) {
+            ERROR("Unexpected character in string");
+        }
+    }
+
+    // ok for there to be no next string
+    return result;
+}
+
+void
+LocDataParser::parseError(const char* /*str*/) {
+    if (!data) {
+        return;
+    }
+
+    const UChar* start = p - U_PARSE_CONTEXT_LEN - 1;
+    if (start < data) {
+        start = data;
+    }
+    for (UChar* x = p; --x >= start;) {
+        if (!*x) {
+            start = x+1;
+            break;
+        }
+    }
+    const UChar* limit = p + U_PARSE_CONTEXT_LEN - 1;
+    if (limit > e) {
+        limit = e;
+    }
+    u_strncpy(pe.preContext, start, (int32_t)(p-start));
+    pe.preContext[p-start] = 0;
+    u_strncpy(pe.postContext, p, (int32_t)(limit-p));
+    pe.postContext[limit-p] = 0;
+    pe.offset = (int32_t)(p - data);
+    
+#ifdef DEBUG
+    fprintf(stderr, "%s at or near character %d: ", str, p-data);
+
+    UnicodeString msg;
+    msg.append(start, p - start);
+    msg.append((UChar)0x002f); /* SOLIDUS/SLASH */
+    msg.append(p, limit-p);
+    msg.append("'");
+    
+    char buf[128];
+    int32_t len = msg.extract(0, msg.length(), buf, 128);
+    if (len >= 128) {
+        buf[127] = 0;
+    } else {
+        buf[len] = 0;
+    }
+    fprintf(stderr, "%s\n", buf);
+    fflush(stderr);
+#endif
+    
+    uprv_free(data);
+    data = NULL;
+    p = NULL;
+    e = NULL;
+    
+    if (U_SUCCESS(ec)) {
+        ec = U_PARSE_ERROR;
+    }
+}
+
+//UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringLocalizationInfo)
+
+StringLocalizationInfo* 
+StringLocalizationInfo::create(const UnicodeString& info, UParseError& perror, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    
+    int32_t len = info.length();
+    if (len == 0) {
+        return NULL; // no error;
+    }
+    
+    UChar* p = (UChar*)uprv_malloc(len * sizeof(UChar));
+    if (!p) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+    info.extract(p, len, status);
+    if (!U_FAILURE(status)) {
+        status = U_ZERO_ERROR; // clear warning about non-termination
+    }
+    
+    LocDataParser parser(perror, status);
+    return parser.parse(p, len);
+}
+
+StringLocalizationInfo::~StringLocalizationInfo() {
+    for (UChar*** p = (UChar***)data; *p; ++p) {
+        // remaining data is simply pointer into our unicode string data.
+        if (*p) uprv_free(*p);
+    }
+    if (data) uprv_free(data);
+    if (info) uprv_free(info);
+}
+
+
+const UChar*
+StringLocalizationInfo::getRuleSetName(int32_t index) const {
+    if (index >= 0 && index < getNumberOfRuleSets()) {
+        return data[0][index];
+    }
+    return NULL;
+}
+
+const UChar*
+StringLocalizationInfo::getLocaleName(int32_t index) const {
+    if (index >= 0 && index < getNumberOfDisplayLocales()) {
+        return data[index+1][0];
+    }
+    return NULL;
+}
+
+const UChar*
+StringLocalizationInfo::getDisplayName(int32_t localeIndex, int32_t ruleIndex) const {
+    if (localeIndex >= 0 && localeIndex < getNumberOfDisplayLocales() &&
+        ruleIndex >= 0 && ruleIndex < getNumberOfRuleSets()) {
+        return data[localeIndex+1][ruleIndex+1];
+    }
+    return NULL;
+}
+
+// ----------
+
+RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
+                                             const UnicodeString& locs,
+                                             const Locale& alocale, UParseError& perror, UErrorCode& status)
+  : ruleSets(NULL)
+  , defaultRuleSet(NULL)
+  , locale(alocale)
+  , collator(NULL)
+  , decimalFormatSymbols(NULL)
+  , lenient(FALSE)
+  , lenientParseRules(NULL)
+  , localizations(NULL)
+  , noParse(FALSE) //TODO: to be removed after #6895
+{
+  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)
+  , defaultRuleSet(NULL)
+  , locale(Locale::getDefault())
+  , collator(NULL)
+  , decimalFormatSymbols(NULL)
+  , lenient(FALSE)
+  , lenientParseRules(NULL)
+  , localizations(NULL)
+  , noParse(FALSE) //TODO: to be removed after #6895
+{
+  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)
+  , defaultRuleSet(NULL)
+  , locale(alocale)
+  , collator(NULL)
+  , decimalFormatSymbols(NULL)
+  , lenient(FALSE)
+  , lenientParseRules(NULL)
+  , localizations(NULL)
+  , noParse(FALSE) //TODO: to be removed after #6895
+{
+  init(description, info, perror, status);
+}
+
+RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
+                         UParseError& perror, 
+                         UErrorCode& status) 
+  : ruleSets(NULL)
+  , defaultRuleSet(NULL)
+  , locale(Locale::getDefault())
+  , collator(NULL)
+  , decimalFormatSymbols(NULL)
+  , lenient(FALSE)
+  , lenientParseRules(NULL)
+  , localizations(NULL)
+  , noParse(FALSE) //TODO: to be removed after #6895
+{
+    init(description, NULL, perror, status);
+}
+
+RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description, 
+                         const Locale& aLocale,
+                         UParseError& perror, 
+                         UErrorCode& status) 
+  : ruleSets(NULL)
+  , defaultRuleSet(NULL)
+  , locale(aLocale)
+  , collator(NULL)
+  , decimalFormatSymbols(NULL)
+  , lenient(FALSE)
+  , lenientParseRules(NULL)
+  , localizations(NULL)
+  , noParse(FALSE) //TODO: to be removed after #6895
+{
+    init(description, NULL, perror, status);
+}
+
+RuleBasedNumberFormat::RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& alocale, UErrorCode& status)
+  : ruleSets(NULL)
+  , defaultRuleSet(NULL)
+  , locale(alocale)
+  , collator(NULL)
+  , decimalFormatSymbols(NULL)
+  , lenient(FALSE)
+  , lenientParseRules(NULL)
+  , localizations(NULL)
+{
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    const char* rules_tag = "RBNFRules";
+    const char* fmt_tag = "";
+    switch (tag) {
+    case URBNF_SPELLOUT: fmt_tag = "SpelloutRules"; break;
+    case URBNF_ORDINAL: fmt_tag = "OrdinalRules"; break;
+    case URBNF_DURATION: fmt_tag = "DurationRules"; break;
+    case URBNF_NUMBERING_SYSTEM: fmt_tag = "NumberingSystemRules"; break;
+    default: status = U_ILLEGAL_ARGUMENT_ERROR; return;
+    }
+
+    // TODO: read localization info from resource
+    LocalizationInfo* locinfo = NULL;
+
+    int32_t len = 0;
+    UResourceBundle* nfrb = ures_open(U_ICUDATA_RBNF, locale.getName(), &status);
+    if (U_SUCCESS(status)) {
+        setLocaleIDs(ures_getLocaleByType(nfrb, ULOC_VALID_LOCALE, &status),
+                     ures_getLocaleByType(nfrb, ULOC_ACTUAL_LOCALE, &status));
+
+        UResourceBundle* rbnfRules = ures_getByKeyWithFallback(nfrb, rules_tag, NULL, &status);
+        if (U_FAILURE(status)) {
+            ures_close(nfrb);
+        }
+        UResourceBundle* ruleSets = ures_getByKeyWithFallback(rbnfRules, fmt_tag, NULL, &status);
+        if (U_FAILURE(status)) {
+            ures_close(rbnfRules);
+            ures_close(nfrb);
+            return;
+        }
+        
+        UnicodeString desc;
+        while (ures_hasNext(ruleSets)) {
+           const UChar* currentString = ures_getNextString(ruleSets,&len,NULL,&status);
+           desc.append(currentString);
+        }
+        UParseError perror;
+        
+
+        init (desc, locinfo, perror, status);
+
+        //TODO: we need a real fix - see #6895 / #6896
+        noParse = FALSE;
+        if (tag == URBNF_SPELLOUT) {
+            const char *lang = alocale.getLanguage();
+            for (int32_t i = 0; NO_SPELLOUT_PARSE_LANGUAGES[i] != NULL; i++) {
+                if (uprv_strcmp(lang, NO_SPELLOUT_PARSE_LANGUAGES[i]) == 0) {
+                    noParse = TRUE;
+                    break;
+                }
+            }
+        }
+        //TODO: end
+
+        ures_close(ruleSets);
+        ures_close(rbnfRules);
+    }
+    ures_close(nfrb);
+}
+
+RuleBasedNumberFormat::RuleBasedNumberFormat(const RuleBasedNumberFormat& rhs)
+  : NumberFormat(rhs)
+  , ruleSets(NULL)
+  , defaultRuleSet(NULL)
+  , locale(rhs.locale)
+  , collator(NULL)
+  , decimalFormatSymbols(NULL)
+  , lenient(FALSE)
+  , lenientParseRules(NULL)
+  , localizations(NULL)
+{
+    this->operator=(rhs);
+}
+
+// --------
+
+RuleBasedNumberFormat&
+RuleBasedNumberFormat::operator=(const RuleBasedNumberFormat& rhs)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    dispose();
+    locale = rhs.locale;
+    lenient = rhs.lenient;
+
+    UnicodeString rules = rhs.getRules();
+    UParseError perror;
+    init(rules, rhs.localizations ? rhs.localizations->ref() : NULL, perror, status);
+
+    //TODO: remove below when we fix the parse bug - See #6895 / #6896
+    noParse = rhs.noParse;
+
+    return *this;
+}
+
+RuleBasedNumberFormat::~RuleBasedNumberFormat()
+{
+    dispose();
+}
+
+Format*
+RuleBasedNumberFormat::clone(void) const
+{
+    RuleBasedNumberFormat * result = NULL;
+    UnicodeString rules = getRules();
+    UErrorCode status = U_ZERO_ERROR;
+    UParseError perror;
+    result = new RuleBasedNumberFormat(rules, localizations, locale, perror, status);
+    /* test for NULL */
+    if (result == 0) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return 0;
+    }
+    if (U_FAILURE(status)) {
+        delete result;
+        result = 0;
+    } else {
+        result->lenient = lenient;
+
+        //TODO: remove below when we fix the parse bug - See #6895 / #6896
+        result->noParse = noParse;
+    }
+    return result;
+}
+
+UBool
+RuleBasedNumberFormat::operator==(const Format& other) const
+{
+    if (this == &other) {
+        return TRUE;
+    }
+
+    if (typeid(*this) == typeid(other)) {
+        const RuleBasedNumberFormat& rhs = (const RuleBasedNumberFormat&)other;
+        if (locale == rhs.locale &&
+            lenient == rhs.lenient &&
+            (localizations == NULL 
+                ? rhs.localizations == NULL 
+                : (rhs.localizations == NULL 
+                    ? FALSE
+                    : *localizations == rhs.localizations))) {
+
+            NFRuleSet** p = ruleSets;
+            NFRuleSet** q = rhs.ruleSets;
+            if (p == NULL) {
+                return q == NULL;
+            } else if (q == NULL) {
+                return FALSE;
+            }
+            while (*p && *q && (**p == **q)) {
+                ++p;
+                ++q;
+            }
+            return *q == NULL && *p == NULL;
+        }
+    }
+
+    return FALSE;
+}
+
+UnicodeString
+RuleBasedNumberFormat::getRules() const
+{
+    UnicodeString result;
+    if (ruleSets != NULL) {
+        for (NFRuleSet** p = ruleSets; *p; ++p) {
+            (*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 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) {
+        for (NFRuleSet** p = ruleSets; *p; ++p) {
+            if ((**p).isPublic()) {
+                ++result;
+            }
+        }
+    }
+    return result;
+}
+
+int32_t 
+RuleBasedNumberFormat::getNumberOfRuleSetDisplayNameLocales(void) const {
+    if (localizations) {
+        return localizations->getNumberOfDisplayLocales();
+    }
+    return 0;
+}
+
+Locale 
+RuleBasedNumberFormat::getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return Locale("");
+    }
+    if (localizations && index >= 0 && index < localizations->getNumberOfDisplayLocales()) {
+        UnicodeString name(TRUE, localizations->getLocaleName(index), -1);
+        char buffer[64];
+        int32_t cap = name.length() + 1;
+        char* bp = buffer;
+        if (cap > 64) {
+            bp = (char *)uprv_malloc(cap);
+            if (bp == NULL) {
+                status = U_MEMORY_ALLOCATION_ERROR;
+                return Locale("");
+            }
+        }
+        name.extract(0, name.length(), bp, cap, UnicodeString::kInvariant);
+        Locale retLocale(bp);
+        if (bp != buffer) {
+            uprv_free(bp);
+        }
+        return retLocale;
+    }
+    status = U_ILLEGAL_ARGUMENT_ERROR;
+    Locale retLocale;
+    return retLocale;
+}
+
+UnicodeString 
+RuleBasedNumberFormat::getRuleSetDisplayName(int32_t index, const Locale& localeParam) {
+    if (localizations && index >= 0 && index < localizations->getNumberOfRuleSets()) {
+        UnicodeString localeName(localeParam.getBaseName(), -1, UnicodeString::kInvariant); 
+        int32_t len = localeName.length();
+        UChar* localeStr = localeName.getBuffer(len + 1);
+        while (len >= 0) {
+            localeStr[len] = 0;
+            int32_t ix = localizations->indexForLocale(localeStr);
+            if (ix >= 0) {
+                UnicodeString name(TRUE, localizations->getDisplayName(ix, index), -1);
+                return name;
+            }
+            
+            // trim trailing portion, skipping over ommitted sections
+            do { --len;} while (len > 0 && localeStr[len] != 0x005f); // underscore
+            while (len > 0 && localeStr[len-1] == 0x005F) --len;
+        }
+        UnicodeString name(TRUE, localizations->getRuleSetName(index), -1);
+        return name;
+    }
+    UnicodeString bogus;
+    bogus.setToBogus();
+    return bogus;
+}
+
+UnicodeString 
+RuleBasedNumberFormat::getRuleSetDisplayName(const UnicodeString& ruleSetName, const Locale& localeParam) {
+    if (localizations) {
+        UnicodeString rsn(ruleSetName);
+        int32_t ix = localizations->indexForRuleSet(rsn.getTerminatedBuffer());
+        return getRuleSetDisplayName(ix, localeParam);
+    }
+    UnicodeString bogus;
+    bogus.setToBogus();
+    return bogus;
+}
+
+NFRuleSet*
+RuleBasedNumberFormat::findRuleSet(const UnicodeString& name, UErrorCode& status) const
+{
+    if (U_SUCCESS(status) && ruleSets) {
+        for (NFRuleSet** p = ruleSets; *p; ++p) {
+            NFRuleSet* rs = *p;
+            if (rs->isNamed(name)) {
+                return rs;
+            }
+        }
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+    }
+    return NULL;
+}
+
+UnicodeString&
+RuleBasedNumberFormat::format(int32_t number,
+                              UnicodeString& toAppendTo,
+                              FieldPosition& /* pos */) const
+{
+    if (defaultRuleSet) defaultRuleSet->format((int64_t)number, toAppendTo, toAppendTo.length());
+    return toAppendTo;
+}
+
+
+UnicodeString&
+RuleBasedNumberFormat::format(int64_t number,
+                              UnicodeString& toAppendTo,
+                              FieldPosition& /* pos */) const
+{
+    if (defaultRuleSet) defaultRuleSet->format(number, toAppendTo, toAppendTo.length());
+    return toAppendTo;
+}
+
+
+UnicodeString&
+RuleBasedNumberFormat::format(double number,
+                              UnicodeString& toAppendTo,
+                              FieldPosition& /* pos */) const
+{
+    if (defaultRuleSet) defaultRuleSet->format(number, toAppendTo, toAppendTo.length());
+    return 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) == 0) {
+            // throw new IllegalArgumentException("Can't use internal rule set");
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+        } else {
+            NFRuleSet *rs = findRuleSet(ruleSetName, status);
+            if (rs) {
+                rs->format((int64_t)number, toAppendTo, toAppendTo.length());
+            }
+        }
+    }
+    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) == 0) {
+            // throw new IllegalArgumentException("Can't use internal rule set");
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+        } else {
+            NFRuleSet *rs = findRuleSet(ruleSetName, status);
+            if (rs) {
+                rs->format(number, toAppendTo, toAppendTo.length());
+            }
+        }
+    }
+    return toAppendTo;
+}
+
+
+// make linker happy
+UnicodeString&
+RuleBasedNumberFormat::format(const Formattable& obj,
+                              UnicodeString& toAppendTo,
+                              FieldPosition& pos,
+                              UErrorCode& status) const
+{
+    return NumberFormat::format(obj, toAppendTo, pos, status);
+}
+
+UnicodeString&
+RuleBasedNumberFormat::format(double number,
+                              const UnicodeString& ruleSetName,
+                              UnicodeString& toAppendTo,
+                              FieldPosition& /* pos */,
+                              UErrorCode& status) const
+{
+    if (U_SUCCESS(status)) {
+        if (ruleSetName.indexOf(gPercentPercent) == 0) {
+            // throw new IllegalArgumentException("Can't use internal rule set");
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+        } else {
+            NFRuleSet *rs = findRuleSet(ruleSetName, status);
+            if (rs) {
+                rs->format(number, toAppendTo, toAppendTo.length());
+            }
+        }
+    }
+    return toAppendTo;
+}
+
+void
+RuleBasedNumberFormat::parse(const UnicodeString& text,
+                             Formattable& result,
+                             ParsePosition& parsePosition) const
+{
+    //TODO: We need a real fix.  See #6895 / #6896
+    if (noParse) {
+        // skip parsing
+        parsePosition.setErrorIndex(0);
+        return;
+    }
+
+    if (!ruleSets) {
+        parsePosition.setErrorIndex(0);
+        return;
+    }
+
+    UnicodeString workingText(text, parsePosition.getIndex());
+    ParsePosition workingPos(0);
+
+    ParsePosition high_pp(0);
+    Formattable high_result;
+
+    for (NFRuleSet** p = ruleSets; *p; ++p) {
+        NFRuleSet *rp = *p;
+        if (rp->isPublic() && rp->isParseable()) {
+            ParsePosition working_pp(0);
+            Formattable working_result;
+
+            rp->parse(workingText, working_pp, kMaxDouble, working_result);
+            if (working_pp.getIndex() > high_pp.getIndex()) {
+                high_pp = working_pp;
+                high_result = working_result;
+
+                if (high_pp.getIndex() == workingText.length()) {
+                    break;
+                }
+            }
+        }
+    }
+
+    int32_t startIndex = parsePosition.getIndex();
+    parsePosition.setIndex(startIndex + high_pp.getIndex());
+    if (high_pp.getIndex() > 0) {
+        parsePosition.setErrorIndex(-1);
+    } else {
+        int32_t errorIndex = (high_pp.getErrorIndex()>0)? high_pp.getErrorIndex(): 0;
+        parsePosition.setErrorIndex(startIndex + errorIndex);
+    }
+    result = high_result;
+    if (result.getType() == Formattable::kDouble) {
+        int32_t r = (int32_t)result.getDouble();
+        if ((double)r == result.getDouble()) {
+            result.setLong(r);
+        }
+    }
+}
+
+#if !UCONFIG_NO_COLLATION
+
+void
+RuleBasedNumberFormat::setLenient(UBool enabled)
+{
+    lenient = enabled;
+    if (!enabled && collator) {
+        delete collator;
+        collator = NULL;
+    }
+}
+
+#endif
+
+void 
+RuleBasedNumberFormat::setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status) {
+    if (U_SUCCESS(status)) {
+        if (ruleSetName.isEmpty()) {
+          if (localizations) {
+              UnicodeString name(TRUE, localizations->getRuleSetName(0), -1);
+              defaultRuleSet = findRuleSet(name, status);
+          } else {
+            initDefaultRuleSet();
+          }
+        } else if (ruleSetName.startsWith(UNICODE_STRING_SIMPLE("%%"))) {
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+        } else {
+            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;
+}
+
+void 
+RuleBasedNumberFormat::initDefaultRuleSet()
+{
+    defaultRuleSet = NULL;
+    if (!ruleSets) {
+      return;
+    }
+
+    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;
+        }
+    }
+
+    defaultRuleSet = *--p;
+    if (!defaultRuleSet->isPublic()) {
+        while (p != ruleSets) {
+            if ((*--p)->isPublic()) {
+                defaultRuleSet = *p;
+                break;
+            }
+        }
+    }
+}
+
+
+void
+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;
+    }
+
+    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
+    // description).  This allows us to look for rule-set boundaries
+    // by searching for ";%" without having to worry about whitespace
+    // between the ; and the %
+    stripWhitespace(description);
+
+    // check to see if there's a set of lenient-parse rules.  If there
+    // is, pull them out into our temporary holding place for them,
+    // and delete them from the description before the real desciption-
+    // parsing code sees them
+    int32_t lp = description.indexOf(gLenientParse);
+    if (lp != -1) {
+        // we've got to make sure we're not in the middle of a rule
+        // (where "%%lenient-parse" would actually get treated as
+        // rule text)
+        if (lp == 0 || description.charAt(lp - 1) == gSemiColon) {
+            // locate the beginning and end of the actual collation
+            // rules (there may be whitespace between the name and
+            // the first token in the description)
+            int lpEnd = description.indexOf(gSemiPercent, lp);
+
+            if (lpEnd == -1) {
+                lpEnd = description.length() - 1;
+            }
+            int lpStart = lp + u_strlen(gLenientParse);
+            while (uprv_isRuleWhiteSpace(description.charAt(lpStart))) {
+                ++lpStart;
+            }
+
+            // copy out the lenient-parse rules and delete them
+            // from the description
+            lenientParseRules = new UnicodeString();
+            /* test for NULL */
+            if (lenientParseRules == 0) {
+                status = U_MEMORY_ALLOCATION_ERROR;
+                return;
+            }
+            lenientParseRules->setTo(description, lpStart, lpEnd - lpStart);
+
+            description.remove(lp, lpEnd + 1 - lp);
+        }
+    }
+
+    // pre-flight parsing the description and count the number of
+    // rule sets (";%" marks the end of one rule set and the beginning
+    // of the next)
+    int numRuleSets = 0;
+    for (int32_t p = description.indexOf(gSemiPercent); p != -1; p = description.indexOf(gSemiPercent, p)) {
+        ++numRuleSets;
+        ++p;
+    }
+    ++numRuleSets;
+
+    // our rule list is an array of the appropriate size
+    ruleSets = (NFRuleSet **)uprv_malloc((numRuleSets + 1) * sizeof(NFRuleSet *));
+    /* test for NULL */
+    if (ruleSets == 0) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+
+    for (int i = 0; i <= numRuleSets; ++i) {
+        ruleSets[i] = NULL;
+    }
+
+    // divide up the descriptions into individual rule-set descriptions
+    // and store them in a temporary array.  At each step, we also
+    // new up a rule set, but all this does is initialize its name
+    // and remove it from its description.  We can't actually parse
+    // the rest of the descriptions and finish initializing everything
+    // because we have to know the names and locations of all the rule
+    // sets before we can actually set everything up
+    if(!numRuleSets) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
+    UnicodeString* ruleSetDescriptions = new UnicodeString[numRuleSets];
+    if (ruleSetDescriptions == 0) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+
+    {
+        int curRuleSet = 0;
+        int32_t start = 0;
+        for (int32_t p = description.indexOf(gSemiPercent); p != -1; p = description.indexOf(gSemiPercent, start)) {
+            ruleSetDescriptions[curRuleSet].setTo(description, start, p + 1 - start);
+            ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status);
+            if (ruleSets[curRuleSet] == 0) {
+                status = U_MEMORY_ALLOCATION_ERROR;
+                goto cleanup;
+            }
+            ++curRuleSet;
+            start = p + 1;
+        }
+        ruleSetDescriptions[curRuleSet].setTo(description, start, description.length() - start);
+        ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status);
+        if (ruleSets[curRuleSet] == 0) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            goto cleanup;
+        }
+    }
+
+    // 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);
+        }
+    }
+
+    // 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.
+    
+    if (localizationInfos) {
+        // confirm the names, if any aren't in the rules, that's an error
+        // it is ok if the rules contain public rule sets that are not in this list
+        for (int32_t i = 0; i < localizationInfos->getNumberOfRuleSets(); ++i) {
+            UnicodeString name(TRUE, localizationInfos->getRuleSetName(i), -1);
+            NFRuleSet* rs = findRuleSet(name, status);
+            if (rs == NULL) {
+                break; // error
+            }
+            if (i == 0) {
+                defaultRuleSet = rs;
+            }
+        }
+    } else {
+        defaultRuleSet = getDefaultRuleSet();
+    }
+
+cleanup:
+    delete[] ruleSetDescriptions;
+}
+
+void
+RuleBasedNumberFormat::stripWhitespace(UnicodeString& description)
+{
+    // iterate through the characters...
+    UnicodeString result;
+
+    int start = 0;
+    while (start != -1 && start < description.length()) {
+        // seek to the first non-whitespace character...
+        while (start < description.length()
+            && uprv_isRuleWhiteSpace(description.charAt(start))) {
+            ++start;
+        }
+
+        // locate the next semicolon in the text and copy the text from
+        // our current position up to that semicolon into the result
+        int32_t p = description.indexOf(gSemiColon, start);
+        if (p == -1) {
+            // or if we don't find a semicolon, just copy the rest of
+            // the string into the result
+            result.append(description, start, description.length() - start);
+            start = -1;
+        }
+        else if (p < description.length()) {
+            result.append(description, start, p + 1 - start);
+            start = p + 1;
+        }
+
+        // when we get here, we've seeked off the end of the sring, and
+        // we terminate the loop (we continue until *start* is -1 rather
+        // than until *p* is -1, because otherwise we'd miss the last
+        // rule in the description)
+        else {
+            start = -1;
+        }
+    }
+
+    description.setTo(result);
+}
+
+
+void
+RuleBasedNumberFormat::dispose()
+{
+    if (ruleSets) {
+        for (NFRuleSet** p = ruleSets; *p; ++p) {
+            delete *p;
+        }
+        uprv_free(ruleSets);
+        ruleSets = NULL;
+    }
+
+#if !UCONFIG_NO_COLLATION
+    delete collator;
+#endif
+    collator = NULL;
+
+    delete decimalFormatSymbols;
+    decimalFormatSymbols = NULL;
+
+    delete lenientParseRules;
+    lenientParseRules = NULL;
+
+    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.
+ * @return The collator to use for lenient parsing, or null if lenient parsing
+ * is turned off.
+*/
+Collator*
+RuleBasedNumberFormat::getCollator() const
+{
+#if !UCONFIG_NO_COLLATION
+    if (!ruleSets) {
+        return NULL;
+    }
+
+    // lazy-evaulate the collator
+    if (collator == NULL && lenient) {
+        // create a default collator based on the formatter's locale,
+        // then pull out that collator's rules, append any additional
+        // rules specified in the description, and create a _new_
+        // collator based on the combinaiton of those rules
+
+        UErrorCode status = U_ZERO_ERROR;
+
+        Collator* temp = Collator::createInstance(locale, status);
+        RuleBasedCollator* newCollator;
+        if (U_SUCCESS(status) && (newCollator = dynamic_cast<RuleBasedCollator*>(temp)) != NULL) {
+            if (lenientParseRules) {
+                UnicodeString rules(newCollator->getRules());
+                rules.append(*lenientParseRules);
+
+                newCollator = new RuleBasedCollator(rules, status);
+                // Exit if newCollator could not be created.
+                if (newCollator == NULL) {
+                        return NULL;
+                }
+            } else {
+                temp = NULL;
+            }
+            if (U_SUCCESS(status)) {
+                newCollator->setAttribute(UCOL_DECOMPOSITION_MODE, UCOL_ON, status);
+                // cast away const
+                ((RuleBasedNumberFormat*)this)->collator = newCollator;
+            } else {
+                delete newCollator;
+            }
+        }
+        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
+{
+    // 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 {
+            delete temp;
+        }
+    }
+    return decimalFormatSymbols;
+}
+
+U_NAMESPACE_END
+
+/* U_HAVE_RBNF */
+#endif