Update ICU to 54.1 step 1

source/i18n/nfsubs.cpp

 /*
 ******************************************************************************
-*   Copyright (C) 1997-2012, International Business Machines
+*   Copyright (C) 1997-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 *   file name:  nfsubs.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 * Modification history
 * Date        Name      Comments
 * 10/11/2001  Doug      Ported from ICU4J
@@ skipping 128 matching lines @@
         divisor = uprv_pow(radix, exponent);
         ldivisor = util64_fromDouble(divisor);
 
         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) const;
-    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos) const;
+    virtual void doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const;
+    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const;
 
     virtual int64_t transformNumber(int64_t number) const { return number % ldivisor; }
     virtual double transformNumber(double number) const { return uprv_fmod(number, divisor); }
 
     virtual UBool doParse(const UnicodeString& text, 
         ParsePosition& parsePosition,
         double baseValue,
         double upperBound,
         UBool lenientParse,
         Formattable& result) const;
@@ skipping 47 matching lines @@
 public:
     FractionalPartSubstitution(int32_t pos,
         const NFRuleSet* ruleSet,
         const RuleBasedNumberFormat* formatter,
         const UnicodeString& description,
         UErrorCode& status);
     virtual ~FractionalPartSubstitution();
 
     virtual UBool operator==(const NFSubstitution& rhs) const;
 
-    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos) const;
-    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/) const {}
+    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const;
+    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, 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,
         Formattable& result) const;
 
@@ skipping 54 matching lines @@
         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*/) const {}
-    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos) const;
+    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, UErrorCode& /*status*/) const {}
+    virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const;
     virtual UBool doParse(const UnicodeString& text, 
         ParsePosition& parsePosition,
         double baseValue,
         double upperBound,
         UBool /*lenientParse*/,
         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; } // '<'
@@ skipping 11 matching lines @@
 public:
     NullSubstitution(int32_t _pos,
         const NFRuleSet* _ruleSet,
         const RuleBasedNumberFormat* formatter,
         const UnicodeString& description,
         UErrorCode& status)
         : NFSubstitution(_pos, _ruleSet, formatter, description, status) {}
     virtual ~NullSubstitution();
 
     virtual void toString(UnicodeString& /*result*/) const {}
-    virtual void doSubstitution(double /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/) const {}
-    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/) const {}
+    virtual void doSubstitution(double /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, UErrorCode& /*status*/) const {}
+    virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, UErrorCode& /*status*/) const {}
     virtual int64_t transformNumber(int64_t /*number*/) const { return 0; }
     virtual double transformNumber(double /*number*/) const { return 0; }
     virtual UBool doParse(const UnicodeString& /*text*/,
         ParsePosition& /*parsePosition*/, 
         double baseValue,
         double /*upperBound*/,
         UBool /*lenientParse*/,
         Formattable& result) const
     { result.setDouble(baseValue); return TRUE; }
     virtual double composeRuleValue(double /*newRuleValue*/, double /*oldRuleValue*/) const { return 0.0; } // never called
@@ skipping 253 matching lines @@
  * 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) const
+NFSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t _pos, 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);
+        ruleSet->format(transformNumber(number), toInsertInto, _pos + this->pos, status);
     } else if (numberFormat != NULL) {
         // or perform the transformation on the number (preserving
         // the result's fractional part if the formatter it set
         // to show it), then use that formatter's format() method
         // to format the result
         double numberToFormat = transformNumber((double)number);
         if (numberFormat->getMaximumFractionDigits() == 0) {
             numberToFormat = uprv_floor(numberToFormat);
         }
 
         UnicodeString temp;
-        numberFormat->format(numberToFormat, temp);
+        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) const {
+NFSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t _pos, 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 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);
+        ruleSet->format(util64_fromDouble(numberToFormat), toInsertInto, _pos + this->pos, 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);
+            ruleSet->format(numberToFormat, toInsertInto, _pos + this->pos, status);
         } else if (numberFormat != NULL) {
             UnicodeString temp;
             numberFormat->format(numberToFormat, temp);
             toInsertInto.insert(_pos + this->pos, temp);
         }
     }
 }
 
 
     //-----------------------------------------------------------------------
@@ skipping 222 matching lines @@
 
 /**
  * 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) const
+ModulusSubstitution::doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t _pos, 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);
+        NFSubstitution::doSubstitution(number, toInsertInto, _pos, 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());
+        ruleToUse->doFormat(numberToFormat, toInsertInto, _pos + getPos(), 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) const
+ModulusSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t _pos, 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);
+        NFSubstitution::doSubstitution(number, toInsertInto, _pos, 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());
+        ruleToUse->doFormat(numberToFormat, toInsertInto, _pos + getPos(), status);
     }
 }
 
 //-----------------------------------------------------------------------
 // parsing
 //-----------------------------------------------------------------------
 
 /**
  * If this is a &gt;&gt;&gt; substitution, match only against ruleToUse.
  * Otherwise, use the superclass function.
@@ skipping 104 matching lines @@
  * 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) const
+FractionalPartSubstitution::doSubstitution(double number, UnicodeString& toInsertInto,
+                                           int32_t _pos, UErrorCode& status) const
 {
   // if we're not in "byDigits" mode, just use the inherited
   // doSubstitution() routine
   if (!byDigits) {
-    NFSubstitution::doSubstitution(number, toInsertInto, _pos);
+    NFSubstitution::doSubstitution(number, toInsertInto, _pos, 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
@@ skipping 21 matching lines @@
     for (int32_t didx = dl.getCount()-1; didx>=dl.getDecimalAt(); 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;
       }
       int64_t digit = didx>=0 ? dl.getDigit(didx) - '0' : 0;
-      getRuleSet()->format(digit, toInsertInto, _pos + getPos());
+      getRuleSet()->format(digit, toInsertInto, _pos + getPos(), 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());
+      getRuleSet()->format((int64_t)0, toInsertInto, _pos + getPos(), status);
     }
   }
 }
 
 //-----------------------------------------------------------------------
 // parsing
 //-----------------------------------------------------------------------
 
 /**
  * If in "by digits" mode, parses the string as if it were a string
@@ skipping 98 matching lines @@
 // AbsoluteValueSubstitution
 //===================================================================
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AbsoluteValueSubstitution)
 
 //===================================================================
 // NumeratorSubstitution
 //===================================================================
 
 void
-NumeratorSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t apos) const {
+NumeratorSubstitution::doSubstitution(double number, UnicodeString& toInsertInto, int32_t apos, 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());
+            aruleSet->format((int64_t)0, toInsertInto, apos + getPos(), 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());
+        aruleSet->format(longNF, toInsertInto, apos + getPos(), 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());
+            aruleSet->format(numberToFormat, toInsertInto, apos + getPos(), status);
         } else {
-            UErrorCode status = U_ZERO_ERROR;
             UnicodeString temp;
             getNumberFormat()->format(numberToFormat, temp, status);
             toInsertInto.insert(apos + getPos(), temp);
         }
     }
 }
 
 UBool 
 NumeratorSubstitution::doParse(const UnicodeString& text, 
                                ParsePosition& parsePosition,
@@ skipping 81 matching lines @@
 // NullSubstitution
 //===================================================================
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NullSubstitution)
 
 U_NAMESPACE_END
 
 /* U_HAVE_RBNF */
 #endif