Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1263 insertions, 1263 deletions

diff --git a/contrib/libs/icu/i18n/nfsubs.cpp b/contrib/libs/icu/i18n/nfsubs.cpp
index 208543d1ac..d9cd907139 100644
--- a/contrib/libs/icu/i18n/nfsubs.cpp
+++ b/contrib/libs/icu/i18n/nfsubs.cpp
@@ -1,584 +1,584 @@
 // © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*   Copyright (C) 1997-2015, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-******************************************************************************
-*   file name:  nfsubs.cpp
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+*   Copyright (C) 1997-2015, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+****************************************************************************** 
+*   file name:  nfsubs.cpp 
 *   encoding:   UTF-8
-*   tab size:   8 (not used)
-*   indentation:4
-*
-* Modification history
-* Date        Name      Comments
-* 10/11/2001  Doug      Ported from ICU4J
-*/
-
-#include <stdio.h>
-#include "utypeinfo.h"  // for 'typeid' to work
-
-#include "nfsubs.h"
+*   tab size:   8 (not used) 
+*   indentation:4 
+* 
+* Modification history 
+* Date        Name      Comments 
+* 10/11/2001  Doug      Ported from ICU4J 
+*/ 
+ 
+#include <stdio.h> 
+#include "utypeinfo.h"  // for 'typeid' to work 
+ 
+#include "nfsubs.h" 
 #include "fmtableimp.h"
 #include "putilimp.h"
 #include "number_decimalquantity.h"
-
-#if U_HAVE_RBNF
-
-static const UChar gLessThan = 0x003c;
-static const UChar gEquals = 0x003d;
-static const UChar gGreaterThan = 0x003e;
-static const UChar gPercent = 0x0025;
-static const UChar gPound = 0x0023;
-static const UChar gZero = 0x0030;
-static const UChar gSpace = 0x0020;
-
-static const UChar gEqualsEquals[] =
-{
-    0x3D, 0x3D, 0
-}; /* "==" */
-static const UChar gGreaterGreaterGreaterThan[] =
-{
-    0x3E, 0x3E, 0x3E, 0
-}; /* ">>>" */
-static const UChar gGreaterGreaterThan[] =
-{
-    0x3E, 0x3E, 0
-}; /* ">>" */
-
-U_NAMESPACE_BEGIN
-
+ 
+#if U_HAVE_RBNF 
+ 
+static const UChar gLessThan = 0x003c; 
+static const UChar gEquals = 0x003d; 
+static const UChar gGreaterThan = 0x003e; 
+static const UChar gPercent = 0x0025; 
+static const UChar gPound = 0x0023; 
+static const UChar gZero = 0x0030; 
+static const UChar gSpace = 0x0020; 
+ 
+static const UChar gEqualsEquals[] = 
+{ 
+    0x3D, 0x3D, 0 
+}; /* "==" */ 
+static const UChar gGreaterGreaterGreaterThan[] = 
+{ 
+    0x3E, 0x3E, 0x3E, 0 
+}; /* ">>>" */ 
+static const UChar gGreaterGreaterThan[] = 
+{ 
+    0x3E, 0x3E, 0 
+}; /* ">>" */ 
+ 
+U_NAMESPACE_BEGIN 
+ 
 using number::impl::DecimalQuantity;
 
-class SameValueSubstitution : public NFSubstitution {
-public:
-    SameValueSubstitution(int32_t pos,
-        const NFRuleSet* ruleset,
-        const UnicodeString& description,
-        UErrorCode& status);
-    virtual ~SameValueSubstitution();
-
-    virtual int64_t transformNumber(int64_t number) const { return number; }
-    virtual double transformNumber(double number) const { return number; }
-    virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const { return newRuleValue; }
-    virtual double calcUpperBound(double oldUpperBound) const { return oldUpperBound; }
-    virtual UChar tokenChar() const { return (UChar)0x003d; } // '='
-
-public:
-    static UClassID getStaticClassID(void);
-    virtual UClassID getDynamicClassID(void) const;
-};
-
-SameValueSubstitution::~SameValueSubstitution() {}
-
-class MultiplierSubstitution : public NFSubstitution {
+class SameValueSubstitution : public NFSubstitution { 
+public: 
+    SameValueSubstitution(int32_t pos, 
+        const NFRuleSet* ruleset, 
+        const UnicodeString& description, 
+        UErrorCode& status); 
+    virtual ~SameValueSubstitution(); 
+ 
+    virtual int64_t transformNumber(int64_t number) const { return number; } 
+    virtual double transformNumber(double number) const { return number; } 
+    virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const { return newRuleValue; } 
+    virtual double calcUpperBound(double oldUpperBound) const { return oldUpperBound; } 
+    virtual UChar tokenChar() const { return (UChar)0x003d; } // '=' 
+ 
+public: 
+    static UClassID getStaticClassID(void); 
+    virtual UClassID getDynamicClassID(void) const; 
+}; 
+ 
+SameValueSubstitution::~SameValueSubstitution() {} 
+ 
+class MultiplierSubstitution : public NFSubstitution { 
     int64_t divisor;
-
-public:
-    MultiplierSubstitution(int32_t _pos,
+ 
+public: 
+    MultiplierSubstitution(int32_t _pos, 
         const NFRule *rule,
-        const NFRuleSet* _ruleSet,
-        const UnicodeString& description,
-        UErrorCode& status)
+        const NFRuleSet* _ruleSet, 
+        const UnicodeString& description, 
+        UErrorCode& status) 
         : NFSubstitution(_pos, _ruleSet, description, status), divisor(rule->getDivisor())
-    {
-        if (divisor == 0) {
-            status = U_PARSE_ERROR;
-        }
-    }
-    virtual ~MultiplierSubstitution();
-
+    { 
+        if (divisor == 0) { 
+            status = U_PARSE_ERROR; 
+        } 
+    } 
+    virtual ~MultiplierSubstitution(); 
+ 
     virtual void setDivisor(int32_t radix, int16_t exponent, UErrorCode& status) { 
         divisor = util64_pow(radix, exponent);
-
-        if(divisor == 0) {
-            status = U_PARSE_ERROR;
-        }
-    }
-
-    virtual UBool operator==(const NFSubstitution& rhs) const;
-
-    virtual int64_t transformNumber(int64_t number) const {
+ 
+        if(divisor == 0) { 
+            status = U_PARSE_ERROR; 
+        } 
+    } 
+ 
+    virtual UBool operator==(const NFSubstitution& rhs) const; 
+ 
+    virtual int64_t transformNumber(int64_t number) const { 
         return number / divisor;
-    }
-
-    virtual double transformNumber(double number) const {
-        if (getRuleSet()) {
-            return uprv_floor(number / divisor);
-        } else {
+    } 
+ 
+    virtual double transformNumber(double number) const { 
+        if (getRuleSet()) { 
+            return uprv_floor(number / divisor); 
+        } else { 
             return number / divisor;
-        }
-    }
-
-    virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const {
-        return newRuleValue * divisor;
-    }
-
+        } 
+    } 
+ 
+    virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const { 
+        return newRuleValue * divisor; 
+    } 
+ 
     virtual double calcUpperBound(double /*oldUpperBound*/) const { return static_cast<double>(divisor); }
-
-    virtual UChar tokenChar() const { return (UChar)0x003c; } // '<'
-
-public:
-    static UClassID getStaticClassID(void);
-    virtual UClassID getDynamicClassID(void) const;
-};
-
-MultiplierSubstitution::~MultiplierSubstitution() {}
-
-class ModulusSubstitution : public NFSubstitution {
+ 
+    virtual UChar tokenChar() const { return (UChar)0x003c; } // '<' 
+ 
+public: 
+    static UClassID getStaticClassID(void); 
+    virtual UClassID getDynamicClassID(void) const; 
+}; 
+ 
+MultiplierSubstitution::~MultiplierSubstitution() {} 
+ 
+class ModulusSubstitution : public NFSubstitution { 
     int64_t  divisor;
-    const NFRule* ruleToUse;
-public:
-    ModulusSubstitution(int32_t pos,
+    const NFRule* ruleToUse; 
+public: 
+    ModulusSubstitution(int32_t pos, 
         const NFRule* rule,
-        const NFRule* rulePredecessor,
-        const NFRuleSet* ruleSet,
-        const UnicodeString& description,
-        UErrorCode& status);
-    virtual ~ModulusSubstitution();
-
+        const NFRule* rulePredecessor, 
+        const NFRuleSet* ruleSet, 
+        const UnicodeString& description, 
+        UErrorCode& status); 
+    virtual ~ModulusSubstitution(); 
+ 
     virtual void setDivisor(int32_t radix, int16_t exponent, UErrorCode& status) { 
         divisor = util64_pow(radix, exponent);
-
-        if (divisor == 0) {
-            status = U_PARSE_ERROR;
-        }
-    }
-
-    virtual UBool operator==(const NFSubstitution& rhs) const;
-
-    virtual void doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const;
-    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const;
-
+ 
+        if (divisor == 0) { 
+            status = U_PARSE_ERROR; 
+        } 
+    } 
+ 
+    virtual UBool operator==(const NFSubstitution& rhs) const; 
+ 
+    virtual void doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const; 
+    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const; 
+ 
     virtual int64_t transformNumber(int64_t number) const { return number % divisor; }
     virtual double transformNumber(double number) const { return uprv_fmod(number, static_cast<double>(divisor)); }
-
-    virtual UBool doParse(const UnicodeString& text, 
-        ParsePosition& parsePosition,
-        double baseValue,
-        double upperBound,
-        UBool lenientParse,
+ 
+    virtual UBool doParse(const UnicodeString& text,  
+        ParsePosition& parsePosition, 
+        double baseValue, 
+        double upperBound, 
+        UBool lenientParse, 
         uint32_t nonNumericalExecutedRuleMask,
-        Formattable& result) const;
-
-    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const {
+        Formattable& result) const; 
+ 
+    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { 
         return oldRuleValue - uprv_fmod(oldRuleValue, static_cast<double>(divisor)) + newRuleValue;
-    }
-
+    } 
+ 
     virtual double calcUpperBound(double /*oldUpperBound*/) const { return static_cast<double>(divisor); }
-
-    virtual UBool isModulusSubstitution() const { return TRUE; }
-
-    virtual UChar tokenChar() const { return (UChar)0x003e; } // '>'
-
-	virtual void toString(UnicodeString& result) const;
-
-public:
-    static UClassID getStaticClassID(void);
-    virtual UClassID getDynamicClassID(void) const;
-};
-
-ModulusSubstitution::~ModulusSubstitution() {}
-
-class IntegralPartSubstitution : public NFSubstitution {
-public:
-    IntegralPartSubstitution(int32_t _pos,
-        const NFRuleSet* _ruleSet,
-        const UnicodeString& description,
-        UErrorCode& status)
-        : NFSubstitution(_pos, _ruleSet, description, status) {}
-    virtual ~IntegralPartSubstitution();
-
-    virtual int64_t transformNumber(int64_t number) const { return number; }
-    virtual double transformNumber(double number) const { return uprv_floor(number); }
-    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue + oldRuleValue; }
-    virtual double calcUpperBound(double /*oldUpperBound*/) const { return DBL_MAX; }
-    virtual UChar tokenChar() const { return (UChar)0x003c; } // '<'
-
-public:
-    static UClassID getStaticClassID(void);
-    virtual UClassID getDynamicClassID(void) const;
-};
-
-IntegralPartSubstitution::~IntegralPartSubstitution() {}
-
-class FractionalPartSubstitution : public NFSubstitution {
-    UBool byDigits;
-    UBool useSpaces;
-    enum { kMaxDecimalDigits = 8 };
-public:
-    FractionalPartSubstitution(int32_t pos,
-        const NFRuleSet* ruleSet,
-        const UnicodeString& description,
-        UErrorCode& status);
-    virtual ~FractionalPartSubstitution();
-
-    virtual UBool operator==(const NFSubstitution& rhs) const;
-
-    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const;
-    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const {}
-    virtual int64_t transformNumber(int64_t /*number*/) const { return 0; }
-    virtual double transformNumber(double number) const { return number - uprv_floor(number); }
-
-    virtual UBool doParse(const UnicodeString& text,
-        ParsePosition& parsePosition,
-        double baseValue,
-        double upperBound,
-        UBool lenientParse,
-        uint32_t nonNumericalExecutedRuleMask,
-        Formattable& result) const;
-
-    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue + oldRuleValue; }
-    virtual double calcUpperBound(double /*oldUpperBound*/) const { return 0.0; }
-    virtual UChar tokenChar() const { return (UChar)0x003e; } // '>'
-
-public:
-    static UClassID getStaticClassID(void);
-    virtual UClassID getDynamicClassID(void) const;
-};
-
-FractionalPartSubstitution::~FractionalPartSubstitution() {}
-
-class AbsoluteValueSubstitution : public NFSubstitution {
-public:
-    AbsoluteValueSubstitution(int32_t _pos,
-        const NFRuleSet* _ruleSet,
-        const UnicodeString& description,
-        UErrorCode& status)
-        : NFSubstitution(_pos, _ruleSet, description, status) {}
-    virtual ~AbsoluteValueSubstitution();
-
-    virtual int64_t transformNumber(int64_t number) const { return number >= 0 ? number : -number; }
-    virtual double transformNumber(double number) const { return uprv_fabs(number); }
-    virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const { return -newRuleValue; }
-    virtual double calcUpperBound(double /*oldUpperBound*/) const { return DBL_MAX; }
-    virtual UChar tokenChar() const { return (UChar)0x003e; } // '>'
-
-public:
-    static UClassID getStaticClassID(void);
-    virtual UClassID getDynamicClassID(void) const;
-};
-
-AbsoluteValueSubstitution::~AbsoluteValueSubstitution() {}
-
-class NumeratorSubstitution : public NFSubstitution {
-    double denominator;
-    int64_t ldenominator;
-    UBool withZeros;
-public:
-    static inline UnicodeString fixdesc(const UnicodeString& desc) {
-        if (desc.endsWith(LTLT, 2)) {
-            UnicodeString result(desc, 0, desc.length()-1);
-            return result;
-        }
-        return desc;
-    }
-    NumeratorSubstitution(int32_t _pos,
-        double _denominator,
-        NFRuleSet* _ruleSet,
-        const UnicodeString& description,
-        UErrorCode& status)
-        : NFSubstitution(_pos, _ruleSet, fixdesc(description), status), denominator(_denominator) 
-    {
-        ldenominator = util64_fromDouble(denominator);
-        withZeros = description.endsWith(LTLT, 2);
-    }
-    virtual ~NumeratorSubstitution();
-
-    virtual UBool operator==(const NFSubstitution& rhs) const;
-
-    virtual int64_t transformNumber(int64_t number) const { return number * ldenominator; }
-    virtual double transformNumber(double number) const { return uprv_round(number * denominator); }
-
-    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const {}
-    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const;
+ 
+    virtual UBool isModulusSubstitution() const { return TRUE; } 
+ 
+    virtual UChar tokenChar() const { return (UChar)0x003e; } // '>' 
+ 
+	virtual void toString(UnicodeString& result) const; 
+ 
+public: 
+    static UClassID getStaticClassID(void); 
+    virtual UClassID getDynamicClassID(void) const; 
+}; 
+ 
+ModulusSubstitution::~ModulusSubstitution() {} 
+ 
+class IntegralPartSubstitution : public NFSubstitution { 
+public: 
+    IntegralPartSubstitution(int32_t _pos, 
+        const NFRuleSet* _ruleSet, 
+        const UnicodeString& description, 
+        UErrorCode& status) 
+        : NFSubstitution(_pos, _ruleSet, description, status) {} 
+    virtual ~IntegralPartSubstitution(); 
+ 
+    virtual int64_t transformNumber(int64_t number) const { return number; } 
+    virtual double transformNumber(double number) const { return uprv_floor(number); } 
+    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue + oldRuleValue; } 
+    virtual double calcUpperBound(double /*oldUpperBound*/) const { return DBL_MAX; } 
+    virtual UChar tokenChar() const { return (UChar)0x003c; } // '<' 
+ 
+public: 
+    static UClassID getStaticClassID(void); 
+    virtual UClassID getDynamicClassID(void) const; 
+}; 
+ 
+IntegralPartSubstitution::~IntegralPartSubstitution() {} 
+ 
+class FractionalPartSubstitution : public NFSubstitution { 
+    UBool byDigits; 
+    UBool useSpaces; 
+    enum { kMaxDecimalDigits = 8 }; 
+public: 
+    FractionalPartSubstitution(int32_t pos, 
+        const NFRuleSet* ruleSet, 
+        const UnicodeString& description, 
+        UErrorCode& status); 
+    virtual ~FractionalPartSubstitution(); 
+ 
+    virtual UBool operator==(const NFSubstitution& rhs) const; 
+ 
+    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const; 
+    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const {} 
+    virtual int64_t transformNumber(int64_t /*number*/) const { return 0; } 
+    virtual double transformNumber(double number) const { return number - uprv_floor(number); } 
+ 
     virtual UBool doParse(const UnicodeString& text, 
-        ParsePosition& parsePosition,
-        double baseValue,
-        double upperBound,
-        UBool /*lenientParse*/,
+        ParsePosition& parsePosition, 
+        double baseValue, 
+        double upperBound, 
+        UBool lenientParse, 
         uint32_t nonNumericalExecutedRuleMask,
-        Formattable& result) const;
-
-    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue / oldRuleValue; }
-    virtual double calcUpperBound(double /*oldUpperBound*/) const { return denominator; }
-    virtual UChar tokenChar() const { return (UChar)0x003c; } // '<'
-private:
-    static const UChar LTLT[2];
-
-public:
-    static UClassID getStaticClassID(void);
-    virtual UClassID getDynamicClassID(void) const;
-};
-
-NumeratorSubstitution::~NumeratorSubstitution() {}
-
-NFSubstitution*
-NFSubstitution::makeSubstitution(int32_t pos,
-                                 const NFRule* rule,
-                                 const NFRule* predecessor,
-                                 const NFRuleSet* ruleSet,
-                                 const RuleBasedNumberFormat* formatter,
-                                 const UnicodeString& description,
-                                 UErrorCode& status)
-{
-    // if the description is empty, return a NullSubstitution
-    if (description.length() == 0) {
-        return NULL;
-    }
-
-    switch (description.charAt(0)) {
-        // if the description begins with '<'...
-    case gLessThan:
-        // throw an exception if the rule is a negative number
-        // rule
-        if (rule->getBaseValue() == NFRule::kNegativeNumberRule) {
-            // throw new IllegalArgumentException("<< not allowed in negative-number rule");
-            status = U_PARSE_ERROR;
-            return NULL;
-        }
-
-        // if the rule is a fraction rule, return an
-        // IntegralPartSubstitution
-        else if (rule->getBaseValue() == NFRule::kImproperFractionRule
-            || rule->getBaseValue() == NFRule::kProperFractionRule
-            || rule->getBaseValue() == NFRule::kMasterRule) {
-            return new IntegralPartSubstitution(pos, ruleSet, description, status);
-        }
-
-        // if the rule set containing the rule is a fraction
-        // rule set, return a NumeratorSubstitution
-        else if (ruleSet->isFractionRuleSet()) {
-            return new NumeratorSubstitution(pos, (double)rule->getBaseValue(),
-                formatter->getDefaultRuleSet(), description, status);
-        }
-
-        // otherwise, return a MultiplierSubstitution
-        else {
+        Formattable& result) const; 
+ 
+    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue + oldRuleValue; } 
+    virtual double calcUpperBound(double /*oldUpperBound*/) const { return 0.0; } 
+    virtual UChar tokenChar() const { return (UChar)0x003e; } // '>' 
+ 
+public: 
+    static UClassID getStaticClassID(void); 
+    virtual UClassID getDynamicClassID(void) const; 
+}; 
+ 
+FractionalPartSubstitution::~FractionalPartSubstitution() {} 
+ 
+class AbsoluteValueSubstitution : public NFSubstitution { 
+public: 
+    AbsoluteValueSubstitution(int32_t _pos, 
+        const NFRuleSet* _ruleSet, 
+        const UnicodeString& description, 
+        UErrorCode& status) 
+        : NFSubstitution(_pos, _ruleSet, description, status) {} 
+    virtual ~AbsoluteValueSubstitution(); 
+ 
+    virtual int64_t transformNumber(int64_t number) const { return number >= 0 ? number : -number; } 
+    virtual double transformNumber(double number) const { return uprv_fabs(number); } 
+    virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const { return -newRuleValue; } 
+    virtual double calcUpperBound(double /*oldUpperBound*/) const { return DBL_MAX; } 
+    virtual UChar tokenChar() const { return (UChar)0x003e; } // '>' 
+ 
+public: 
+    static UClassID getStaticClassID(void); 
+    virtual UClassID getDynamicClassID(void) const; 
+}; 
+ 
+AbsoluteValueSubstitution::~AbsoluteValueSubstitution() {} 
+ 
+class NumeratorSubstitution : public NFSubstitution { 
+    double denominator; 
+    int64_t ldenominator; 
+    UBool withZeros; 
+public: 
+    static inline UnicodeString fixdesc(const UnicodeString& desc) { 
+        if (desc.endsWith(LTLT, 2)) { 
+            UnicodeString result(desc, 0, desc.length()-1); 
+            return result; 
+        } 
+        return desc; 
+    } 
+    NumeratorSubstitution(int32_t _pos, 
+        double _denominator, 
+        NFRuleSet* _ruleSet, 
+        const UnicodeString& description, 
+        UErrorCode& status) 
+        : NFSubstitution(_pos, _ruleSet, fixdesc(description), status), denominator(_denominator)  
+    { 
+        ldenominator = util64_fromDouble(denominator); 
+        withZeros = description.endsWith(LTLT, 2); 
+    } 
+    virtual ~NumeratorSubstitution(); 
+ 
+    virtual UBool operator==(const NFSubstitution& rhs) const; 
+ 
+    virtual int64_t transformNumber(int64_t number) const { return number * ldenominator; } 
+    virtual double transformNumber(double number) const { return uprv_round(number * denominator); } 
+ 
+    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const {} 
+    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const; 
+    virtual UBool doParse(const UnicodeString& text,  
+        ParsePosition& parsePosition, 
+        double baseValue, 
+        double upperBound, 
+        UBool /*lenientParse*/, 
+        uint32_t nonNumericalExecutedRuleMask,
+        Formattable& result) const; 
+ 
+    virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue / oldRuleValue; } 
+    virtual double calcUpperBound(double /*oldUpperBound*/) const { return denominator; } 
+    virtual UChar tokenChar() const { return (UChar)0x003c; } // '<' 
+private: 
+    static const UChar LTLT[2]; 
+ 
+public: 
+    static UClassID getStaticClassID(void); 
+    virtual UClassID getDynamicClassID(void) const; 
+}; 
+ 
+NumeratorSubstitution::~NumeratorSubstitution() {} 
+ 
+NFSubstitution* 
+NFSubstitution::makeSubstitution(int32_t pos, 
+                                 const NFRule* rule, 
+                                 const NFRule* predecessor, 
+                                 const NFRuleSet* ruleSet, 
+                                 const RuleBasedNumberFormat* formatter, 
+                                 const UnicodeString& description, 
+                                 UErrorCode& status) 
+{ 
+    // if the description is empty, return a NullSubstitution 
+    if (description.length() == 0) { 
+        return NULL; 
+    } 
+ 
+    switch (description.charAt(0)) { 
+        // if the description begins with '<'... 
+    case gLessThan: 
+        // throw an exception if the rule is a negative number 
+        // rule 
+        if (rule->getBaseValue() == NFRule::kNegativeNumberRule) { 
+            // throw new IllegalArgumentException("<< not allowed in negative-number rule"); 
+            status = U_PARSE_ERROR; 
+            return NULL; 
+        } 
+ 
+        // if the rule is a fraction rule, return an 
+        // IntegralPartSubstitution 
+        else if (rule->getBaseValue() == NFRule::kImproperFractionRule 
+            || rule->getBaseValue() == NFRule::kProperFractionRule 
+            || rule->getBaseValue() == NFRule::kMasterRule) { 
+            return new IntegralPartSubstitution(pos, ruleSet, description, status); 
+        } 
+ 
+        // if the rule set containing the rule is a fraction 
+        // rule set, return a NumeratorSubstitution 
+        else if (ruleSet->isFractionRuleSet()) { 
+            return new NumeratorSubstitution(pos, (double)rule->getBaseValue(), 
+                formatter->getDefaultRuleSet(), description, status); 
+        } 
+ 
+        // otherwise, return a MultiplierSubstitution 
+        else { 
             return new MultiplierSubstitution(pos, rule, ruleSet,
-                description, status);
-        }
-
-        // if the description begins with '>'...
-    case gGreaterThan:
-        // if the rule is a negative-number rule, return
-        // an AbsoluteValueSubstitution
-        if (rule->getBaseValue() == NFRule::kNegativeNumberRule) {
-            return new AbsoluteValueSubstitution(pos, ruleSet, description, status);
-        }
-
-        // if the rule is a fraction rule, return a
-        // FractionalPartSubstitution
-        else if (rule->getBaseValue() == NFRule::kImproperFractionRule
-            || rule->getBaseValue() == NFRule::kProperFractionRule
-            || rule->getBaseValue() == NFRule::kMasterRule) {
-            return new FractionalPartSubstitution(pos, ruleSet, description, status);
-        }
-
-        // if the rule set owning the rule is a fraction rule set,
-        // throw an exception
-        else if (ruleSet->isFractionRuleSet()) {
-            // throw new IllegalArgumentException(">> not allowed in fraction rule set");
-            status = U_PARSE_ERROR;
-            return NULL;
-        }
-
-        // otherwise, return a ModulusSubstitution
-        else {
+                description, status); 
+        } 
+ 
+        // if the description begins with '>'... 
+    case gGreaterThan: 
+        // if the rule is a negative-number rule, return 
+        // an AbsoluteValueSubstitution 
+        if (rule->getBaseValue() == NFRule::kNegativeNumberRule) { 
+            return new AbsoluteValueSubstitution(pos, ruleSet, description, status); 
+        } 
+ 
+        // if the rule is a fraction rule, return a 
+        // FractionalPartSubstitution 
+        else if (rule->getBaseValue() == NFRule::kImproperFractionRule 
+            || rule->getBaseValue() == NFRule::kProperFractionRule 
+            || rule->getBaseValue() == NFRule::kMasterRule) { 
+            return new FractionalPartSubstitution(pos, ruleSet, description, status); 
+        } 
+ 
+        // if the rule set owning the rule is a fraction rule set, 
+        // throw an exception 
+        else if (ruleSet->isFractionRuleSet()) { 
+            // throw new IllegalArgumentException(">> not allowed in fraction rule set"); 
+            status = U_PARSE_ERROR; 
+            return NULL; 
+        } 
+ 
+        // otherwise, return a ModulusSubstitution 
+        else { 
             return new ModulusSubstitution(pos, rule, predecessor,
-                ruleSet, description, status);
-        }
-
-        // if the description begins with '=', always return a
-        // SameValueSubstitution
-    case gEquals:
-        return new SameValueSubstitution(pos, ruleSet, description, status);
-
-        // and if it's anything else, throw an exception
-    default:
-        // throw new IllegalArgumentException("Illegal substitution character");
-        status = U_PARSE_ERROR;
-    }
-    return NULL;
-}
-
-NFSubstitution::NFSubstitution(int32_t _pos,
-                               const NFRuleSet* _ruleSet,
-                               const UnicodeString& description,
-                               UErrorCode& status)
-                               : pos(_pos), ruleSet(NULL), numberFormat(NULL)
-{
-    // the description should begin and end with the same character.
-    // If it doesn't that's a syntax error.  Otherwise,
-    // makeSubstitution() was the only thing that needed to know
-    // about these characters, so strip them off
-    UnicodeString workingDescription(description);
-    if (description.length() >= 2
-        && description.charAt(0) == description.charAt(description.length() - 1))
-    {
-        workingDescription.remove(description.length() - 1, 1);
-        workingDescription.remove(0, 1);
-    }
-    else if (description.length() != 0) {
-        // throw new IllegalArgumentException("Illegal substitution syntax");
-        status = U_PARSE_ERROR;
-        return;
-    }
-
-    if (workingDescription.length() == 0) {
-        // if the description was just two paired token characters
-        // (i.e., "<<" or ">>"), it uses the rule set it belongs to to
-        // format its result
-        this->ruleSet = _ruleSet;
-    }
-    else if (workingDescription.charAt(0) == gPercent) {
-        // if the description contains a rule set name, that's the rule
-        // set we use to format the result: get a reference to the
-        // names rule set
-        this->ruleSet = _ruleSet->getOwner()->findRuleSet(workingDescription, status);
-    }
-    else if (workingDescription.charAt(0) == gPound || workingDescription.charAt(0) ==gZero) {
-        // if the description begins with 0 or #, treat it as a
-        // DecimalFormat pattern, and initialize a DecimalFormat with
-        // that pattern (then set it to use the DecimalFormatSymbols
-        // belonging to our formatter)
-        const DecimalFormatSymbols* sym = _ruleSet->getOwner()->getDecimalFormatSymbols();
-        if (!sym) {
-            status = U_MISSING_RESOURCE_ERROR;
-            return;
-        }
-        DecimalFormat *tempNumberFormat = new DecimalFormat(workingDescription, *sym, status);
-        /* test for NULL */
-        if (!tempNumberFormat) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-            return;
-        }
-        if (U_FAILURE(status)) {
-            delete tempNumberFormat;
-            return;
-        }
-        this->numberFormat = tempNumberFormat;
-    }
-    else if (workingDescription.charAt(0) == gGreaterThan) {
-        // if the description is ">>>", this substitution bypasses the
-        // usual rule-search process and always uses the rule that precedes
-        // it in its own rule set's rule list (this is used for place-value
-        // notations: formats where you want to see a particular part of
-        // a number even when it's 0)
-
-        // this causes problems when >>> is used in a frationalPartSubstitution
-        // this->ruleSet = NULL;
-        this->ruleSet = _ruleSet;
-        this->numberFormat = NULL;
-    }
-    else {
-        // and of the description is none of these things, it's a syntax error
-
-        // throw new IllegalArgumentException("Illegal substitution syntax");
-        status = U_PARSE_ERROR;
-    }
-}
-
-NFSubstitution::~NFSubstitution()
-{
-    delete numberFormat;
-    numberFormat = NULL;
-}
-
-/**
- * Set's the substitution's divisor.  Used by NFRule.setBaseValue().
- * A no-op for all substitutions except multiplier and modulus
- * substitutions.
- * @param radix The radix of the divisor
- * @param exponent The exponent of the divisor
- */
-void
+                ruleSet, description, status); 
+        } 
+ 
+        // if the description begins with '=', always return a 
+        // SameValueSubstitution 
+    case gEquals: 
+        return new SameValueSubstitution(pos, ruleSet, description, status); 
+ 
+        // and if it's anything else, throw an exception 
+    default: 
+        // throw new IllegalArgumentException("Illegal substitution character"); 
+        status = U_PARSE_ERROR; 
+    } 
+    return NULL; 
+} 
+ 
+NFSubstitution::NFSubstitution(int32_t _pos, 
+                               const NFRuleSet* _ruleSet, 
+                               const UnicodeString& description, 
+                               UErrorCode& status) 
+                               : pos(_pos), ruleSet(NULL), numberFormat(NULL) 
+{ 
+    // the description should begin and end with the same character. 
+    // If it doesn't that's a syntax error.  Otherwise, 
+    // makeSubstitution() was the only thing that needed to know 
+    // about these characters, so strip them off 
+    UnicodeString workingDescription(description); 
+    if (description.length() >= 2 
+        && description.charAt(0) == description.charAt(description.length() - 1)) 
+    { 
+        workingDescription.remove(description.length() - 1, 1); 
+        workingDescription.remove(0, 1); 
+    } 
+    else if (description.length() != 0) { 
+        // throw new IllegalArgumentException("Illegal substitution syntax"); 
+        status = U_PARSE_ERROR; 
+        return; 
+    } 
+ 
+    if (workingDescription.length() == 0) { 
+        // if the description was just two paired token characters 
+        // (i.e., "<<" or ">>"), it uses the rule set it belongs to to 
+        // format its result 
+        this->ruleSet = _ruleSet; 
+    } 
+    else if (workingDescription.charAt(0) == gPercent) { 
+        // if the description contains a rule set name, that's the rule 
+        // set we use to format the result: get a reference to the 
+        // names rule set 
+        this->ruleSet = _ruleSet->getOwner()->findRuleSet(workingDescription, status); 
+    } 
+    else if (workingDescription.charAt(0) == gPound || workingDescription.charAt(0) ==gZero) { 
+        // if the description begins with 0 or #, treat it as a 
+        // DecimalFormat pattern, and initialize a DecimalFormat with 
+        // that pattern (then set it to use the DecimalFormatSymbols 
+        // belonging to our formatter) 
+        const DecimalFormatSymbols* sym = _ruleSet->getOwner()->getDecimalFormatSymbols(); 
+        if (!sym) { 
+            status = U_MISSING_RESOURCE_ERROR; 
+            return; 
+        } 
+        DecimalFormat *tempNumberFormat = new DecimalFormat(workingDescription, *sym, status); 
+        /* test for NULL */ 
+        if (!tempNumberFormat) { 
+            status = U_MEMORY_ALLOCATION_ERROR; 
+            return; 
+        } 
+        if (U_FAILURE(status)) { 
+            delete tempNumberFormat; 
+            return; 
+        } 
+        this->numberFormat = tempNumberFormat; 
+    } 
+    else if (workingDescription.charAt(0) == gGreaterThan) { 
+        // if the description is ">>>", this substitution bypasses the 
+        // usual rule-search process and always uses the rule that precedes 
+        // it in its own rule set's rule list (this is used for place-value 
+        // notations: formats where you want to see a particular part of 
+        // a number even when it's 0) 
+ 
+        // this causes problems when >>> is used in a frationalPartSubstitution 
+        // this->ruleSet = NULL; 
+        this->ruleSet = _ruleSet; 
+        this->numberFormat = NULL; 
+    } 
+    else { 
+        // and of the description is none of these things, it's a syntax error 
+ 
+        // throw new IllegalArgumentException("Illegal substitution syntax"); 
+        status = U_PARSE_ERROR; 
+    } 
+} 
+ 
+NFSubstitution::~NFSubstitution() 
+{ 
+    delete numberFormat; 
+    numberFormat = NULL; 
+} 
+ 
+/** 
+ * Set's the substitution's divisor.  Used by NFRule.setBaseValue(). 
+ * A no-op for all substitutions except multiplier and modulus 
+ * substitutions. 
+ * @param radix The radix of the divisor 
+ * @param exponent The exponent of the divisor 
+ */ 
+void 
 NFSubstitution::setDivisor(int32_t /*radix*/, int16_t /*exponent*/, UErrorCode& /*status*/) {
-  // a no-op for all substitutions except multiplier and modulus substitutions
-}
-
-void
-NFSubstitution::setDecimalFormatSymbols(const DecimalFormatSymbols &newSymbols, UErrorCode& /*status*/) {
-    if (numberFormat != NULL) {
-        numberFormat->setDecimalFormatSymbols(newSymbols);
-    }
-}
-
-//-----------------------------------------------------------------------
-// boilerplate
-//-----------------------------------------------------------------------
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NFSubstitution)
-
-/**
- * Compares two substitutions for equality
- * @param The substitution to compare this one to
- * @return true if the two substitutions are functionally equivalent
- */
-UBool
-NFSubstitution::operator==(const NFSubstitution& rhs) const
-{
-  // compare class and all of the fields all substitutions have
-  // in common
-  // this should be called by subclasses before their own equality tests
-  return typeid(*this) == typeid(rhs)
-  && pos == rhs.pos
-  && (ruleSet == NULL) == (rhs.ruleSet == NULL)
-  // && ruleSet == rhs.ruleSet causes circularity, other checks to make instead?
-  && (numberFormat == NULL
-      ? (rhs.numberFormat == NULL)
-      : (*numberFormat == *rhs.numberFormat));
-}
-
-/**
- * Returns a textual description of the substitution
- * @return A textual description of the substitution.  This might
- * not be identical to the description it was created from, but
- * it'll produce the same result.
- */
-void
-NFSubstitution::toString(UnicodeString& text) const
-{
-  // use tokenChar() to get the character at the beginning and
-  // end of the substitutin token.  In between them will go
-  // either the name of the rule set it uses, or the pattern of
-  // the DecimalFormat it uses
-  text.remove();
-  text.append(tokenChar());
-
-  UnicodeString temp;
-  if (ruleSet != NULL) {
-    ruleSet->getName(temp);
-  } else if (numberFormat != NULL) {
-    numberFormat->toPattern(temp);
-  }
-  text.append(temp);
-  text.append(tokenChar());
-}
-
-//-----------------------------------------------------------------------
-// formatting
-//-----------------------------------------------------------------------
-
-/**
- * Performs a mathematical operation on the number, formats it using
- * either ruleSet or decimalFormat, and inserts the result into
- * toInsertInto.
- * @param number The number being formatted.
- * @param toInsertInto The string we insert the result into
- * @param pos The position in toInsertInto where the owning rule's
- * rule text begins (this value is added to this substitution's
- * position to determine exactly where to insert the new text)
- */
-void
-NFSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const
-{
-    if (ruleSet != NULL) {
+  // a no-op for all substitutions except multiplier and modulus substitutions 
+} 
+ 
+void 
+NFSubstitution::setDecimalFormatSymbols(const DecimalFormatSymbols &newSymbols, UErrorCode& /*status*/) { 
+    if (numberFormat != NULL) { 
+        numberFormat->setDecimalFormatSymbols(newSymbols); 
+    } 
+} 
+ 
+//----------------------------------------------------------------------- 
+// boilerplate 
+//----------------------------------------------------------------------- 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NFSubstitution) 
+ 
+/** 
+ * Compares two substitutions for equality 
+ * @param The substitution to compare this one to 
+ * @return true if the two substitutions are functionally equivalent 
+ */ 
+UBool 
+NFSubstitution::operator==(const NFSubstitution& rhs) const 
+{ 
+  // compare class and all of the fields all substitutions have 
+  // in common 
+  // this should be called by subclasses before their own equality tests 
+  return typeid(*this) == typeid(rhs) 
+  && pos == rhs.pos 
+  && (ruleSet == NULL) == (rhs.ruleSet == NULL) 
+  // && ruleSet == rhs.ruleSet causes circularity, other checks to make instead? 
+  && (numberFormat == NULL 
+      ? (rhs.numberFormat == NULL) 
+      : (*numberFormat == *rhs.numberFormat)); 
+} 
+ 
+/** 
+ * Returns a textual description of the substitution 
+ * @return A textual description of the substitution.  This might 
+ * not be identical to the description it was created from, but 
+ * it'll produce the same result. 
+ */ 
+void 
+NFSubstitution::toString(UnicodeString& text) const 
+{ 
+  // use tokenChar() to get the character at the beginning and 
+  // end of the substitutin token.  In between them will go 
+  // either the name of the rule set it uses, or the pattern of 
+  // the DecimalFormat it uses 
+  text.remove(); 
+  text.append(tokenChar()); 
+ 
+  UnicodeString temp; 
+  if (ruleSet != NULL) { 
+    ruleSet->getName(temp); 
+  } else if (numberFormat != NULL) { 
+    numberFormat->toPattern(temp); 
+  } 
+  text.append(temp); 
+  text.append(tokenChar()); 
+} 
+ 
+//----------------------------------------------------------------------- 
+// formatting 
+//----------------------------------------------------------------------- 
+ 
+/** 
+ * Performs a mathematical operation on the number, formats it using 
+ * either ruleSet or decimalFormat, and inserts the result into 
+ * toInsertInto. 
+ * @param number The number being formatted. 
+ * @param toInsertInto The string we insert the result into 
+ * @param pos The position in toInsertInto where the owning rule's 
+ * rule text begins (this value is added to this substitution's 
+ * position to determine exactly where to insert the new text) 
+ */ 
+void 
+NFSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const 
+{ 
+    if (ruleSet != NULL) { 
         // Perform a transformation on the number that is dependent
-        // on the type of substitution this is, then just call its
-        // rule set's format() method to format the result
-        ruleSet->format(transformNumber(number), toInsertInto, _pos + this->pos, recursionCount, status);
-    } else if (numberFormat != NULL) {
+        // on the type of substitution this is, then just call its 
+        // rule set's format() method to format the result 
+        ruleSet->format(transformNumber(number), toInsertInto, _pos + this->pos, recursionCount, status); 
+    } else if (numberFormat != NULL) { 
         if (number <= MAX_INT64_IN_DOUBLE) {
             // or perform the transformation on the number (preserving
             // the result's fractional part if the formatter it set
@@ -588,7 +588,7 @@ NFSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int3
             if (numberFormat->getMaximumFractionDigits() == 0) {
                 numberToFormat = uprv_floor(numberToFormat);
             }
-
+ 
             UnicodeString temp;
             numberFormat->format(numberToFormat, temp, status);
             toInsertInto.insert(_pos + this->pos, temp);
@@ -606,740 +606,740 @@ NFSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int3
             numberFormat->format(numberToFormat, temp, status);
             toInsertInto.insert(_pos + this->pos, temp);
         } 
-    }
-}
-
-/**
- * Performs a mathematical operation on the number, formats it using
- * either ruleSet or decimalFormat, and inserts the result into
- * toInsertInto.
- * @param number The number being formatted.
- * @param toInsertInto The string we insert the result into
- * @param pos The position in toInsertInto where the owning rule's
- * rule text begins (this value is added to this substitution's
- * position to determine exactly where to insert the new text)
- */
-void
-NFSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const {
-    // perform a transformation on the number being formatted that
-    // is dependent on the type of substitution this is
-    double numberToFormat = transformNumber(number);
-
-    if (uprv_isInfinite(numberToFormat)) {
-        // This is probably a minus rule. Combine it with an infinite rule.
-        const NFRule *infiniteRule = ruleSet->findDoubleRule(uprv_getInfinity());
-        infiniteRule->doFormat(numberToFormat, toInsertInto, _pos + this->pos, recursionCount, status);
-        return;
-    }
-
-    // if the result is an integer, from here on out we work in integer
-    // space (saving time and memory and preserving accuracy)
-    if (numberToFormat == uprv_floor(numberToFormat) && ruleSet != NULL) {
-        ruleSet->format(util64_fromDouble(numberToFormat), toInsertInto, _pos + this->pos, recursionCount, status);
-
-        // if the result isn't an integer, then call either our rule set's
-        // format() method or our DecimalFormat's format() method to
-        // format the result
-    } else {
-        if (ruleSet != NULL) {
-            ruleSet->format(numberToFormat, toInsertInto, _pos + this->pos, recursionCount, status);
-        } else if (numberFormat != NULL) {
-            UnicodeString temp;
-            numberFormat->format(numberToFormat, temp);
-            toInsertInto.insert(_pos + this->pos, temp);
-        }
-    }
-}
-
-
-    //-----------------------------------------------------------------------
-    // parsing
-    //-----------------------------------------------------------------------
-
-#ifdef RBNF_DEBUG
-#include <stdio.h>
-#endif
-
-/**
- * Parses a string using the rule set or DecimalFormat belonging
- * to this substitution.  If there's a match, a mathematical
- * operation (the inverse of the one used in formatting) is
- * performed on the result of the parse and the value passed in
- * and returned as the result.  The parse position is updated to
- * point to the first unmatched character in the string.
- * @param text The string to parse
- * @param parsePosition On entry, ignored, but assumed to be 0.
- * On exit, this is updated to point to the first unmatched
- * character (or 0 if the substitution didn't match)
- * @param baseValue A partial parse result that should be
- * combined with the result of this parse
- * @param upperBound When searching the rule set for a rule
- * matching the string passed in, only rules with base values
- * lower than this are considered
- * @param lenientParse If true and matching against rules fails,
- * the substitution will also try matching the text against
- * numerals using a default-costructed NumberFormat.  If false,
- * no extra work is done.  (This value is false whenever the
- * formatter isn't in lenient-parse mode, but is also false
- * under some conditions even when the formatter _is_ in
- * lenient-parse mode.)
- * @return If there's a match, this is the result of composing
- * baseValue with whatever was returned from matching the
- * characters.  This will be either a Long or a Double.  If there's
- * no match this is new Long(0) (not null), and parsePosition
- * is left unchanged.
- */
-UBool
-NFSubstitution::doParse(const UnicodeString& text,
-                        ParsePosition& parsePosition,
-                        double baseValue,
-                        double upperBound,
-                        UBool lenientParse,
+    } 
+} 
+ 
+/** 
+ * Performs a mathematical operation on the number, formats it using 
+ * either ruleSet or decimalFormat, and inserts the result into 
+ * toInsertInto. 
+ * @param number The number being formatted. 
+ * @param toInsertInto The string we insert the result into 
+ * @param pos The position in toInsertInto where the owning rule's 
+ * rule text begins (this value is added to this substitution's 
+ * position to determine exactly where to insert the new text) 
+ */ 
+void 
+NFSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const { 
+    // perform a transformation on the number being formatted that 
+    // is dependent on the type of substitution this is 
+    double numberToFormat = transformNumber(number); 
+ 
+    if (uprv_isInfinite(numberToFormat)) { 
+        // This is probably a minus rule. Combine it with an infinite rule. 
+        const NFRule *infiniteRule = ruleSet->findDoubleRule(uprv_getInfinity()); 
+        infiniteRule->doFormat(numberToFormat, toInsertInto, _pos + this->pos, recursionCount, status); 
+        return; 
+    } 
+ 
+    // if the result is an integer, from here on out we work in integer 
+    // space (saving time and memory and preserving accuracy) 
+    if (numberToFormat == uprv_floor(numberToFormat) && ruleSet != NULL) { 
+        ruleSet->format(util64_fromDouble(numberToFormat), toInsertInto, _pos + this->pos, recursionCount, status); 
+ 
+        // if the result isn't an integer, then call either our rule set's 
+        // format() method or our DecimalFormat's format() method to 
+        // format the result 
+    } else { 
+        if (ruleSet != NULL) { 
+            ruleSet->format(numberToFormat, toInsertInto, _pos + this->pos, recursionCount, status); 
+        } else if (numberFormat != NULL) { 
+            UnicodeString temp; 
+            numberFormat->format(numberToFormat, temp); 
+            toInsertInto.insert(_pos + this->pos, temp); 
+        } 
+    } 
+} 
+ 
+ 
+    //----------------------------------------------------------------------- 
+    // parsing 
+    //----------------------------------------------------------------------- 
+ 
+#ifdef RBNF_DEBUG 
+#include <stdio.h> 
+#endif 
+ 
+/** 
+ * Parses a string using the rule set or DecimalFormat belonging 
+ * to this substitution.  If there's a match, a mathematical 
+ * operation (the inverse of the one used in formatting) is 
+ * performed on the result of the parse and the value passed in 
+ * and returned as the result.  The parse position is updated to 
+ * point to the first unmatched character in the string. 
+ * @param text The string to parse 
+ * @param parsePosition On entry, ignored, but assumed to be 0. 
+ * On exit, this is updated to point to the first unmatched 
+ * character (or 0 if the substitution didn't match) 
+ * @param baseValue A partial parse result that should be 
+ * combined with the result of this parse 
+ * @param upperBound When searching the rule set for a rule 
+ * matching the string passed in, only rules with base values 
+ * lower than this are considered 
+ * @param lenientParse If true and matching against rules fails, 
+ * the substitution will also try matching the text against 
+ * numerals using a default-costructed NumberFormat.  If false, 
+ * no extra work is done.  (This value is false whenever the 
+ * formatter isn't in lenient-parse mode, but is also false 
+ * under some conditions even when the formatter _is_ in 
+ * lenient-parse mode.) 
+ * @return If there's a match, this is the result of composing 
+ * baseValue with whatever was returned from matching the 
+ * characters.  This will be either a Long or a Double.  If there's 
+ * no match this is new Long(0) (not null), and parsePosition 
+ * is left unchanged. 
+ */ 
+UBool 
+NFSubstitution::doParse(const UnicodeString& text, 
+                        ParsePosition& parsePosition, 
+                        double baseValue, 
+                        double upperBound, 
+                        UBool lenientParse, 
                         uint32_t nonNumericalExecutedRuleMask,
-                        Formattable& result) const
-{
-#ifdef RBNF_DEBUG
-    fprintf(stderr, "<nfsubs> %x bv: %g ub: %g\n", this, baseValue, upperBound);
-#endif
-    // figure out the highest base value a rule can have and match
-    // the text being parsed (this varies according to the type of
-    // substitutions: multiplier, modulus, and numerator substitutions
-    // restrict the search to rules with base values lower than their
-    // own; same-value substitutions leave the upper bound wherever
-    // it was, and the others allow any rule to match
-    upperBound = calcUpperBound(upperBound);
-
-    // use our rule set to parse the text.  If that fails and
-    // lenient parsing is enabled (this is always false if the
-    // formatter's lenient-parsing mode is off, but it may also
-    // be false even when the formatter's lenient-parse mode is
-    // on), then also try parsing the text using a default-
-    // constructed NumberFormat
-    if (ruleSet != NULL) {
+                        Formattable& result) const 
+{ 
+#ifdef RBNF_DEBUG 
+    fprintf(stderr, "<nfsubs> %x bv: %g ub: %g\n", this, baseValue, upperBound); 
+#endif 
+    // figure out the highest base value a rule can have and match 
+    // the text being parsed (this varies according to the type of 
+    // substitutions: multiplier, modulus, and numerator substitutions 
+    // restrict the search to rules with base values lower than their 
+    // own; same-value substitutions leave the upper bound wherever 
+    // it was, and the others allow any rule to match 
+    upperBound = calcUpperBound(upperBound); 
+ 
+    // use our rule set to parse the text.  If that fails and 
+    // lenient parsing is enabled (this is always false if the 
+    // formatter's lenient-parsing mode is off, but it may also 
+    // be false even when the formatter's lenient-parse mode is 
+    // on), then also try parsing the text using a default- 
+    // constructed NumberFormat 
+    if (ruleSet != NULL) { 
         ruleSet->parse(text, parsePosition, upperBound, nonNumericalExecutedRuleMask, result);
-        if (lenientParse && !ruleSet->isFractionRuleSet() && parsePosition.getIndex() == 0) {
-            UErrorCode status = U_ZERO_ERROR;
-            NumberFormat* fmt = NumberFormat::createInstance(status);
-            if (U_SUCCESS(status)) {
-                fmt->parse(text, result, parsePosition);
-            }
-            delete fmt;
-        }
-
-        // ...or use our DecimalFormat to parse the text
-    } else if (numberFormat != NULL) {
-        numberFormat->parse(text, result, parsePosition);
-    }
-
-    // if the parse was successful, we've already advanced the caller's
-    // parse position (this is the one function that doesn't have one
-    // of its own).  Derive a parse result and return it as a Long,
-    // if possible, or a Double
-    if (parsePosition.getIndex() != 0) {
-        UErrorCode status = U_ZERO_ERROR;
-        double tempResult = result.getDouble(status);
-
-        // composeRuleValue() produces a full parse result from
-        // the partial parse result passed to this function from
-        // the caller (this is either the owning rule's base value
-        // or the partial result obtained from composing the
-        // owning rule's base value with its other substitution's
-        // parse result) and the partial parse result obtained by
-        // matching the substitution (which will be the same value
-        // the caller would get by parsing just this part of the
-        // text with RuleBasedNumberFormat.parse() ).  How the two
-        // values are used to derive the full parse result depends
-        // on the types of substitutions: For a regular rule, the
-        // ultimate result is its multiplier substitution's result
-        // times the rule's divisor (or the rule's base value) plus
-        // the modulus substitution's result (which will actually
-        // supersede part of the rule's base value).  For a negative-
-        // number rule, the result is the negative of its substitution's
-        // result.  For a fraction rule, it's the sum of its two
-        // substitution results.  For a rule in a fraction rule set,
-        // it's the numerator substitution's result divided by
-        // the rule's base value.  Results from same-value substitutions
-        // propagate back upard, and null substitutions don't affect
-        // the result.
-        tempResult = composeRuleValue(tempResult, baseValue);
-        result.setDouble(tempResult);
-        return TRUE;
-        // if the parse was UNsuccessful, return 0
-    } else {
-        result.setLong(0);
-        return FALSE;
-    }
-}
-
-    /**
-     * Returns true if this is a modulus substitution.  (We didn't do this
-     * with instanceof partially because it causes source files to
-     * proliferate and partially because we have to port this to C++.)
-     * @return true if this object is an instance of ModulusSubstitution
-     */
-UBool
-NFSubstitution::isModulusSubstitution() const {
-    return FALSE;
-}
-
-//===================================================================
-// SameValueSubstitution
-//===================================================================
-
-/**
- * A substitution that passes the value passed to it through unchanged.
- * Represented by == in rule descriptions.
- */
-SameValueSubstitution::SameValueSubstitution(int32_t _pos,
-                        const NFRuleSet* _ruleSet,
-                        const UnicodeString& description,
-                        UErrorCode& status)
-: NFSubstitution(_pos, _ruleSet, description, status)
-{
-    if (0 == description.compare(gEqualsEquals, 2)) {
-        // throw new IllegalArgumentException("== is not a legal token");
-        status = U_PARSE_ERROR;
-    }
-}
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SameValueSubstitution)
-
-//===================================================================
-// MultiplierSubstitution
-//===================================================================
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MultiplierSubstitution)
-
-UBool MultiplierSubstitution::operator==(const NFSubstitution& rhs) const
-{
-    return NFSubstitution::operator==(rhs) &&
-        divisor == ((const MultiplierSubstitution*)&rhs)->divisor;
-}
-
-
-//===================================================================
-// ModulusSubstitution
-//===================================================================
-
-/**
- * A substitution that divides the number being formatted by the its rule's
- * divisor and formats the remainder.  Represented by "&gt;&gt;" in a
- * regular rule.
- */
-ModulusSubstitution::ModulusSubstitution(int32_t _pos,
+        if (lenientParse && !ruleSet->isFractionRuleSet() && parsePosition.getIndex() == 0) { 
+            UErrorCode status = U_ZERO_ERROR; 
+            NumberFormat* fmt = NumberFormat::createInstance(status); 
+            if (U_SUCCESS(status)) { 
+                fmt->parse(text, result, parsePosition); 
+            } 
+            delete fmt; 
+        } 
+ 
+        // ...or use our DecimalFormat to parse the text 
+    } else if (numberFormat != NULL) { 
+        numberFormat->parse(text, result, parsePosition); 
+    } 
+ 
+    // if the parse was successful, we've already advanced the caller's 
+    // parse position (this is the one function that doesn't have one 
+    // of its own).  Derive a parse result and return it as a Long, 
+    // if possible, or a Double 
+    if (parsePosition.getIndex() != 0) { 
+        UErrorCode status = U_ZERO_ERROR; 
+        double tempResult = result.getDouble(status); 
+ 
+        // composeRuleValue() produces a full parse result from 
+        // the partial parse result passed to this function from 
+        // the caller (this is either the owning rule's base value 
+        // or the partial result obtained from composing the 
+        // owning rule's base value with its other substitution's 
+        // parse result) and the partial parse result obtained by 
+        // matching the substitution (which will be the same value 
+        // the caller would get by parsing just this part of the 
+        // text with RuleBasedNumberFormat.parse() ).  How the two 
+        // values are used to derive the full parse result depends 
+        // on the types of substitutions: For a regular rule, the 
+        // ultimate result is its multiplier substitution's result 
+        // times the rule's divisor (or the rule's base value) plus 
+        // the modulus substitution's result (which will actually 
+        // supersede part of the rule's base value).  For a negative- 
+        // number rule, the result is the negative of its substitution's 
+        // result.  For a fraction rule, it's the sum of its two 
+        // substitution results.  For a rule in a fraction rule set, 
+        // it's the numerator substitution's result divided by 
+        // the rule's base value.  Results from same-value substitutions 
+        // propagate back upard, and null substitutions don't affect 
+        // the result. 
+        tempResult = composeRuleValue(tempResult, baseValue); 
+        result.setDouble(tempResult); 
+        return TRUE; 
+        // if the parse was UNsuccessful, return 0 
+    } else { 
+        result.setLong(0); 
+        return FALSE; 
+    } 
+} 
+ 
+    /** 
+     * Returns true if this is a modulus substitution.  (We didn't do this 
+     * with instanceof partially because it causes source files to 
+     * proliferate and partially because we have to port this to C++.) 
+     * @return true if this object is an instance of ModulusSubstitution 
+     */ 
+UBool 
+NFSubstitution::isModulusSubstitution() const { 
+    return FALSE; 
+} 
+ 
+//=================================================================== 
+// SameValueSubstitution 
+//=================================================================== 
+ 
+/** 
+ * A substitution that passes the value passed to it through unchanged. 
+ * Represented by == in rule descriptions. 
+ */ 
+SameValueSubstitution::SameValueSubstitution(int32_t _pos, 
+                        const NFRuleSet* _ruleSet, 
+                        const UnicodeString& description, 
+                        UErrorCode& status) 
+: NFSubstitution(_pos, _ruleSet, description, status) 
+{ 
+    if (0 == description.compare(gEqualsEquals, 2)) { 
+        // throw new IllegalArgumentException("== is not a legal token"); 
+        status = U_PARSE_ERROR; 
+    } 
+} 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SameValueSubstitution) 
+ 
+//=================================================================== 
+// MultiplierSubstitution 
+//=================================================================== 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MultiplierSubstitution) 
+ 
+UBool MultiplierSubstitution::operator==(const NFSubstitution& rhs) const 
+{ 
+    return NFSubstitution::operator==(rhs) && 
+        divisor == ((const MultiplierSubstitution*)&rhs)->divisor; 
+} 
+ 
+ 
+//=================================================================== 
+// ModulusSubstitution 
+//=================================================================== 
+ 
+/** 
+ * A substitution that divides the number being formatted by the its rule's 
+ * divisor and formats the remainder.  Represented by "&gt;&gt;" in a 
+ * regular rule. 
+ */ 
+ModulusSubstitution::ModulusSubstitution(int32_t _pos, 
                                          const NFRule* rule,
-                                         const NFRule* predecessor,
-                                         const NFRuleSet* _ruleSet,
-                                         const UnicodeString& description,
-                                         UErrorCode& status)
- : NFSubstitution(_pos, _ruleSet, description, status)
+                                         const NFRule* predecessor, 
+                                         const NFRuleSet* _ruleSet, 
+                                         const UnicodeString& description, 
+                                         UErrorCode& status) 
+ : NFSubstitution(_pos, _ruleSet, description, status) 
  , divisor(rule->getDivisor())
- , ruleToUse(NULL)
-{
-  // the owning rule's divisor controls the behavior of this
-  // substitution: rather than keeping a backpointer to the rule,
-  // we keep a copy of the divisor
-
+ , ruleToUse(NULL) 
+{ 
+  // the owning rule's divisor controls the behavior of this 
+  // substitution: rather than keeping a backpointer to the rule, 
+  // we keep a copy of the divisor 
+ 
   if (divisor == 0) {
-      status = U_PARSE_ERROR;
-  }
-
-  if (0 == description.compare(gGreaterGreaterGreaterThan, 3)) {
-    // the >>> token doesn't alter how this substituion calculates the
-    // values it uses for formatting and parsing, but it changes
-    // what's done with that value after it's obtained: >>> short-
-    // circuits the rule-search process and goes straight to the
-    // specified rule to format the substitution value
-    ruleToUse = predecessor;
-  }
-}
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ModulusSubstitution)
-
-UBool ModulusSubstitution::operator==(const NFSubstitution& rhs) const
-{
-  return NFSubstitution::operator==(rhs) &&
-  divisor == ((const ModulusSubstitution*)&rhs)->divisor &&
-  ruleToUse == ((const ModulusSubstitution*)&rhs)->ruleToUse;
-}
-
-//-----------------------------------------------------------------------
-// formatting
-//-----------------------------------------------------------------------
-
-
-/**
- * If this is a &gt;&gt;&gt; substitution, use ruleToUse to fill in
- * the substitution.  Otherwise, just use the superclass function.
- * @param number The number being formatted
- * @toInsertInto The string to insert the result of this substitution
- * into
- * @param pos The position of the rule text in toInsertInto
- */
-void
-ModulusSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const
-{
-    // if this isn't a >>> substitution, just use the inherited version
-    // of this function (which uses either a rule set or a DecimalFormat
-    // to format its substitution value)
-    if (ruleToUse == NULL) {
-        NFSubstitution::doSubstitution(number, toInsertInto, _pos, recursionCount, status);
-
-        // a >>> substitution goes straight to a particular rule to
-        // format the substitution value
-    } else {
-        int64_t numberToFormat = transformNumber(number);
-        ruleToUse->doFormat(numberToFormat, toInsertInto, _pos + getPos(), recursionCount, status);
-    }
-}
-
-/**
-* If this is a &gt;&gt;&gt; substitution, use ruleToUse to fill in
-* the substitution.  Otherwise, just use the superclass function.
-* @param number The number being formatted
-* @toInsertInto The string to insert the result of this substitution
-* into
-* @param pos The position of the rule text in toInsertInto
-*/
-void
-ModulusSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const
-{
-    // if this isn't a >>> substitution, just use the inherited version
-    // of this function (which uses either a rule set or a DecimalFormat
-    // to format its substitution value)
-    if (ruleToUse == NULL) {
-        NFSubstitution::doSubstitution(number, toInsertInto, _pos, recursionCount, status);
-
-        // a >>> substitution goes straight to a particular rule to
-        // format the substitution value
-    } else {
-        double numberToFormat = transformNumber(number);
-
-        ruleToUse->doFormat(numberToFormat, toInsertInto, _pos + getPos(), recursionCount, status);
-    }
-}
-
-//-----------------------------------------------------------------------
-// parsing
-//-----------------------------------------------------------------------
-
-/**
- * If this is a &gt;&gt;&gt; substitution, match only against ruleToUse.
- * Otherwise, use the superclass function.
- * @param text The string to parse
- * @param parsePosition Ignored on entry, updated on exit to point to
- * the first unmatched character.
- * @param baseValue The partial parse result prior to calling this
- * routine.
- */
-UBool
-ModulusSubstitution::doParse(const UnicodeString& text,
-                             ParsePosition& parsePosition,
-                             double baseValue,
-                             double upperBound,
-                             UBool lenientParse,
+      status = U_PARSE_ERROR; 
+  } 
+ 
+  if (0 == description.compare(gGreaterGreaterGreaterThan, 3)) { 
+    // the >>> token doesn't alter how this substituion calculates the 
+    // values it uses for formatting and parsing, but it changes 
+    // what's done with that value after it's obtained: >>> short- 
+    // circuits the rule-search process and goes straight to the 
+    // specified rule to format the substitution value 
+    ruleToUse = predecessor; 
+  } 
+} 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ModulusSubstitution) 
+ 
+UBool ModulusSubstitution::operator==(const NFSubstitution& rhs) const 
+{ 
+  return NFSubstitution::operator==(rhs) && 
+  divisor == ((const ModulusSubstitution*)&rhs)->divisor && 
+  ruleToUse == ((const ModulusSubstitution*)&rhs)->ruleToUse; 
+} 
+ 
+//----------------------------------------------------------------------- 
+// formatting 
+//----------------------------------------------------------------------- 
+ 
+ 
+/** 
+ * If this is a &gt;&gt;&gt; substitution, use ruleToUse to fill in 
+ * the substitution.  Otherwise, just use the superclass function. 
+ * @param number The number being formatted 
+ * @toInsertInto The string to insert the result of this substitution 
+ * into 
+ * @param pos The position of the rule text in toInsertInto 
+ */ 
+void 
+ModulusSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const 
+{ 
+    // if this isn't a >>> substitution, just use the inherited version 
+    // of this function (which uses either a rule set or a DecimalFormat 
+    // to format its substitution value) 
+    if (ruleToUse == NULL) { 
+        NFSubstitution::doSubstitution(number, toInsertInto, _pos, recursionCount, status); 
+ 
+        // a >>> substitution goes straight to a particular rule to 
+        // format the substitution value 
+    } else { 
+        int64_t numberToFormat = transformNumber(number); 
+        ruleToUse->doFormat(numberToFormat, toInsertInto, _pos + getPos(), recursionCount, status); 
+    } 
+} 
+ 
+/** 
+* If this is a &gt;&gt;&gt; substitution, use ruleToUse to fill in 
+* the substitution.  Otherwise, just use the superclass function. 
+* @param number The number being formatted 
+* @toInsertInto The string to insert the result of this substitution 
+* into 
+* @param pos The position of the rule text in toInsertInto 
+*/ 
+void 
+ModulusSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t _pos, int32_t recursionCount, UErrorCode& status) const 
+{ 
+    // if this isn't a >>> substitution, just use the inherited version 
+    // of this function (which uses either a rule set or a DecimalFormat 
+    // to format its substitution value) 
+    if (ruleToUse == NULL) { 
+        NFSubstitution::doSubstitution(number, toInsertInto, _pos, recursionCount, status); 
+ 
+        // a >>> substitution goes straight to a particular rule to 
+        // format the substitution value 
+    } else { 
+        double numberToFormat = transformNumber(number); 
+ 
+        ruleToUse->doFormat(numberToFormat, toInsertInto, _pos + getPos(), recursionCount, status); 
+    } 
+} 
+ 
+//----------------------------------------------------------------------- 
+// parsing 
+//----------------------------------------------------------------------- 
+ 
+/** 
+ * If this is a &gt;&gt;&gt; substitution, match only against ruleToUse. 
+ * Otherwise, use the superclass function. 
+ * @param text The string to parse 
+ * @param parsePosition Ignored on entry, updated on exit to point to 
+ * the first unmatched character. 
+ * @param baseValue The partial parse result prior to calling this 
+ * routine. 
+ */ 
+UBool 
+ModulusSubstitution::doParse(const UnicodeString& text, 
+                             ParsePosition& parsePosition, 
+                             double baseValue, 
+                             double upperBound, 
+                             UBool lenientParse, 
                              uint32_t nonNumericalExecutedRuleMask,
-                             Formattable& result) const
-{
-    // if this isn't a >>> substitution, we can just use the
-    // inherited parse() routine to do the parsing
-    if (ruleToUse == NULL) {
+                             Formattable& result) const 
+{ 
+    // if this isn't a >>> substitution, we can just use the 
+    // inherited parse() routine to do the parsing 
+    if (ruleToUse == NULL) { 
         return NFSubstitution::doParse(text, parsePosition, baseValue, upperBound, lenientParse, nonNumericalExecutedRuleMask, result);
-
-        // but if it IS a >>> substitution, we have to do it here: we
-        // use the specific rule's doParse() method, and then we have to
-        // do some of the other work of NFRuleSet.parse()
-    } else {
+ 
+        // but if it IS a >>> substitution, we have to do it here: we 
+        // use the specific rule's doParse() method, and then we have to 
+        // do some of the other work of NFRuleSet.parse() 
+    } else { 
         ruleToUse->doParse(text, parsePosition, FALSE, upperBound, nonNumericalExecutedRuleMask, result);
-
-        if (parsePosition.getIndex() != 0) {
-            UErrorCode status = U_ZERO_ERROR;
-            double tempResult = result.getDouble(status);
-            tempResult = composeRuleValue(tempResult, baseValue);
-            result.setDouble(tempResult);
-        }
-
-        return TRUE;
-    }
-}
-/**
- * Returns a textual description of the substitution
- * @return A textual description of the substitution.  This might
- * not be identical to the description it was created from, but
- * it'll produce the same result.
- */
-void
-ModulusSubstitution::toString(UnicodeString& text) const
-{
-  // use tokenChar() to get the character at the beginning and
-  // end of the substitutin token.  In between them will go
-  // either the name of the rule set it uses, or the pattern of
-  // the DecimalFormat it uses
-
-  if ( ruleToUse != NULL ) { // Must have been a >>> substitution.
-      text.remove();
-      text.append(tokenChar());
-      text.append(tokenChar());
-      text.append(tokenChar());
-  } else { // Otherwise just use the super-class function.
-	  NFSubstitution::toString(text);
-  }
-}
-//===================================================================
-// IntegralPartSubstitution
-//===================================================================
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IntegralPartSubstitution)
-
-
-//===================================================================
-// FractionalPartSubstitution
-//===================================================================
-
-
-    /**
-     * Constructs a FractionalPartSubstitution.  This object keeps a flag
-     * telling whether it should format by digits or not.  In addition,
-     * it marks the rule set it calls (if any) as a fraction rule set.
-     */
-FractionalPartSubstitution::FractionalPartSubstitution(int32_t _pos,
-                             const NFRuleSet* _ruleSet,
-                             const UnicodeString& description,
-                             UErrorCode& status)
- : NFSubstitution(_pos, _ruleSet, description, status)
- , byDigits(FALSE)
- , useSpaces(TRUE)
-
-{
-    // akk, ruleSet can change in superclass constructor
-    if (0 == description.compare(gGreaterGreaterThan, 2) ||
-        0 == description.compare(gGreaterGreaterGreaterThan, 3) ||
-        _ruleSet == getRuleSet()) {
-        byDigits = TRUE;
-        if (0 == description.compare(gGreaterGreaterGreaterThan, 3)) {
-            useSpaces = FALSE;
-        }
-    } else {
-        // cast away const
-        ((NFRuleSet*)getRuleSet())->makeIntoFractionRuleSet();
-    }
-}
-
-//-----------------------------------------------------------------------
-// formatting
-//-----------------------------------------------------------------------
-
-/**
- * If in "by digits" mode, fills in the substitution one decimal digit
- * at a time using the rule set containing this substitution.
- * Otherwise, uses the superclass function.
- * @param number The number being formatted
- * @param toInsertInto The string to insert the result of formatting
- * the substitution into
- * @param pos The position of the owning rule's rule text in
- * toInsertInto
- */
-void
-FractionalPartSubstitution::doSubstitution(double number, UnicodeString& toInsertInto,
-                                           int32_t _pos, int32_t recursionCount, UErrorCode& status) const
-{
-  // if we're not in "byDigits" mode, just use the inherited
-  // doSubstitution() routine
-  if (!byDigits) {
-    NFSubstitution::doSubstitution(number, toInsertInto, _pos, recursionCount, status);
-
-    // if we're in "byDigits" mode, transform the value into an integer
-    // by moving the decimal point eight places to the right and
-    // pulling digits off the right one at a time, formatting each digit
-    // as an integer using this substitution's owning rule set
-    // (this is slower, but more accurate, than doing it from the
-    // other end)
-  } else {
-    //          int32_t numberToFormat = (int32_t)uprv_round(transformNumber(number) * uprv_pow(10, kMaxDecimalDigits));
-    //          // this flag keeps us from formatting trailing zeros.  It starts
-    //          // out false because we're pulling from the right, and switches
-    //          // to true the first time we encounter a non-zero digit
-    //          UBool doZeros = FALSE;
-    //          for (int32_t i = 0; i < kMaxDecimalDigits; i++) {
-    //              int64_t digit = numberToFormat % 10;
-    //              if (digit != 0 || doZeros) {
-    //                  if (doZeros && useSpaces) {
-    //                      toInsertInto.insert(_pos + getPos(), gSpace);
-    //                  }
-    //                  doZeros = TRUE;
-    //                  getRuleSet()->format(digit, toInsertInto, _pos + getPos());
-    //              }
-    //              numberToFormat /= 10;
-    //          }
-
+ 
+        if (parsePosition.getIndex() != 0) { 
+            UErrorCode status = U_ZERO_ERROR; 
+            double tempResult = result.getDouble(status); 
+            tempResult = composeRuleValue(tempResult, baseValue); 
+            result.setDouble(tempResult); 
+        } 
+ 
+        return TRUE; 
+    } 
+} 
+/** 
+ * Returns a textual description of the substitution 
+ * @return A textual description of the substitution.  This might 
+ * not be identical to the description it was created from, but 
+ * it'll produce the same result. 
+ */ 
+void 
+ModulusSubstitution::toString(UnicodeString& text) const 
+{ 
+  // use tokenChar() to get the character at the beginning and 
+  // end of the substitutin token.  In between them will go 
+  // either the name of the rule set it uses, or the pattern of 
+  // the DecimalFormat it uses 
+ 
+  if ( ruleToUse != NULL ) { // Must have been a >>> substitution. 
+      text.remove(); 
+      text.append(tokenChar()); 
+      text.append(tokenChar()); 
+      text.append(tokenChar()); 
+  } else { // Otherwise just use the super-class function. 
+	  NFSubstitution::toString(text); 
+  } 
+} 
+//=================================================================== 
+// IntegralPartSubstitution 
+//=================================================================== 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IntegralPartSubstitution) 
+ 
+ 
+//=================================================================== 
+// FractionalPartSubstitution 
+//=================================================================== 
+ 
+ 
+    /** 
+     * Constructs a FractionalPartSubstitution.  This object keeps a flag 
+     * telling whether it should format by digits or not.  In addition, 
+     * it marks the rule set it calls (if any) as a fraction rule set. 
+     */ 
+FractionalPartSubstitution::FractionalPartSubstitution(int32_t _pos, 
+                             const NFRuleSet* _ruleSet, 
+                             const UnicodeString& description, 
+                             UErrorCode& status) 
+ : NFSubstitution(_pos, _ruleSet, description, status) 
+ , byDigits(FALSE) 
+ , useSpaces(TRUE) 
+ 
+{ 
+    // akk, ruleSet can change in superclass constructor 
+    if (0 == description.compare(gGreaterGreaterThan, 2) || 
+        0 == description.compare(gGreaterGreaterGreaterThan, 3) || 
+        _ruleSet == getRuleSet()) { 
+        byDigits = TRUE; 
+        if (0 == description.compare(gGreaterGreaterGreaterThan, 3)) { 
+            useSpaces = FALSE; 
+        } 
+    } else { 
+        // cast away const 
+        ((NFRuleSet*)getRuleSet())->makeIntoFractionRuleSet(); 
+    } 
+} 
+ 
+//----------------------------------------------------------------------- 
+// formatting 
+//----------------------------------------------------------------------- 
+ 
+/** 
+ * If in "by digits" mode, fills in the substitution one decimal digit 
+ * at a time using the rule set containing this substitution. 
+ * Otherwise, uses the superclass function. 
+ * @param number The number being formatted 
+ * @param toInsertInto The string to insert the result of formatting 
+ * the substitution into 
+ * @param pos The position of the owning rule's rule text in 
+ * toInsertInto 
+ */ 
+void 
+FractionalPartSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, 
+                                           int32_t _pos, int32_t recursionCount, UErrorCode& status) const 
+{ 
+  // if we're not in "byDigits" mode, just use the inherited 
+  // doSubstitution() routine 
+  if (!byDigits) { 
+    NFSubstitution::doSubstitution(number, toInsertInto, _pos, recursionCount, status); 
+ 
+    // if we're in "byDigits" mode, transform the value into an integer 
+    // by moving the decimal point eight places to the right and 
+    // pulling digits off the right one at a time, formatting each digit 
+    // as an integer using this substitution's owning rule set 
+    // (this is slower, but more accurate, than doing it from the 
+    // other end) 
+  } else { 
+    //          int32_t numberToFormat = (int32_t)uprv_round(transformNumber(number) * uprv_pow(10, kMaxDecimalDigits)); 
+    //          // this flag keeps us from formatting trailing zeros.  It starts 
+    //          // out false because we're pulling from the right, and switches 
+    //          // to true the first time we encounter a non-zero digit 
+    //          UBool doZeros = FALSE; 
+    //          for (int32_t i = 0; i < kMaxDecimalDigits; i++) { 
+    //              int64_t digit = numberToFormat % 10; 
+    //              if (digit != 0 || doZeros) { 
+    //                  if (doZeros && useSpaces) { 
+    //                      toInsertInto.insert(_pos + getPos(), gSpace); 
+    //                  } 
+    //                  doZeros = TRUE; 
+    //                  getRuleSet()->format(digit, toInsertInto, _pos + getPos()); 
+    //              } 
+    //              numberToFormat /= 10; 
+    //          } 
+ 
     DecimalQuantity dl;
     dl.setToDouble(number);
     dl.roundToMagnitude(-20, UNUM_ROUND_HALFEVEN, status);     // round to 20 fraction digits.
-    
-    UBool pad = FALSE;
+     
+    UBool pad = FALSE; 
     for (int32_t didx = dl.getLowerDisplayMagnitude(); didx<0; didx++) {
-      // Loop iterates over fraction digits, starting with the LSD.
-      //   include both real digits from the number, and zeros
-      //   to the left of the MSD but to the right of the decimal point.
-      if (pad && useSpaces) {
-        toInsertInto.insert(_pos + getPos(), gSpace);
-      } else {
-        pad = TRUE;
-      }
+      // Loop iterates over fraction digits, starting with the LSD. 
+      //   include both real digits from the number, and zeros 
+      //   to the left of the MSD but to the right of the decimal point. 
+      if (pad && useSpaces) { 
+        toInsertInto.insert(_pos + getPos(), gSpace); 
+      } else { 
+        pad = TRUE; 
+      } 
       int64_t digit = dl.getDigit(didx);
-      getRuleSet()->format(digit, toInsertInto, _pos + getPos(), recursionCount, status);
-    }
-
-    if (!pad) {
-      // hack around lack of precision in digitlist. if we would end up with
-      // "foo point" make sure we add a " zero" to the end.
-      getRuleSet()->format((int64_t)0, toInsertInto, _pos + getPos(), recursionCount, status);
-    }
-  }
-}
-
-//-----------------------------------------------------------------------
-// parsing
-//-----------------------------------------------------------------------
-
-/**
- * If in "by digits" mode, parses the string as if it were a string
- * of individual digits; otherwise, uses the superclass function.
- * @param text The string to parse
- * @param parsePosition Ignored on entry, but updated on exit to point
- * to the first unmatched character
- * @param baseValue The partial parse result prior to entering this
- * function
- * @param upperBound Only consider rules with base values lower than
- * this when filling in the substitution
- * @param lenientParse If true, try matching the text as numerals if
- * matching as words doesn't work
- * @return If the match was successful, the current partial parse
- * result; otherwise new Long(0).  The result is either a Long or
- * a Double.
- */
-
-UBool
-FractionalPartSubstitution::doParse(const UnicodeString& text,
-                ParsePosition& parsePosition,
-                double baseValue,
-                double /*upperBound*/,
-                UBool lenientParse,
+      getRuleSet()->format(digit, toInsertInto, _pos + getPos(), recursionCount, status); 
+    } 
+ 
+    if (!pad) { 
+      // hack around lack of precision in digitlist. if we would end up with 
+      // "foo point" make sure we add a " zero" to the end. 
+      getRuleSet()->format((int64_t)0, toInsertInto, _pos + getPos(), recursionCount, status); 
+    } 
+  } 
+} 
+ 
+//----------------------------------------------------------------------- 
+// parsing 
+//----------------------------------------------------------------------- 
+ 
+/** 
+ * If in "by digits" mode, parses the string as if it were a string 
+ * of individual digits; otherwise, uses the superclass function. 
+ * @param text The string to parse 
+ * @param parsePosition Ignored on entry, but updated on exit to point 
+ * to the first unmatched character 
+ * @param baseValue The partial parse result prior to entering this 
+ * function 
+ * @param upperBound Only consider rules with base values lower than 
+ * this when filling in the substitution 
+ * @param lenientParse If true, try matching the text as numerals if 
+ * matching as words doesn't work 
+ * @return If the match was successful, the current partial parse 
+ * result; otherwise new Long(0).  The result is either a Long or 
+ * a Double. 
+ */ 
+ 
+UBool 
+FractionalPartSubstitution::doParse(const UnicodeString& text, 
+                ParsePosition& parsePosition, 
+                double baseValue, 
+                double /*upperBound*/, 
+                UBool lenientParse, 
                 uint32_t nonNumericalExecutedRuleMask,
-                Formattable& resVal) const
-{
-    // if we're not in byDigits mode, we can just use the inherited
-    // doParse()
-    if (!byDigits) {
+                Formattable& resVal) const 
+{ 
+    // if we're not in byDigits mode, we can just use the inherited 
+    // doParse() 
+    if (!byDigits) { 
         return NFSubstitution::doParse(text, parsePosition, baseValue, 0, lenientParse, nonNumericalExecutedRuleMask, resVal);
-
-        // if we ARE in byDigits mode, parse the text one digit at a time
-        // using this substitution's owning rule set (we do this by setting
-        // upperBound to 10 when calling doParse() ) until we reach
-        // nonmatching text
-    } else {
-        UnicodeString workText(text);
-        ParsePosition workPos(1);
-        double result = 0;
-        int32_t digit;
-//          double p10 = 0.1;
-
+ 
+        // if we ARE in byDigits mode, parse the text one digit at a time 
+        // using this substitution's owning rule set (we do this by setting 
+        // upperBound to 10 when calling doParse() ) until we reach 
+        // nonmatching text 
+    } else { 
+        UnicodeString workText(text); 
+        ParsePosition workPos(1); 
+        double result = 0; 
+        int32_t digit; 
+//          double p10 = 0.1; 
+ 
         DecimalQuantity dl;
         int32_t totalDigits = 0;
-        NumberFormat* fmt = NULL;
-        while (workText.length() > 0 && workPos.getIndex() != 0) {
-            workPos.setIndex(0);
-            Formattable temp;
+        NumberFormat* fmt = NULL; 
+        while (workText.length() > 0 && workPos.getIndex() != 0) { 
+            workPos.setIndex(0); 
+            Formattable temp; 
             getRuleSet()->parse(workText, workPos, 10, nonNumericalExecutedRuleMask, temp);
-            UErrorCode status = U_ZERO_ERROR;
-            digit = temp.getLong(status);
-//            digit = temp.getType() == Formattable::kLong ?
-//               temp.getLong() :
-//            (int32_t)temp.getDouble();
-
-            if (lenientParse && workPos.getIndex() == 0) {
-                if (!fmt) {
-                    status = U_ZERO_ERROR;
-                    fmt = NumberFormat::createInstance(status);
-                    if (U_FAILURE(status)) {
-                        delete fmt;
-                        fmt = NULL;
-                    }
-                }
-                if (fmt) {
-                    fmt->parse(workText, temp, workPos);
-                    digit = temp.getLong(status);
-                }
-            }
-
-            if (workPos.getIndex() != 0) {
+            UErrorCode status = U_ZERO_ERROR; 
+            digit = temp.getLong(status); 
+//            digit = temp.getType() == Formattable::kLong ? 
+//               temp.getLong() : 
+//            (int32_t)temp.getDouble(); 
+ 
+            if (lenientParse && workPos.getIndex() == 0) { 
+                if (!fmt) { 
+                    status = U_ZERO_ERROR; 
+                    fmt = NumberFormat::createInstance(status); 
+                    if (U_FAILURE(status)) { 
+                        delete fmt; 
+                        fmt = NULL; 
+                    } 
+                } 
+                if (fmt) { 
+                    fmt->parse(workText, temp, workPos); 
+                    digit = temp.getLong(status); 
+                } 
+            } 
+ 
+            if (workPos.getIndex() != 0) { 
                 dl.appendDigit(static_cast<int8_t>(digit), 0, true);
                 totalDigits++;
-//                  result += digit * p10;
-//                  p10 /= 10;
-                parsePosition.setIndex(parsePosition.getIndex() + workPos.getIndex());
-                workText.removeBetween(0, workPos.getIndex());
-                while (workText.length() > 0 && workText.charAt(0) == gSpace) {
-                    workText.removeBetween(0, 1);
-                    parsePosition.setIndex(parsePosition.getIndex() + 1);
-                }
-            }
-        }
-        delete fmt;
-
+//                  result += digit * p10; 
+//                  p10 /= 10; 
+                parsePosition.setIndex(parsePosition.getIndex() + workPos.getIndex()); 
+                workText.removeBetween(0, workPos.getIndex()); 
+                while (workText.length() > 0 && workText.charAt(0) == gSpace) { 
+                    workText.removeBetween(0, 1); 
+                    parsePosition.setIndex(parsePosition.getIndex() + 1); 
+                } 
+            } 
+        } 
+        delete fmt; 
+ 
         dl.adjustMagnitude(-totalDigits);
         result = dl.toDouble();
-        result = composeRuleValue(result, baseValue);
-        resVal.setDouble(result);
-        return TRUE;
-    }
-}
-
-UBool
-FractionalPartSubstitution::operator==(const NFSubstitution& rhs) const
-{
-  return NFSubstitution::operator==(rhs) &&
-  ((const FractionalPartSubstitution*)&rhs)->byDigits == byDigits;
-}
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(FractionalPartSubstitution)
-
-
-//===================================================================
-// AbsoluteValueSubstitution
-//===================================================================
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AbsoluteValueSubstitution)
-
-//===================================================================
-// NumeratorSubstitution
-//===================================================================
-
-void
-NumeratorSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t apos, int32_t recursionCount, UErrorCode& status) const {
-    // perform a transformation on the number being formatted that
-    // is dependent on the type of substitution this is
-
-    double numberToFormat = transformNumber(number);
-    int64_t longNF = util64_fromDouble(numberToFormat);
-
-    const NFRuleSet* aruleSet = getRuleSet();
-    if (withZeros && aruleSet != NULL) {
-        // if there are leading zeros in the decimal expansion then emit them
-        int64_t nf =longNF;
-        int32_t len = toInsertInto.length();
-        while ((nf *= 10) < denominator) {
-            toInsertInto.insert(apos + getPos(), gSpace);
-            aruleSet->format((int64_t)0, toInsertInto, apos + getPos(), recursionCount, status);
-        }
-        apos += toInsertInto.length() - len;
-    }
-
-    // if the result is an integer, from here on out we work in integer
-    // space (saving time and memory and preserving accuracy)
-    if (numberToFormat == longNF && aruleSet != NULL) {
-        aruleSet->format(longNF, toInsertInto, apos + getPos(), recursionCount, status);
-
-        // if the result isn't an integer, then call either our rule set's
-        // format() method or our DecimalFormat's format() method to
-        // format the result
-    } else {
-        if (aruleSet != NULL) {
-            aruleSet->format(numberToFormat, toInsertInto, apos + getPos(), recursionCount, status);
-        } else {
-            UnicodeString temp;
-            getNumberFormat()->format(numberToFormat, temp, status);
-            toInsertInto.insert(apos + getPos(), temp);
-        }
-    }
-}
-
+        result = composeRuleValue(result, baseValue); 
+        resVal.setDouble(result); 
+        return TRUE; 
+    } 
+} 
+ 
 UBool 
-NumeratorSubstitution::doParse(const UnicodeString& text, 
-                               ParsePosition& parsePosition,
-                               double baseValue,
-                               double upperBound,
-                               UBool /*lenientParse*/,
+FractionalPartSubstitution::operator==(const NFSubstitution& rhs) const 
+{ 
+  return NFSubstitution::operator==(rhs) && 
+  ((const FractionalPartSubstitution*)&rhs)->byDigits == byDigits; 
+} 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(FractionalPartSubstitution) 
+ 
+ 
+//=================================================================== 
+// AbsoluteValueSubstitution 
+//=================================================================== 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AbsoluteValueSubstitution) 
+ 
+//=================================================================== 
+// NumeratorSubstitution 
+//=================================================================== 
+ 
+void 
+NumeratorSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t apos, int32_t recursionCount, UErrorCode& status) const { 
+    // perform a transformation on the number being formatted that 
+    // is dependent on the type of substitution this is 
+ 
+    double numberToFormat = transformNumber(number); 
+    int64_t longNF = util64_fromDouble(numberToFormat); 
+ 
+    const NFRuleSet* aruleSet = getRuleSet(); 
+    if (withZeros && aruleSet != NULL) { 
+        // if there are leading zeros in the decimal expansion then emit them 
+        int64_t nf =longNF; 
+        int32_t len = toInsertInto.length(); 
+        while ((nf *= 10) < denominator) { 
+            toInsertInto.insert(apos + getPos(), gSpace); 
+            aruleSet->format((int64_t)0, toInsertInto, apos + getPos(), recursionCount, status); 
+        } 
+        apos += toInsertInto.length() - len; 
+    } 
+ 
+    // if the result is an integer, from here on out we work in integer 
+    // space (saving time and memory and preserving accuracy) 
+    if (numberToFormat == longNF && aruleSet != NULL) { 
+        aruleSet->format(longNF, toInsertInto, apos + getPos(), recursionCount, status); 
+ 
+        // if the result isn't an integer, then call either our rule set's 
+        // format() method or our DecimalFormat's format() method to 
+        // format the result 
+    } else { 
+        if (aruleSet != NULL) { 
+            aruleSet->format(numberToFormat, toInsertInto, apos + getPos(), recursionCount, status); 
+        } else { 
+            UnicodeString temp; 
+            getNumberFormat()->format(numberToFormat, temp, status); 
+            toInsertInto.insert(apos + getPos(), temp); 
+        } 
+    } 
+} 
+ 
+UBool  
+NumeratorSubstitution::doParse(const UnicodeString& text,  
+                               ParsePosition& parsePosition, 
+                               double baseValue, 
+                               double upperBound, 
+                               UBool /*lenientParse*/, 
                                uint32_t nonNumericalExecutedRuleMask,
-                               Formattable& result) const
-{
-    // we don't have to do anything special to do the parsing here,
-    // but we have to turn lenient parsing off-- if we leave it on,
-    // it SERIOUSLY messes up the algorithm
-
-    // if withZeros is true, we need to count the zeros
-    // and use that to adjust the parse result
-    UErrorCode status = U_ZERO_ERROR;
-    int32_t zeroCount = 0;
-    UnicodeString workText(text);
-
-    if (withZeros) {
-        ParsePosition workPos(1);
-        Formattable temp;
-
-        while (workText.length() > 0 && workPos.getIndex() != 0) {
-            workPos.setIndex(0);
+                               Formattable& result) const 
+{ 
+    // we don't have to do anything special to do the parsing here, 
+    // but we have to turn lenient parsing off-- if we leave it on, 
+    // it SERIOUSLY messes up the algorithm 
+ 
+    // if withZeros is true, we need to count the zeros 
+    // and use that to adjust the parse result 
+    UErrorCode status = U_ZERO_ERROR; 
+    int32_t zeroCount = 0; 
+    UnicodeString workText(text); 
+ 
+    if (withZeros) { 
+        ParsePosition workPos(1); 
+        Formattable temp; 
+ 
+        while (workText.length() > 0 && workPos.getIndex() != 0) { 
+            workPos.setIndex(0); 
             getRuleSet()->parse(workText, workPos, 1, nonNumericalExecutedRuleMask, temp); // parse zero or nothing at all
-            if (workPos.getIndex() == 0) {
-                // we failed, either there were no more zeros, or the number was formatted with digits
-                // either way, we're done
-                break;
-            }
-
-            ++zeroCount;
-            parsePosition.setIndex(parsePosition.getIndex() + workPos.getIndex());
-            workText.remove(0, workPos.getIndex());
-            while (workText.length() > 0 && workText.charAt(0) == gSpace) {
-                workText.remove(0, 1);
-                parsePosition.setIndex(parsePosition.getIndex() + 1);
-            }
-        }
-
-        workText = text;
-        workText.remove(0, (int32_t)parsePosition.getIndex());
-        parsePosition.setIndex(0);
-    }
-
-    // we've parsed off the zeros, now let's parse the rest from our current position
+            if (workPos.getIndex() == 0) { 
+                // we failed, either there were no more zeros, or the number was formatted with digits 
+                // either way, we're done 
+                break; 
+            } 
+ 
+            ++zeroCount; 
+            parsePosition.setIndex(parsePosition.getIndex() + workPos.getIndex()); 
+            workText.remove(0, workPos.getIndex()); 
+            while (workText.length() > 0 && workText.charAt(0) == gSpace) { 
+                workText.remove(0, 1); 
+                parsePosition.setIndex(parsePosition.getIndex() + 1); 
+            } 
+        } 
+ 
+        workText = text; 
+        workText.remove(0, (int32_t)parsePosition.getIndex()); 
+        parsePosition.setIndex(0); 
+    } 
+ 
+    // we've parsed off the zeros, now let's parse the rest from our current position 
     NFSubstitution::doParse(workText, parsePosition, withZeros ? 1 : baseValue, upperBound, FALSE, nonNumericalExecutedRuleMask, result);
-
-    if (withZeros) {
-        // any base value will do in this case.  is there a way to
-        // force this to not bother trying all the base values?
-
-        // compute the 'effective' base and prescale the value down
-        int64_t n = result.getLong(status); // force conversion!
-        int64_t d = 1;
-        int32_t pow = 0;
-        while (d <= n) {
-            d *= 10;
-            ++pow;
-        }
-        // now add the zeros
-        while (zeroCount > 0) {
-            d *= 10;
-            --zeroCount;
-        }
-        // d is now our true denominator
-        result.setDouble((double)n/(double)d);
-    }
-
-    return TRUE;
-}
-
-UBool
-NumeratorSubstitution::operator==(const NFSubstitution& rhs) const
-{
-    return NFSubstitution::operator==(rhs) &&
-        denominator == ((const NumeratorSubstitution*)&rhs)->denominator;
-}
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NumeratorSubstitution)
-
-const UChar NumeratorSubstitution::LTLT[] = { 0x003c, 0x003c };
-        
-U_NAMESPACE_END
-
-/* U_HAVE_RBNF */
-#endif
-
+ 
+    if (withZeros) { 
+        // any base value will do in this case.  is there a way to 
+        // force this to not bother trying all the base values? 
+ 
+        // compute the 'effective' base and prescale the value down 
+        int64_t n = result.getLong(status); // force conversion! 
+        int64_t d = 1; 
+        int32_t pow = 0; 
+        while (d <= n) { 
+            d *= 10; 
+            ++pow; 
+        } 
+        // now add the zeros 
+        while (zeroCount > 0) { 
+            d *= 10; 
+            --zeroCount; 
+        } 
+        // d is now our true denominator 
+        result.setDouble((double)n/(double)d); 
+    } 
+ 
+    return TRUE; 
+} 
+ 
+UBool 
+NumeratorSubstitution::operator==(const NFSubstitution& rhs) const 
+{ 
+    return NFSubstitution::operator==(rhs) && 
+        denominator == ((const NumeratorSubstitution*)&rhs)->denominator; 
+} 
+ 
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NumeratorSubstitution) 
+ 
+const UChar NumeratorSubstitution::LTLT[] = { 0x003c, 0x003c }; 
+         
+U_NAMESPACE_END 
+ 
+/* U_HAVE_RBNF */ 
+#endif 
+