diff options
author | Peter Breitenlohner <peb@mppmu.mpg.de> | 2013-03-07 13:41:10 +0000 |
---|---|---|
committer | Peter Breitenlohner <peb@mppmu.mpg.de> | 2013-03-07 13:41:10 +0000 |
commit | 6b2a8ddefb5477afc77abeee7d0f8d7b2a7049f3 (patch) | |
tree | f609e21ecbbf268b582f9d8cba3642b464d932aa /Build/source/libs/icu/icu-50.1/i18n/nfsubs.cpp | |
parent | 3685e17fe98b53a9142f9edc6c8c335952fb57f0 (diff) |
icu 51.1 (51_rc)
git-svn-id: svn://tug.org/texlive/trunk@29305 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/icu/icu-50.1/i18n/nfsubs.cpp')
-rw-r--r-- | Build/source/libs/icu/icu-50.1/i18n/nfsubs.cpp | 1364 |
1 files changed, 0 insertions, 1364 deletions
diff --git a/Build/source/libs/icu/icu-50.1/i18n/nfsubs.cpp b/Build/source/libs/icu/icu-50.1/i18n/nfsubs.cpp deleted file mode 100644 index 35c9ce1a3c8..00000000000 --- a/Build/source/libs/icu/icu-50.1/i18n/nfsubs.cpp +++ /dev/null @@ -1,1364 +0,0 @@ -/* -****************************************************************************** -* Copyright (C) 1997-2012, 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 -*/ - -#include <stdio.h> -#include "utypeinfo.h" // for 'typeid' to work - -#include "nfsubs.h" -#include "digitlst.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 - -class SameValueSubstitution : public NFSubstitution { -public: - SameValueSubstitution(int32_t pos, - const NFRuleSet* ruleset, - const RuleBasedNumberFormat* formatter, - 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 { - double divisor; - int64_t ldivisor; - -public: - MultiplierSubstitution(int32_t _pos, - double _divisor, - const NFRuleSet* _ruleSet, - const RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status) - : NFSubstitution(_pos, _ruleSet, formatter, description, status), divisor(_divisor) - { - ldivisor = util64_fromDouble(divisor); - if (divisor == 0) { - status = U_PARSE_ERROR; - } - } - virtual ~MultiplierSubstitution(); - - virtual void setDivisor(int32_t radix, int32_t exponent, UErrorCode& status) { - divisor = uprv_pow(radix, exponent); - ldivisor = util64_fromDouble(divisor); - - if(divisor == 0) { - status = U_PARSE_ERROR; - } - } - - virtual UBool operator==(const NFSubstitution& rhs) const; - - virtual int64_t transformNumber(int64_t number) const { - return number / ldivisor; - } - - 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 calcUpperBound(double /*oldUpperBound*/) const { return divisor; } - - virtual UChar tokenChar() const { return (UChar)0x003c; } // '<' - -public: - static UClassID getStaticClassID(void); - virtual UClassID getDynamicClassID(void) const; -}; - -MultiplierSubstitution::~MultiplierSubstitution() {} - -class ModulusSubstitution : public NFSubstitution { - double divisor; - int64_t ldivisor; - const NFRule* ruleToUse; -public: - ModulusSubstitution(int32_t pos, - double _divisor, - const NFRule* rulePredecessor, - const NFRuleSet* ruleSet, - const RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status); - virtual ~ModulusSubstitution(); - - virtual void setDivisor(int32_t radix, int32_t exponent, UErrorCode& status) { - 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 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; - - virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { - return oldRuleValue - uprv_fmod(oldRuleValue, divisor) + newRuleValue; - } - - virtual double calcUpperBound(double /*oldUpperBound*/) const { return 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 RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status) - : NFSubstitution(_pos, _ruleSet, formatter, 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 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 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; - - 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 RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status) - : NFSubstitution(_pos, _ruleSet, formatter, 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, - const NFRuleSet* _ruleSet, - const RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status) - : NFSubstitution(_pos, _ruleSet, formatter, 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*/) const {} - virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos) 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; } // '<' -private: - static const UChar LTLT[2]; - -public: - static UClassID getStaticClassID(void); - virtual UClassID getDynamicClassID(void) const; -}; - -NumeratorSubstitution::~NumeratorSubstitution() {} - -class NullSubstitution : public NFSubstitution { -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 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 - virtual double calcUpperBound(double /*oldUpperBound*/) const { return 0; } // never called - virtual UBool isNullSubstitution() const { return TRUE; } - virtual UChar tokenChar() const { return (UChar)0x0020; } // ' ' never called - -public: - static UClassID getStaticClassID(void); - virtual UClassID getDynamicClassID(void) const; -}; - -NullSubstitution::~NullSubstitution() {} - -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 new NullSubstitution(pos, ruleSet, formatter, description, status); - } - - 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, formatter, 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(), formatter, description, status); - } - - // otherwise, return a MultiplierSubstitution - else { - return new MultiplierSubstitution(pos, rule->getDivisor(), ruleSet, - formatter, 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, formatter, 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, formatter, 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->getDivisor(), predecessor, - ruleSet, formatter, description, status); - } - - // if the description begins with '=', always return a - // SameValueSubstitution - case gEquals: - return new SameValueSubstitution(pos, ruleSet, formatter, 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 RuleBasedNumberFormat* formatter, - 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 the description was just two paired token characters - // (i.e., "<<" or ">>"), it uses the rule set it belongs to to - // format its result - if (workingDescription.length() == 0) { - this->ruleSet = _ruleSet; - } - // 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 - else if (workingDescription.charAt(0) == gPercent) { - this->ruleSet = formatter->findRuleSet(workingDescription, status); - } - // 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) - else if (workingDescription.charAt(0) == gPound || workingDescription.charAt(0) ==gZero) { - DecimalFormatSymbols* sym = formatter->getDecimalFormatSymbols(); - if (!sym) { - status = U_MISSING_RESOURCE_ERROR; - return; - } - this->numberFormat = new DecimalFormat(workingDescription, *sym, status); - /* test for NULL */ - if (this->numberFormat == 0) { - status = U_MEMORY_ALLOCATION_ERROR; - return; - } - if (U_FAILURE(status)) { - delete (DecimalFormat*)this->numberFormat; - this->numberFormat = NULL; - return; - } - // this->numberFormat->setDecimalFormatSymbols(formatter->getDecimalFormatSymbols()); - } - // 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) - else if (workingDescription.charAt(0) == gGreaterThan) { - // this causes problems when >>> is used in a frationalPartSubstitution - // this->ruleSet = NULL; - this->ruleSet = _ruleSet; - this->numberFormat = NULL; - } - // and of the description is none of these things, it's a syntax error - else { - // throw new IllegalArgumentException("Illegal substitution syntax"); - status = U_PARSE_ERROR; - } -} - -NFSubstitution::~NFSubstitution() -{ - // cast away const - delete (NumberFormat*)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*/, int32_t /*exponent*/, UErrorCode& /*status*/) { - // a no-op for all substitutions except multiplier and modulus substitutions -} - - -//----------------------------------------------------------------------- -// 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) 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); - } 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); - 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 { - // 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); - - // 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); - } 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, - 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, 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; - } -} - -UBool -NFSubstitution::isNullSubstitution() const { - 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 RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status) -: NFSubstitution(_pos, _ruleSet, formatter, 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 ">>" in a - * regular rule. - */ -ModulusSubstitution::ModulusSubstitution(int32_t _pos, - double _divisor, - const NFRule* predecessor, - const NFRuleSet* _ruleSet, - const RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status) - : NFSubstitution(_pos, _ruleSet, formatter, description, status) - , divisor(_divisor) - , ruleToUse(NULL) -{ - ldivisor = util64_fromDouble(_divisor); - - // 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 (ldivisor == 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 >>> 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 -{ - // 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); - - // 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()); - } -} - -/** -* If this is a >>> 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 -{ - // 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); - - // a >>> substitution goes straight to a particular rule to - // format the substitution value - } else { - double numberToFormat = transformNumber(number); - - ruleToUse->doFormat(numberToFormat, toInsertInto, _pos + getPos()); - } -} - -//----------------------------------------------------------------------- -// parsing -//----------------------------------------------------------------------- - -/** - * If this is a >>> 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, - 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, 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 { - ruleToUse->doParse(text, parsePosition, FALSE, upperBound, 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 RuleBasedNumberFormat* formatter, - const UnicodeString& description, - UErrorCode& status) - : NFSubstitution(_pos, _ruleSet, formatter, 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) const -{ - // if we're not in "byDigits" mode, just use the inherited - // doSubstitution() routine - if (!byDigits) { - NFSubstitution::doSubstitution(number, toInsertInto, _pos); - - // 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; - // } - - DigitList dl; - dl.set(number); - dl.roundFixedPoint(20); // round to 20 fraction digits. - dl.reduce(); // Removes any trailing zeros. - - UBool pad = FALSE; - 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()); - } - - 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()); - } - } -} - -//----------------------------------------------------------------------- -// 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, - 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, 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; - - DigitList dl; - NumberFormat* fmt = NULL; - while (workText.length() > 0 && workPos.getIndex() != 0) { - workPos.setIndex(0); - Formattable temp; - getRuleSet()->parse(workText, workPos, 10, 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) { - dl.append((char)('0' + digit)); -// 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 = dl.getCount() == 0 ? 0 : dl.getDouble(); - 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) 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()); - } - 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()); - - // 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()); - } 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, - double baseValue, - double upperBound, - UBool /*lenientParse*/, - 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, 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 - NFSubstitution::doParse(workText, parsePosition, withZeros ? 1 : baseValue, upperBound, FALSE, 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 }; - -//=================================================================== -// NullSubstitution -//=================================================================== - -UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NullSubstitution) - -U_NAMESPACE_END - -/* U_HAVE_RBNF */ -#endif - |