diff options
Diffstat (limited to 'deps/icu-small/source/i18n/decimfmt.cpp')
| -rw-r--r-- | deps/icu-small/source/i18n/decimfmt.cpp | 3266 |
1 files changed, 3266 insertions, 0 deletions
diff --git a/deps/icu-small/source/i18n/decimfmt.cpp b/deps/icu-small/source/i18n/decimfmt.cpp new file mode 100644 index 0000000000..0b67e63be9 --- /dev/null +++ b/deps/icu-small/source/i18n/decimfmt.cpp @@ -0,0 +1,3266 @@ +/* +******************************************************************************* +* Copyright (C) 1997-2015, International Business Machines Corporation and * +* others. All Rights Reserved. * +******************************************************************************* +* +* File DECIMFMT.CPP +* +* Modification History: +* +* Date Name Description +* 02/19/97 aliu Converted from java. +* 03/20/97 clhuang Implemented with new APIs. +* 03/31/97 aliu Moved isLONG_MIN to DigitList, and fixed it. +* 04/3/97 aliu Rewrote parsing and formatting completely, and +* cleaned up and debugged. Actually works now. +* Implemented NAN and INF handling, for both parsing +* and formatting. Extensive testing & debugging. +* 04/10/97 aliu Modified to compile on AIX. +* 04/16/97 aliu Rewrote to use DigitList, which has been resurrected. +* Changed DigitCount to int per code review. +* 07/09/97 helena Made ParsePosition into a class. +* 08/26/97 aliu Extensive changes to applyPattern; completely +* rewritten from the Java. +* 09/09/97 aliu Ported over support for exponential formats. +* 07/20/98 stephen JDK 1.2 sync up. +* Various instances of '0' replaced with 'NULL' +* Check for grouping size in subFormat() +* Brought subParse() in line with Java 1.2 +* Added method appendAffix() +* 08/24/1998 srl Removed Mutex calls. This is not a thread safe class! +* 02/22/99 stephen Removed character literals for EBCDIC safety +* 06/24/99 helena Integrated Alan's NF enhancements and Java2 bug fixes +* 06/28/99 stephen Fixed bugs in toPattern(). +* 06/29/99 stephen Fixed operator= to copy fFormatWidth, fPad, +* fPadPosition +******************************************************************************** +*/ + +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/uniset.h" +#include "unicode/currpinf.h" +#include "unicode/plurrule.h" +#include "unicode/utf16.h" +#include "unicode/numsys.h" +#include "unicode/localpointer.h" +#include "uresimp.h" +#include "ucurrimp.h" +#include "charstr.h" +#include "patternprops.h" +#include "cstring.h" +#include "uassert.h" +#include "hash.h" +#include "decfmtst.h" +#include "plurrule_impl.h" +#include "decimalformatpattern.h" +#include "fmtableimp.h" +#include "decimfmtimpl.h" +#include "visibledigits.h" + +/* + * On certain platforms, round is a macro defined in math.h + * This undefine is to avoid conflict between the macro and + * the function defined below. + */ +#ifdef round +#undef round +#endif + + +U_NAMESPACE_BEGIN + +#ifdef FMT_DEBUG +#include <stdio.h> +static void _debugout(const char *f, int l, const UnicodeString& s) { + char buf[2000]; + s.extract((int32_t) 0, s.length(), buf, "utf-8"); + printf("%s:%d: %s\n", f,l, buf); +} +#define debugout(x) _debugout(__FILE__,__LINE__,x) +#define debug(x) printf("%s:%d: %s\n", __FILE__,__LINE__, x); +static const UnicodeString dbg_null("<NULL>",""); +#define DEREFSTR(x) ((x!=NULL)?(*x):(dbg_null)) +#else +#define debugout(x) +#define debug(x) +#endif + + +/* For currency parsing purose, + * Need to remember all prefix patterns and suffix patterns of + * every currency format pattern, + * including the pattern of default currecny style + * and plural currency style. And the patterns are set through applyPattern. + */ +struct AffixPatternsForCurrency : public UMemory { + // negative prefix pattern + UnicodeString negPrefixPatternForCurrency; + // negative suffix pattern + UnicodeString negSuffixPatternForCurrency; + // positive prefix pattern + UnicodeString posPrefixPatternForCurrency; + // positive suffix pattern + UnicodeString posSuffixPatternForCurrency; + int8_t patternType; + + AffixPatternsForCurrency(const UnicodeString& negPrefix, + const UnicodeString& negSuffix, + const UnicodeString& posPrefix, + const UnicodeString& posSuffix, + int8_t type) { + negPrefixPatternForCurrency = negPrefix; + negSuffixPatternForCurrency = negSuffix; + posPrefixPatternForCurrency = posPrefix; + posSuffixPatternForCurrency = posSuffix; + patternType = type; + } +#ifdef FMT_DEBUG + void dump() const { + debugout( UnicodeString("AffixPatternsForCurrency( -=\"") + + negPrefixPatternForCurrency + (UnicodeString)"\"/\"" + + negSuffixPatternForCurrency + (UnicodeString)"\" +=\"" + + posPrefixPatternForCurrency + (UnicodeString)"\"/\"" + + posSuffixPatternForCurrency + (UnicodeString)"\" )"); + } +#endif +}; + +/* affix for currency formatting when the currency sign in the pattern + * equals to 3, such as the pattern contains 3 currency sign or + * the formatter style is currency plural format style. + */ +struct AffixesForCurrency : public UMemory { + // negative prefix + UnicodeString negPrefixForCurrency; + // negative suffix + UnicodeString negSuffixForCurrency; + // positive prefix + UnicodeString posPrefixForCurrency; + // positive suffix + UnicodeString posSuffixForCurrency; + + int32_t formatWidth; + + AffixesForCurrency(const UnicodeString& negPrefix, + const UnicodeString& negSuffix, + const UnicodeString& posPrefix, + const UnicodeString& posSuffix) { + negPrefixForCurrency = negPrefix; + negSuffixForCurrency = negSuffix; + posPrefixForCurrency = posPrefix; + posSuffixForCurrency = posSuffix; + } +#ifdef FMT_DEBUG + void dump() const { + debugout( UnicodeString("AffixesForCurrency( -=\"") + + negPrefixForCurrency + (UnicodeString)"\"/\"" + + negSuffixForCurrency + (UnicodeString)"\" +=\"" + + posPrefixForCurrency + (UnicodeString)"\"/\"" + + posSuffixForCurrency + (UnicodeString)"\" )"); + } +#endif +}; + +U_CDECL_BEGIN + +/** + * @internal ICU 4.2 + */ +static UBool U_CALLCONV decimfmtAffixPatternValueComparator(UHashTok val1, UHashTok val2); + + +static UBool +U_CALLCONV decimfmtAffixPatternValueComparator(UHashTok val1, UHashTok val2) { + const AffixPatternsForCurrency* affix_1 = + (AffixPatternsForCurrency*)val1.pointer; + const AffixPatternsForCurrency* affix_2 = + (AffixPatternsForCurrency*)val2.pointer; + return affix_1->negPrefixPatternForCurrency == + affix_2->negPrefixPatternForCurrency && + affix_1->negSuffixPatternForCurrency == + affix_2->negSuffixPatternForCurrency && + affix_1->posPrefixPatternForCurrency == + affix_2->posPrefixPatternForCurrency && + affix_1->posSuffixPatternForCurrency == + affix_2->posSuffixPatternForCurrency && + affix_1->patternType == affix_2->patternType; +} + +U_CDECL_END + + + + +// ***************************************************************************** +// class DecimalFormat +// ***************************************************************************** + +UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DecimalFormat) + +// Constants for characters used in programmatic (unlocalized) patterns. +#define kPatternZeroDigit ((UChar)0x0030) /*'0'*/ +#define kPatternSignificantDigit ((UChar)0x0040) /*'@'*/ +#define kPatternGroupingSeparator ((UChar)0x002C) /*','*/ +#define kPatternDecimalSeparator ((UChar)0x002E) /*'.'*/ +#define kPatternPerMill ((UChar)0x2030) +#define kPatternPercent ((UChar)0x0025) /*'%'*/ +#define kPatternDigit ((UChar)0x0023) /*'#'*/ +#define kPatternSeparator ((UChar)0x003B) /*';'*/ +#define kPatternExponent ((UChar)0x0045) /*'E'*/ +#define kPatternPlus ((UChar)0x002B) /*'+'*/ +#define kPatternMinus ((UChar)0x002D) /*'-'*/ +#define kPatternPadEscape ((UChar)0x002A) /*'*'*/ +#define kQuote ((UChar)0x0027) /*'\''*/ +/** + * The CURRENCY_SIGN is the standard Unicode symbol for currency. It + * is used in patterns and substitued with either the currency symbol, + * or if it is doubled, with the international currency symbol. If the + * CURRENCY_SIGN is seen in a pattern, then the decimal separator is + * replaced with the monetary decimal separator. + */ +#define kCurrencySign ((UChar)0x00A4) +#define kDefaultPad ((UChar)0x0020) /* */ + +const int32_t DecimalFormat::kDoubleIntegerDigits = 309; +const int32_t DecimalFormat::kDoubleFractionDigits = 340; + +const int32_t DecimalFormat::kMaxScientificIntegerDigits = 8; + +/** + * These are the tags we expect to see in normal resource bundle files associated + * with a locale. + */ +const char DecimalFormat::fgNumberPatterns[]="NumberPatterns"; // Deprecated - not used +static const char fgNumberElements[]="NumberElements"; +static const char fgLatn[]="latn"; +static const char fgPatterns[]="patterns"; +static const char fgDecimalFormat[]="decimalFormat"; +static const char fgCurrencyFormat[]="currencyFormat"; + +inline int32_t _min(int32_t a, int32_t b) { return (a<b) ? a : b; } +inline int32_t _max(int32_t a, int32_t b) { return (a<b) ? b : a; } + +//------------------------------------------------------------------------------ +// Constructs a DecimalFormat instance in the default locale. + +DecimalFormat::DecimalFormat(UErrorCode& status) { + init(); + UParseError parseError; + construct(status, parseError); +} + +//------------------------------------------------------------------------------ +// Constructs a DecimalFormat instance with the specified number format +// pattern in the default locale. + +DecimalFormat::DecimalFormat(const UnicodeString& pattern, + UErrorCode& status) { + init(); + UParseError parseError; + construct(status, parseError, &pattern); +} + +//------------------------------------------------------------------------------ +// Constructs a DecimalFormat instance with the specified number format +// pattern and the number format symbols in the default locale. The +// created instance owns the symbols. + +DecimalFormat::DecimalFormat(const UnicodeString& pattern, + DecimalFormatSymbols* symbolsToAdopt, + UErrorCode& status) { + init(); + UParseError parseError; + if (symbolsToAdopt == NULL) + status = U_ILLEGAL_ARGUMENT_ERROR; + construct(status, parseError, &pattern, symbolsToAdopt); +} + +DecimalFormat::DecimalFormat( const UnicodeString& pattern, + DecimalFormatSymbols* symbolsToAdopt, + UParseError& parseErr, + UErrorCode& status) { + init(); + if (symbolsToAdopt == NULL) + status = U_ILLEGAL_ARGUMENT_ERROR; + construct(status,parseErr, &pattern, symbolsToAdopt); +} + +//------------------------------------------------------------------------------ +// Constructs a DecimalFormat instance with the specified number format +// pattern and the number format symbols in the default locale. The +// created instance owns the clone of the symbols. + +DecimalFormat::DecimalFormat(const UnicodeString& pattern, + const DecimalFormatSymbols& symbols, + UErrorCode& status) { + init(); + UParseError parseError; + construct(status, parseError, &pattern, new DecimalFormatSymbols(symbols)); +} + +//------------------------------------------------------------------------------ +// Constructs a DecimalFormat instance with the specified number format +// pattern, the number format symbols, and the number format style. +// The created instance owns the clone of the symbols. + +DecimalFormat::DecimalFormat(const UnicodeString& pattern, + DecimalFormatSymbols* symbolsToAdopt, + UNumberFormatStyle style, + UErrorCode& status) { + init(); + fStyle = style; + UParseError parseError; + construct(status, parseError, &pattern, symbolsToAdopt); +} + +//----------------------------------------------------------------------------- +// Common DecimalFormat initialization. +// Put all fields of an uninitialized object into a known state. +// Common code, shared by all constructors. +// Can not fail. Leave the object in good enough shape that the destructor +// or assignment operator can run successfully. +void +DecimalFormat::init() { + fBoolFlags.clear(); + fStyle = UNUM_DECIMAL; + fAffixPatternsForCurrency = NULL; + fCurrencyPluralInfo = NULL; +#if UCONFIG_HAVE_PARSEALLINPUT + fParseAllInput = UNUM_MAYBE; +#endif + + fStaticSets = NULL; + fImpl = NULL; +} + +//------------------------------------------------------------------------------ +// Constructs a DecimalFormat instance with the specified number format +// pattern and the number format symbols in the desired locale. The +// created instance owns the symbols. + +void +DecimalFormat::construct(UErrorCode& status, + UParseError& parseErr, + const UnicodeString* pattern, + DecimalFormatSymbols* symbolsToAdopt) +{ + LocalPointer<DecimalFormatSymbols> adoptedSymbols(symbolsToAdopt); + if (U_FAILURE(status)) + return; + + if (adoptedSymbols.isNull()) + { + adoptedSymbols.adoptInstead( + new DecimalFormatSymbols(Locale::getDefault(), status)); + if (adoptedSymbols.isNull() && U_SUCCESS(status)) { + status = U_MEMORY_ALLOCATION_ERROR; + } + if (U_FAILURE(status)) { + return; + } + } + fStaticSets = DecimalFormatStaticSets::getStaticSets(status); + if (U_FAILURE(status)) { + return; + } + + UnicodeString str; + // Uses the default locale's number format pattern if there isn't + // one specified. + if (pattern == NULL) + { + UErrorCode nsStatus = U_ZERO_ERROR; + LocalPointer<NumberingSystem> ns( + NumberingSystem::createInstance(nsStatus)); + if (U_FAILURE(nsStatus)) { + status = nsStatus; + return; + } + + int32_t len = 0; + UResourceBundle *top = ures_open(NULL, Locale::getDefault().getName(), &status); + + UResourceBundle *resource = ures_getByKeyWithFallback(top, fgNumberElements, NULL, &status); + resource = ures_getByKeyWithFallback(resource, ns->getName(), resource, &status); + resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &status); + const UChar *resStr = ures_getStringByKeyWithFallback(resource, fgDecimalFormat, &len, &status); + if ( status == U_MISSING_RESOURCE_ERROR && uprv_strcmp(fgLatn,ns->getName())) { + status = U_ZERO_ERROR; + resource = ures_getByKeyWithFallback(top, fgNumberElements, resource, &status); + resource = ures_getByKeyWithFallback(resource, fgLatn, resource, &status); + resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &status); + resStr = ures_getStringByKeyWithFallback(resource, fgDecimalFormat, &len, &status); + } + str.setTo(TRUE, resStr, len); + pattern = &str; + ures_close(resource); + ures_close(top); + } + + fImpl = new DecimalFormatImpl(this, *pattern, adoptedSymbols.getAlias(), parseErr, status); + if (fImpl) { + adoptedSymbols.orphan(); + } else if (U_SUCCESS(status)) { + status = U_MEMORY_ALLOCATION_ERROR; + } + if (U_FAILURE(status)) { + return; + } + + if (U_FAILURE(status)) + { + return; + } + + const UnicodeString* patternUsed; + UnicodeString currencyPluralPatternForOther; + // apply pattern + if (fStyle == UNUM_CURRENCY_PLURAL) { + fCurrencyPluralInfo = new CurrencyPluralInfo(fImpl->fSymbols->getLocale(), status); + if (U_FAILURE(status)) { + return; + } + + // the pattern used in format is not fixed until formatting, + // in which, the number is known and + // will be used to pick the right pattern based on plural count. + // Here, set the pattern as the pattern of plural count == "other". + // For most locale, the patterns are probably the same for all + // plural count. If not, the right pattern need to be re-applied + // during format. + fCurrencyPluralInfo->getCurrencyPluralPattern(UNICODE_STRING("other", 5), currencyPluralPatternForOther); + // TODO(refactor): Revisit, we are setting the pattern twice. + fImpl->applyPatternFavorCurrencyPrecision( + currencyPluralPatternForOther, status); + patternUsed = ¤cyPluralPatternForOther; + + } else { + patternUsed = pattern; + } + + if (patternUsed->indexOf(kCurrencySign) != -1) { + // initialize for currency, not only for plural format, + // but also for mix parsing + if (fCurrencyPluralInfo == NULL) { + fCurrencyPluralInfo = new CurrencyPluralInfo(fImpl->fSymbols->getLocale(), status); + if (U_FAILURE(status)) { + return; + } + } + // need it for mix parsing + setupCurrencyAffixPatterns(status); + } +} + +static void +applyPatternWithNoSideEffects( + const UnicodeString& pattern, + UParseError& parseError, + UnicodeString &negPrefix, + UnicodeString &negSuffix, + UnicodeString &posPrefix, + UnicodeString &posSuffix, + UErrorCode& status) { + if (U_FAILURE(status)) + { + return; + } + DecimalFormatPatternParser patternParser; + DecimalFormatPattern out; + patternParser.applyPatternWithoutExpandAffix( + pattern, + out, + parseError, + status); + if (U_FAILURE(status)) { + return; + } + negPrefix = out.fNegPrefixPattern; + negSuffix = out.fNegSuffixPattern; + posPrefix = out.fPosPrefixPattern; + posSuffix = out.fPosSuffixPattern; +} + +void +DecimalFormat::setupCurrencyAffixPatterns(UErrorCode& status) { + if (U_FAILURE(status)) { + return; + } + UParseError parseErr; + fAffixPatternsForCurrency = initHashForAffixPattern(status); + if (U_FAILURE(status)) { + return; + } + + NumberingSystem *ns = NumberingSystem::createInstance(fImpl->fSymbols->getLocale(),status); + if (U_FAILURE(status)) { + return; + } + + // Save the default currency patterns of this locale. + // Here, chose onlyApplyPatternWithoutExpandAffix without + // expanding the affix patterns into affixes. + UnicodeString currencyPattern; + UErrorCode error = U_ZERO_ERROR; + + UResourceBundle *resource = ures_open(NULL, fImpl->fSymbols->getLocale().getName(), &error); + UResourceBundle *numElements = ures_getByKeyWithFallback(resource, fgNumberElements, NULL, &error); + resource = ures_getByKeyWithFallback(numElements, ns->getName(), resource, &error); + resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &error); + int32_t patLen = 0; + const UChar *patResStr = ures_getStringByKeyWithFallback(resource, fgCurrencyFormat, &patLen, &error); + if ( error == U_MISSING_RESOURCE_ERROR && uprv_strcmp(ns->getName(),fgLatn)) { + error = U_ZERO_ERROR; + resource = ures_getByKeyWithFallback(numElements, fgLatn, resource, &error); + resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &error); + patResStr = ures_getStringByKeyWithFallback(resource, fgCurrencyFormat, &patLen, &error); + } + ures_close(numElements); + ures_close(resource); + delete ns; + + if (U_SUCCESS(error)) { + UnicodeString negPrefix; + UnicodeString negSuffix; + UnicodeString posPrefix; + UnicodeString posSuffix; + applyPatternWithNoSideEffects(UnicodeString(patResStr, patLen), + parseErr, + negPrefix, negSuffix, posPrefix, posSuffix, status); + AffixPatternsForCurrency* affixPtn = new AffixPatternsForCurrency( + negPrefix, + negSuffix, + posPrefix, + posSuffix, + UCURR_SYMBOL_NAME); + fAffixPatternsForCurrency->put(UNICODE_STRING("default", 7), affixPtn, status); + } + + // save the unique currency plural patterns of this locale. + Hashtable* pluralPtn = fCurrencyPluralInfo->fPluralCountToCurrencyUnitPattern; + const UHashElement* element = NULL; + int32_t pos = UHASH_FIRST; + Hashtable pluralPatternSet; + while ((element = pluralPtn->nextElement(pos)) != NULL) { + const UHashTok valueTok = element->value; + const UnicodeString* value = (UnicodeString*)valueTok.pointer; + const UHashTok keyTok = element->key; + const UnicodeString* key = (UnicodeString*)keyTok.pointer; + if (pluralPatternSet.geti(*value) != 1) { + UnicodeString negPrefix; + UnicodeString negSuffix; + UnicodeString posPrefix; + UnicodeString posSuffix; + pluralPatternSet.puti(*value, 1, status); + applyPatternWithNoSideEffects( + *value, parseErr, + negPrefix, negSuffix, posPrefix, posSuffix, status); + AffixPatternsForCurrency* affixPtn = new AffixPatternsForCurrency( + negPrefix, + negSuffix, + posPrefix, + posSuffix, + UCURR_LONG_NAME); + fAffixPatternsForCurrency->put(*key, affixPtn, status); + } + } +} + + +//------------------------------------------------------------------------------ + +DecimalFormat::~DecimalFormat() +{ + deleteHashForAffixPattern(); + delete fCurrencyPluralInfo; + delete fImpl; +} + +//------------------------------------------------------------------------------ +// copy constructor + +DecimalFormat::DecimalFormat(const DecimalFormat &source) : + NumberFormat(source) { + init(); + *this = source; +} + +//------------------------------------------------------------------------------ +// assignment operator + +template <class T> +static void _clone_ptr(T** pdest, const T* source) { + delete *pdest; + if (source == NULL) { + *pdest = NULL; + } else { + *pdest = static_cast<T*>(source->clone()); + } +} + +DecimalFormat& +DecimalFormat::operator=(const DecimalFormat& rhs) +{ + if(this != &rhs) { + UErrorCode status = U_ZERO_ERROR; + NumberFormat::operator=(rhs); + if (fImpl == NULL) { + fImpl = new DecimalFormatImpl(this, *rhs.fImpl, status); + } else { + fImpl->assign(*rhs.fImpl, status); + } + fStaticSets = DecimalFormatStaticSets::getStaticSets(status); + fStyle = rhs.fStyle; + _clone_ptr(&fCurrencyPluralInfo, rhs.fCurrencyPluralInfo); + deleteHashForAffixPattern(); + if (rhs.fAffixPatternsForCurrency) { + UErrorCode status = U_ZERO_ERROR; + fAffixPatternsForCurrency = initHashForAffixPattern(status); + copyHashForAffixPattern(rhs.fAffixPatternsForCurrency, + fAffixPatternsForCurrency, status); + } + } + + return *this; +} + +//------------------------------------------------------------------------------ + +UBool +DecimalFormat::operator==(const Format& that) const +{ + if (this == &that) + return TRUE; + + // NumberFormat::operator== guarantees this cast is safe + const DecimalFormat* other = (DecimalFormat*)&that; + + return ( + NumberFormat::operator==(that) && + fBoolFlags.getAll() == other->fBoolFlags.getAll() && + *fImpl == *other->fImpl); + +} + +//------------------------------------------------------------------------------ + +Format* +DecimalFormat::clone() const +{ + return new DecimalFormat(*this); +} + + +FixedDecimal +DecimalFormat::getFixedDecimal(double number, UErrorCode &status) const { + VisibleDigitsWithExponent digits; + initVisibleDigitsWithExponent(number, digits, status); + if (U_FAILURE(status)) { + return FixedDecimal(); + } + return FixedDecimal(digits.getMantissa()); +} + +VisibleDigitsWithExponent & +DecimalFormat::initVisibleDigitsWithExponent( + double number, + VisibleDigitsWithExponent &digits, + UErrorCode &status) const { + return fImpl->initVisibleDigitsWithExponent(number, digits, status); +} + +FixedDecimal +DecimalFormat::getFixedDecimal(const Formattable &number, UErrorCode &status) const { + VisibleDigitsWithExponent digits; + initVisibleDigitsWithExponent(number, digits, status); + if (U_FAILURE(status)) { + return FixedDecimal(); + } + return FixedDecimal(digits.getMantissa()); +} + +VisibleDigitsWithExponent & +DecimalFormat::initVisibleDigitsWithExponent( + const Formattable &number, + VisibleDigitsWithExponent &digits, + UErrorCode &status) const { + if (U_FAILURE(status)) { + return digits; + } + if (!number.isNumeric()) { + status = U_ILLEGAL_ARGUMENT_ERROR; + return digits; + } + + DigitList *dl = number.getDigitList(); + if (dl != NULL) { + DigitList dlCopy(*dl); + return fImpl->initVisibleDigitsWithExponent( + dlCopy, digits, status); + } + + Formattable::Type type = number.getType(); + if (type == Formattable::kDouble || type == Formattable::kLong) { + return fImpl->initVisibleDigitsWithExponent( + number.getDouble(status), digits, status); + } + return fImpl->initVisibleDigitsWithExponent( + number.getInt64(), digits, status); +} + + +// Create a fixed decimal from a DigitList. +// The digit list may be modified. +// Internal function only. +FixedDecimal +DecimalFormat::getFixedDecimal(DigitList &number, UErrorCode &status) const { + VisibleDigitsWithExponent digits; + initVisibleDigitsWithExponent(number, digits, status); + if (U_FAILURE(status)) { + return FixedDecimal(); + } + return FixedDecimal(digits.getMantissa()); +} + +VisibleDigitsWithExponent & +DecimalFormat::initVisibleDigitsWithExponent( + DigitList &number, + VisibleDigitsWithExponent &digits, + UErrorCode &status) const { + return fImpl->initVisibleDigitsWithExponent( + number, digits, status); +} + + +//------------------------------------------------------------------------------ + +UnicodeString& +DecimalFormat::format(int32_t number, + UnicodeString& appendTo, + FieldPosition& fieldPosition) const +{ + UErrorCode status = U_ZERO_ERROR; + return fImpl->format(number, appendTo, fieldPosition, status); +} + +UnicodeString& +DecimalFormat::format(int32_t number, + UnicodeString& appendTo, + FieldPosition& fieldPosition, + UErrorCode& status) const +{ + return fImpl->format(number, appendTo, fieldPosition, status); +} + +UnicodeString& +DecimalFormat::format(int32_t number, + UnicodeString& appendTo, + FieldPositionIterator* posIter, + UErrorCode& status) const +{ + return fImpl->format(number, appendTo, posIter, status); +} + + +//------------------------------------------------------------------------------ + +UnicodeString& +DecimalFormat::format(int64_t number, + UnicodeString& appendTo, + FieldPosition& fieldPosition) const +{ + UErrorCode status = U_ZERO_ERROR; /* ignored */ + return fImpl->format(number, appendTo, fieldPosition, status); +} + +UnicodeString& +DecimalFormat::format(int64_t number, + UnicodeString& appendTo, + FieldPosition& fieldPosition, + UErrorCode& status) const +{ + return fImpl->format(number, appendTo, fieldPosition, status); +} + +UnicodeString& +DecimalFormat::format(int64_t number, + UnicodeString& appendTo, + FieldPositionIterator* posIter, + UErrorCode& status) const +{ + return fImpl->format(number, appendTo, posIter, status); +} + +//------------------------------------------------------------------------------ + +UnicodeString& +DecimalFormat::format( double number, + UnicodeString& appendTo, + FieldPosition& fieldPosition) const +{ + UErrorCode status = U_ZERO_ERROR; /* ignored */ + return fImpl->format(number, appendTo, fieldPosition, status); +} + +UnicodeString& +DecimalFormat::format( double number, + UnicodeString& appendTo, + FieldPosition& fieldPosition, + UErrorCode& status) const +{ + return fImpl->format(number, appendTo, fieldPosition, status); +} + +UnicodeString& +DecimalFormat::format( double number, + UnicodeString& appendTo, + FieldPositionIterator* posIter, + UErrorCode& status) const +{ + return fImpl->format(number, appendTo, posIter, status); +} + +//------------------------------------------------------------------------------ + + +UnicodeString& +DecimalFormat::format(const StringPiece &number, + UnicodeString &toAppendTo, + FieldPositionIterator *posIter, + UErrorCode &status) const +{ + return fImpl->format(number, toAppendTo, posIter, status); +} + + +UnicodeString& +DecimalFormat::format(const DigitList &number, + UnicodeString &appendTo, + FieldPositionIterator *posIter, + UErrorCode &status) const { + return fImpl->format(number, appendTo, posIter, status); +} + + +UnicodeString& +DecimalFormat::format(const DigitList &number, + UnicodeString& appendTo, + FieldPosition& pos, + UErrorCode &status) const { + return fImpl->format(number, appendTo, pos, status); +} + +UnicodeString& +DecimalFormat::format(const VisibleDigitsWithExponent &number, + UnicodeString &appendTo, + FieldPositionIterator *posIter, + UErrorCode &status) const { + return fImpl->format(number, appendTo, posIter, status); +} + + +UnicodeString& +DecimalFormat::format(const VisibleDigitsWithExponent &number, + UnicodeString& appendTo, + FieldPosition& pos, + UErrorCode &status) const { + return fImpl->format(number, appendTo, pos, status); +} + +DigitList& +DecimalFormat::_round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const { + adjustedNum = number; + fImpl->round(adjustedNum, status); + isNegative = !adjustedNum.isPositive(); + return adjustedNum; +} + +void +DecimalFormat::parse(const UnicodeString& text, + Formattable& result, + ParsePosition& parsePosition) const { + parse(text, result, parsePosition, NULL); +} + +CurrencyAmount* DecimalFormat::parseCurrency(const UnicodeString& text, + ParsePosition& pos) const { + Formattable parseResult; + int32_t start = pos.getIndex(); + UChar curbuf[4] = {}; + parse(text, parseResult, pos, curbuf); + if (pos.getIndex() != start) { + UErrorCode ec = U_ZERO_ERROR; + LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curbuf, ec), ec); + if (U_FAILURE(ec)) { + pos.setIndex(start); // indicate failure + } else { + return currAmt.orphan(); + } + } + return NULL; +} + +/** + * Parses the given text as a number, optionally providing a currency amount. + * @param text the string to parse + * @param result output parameter for the numeric result. + * @param parsePosition input-output position; on input, the + * position within text to match; must have 0 <= pos.getIndex() < + * text.length(); on output, the position after the last matched + * character. If the parse fails, the position in unchanged upon + * output. + * @param currency if non-NULL, it should point to a 4-UChar buffer. + * In this case the text is parsed as a currency format, and the + * ISO 4217 code for the parsed currency is put into the buffer. + * Otherwise the text is parsed as a non-currency format. + */ +void DecimalFormat::parse(const UnicodeString& text, + Formattable& result, + ParsePosition& parsePosition, + UChar* currency) const { + int32_t startIdx, backup; + int32_t i = startIdx = backup = parsePosition.getIndex(); + + // clear any old contents in the result. In particular, clears any DigitList + // that it may be holding. + result.setLong(0); + if (currency != NULL) { + for (int32_t ci=0; ci<4; ci++) { + currency[ci] = 0; + } + } + + // Handle NaN as a special case: + int32_t formatWidth = fImpl->getOldFormatWidth(); + + // Skip padding characters, if around prefix + if (formatWidth > 0 && ( + fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix || + fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix)) { + i = skipPadding(text, i); + } + + if (isLenient()) { + // skip any leading whitespace + i = backup = skipUWhiteSpace(text, i); + } + + // If the text is composed of the representation of NaN, returns NaN.length + const UnicodeString *nan = &fImpl->getConstSymbol(DecimalFormatSymbols::kNaNSymbol); + int32_t nanLen = (text.compare(i, nan->length(), *nan) + ? 0 : nan->length()); + if (nanLen) { + i += nanLen; + if (formatWidth > 0 && (fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix || fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix)) { + i = skipPadding(text, i); + } + parsePosition.setIndex(i); + result.setDouble(uprv_getNaN()); + return; + } + + // NaN parse failed; start over + i = backup; + parsePosition.setIndex(i); + + // status is used to record whether a number is infinite. + UBool status[fgStatusLength]; + + DigitList *digits = result.getInternalDigitList(); // get one from the stack buffer + if (digits == NULL) { + return; // no way to report error from here. + } + + if (fImpl->fMonetary) { + if (!parseForCurrency(text, parsePosition, *digits, + status, currency)) { + return; + } + } else { + if (!subparse(text, + &fImpl->fAffixes.fNegativePrefix.getOtherVariant().toString(), + &fImpl->fAffixes.fNegativeSuffix.getOtherVariant().toString(), + &fImpl->fAffixes.fPositivePrefix.getOtherVariant().toString(), + &fImpl->fAffixes.fPositiveSuffix.getOtherVariant().toString(), + FALSE, UCURR_SYMBOL_NAME, + parsePosition, *digits, status, currency)) { + debug("!subparse(...) - rewind"); + parsePosition.setIndex(startIdx); + return; + } + } + + // Handle infinity + if (status[fgStatusInfinite]) { + double inf = uprv_getInfinity(); + result.setDouble(digits->isPositive() ? inf : -inf); + // TODO: set the dl to infinity, and let it fall into the code below. + } + + else { + + if (!fImpl->fMultiplier.isZero()) { + UErrorCode ec = U_ZERO_ERROR; + digits->div(fImpl->fMultiplier, ec); + } + + if (fImpl->fScale != 0) { + DigitList ten; + ten.set((int32_t)10); + if (fImpl->fScale > 0) { + for (int32_t i = fImpl->fScale; i > 0; i--) { + UErrorCode ec = U_ZERO_ERROR; + digits->div(ten,ec); + } + } else { + for (int32_t i = fImpl->fScale; i < 0; i++) { + UErrorCode ec = U_ZERO_ERROR; + digits->mult(ten,ec); + } + } + } + + // Negative zero special case: + // if parsing integerOnly, change to +0, which goes into an int32 in a Formattable. + // if not parsing integerOnly, leave as -0, which a double can represent. + if (digits->isZero() && !digits->isPositive() && isParseIntegerOnly()) { + digits->setPositive(TRUE); + } + result.adoptDigitList(digits); + } +} + + + +UBool +DecimalFormat::parseForCurrency(const UnicodeString& text, + ParsePosition& parsePosition, + DigitList& digits, + UBool* status, + UChar* currency) const { + UnicodeString positivePrefix; + UnicodeString positiveSuffix; + UnicodeString negativePrefix; + UnicodeString negativeSuffix; + fImpl->fPositivePrefixPattern.toString(positivePrefix); + fImpl->fPositiveSuffixPattern.toString(positiveSuffix); + fImpl->fNegativePrefixPattern.toString(negativePrefix); + fImpl->fNegativeSuffixPattern.toString(negativeSuffix); + + int origPos = parsePosition.getIndex(); + int maxPosIndex = origPos; + int maxErrorPos = -1; + // First, parse against current pattern. + // Since current pattern could be set by applyPattern(), + // it could be an arbitrary pattern, and it may not be the one + // defined in current locale. + UBool tmpStatus[fgStatusLength]; + ParsePosition tmpPos(origPos); + DigitList tmpDigitList; + UBool found; + if (fStyle == UNUM_CURRENCY_PLURAL) { + found = subparse(text, + &negativePrefix, &negativeSuffix, + &positivePrefix, &positiveSuffix, + TRUE, UCURR_LONG_NAME, + tmpPos, tmpDigitList, tmpStatus, currency); + } else { + found = subparse(text, + &negativePrefix, &negativeSuffix, + &positivePrefix, &positiveSuffix, + TRUE, UCURR_SYMBOL_NAME, + tmpPos, tmpDigitList, tmpStatus, currency); + } + if (found) { + if (tmpPos.getIndex() > maxPosIndex) { + maxPosIndex = tmpPos.getIndex(); + for (int32_t i = 0; i < fgStatusLength; ++i) { + status[i] = tmpStatus[i]; + } + digits = tmpDigitList; + } + } else { + maxErrorPos = tmpPos.getErrorIndex(); + } + // Then, parse against affix patterns. + // Those are currency patterns and currency plural patterns. + int32_t pos = UHASH_FIRST; + const UHashElement* element = NULL; + while ( (element = fAffixPatternsForCurrency->nextElement(pos)) != NULL ) { + const UHashTok valueTok = element->value; + const AffixPatternsForCurrency* affixPtn = (AffixPatternsForCurrency*)valueTok.pointer; + UBool tmpStatus[fgStatusLength]; + ParsePosition tmpPos(origPos); + DigitList tmpDigitList; + +#ifdef FMT_DEBUG + debug("trying affix for currency.."); + affixPtn->dump(); +#endif + + UBool result = subparse(text, + &affixPtn->negPrefixPatternForCurrency, + &affixPtn->negSuffixPatternForCurrency, + &affixPtn->posPrefixPatternForCurrency, + &affixPtn->posSuffixPatternForCurrency, + TRUE, affixPtn->patternType, + tmpPos, tmpDigitList, tmpStatus, currency); + if (result) { + found = true; + if (tmpPos.getIndex() > maxPosIndex) { + maxPosIndex = tmpPos.getIndex(); + for (int32_t i = 0; i < fgStatusLength; ++i) { + status[i] = tmpStatus[i]; + } + digits = tmpDigitList; + } + } else { + maxErrorPos = (tmpPos.getErrorIndex() > maxErrorPos) ? + tmpPos.getErrorIndex() : maxErrorPos; + } + } + // Finally, parse against simple affix to find the match. + // For example, in TestMonster suite, + // if the to-be-parsed text is "-\u00A40,00". + // complexAffixCompare will not find match, + // since there is no ISO code matches "\u00A4", + // and the parse stops at "\u00A4". + // We will just use simple affix comparison (look for exact match) + // to pass it. + // + // TODO: We should parse against simple affix first when + // output currency is not requested. After the complex currency + // parsing implementation was introduced, the default currency + // instance parsing slowed down because of the new code flow. + // I filed #10312 - Yoshito + UBool tmpStatus_2[fgStatusLength]; + ParsePosition tmpPos_2(origPos); + DigitList tmpDigitList_2; + + // Disable complex currency parsing and try it again. + UBool result = subparse(text, + &fImpl->fAffixes.fNegativePrefix.getOtherVariant().toString(), + &fImpl->fAffixes.fNegativeSuffix.getOtherVariant().toString(), + &fImpl->fAffixes.fPositivePrefix.getOtherVariant().toString(), + &fImpl->fAffixes.fPositiveSuffix.getOtherVariant().toString(), + FALSE /* disable complex currency parsing */, UCURR_SYMBOL_NAME, + tmpPos_2, tmpDigitList_2, tmpStatus_2, + currency); + if (result) { + if (tmpPos_2.getIndex() > maxPosIndex) { + maxPosIndex = tmpPos_2.getIndex(); + for (int32_t i = 0; i < fgStatusLength; ++i) { + status[i] = tmpStatus_2[i]; + } + digits = tmpDigitList_2; + } + found = true; + } else { + maxErrorPos = (tmpPos_2.getErrorIndex() > maxErrorPos) ? + tmpPos_2.getErrorIndex() : maxErrorPos; + } + + if (!found) { + //parsePosition.setIndex(origPos); + parsePosition.setErrorIndex(maxErrorPos); + } else { + parsePosition.setIndex(maxPosIndex); + parsePosition.setErrorIndex(-1); + } + return found; +} + + +/** + * Parse the given text into a number. The text is parsed beginning at + * parsePosition, until an unparseable character is seen. + * @param text the string to parse. + * @param negPrefix negative prefix. + * @param negSuffix negative suffix. + * @param posPrefix positive prefix. + * @param posSuffix positive suffix. + * @param complexCurrencyParsing whether it is complex currency parsing or not. + * @param type the currency type to parse against, LONG_NAME only or not. + * @param parsePosition The position at which to being parsing. Upon + * return, the first unparsed character. + * @param digits the DigitList to set to the parsed value. + * @param status output param containing boolean status flags indicating + * whether the value was infinite and whether it was positive. + * @param currency return value for parsed currency, for generic + * currency parsing mode, or NULL for normal parsing. In generic + * currency parsing mode, any currency is parsed, not just the + * currency that this formatter is set to. + */ +UBool DecimalFormat::subparse(const UnicodeString& text, + const UnicodeString* negPrefix, + const UnicodeString* negSuffix, + const UnicodeString* posPrefix, + const UnicodeString* posSuffix, + UBool complexCurrencyParsing, + int8_t type, + ParsePosition& parsePosition, + DigitList& digits, UBool* status, + UChar* currency) const +{ + // The parsing process builds up the number as char string, in the neutral format that + // will be acceptable to the decNumber library, then at the end passes that string + // off for conversion to a decNumber. + UErrorCode err = U_ZERO_ERROR; + CharString parsedNum; + digits.setToZero(); + + int32_t position = parsePosition.getIndex(); + int32_t oldStart = position; + int32_t textLength = text.length(); // One less pointer to follow + UBool strictParse = !isLenient(); + UChar32 zero = fImpl->getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0); + const UnicodeString *groupingString = &fImpl->getConstSymbol( + !fImpl->fMonetary ? + DecimalFormatSymbols::kGroupingSeparatorSymbol : DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol); + UChar32 groupingChar = groupingString->char32At(0); + int32_t groupingStringLength = groupingString->length(); + int32_t groupingCharLength = U16_LENGTH(groupingChar); + UBool groupingUsed = isGroupingUsed(); +#ifdef FMT_DEBUG + UChar dbgbuf[300]; + UnicodeString s(dbgbuf,0,300);; + s.append((UnicodeString)"PARSE \"").append(text.tempSubString(position)).append((UnicodeString)"\" " ); +#define DBGAPPD(x) if(x) { s.append(UnicodeString(#x "=")); if(x->isEmpty()) { s.append(UnicodeString("<empty>")); } else { s.append(*x); } s.append(UnicodeString(" ")); } else { s.append(UnicodeString(#x "=NULL ")); } + DBGAPPD(negPrefix); + DBGAPPD(negSuffix); + DBGAPPD(posPrefix); + DBGAPPD(posSuffix); + debugout(s); +#endif + + UBool fastParseOk = false; /* TRUE iff fast parse is OK */ + // UBool fastParseHadDecimal = FALSE; /* true if fast parse saw a decimal point. */ + if((fImpl->isParseFastpath()) && !fImpl->fMonetary && + text.length()>0 && + text.length()<32 && + (posPrefix==NULL||posPrefix->isEmpty()) && + (posSuffix==NULL||posSuffix->isEmpty()) && + // (negPrefix==NULL||negPrefix->isEmpty()) && + // (negSuffix==NULL||(negSuffix->isEmpty()) ) && + TRUE) { // optimized path + int j=position; + int l=text.length(); + int digitCount=0; + UChar32 ch = text.char32At(j); + const UnicodeString *decimalString = &fImpl->getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol); + UChar32 decimalChar = 0; + UBool intOnly = FALSE; + UChar32 lookForGroup = (groupingUsed&&intOnly&&strictParse)?groupingChar:0; + + int32_t decimalCount = decimalString->countChar32(0,3); + if(isParseIntegerOnly()) { + decimalChar = 0; // not allowed + intOnly = TRUE; // Don't look for decimals. + } else if(decimalCount==1) { + decimalChar = decimalString->char32At(0); // Look for this decimal + } else if(decimalCount==0) { + decimalChar=0; // NO decimal set + } else { + j=l+1;//Set counter to end of line, so that we break. Unknown decimal situation. + } + +#ifdef FMT_DEBUG + printf("Preparing to do fastpath parse: decimalChar=U+%04X, groupingChar=U+%04X, first ch=U+%04X intOnly=%c strictParse=%c\n", + decimalChar, groupingChar, ch, + (intOnly)?'y':'n', + (strictParse)?'y':'n'); +#endif + if(ch==0x002D) { // '-' + j=l+1;//=break - negative number. + + /* + parsedNum.append('-',err); + j+=U16_LENGTH(ch); + if(j<l) ch = text.char32At(j); + */ + } else { + parsedNum.append('+',err); + } + while(j<l) { + int32_t digit = ch - zero; + if(digit >=0 && digit <= 9) { + parsedNum.append((char)(digit + '0'), err); + if((digitCount>0) || digit!=0 || j==(l-1)) { + digitCount++; + } + } else if(ch == 0) { // break out + digitCount=-1; + break; + } else if(ch == decimalChar) { + parsedNum.append((char)('.'), err); + decimalChar=0; // no more decimals. + // fastParseHadDecimal=TRUE; + } else if(ch == lookForGroup) { + // ignore grouping char. No decimals, so it has to be an ignorable grouping sep + } else if(intOnly && (lookForGroup!=0) && !u_isdigit(ch)) { + // parsing integer only and can fall through + } else { + digitCount=-1; // fail - fall through to slow parse + break; + } + j+=U16_LENGTH(ch); + ch = text.char32At(j); // for next + } + if( + ((j==l)||intOnly) // end OR only parsing integer + && (digitCount>0)) { // and have at least one digit + fastParseOk=true; // Fast parse OK! + +#ifdef SKIP_OPT + debug("SKIP_OPT"); + /* for testing, try it the slow way. also */ + fastParseOk=false; + parsedNum.clear(); +#else + parsePosition.setIndex(position=j); + status[fgStatusInfinite]=false; +#endif + } else { + // was not OK. reset, retry +#ifdef FMT_DEBUG + printf("Fall through: j=%d, l=%d, digitCount=%d\n", j, l, digitCount); +#endif + parsedNum.clear(); + } + } else { +#ifdef FMT_DEBUG + printf("Could not fastpath parse. "); + printf("text.length()=%d ", text.length()); + printf("posPrefix=%p posSuffix=%p ", posPrefix, posSuffix); + + printf("\n"); +#endif + } + + UnicodeString formatPattern; + toPattern(formatPattern); + + if(!fastParseOk +#if UCONFIG_HAVE_PARSEALLINPUT + && fParseAllInput!=UNUM_YES +#endif + ) + { + int32_t formatWidth = fImpl->getOldFormatWidth(); + // Match padding before prefix + if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) { + position = skipPadding(text, position); + } + + // Match positive and negative prefixes; prefer longest match. + int32_t posMatch = compareAffix(text, position, FALSE, TRUE, posPrefix, complexCurrencyParsing, type, currency); + int32_t negMatch = compareAffix(text, position, TRUE, TRUE, negPrefix, complexCurrencyParsing, type, currency); + if (posMatch >= 0 && negMatch >= 0) { + if (posMatch > negMatch) { + negMatch = -1; + } else if (negMatch > posMatch) { + posMatch = -1; + } + } + if (posMatch >= 0) { + position += posMatch; + parsedNum.append('+', err); + } else if (negMatch >= 0) { + position += negMatch; + parsedNum.append('-', err); + } else if (strictParse){ + parsePosition.setErrorIndex(position); + return FALSE; + } else { + // Temporary set positive. This might be changed after checking suffix + parsedNum.append('+', err); + } + + // Match padding before prefix + if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) { + position = skipPadding(text, position); + } + + if (! strictParse) { + position = skipUWhiteSpace(text, position); + } + + // process digits or Inf, find decimal position + const UnicodeString *inf = &fImpl->getConstSymbol(DecimalFormatSymbols::kInfinitySymbol); + int32_t infLen = (text.compare(position, inf->length(), *inf) + ? 0 : inf->length()); + position += infLen; // infLen is non-zero when it does equal to infinity + status[fgStatusInfinite] = infLen != 0; + + if (infLen != 0) { + parsedNum.append("Infinity", err); + } else { + // We now have a string of digits, possibly with grouping symbols, + // and decimal points. We want to process these into a DigitList. + // We don't want to put a bunch of leading zeros into the DigitList + // though, so we keep track of the location of the decimal point, + // put only significant digits into the DigitList, and adjust the + // exponent as needed. + + + UBool strictFail = FALSE; // did we exit with a strict parse failure? + int32_t lastGroup = -1; // where did we last see a grouping separator? + int32_t digitStart = position; + int32_t gs2 = fImpl->fEffGrouping.fGrouping2 == 0 ? fImpl->fEffGrouping.fGrouping : fImpl->fEffGrouping.fGrouping2; + + const UnicodeString *decimalString; + if (fImpl->fMonetary) { + decimalString = &fImpl->getConstSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol); + } else { + decimalString = &fImpl->getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol); + } + UChar32 decimalChar = decimalString->char32At(0); + int32_t decimalStringLength = decimalString->length(); + int32_t decimalCharLength = U16_LENGTH(decimalChar); + + UBool sawDecimal = FALSE; + UChar32 sawDecimalChar = 0xFFFF; + UBool sawGrouping = FALSE; + UChar32 sawGroupingChar = 0xFFFF; + UBool sawDigit = FALSE; + int32_t backup = -1; + int32_t digit; + + // equivalent grouping and decimal support + const UnicodeSet *decimalSet = NULL; + const UnicodeSet *groupingSet = NULL; + + if (decimalCharLength == decimalStringLength) { + decimalSet = DecimalFormatStaticSets::getSimilarDecimals(decimalChar, strictParse); + } + + if (groupingCharLength == groupingStringLength) { + if (strictParse) { + groupingSet = fStaticSets->fStrictDefaultGroupingSeparators; + } else { + groupingSet = fStaticSets->fDefaultGroupingSeparators; + } + } + + // We need to test groupingChar and decimalChar separately from groupingSet and decimalSet, if the sets are even initialized. + // If sawDecimal is TRUE, only consider sawDecimalChar and NOT decimalSet + // If a character matches decimalSet, don't consider it to be a member of the groupingSet. + + // We have to track digitCount ourselves, because digits.fCount will + // pin when the maximum allowable digits is reached. + int32_t digitCount = 0; + int32_t integerDigitCount = 0; + + for (; position < textLength; ) + { + UChar32 ch = text.char32At(position); + + /* We recognize all digit ranges, not only the Latin digit range + * '0'..'9'. We do so by using the Character.digit() method, + * which converts a valid Unicode digit to the range 0..9. + * + * The character 'ch' may be a digit. If so, place its value + * from 0 to 9 in 'digit'. First try using the locale digit, + * which may or MAY NOT be a standard Unicode digit range. If + * this fails, try using the standard Unicode digit ranges by + * calling Character.digit(). If this also fails, digit will + * have a value outside the range 0..9. + */ + digit = ch - zero; + if (digit < 0 || digit > 9) + { + digit = u_charDigitValue(ch); + } + + // As a last resort, look through the localized digits if the zero digit + // is not a "standard" Unicode digit. + if ( (digit < 0 || digit > 9) && u_charDigitValue(zero) != 0) { + digit = 0; + if ( fImpl->getConstSymbol((DecimalFormatSymbols::ENumberFormatSymbol)(DecimalFormatSymbols::kZeroDigitSymbol)).char32At(0) == ch ) { + break; + } + for (digit = 1 ; digit < 10 ; digit++ ) { + if ( fImpl->getConstSymbol((DecimalFormatSymbols::ENumberFormatSymbol)(DecimalFormatSymbols::kOneDigitSymbol+digit-1)).char32At(0) == ch ) { + break; + } + } + } + + if (digit >= 0 && digit <= 9) + { + if (strictParse && backup != -1) { + // comma followed by digit, so group before comma is a + // secondary group. If there was a group separator + // before that, the group must == the secondary group + // length, else it can be <= the the secondary group + // length. + if ((lastGroup != -1 && backup - lastGroup - 1 != gs2) || + (lastGroup == -1 && position - digitStart - 1 > gs2)) { + strictFail = TRUE; + break; + } + + lastGroup = backup; + } + + // Cancel out backup setting (see grouping handler below) + backup = -1; + sawDigit = TRUE; + + // Note: this will append leading zeros + parsedNum.append((char)(digit + '0'), err); + + // count any digit that's not a leading zero + if (digit > 0 || digitCount > 0 || sawDecimal) { + digitCount += 1; + + // count any integer digit that's not a leading zero + if (! sawDecimal) { + integerDigitCount += 1; + } + } + + position += U16_LENGTH(ch); + } + else if (groupingStringLength > 0 && + matchGrouping(groupingChar, sawGrouping, sawGroupingChar, groupingSet, + decimalChar, decimalSet, + ch) && groupingUsed) + { + if (sawDecimal) { + break; + } + + if (strictParse) { + if ((!sawDigit || backup != -1)) { + // leading group, or two group separators in a row + strictFail = TRUE; + break; + } + } + + // Ignore grouping characters, if we are using them, but require + // that they be followed by a digit. Otherwise we backup and + // reprocess them. + backup = position; + position += groupingStringLength; + sawGrouping=TRUE; + // Once we see a grouping character, we only accept that grouping character from then on. + sawGroupingChar=ch; + } + else if (matchDecimal(decimalChar,sawDecimal,sawDecimalChar, decimalSet, ch)) + { + if (strictParse) { + if (backup != -1 || + (lastGroup != -1 && position - lastGroup != fImpl->fEffGrouping.fGrouping + 1)) { + strictFail = TRUE; + break; + } + } + + // If we're only parsing integers, or if we ALREADY saw the + // decimal, then don't parse this one. + if (isParseIntegerOnly() || sawDecimal) { + break; + } + + parsedNum.append('.', err); + position += decimalStringLength; + sawDecimal = TRUE; + // Once we see a decimal character, we only accept that decimal character from then on. + sawDecimalChar=ch; + // decimalSet is considered to consist of (ch,ch) + } + else { + + if(!fBoolFlags.contains(UNUM_PARSE_NO_EXPONENT) || // don't parse if this is set unless.. + isScientificNotation()) { // .. it's an exponent format - ignore setting and parse anyways + const UnicodeString *tmp; + tmp = &fImpl->getConstSymbol(DecimalFormatSymbols::kExponentialSymbol); + // TODO: CASE + if (!text.caseCompare(position, tmp->length(), *tmp, U_FOLD_CASE_DEFAULT)) // error code is set below if !sawDigit + { + // Parse sign, if present + int32_t pos = position + tmp->length(); + char exponentSign = '+'; + + if (pos < textLength) + { + tmp = &fImpl->getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol); + if (!text.compare(pos, tmp->length(), *tmp)) + { + pos += tmp->length(); + } + else { + tmp = &fImpl->getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol); + if (!text.compare(pos, tmp->length(), *tmp)) + { + exponentSign = '-'; + pos += tmp->length(); + } + } + } + + UBool sawExponentDigit = FALSE; + while (pos < textLength) { + ch = text[(int32_t)pos]; + digit = ch - zero; + + if (digit < 0 || digit > 9) { + digit = u_charDigitValue(ch); + } + if (0 <= digit && digit <= 9) { + if (!sawExponentDigit) { + parsedNum.append('E', err); + parsedNum.append(exponentSign, err); + sawExponentDigit = TRUE; + } + ++pos; + parsedNum.append((char)(digit + '0'), err); + } else { + break; + } + } + + if (sawExponentDigit) { + position = pos; // Advance past the exponent + } + + break; // Whether we fail or succeed, we exit this loop + } else { + break; + } + } else { // not parsing exponent + break; + } + } + } + + // if we didn't see a decimal and it is required, check to see if the pattern had one + if(!sawDecimal && isDecimalPatternMatchRequired()) + { + if(formatPattern.indexOf(DecimalFormatSymbols::kDecimalSeparatorSymbol) != 0) + { + parsePosition.setIndex(oldStart); + parsePosition.setErrorIndex(position); + debug("decimal point match required fail!"); + return FALSE; + } + } + + if (backup != -1) + { + position = backup; + } + + if (strictParse && !sawDecimal) { + if (lastGroup != -1 && position - lastGroup != fImpl->fEffGrouping.fGrouping + 1) { + strictFail = TRUE; + } + } + + if (strictFail) { + // only set with strictParse and a grouping separator error + + parsePosition.setIndex(oldStart); + parsePosition.setErrorIndex(position); + debug("strictFail!"); + return FALSE; + } + + // If there was no decimal point we have an integer + + // If none of the text string was recognized. For example, parse + // "x" with pattern "#0.00" (return index and error index both 0) + // parse "$" with pattern "$#0.00". (return index 0 and error index + // 1). + if (!sawDigit && digitCount == 0) { +#ifdef FMT_DEBUG + debug("none of text rec"); + printf("position=%d\n",position); +#endif + parsePosition.setIndex(oldStart); + parsePosition.setErrorIndex(oldStart); + return FALSE; + } + } + + // Match padding before suffix + if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) { + position = skipPadding(text, position); + } + + int32_t posSuffixMatch = -1, negSuffixMatch = -1; + + // Match positive and negative suffixes; prefer longest match. + if (posMatch >= 0 || (!strictParse && negMatch < 0)) { + posSuffixMatch = compareAffix(text, position, FALSE, FALSE, posSuffix, complexCurrencyParsing, type, currency); + } + if (negMatch >= 0) { + negSuffixMatch = compareAffix(text, position, TRUE, FALSE, negSuffix, complexCurrencyParsing, type, currency); + } + if (posSuffixMatch >= 0 && negSuffixMatch >= 0) { + if (posSuffixMatch > negSuffixMatch) { + negSuffixMatch = -1; + } else if (negSuffixMatch > posSuffixMatch) { + posSuffixMatch = -1; + } + } + + // Fail if neither or both + if (strictParse && ((posSuffixMatch >= 0) == (negSuffixMatch >= 0))) { + parsePosition.setErrorIndex(position); + debug("neither or both"); + return FALSE; + } + + position += (posSuffixMatch >= 0 ? posSuffixMatch : (negSuffixMatch >= 0 ? negSuffixMatch : 0)); + + // Match padding before suffix + if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) { + position = skipPadding(text, position); + } + + parsePosition.setIndex(position); + + parsedNum.data()[0] = (posSuffixMatch >= 0 || (!strictParse && negMatch < 0 && negSuffixMatch < 0)) ? '+' : '-'; +#ifdef FMT_DEBUG +printf("PP -> %d, SLOW = [%s]! pp=%d, os=%d, err=%s\n", position, parsedNum.data(), parsePosition.getIndex(),oldStart,u_errorName(err)); +#endif + } /* end SLOW parse */ + if(parsePosition.getIndex() == oldStart) + { +#ifdef FMT_DEBUG + printf(" PP didnt move, err\n"); +#endif + parsePosition.setErrorIndex(position); + return FALSE; + } +#if UCONFIG_HAVE_PARSEALLINPUT + else if (fParseAllInput==UNUM_YES&&parsePosition.getIndex()!=textLength) + { +#ifdef FMT_DEBUG + printf(" PP didnt consume all (UNUM_YES), err\n"); +#endif + parsePosition.setErrorIndex(position); + return FALSE; + } +#endif + // uint32_t bits = (fastParseOk?kFastpathOk:0) | + // (fastParseHadDecimal?0:kNoDecimal); + //printf("FPOK=%d, FPHD=%d, bits=%08X\n", fastParseOk, fastParseHadDecimal, bits); + digits.set(parsedNum.toStringPiece(), + err, + 0//bits + ); + + if (U_FAILURE(err)) { +#ifdef FMT_DEBUG + printf(" err setting %s\n", u_errorName(err)); +#endif + parsePosition.setErrorIndex(position); + return FALSE; + } + + // check if we missed a required decimal point + if(fastParseOk && isDecimalPatternMatchRequired()) + { + if(formatPattern.indexOf(DecimalFormatSymbols::kDecimalSeparatorSymbol) != 0) + { + parsePosition.setIndex(oldStart); + parsePosition.setErrorIndex(position); + debug("decimal point match required fail!"); + return FALSE; + } + } + + + return TRUE; +} + +/** + * Starting at position, advance past a run of pad characters, if any. + * Return the index of the first character after position that is not a pad + * character. Result is >= position. + */ +int32_t DecimalFormat::skipPadding(const UnicodeString& text, int32_t position) const { + int32_t padLen = U16_LENGTH(fImpl->fAffixes.fPadChar); + while (position < text.length() && + text.char32At(position) == fImpl->fAffixes.fPadChar) { + position += padLen; + } + return position; +} + +/** + * Return the length matched by the given affix, or -1 if none. + * Runs of white space in the affix, match runs of white space in + * the input. Pattern white space and input white space are + * determined differently; see code. + * @param text input text + * @param pos offset into input at which to begin matching + * @param isNegative + * @param isPrefix + * @param affixPat affix pattern used for currency affix comparison. + * @param complexCurrencyParsing whether it is currency parsing or not + * @param type the currency type to parse against, LONG_NAME only or not. + * @param currency return value for parsed currency, for generic + * currency parsing mode, or null for normal parsing. In generic + * currency parsing mode, any currency is parsed, not just the + * currency that this formatter is set to. + * @return length of input that matches, or -1 if match failure + */ +int32_t DecimalFormat::compareAffix(const UnicodeString& text, + int32_t pos, + UBool isNegative, + UBool isPrefix, + const UnicodeString* affixPat, + UBool complexCurrencyParsing, + int8_t type, + UChar* currency) const +{ + const UnicodeString *patternToCompare; + if (currency != NULL || + (fImpl->fMonetary && complexCurrencyParsing)) { + + if (affixPat != NULL) { + return compareComplexAffix(*affixPat, text, pos, type, currency); + } + } + + if (isNegative) { + if (isPrefix) { + patternToCompare = &fImpl->fAffixes.fNegativePrefix.getOtherVariant().toString(); + } + else { + patternToCompare = &fImpl->fAffixes.fNegativeSuffix.getOtherVariant().toString(); + } + } + else { + if (isPrefix) { + patternToCompare = &fImpl->fAffixes.fPositivePrefix.getOtherVariant().toString(); + } + else { + patternToCompare = &fImpl->fAffixes.fPositiveSuffix.getOtherVariant().toString(); + } + } + return compareSimpleAffix(*patternToCompare, text, pos, isLenient()); +} + +UBool DecimalFormat::equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const { + if (lhs == rhs) { + return TRUE; + } + U_ASSERT(fStaticSets != NULL); // should already be loaded + const UnicodeSet *minusSigns = fStaticSets->fMinusSigns; + const UnicodeSet *plusSigns = fStaticSets->fPlusSigns; + return (minusSigns->contains(lhs) && minusSigns->contains(rhs)) || + (plusSigns->contains(lhs) && plusSigns->contains(rhs)); +} + +// check for LRM 0x200E, RLM 0x200F, ALM 0x061C +#define IS_BIDI_MARK(c) (c==0x200E || c==0x200F || c==0x061C) + +#define TRIM_BUFLEN 32 +UnicodeString& DecimalFormat::trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix) { + UChar trimBuf[TRIM_BUFLEN]; + int32_t affixLen = affix.length(); + int32_t affixPos, trimLen = 0; + + for (affixPos = 0; affixPos < affixLen; affixPos++) { + UChar c = affix.charAt(affixPos); + if (!IS_BIDI_MARK(c)) { + if (trimLen < TRIM_BUFLEN) { + trimBuf[trimLen++] = c; + } else { + trimLen = 0; + break; + } + } + } + return (trimLen > 0)? trimmedAffix.setTo(trimBuf, trimLen): trimmedAffix.setTo(affix); +} + +/** + * Return the length matched by the given affix, or -1 if none. + * Runs of white space in the affix, match runs of white space in + * the input. Pattern white space and input white space are + * determined differently; see code. + * @param affix pattern string, taken as a literal + * @param input input text + * @param pos offset into input at which to begin matching + * @return length of input that matches, or -1 if match failure + */ +int32_t DecimalFormat::compareSimpleAffix(const UnicodeString& affix, + const UnicodeString& input, + int32_t pos, + UBool lenient) const { + int32_t start = pos; + UnicodeString trimmedAffix; + // For more efficiency we should keep lazily-created trimmed affixes around in + // instance variables instead of trimming each time they are used (the next step) + trimMarksFromAffix(affix, trimmedAffix); + UChar32 affixChar = trimmedAffix.char32At(0); + int32_t affixLength = trimmedAffix.length(); + int32_t inputLength = input.length(); + int32_t affixCharLength = U16_LENGTH(affixChar); + UnicodeSet *affixSet; + UErrorCode status = U_ZERO_ERROR; + + U_ASSERT(fStaticSets != NULL); // should already be loaded + + if (U_FAILURE(status)) { + return -1; + } + if (!lenient) { + affixSet = fStaticSets->fStrictDashEquivalents; + + // If the trimmedAffix is exactly one character long and that character + // is in the dash set and the very next input character is also + // in the dash set, return a match. + if (affixCharLength == affixLength && affixSet->contains(affixChar)) { + UChar32 ic = input.char32At(pos); + if (affixSet->contains(ic)) { + pos += U16_LENGTH(ic); + pos = skipBidiMarks(input, pos); // skip any trailing bidi marks + return pos - start; + } + } + + for (int32_t i = 0; i < affixLength; ) { + UChar32 c = trimmedAffix.char32At(i); + int32_t len = U16_LENGTH(c); + if (PatternProps::isWhiteSpace(c)) { + // We may have a pattern like: \u200F \u0020 + // and input text like: \u200F \u0020 + // Note that U+200F and U+0020 are Pattern_White_Space but only + // U+0020 is UWhiteSpace. So we have to first do a direct + // match of the run of Pattern_White_Space in the pattern, + // then match any extra characters. + UBool literalMatch = FALSE; + while (pos < inputLength) { + UChar32 ic = input.char32At(pos); + if (ic == c) { + literalMatch = TRUE; + i += len; + pos += len; + if (i == affixLength) { + break; + } + c = trimmedAffix.char32At(i); + len = U16_LENGTH(c); + if (!PatternProps::isWhiteSpace(c)) { + break; + } + } else if (IS_BIDI_MARK(ic)) { + pos ++; // just skip over this input text + } else { + break; + } + } + + // Advance over run in pattern + i = skipPatternWhiteSpace(trimmedAffix, i); + + // Advance over run in input text + // Must see at least one white space char in input, + // unless we've already matched some characters literally. + int32_t s = pos; + pos = skipUWhiteSpace(input, pos); + if (pos == s && !literalMatch) { + return -1; + } + + // If we skip UWhiteSpace in the input text, we need to skip it in the pattern. + // Otherwise, the previous lines may have skipped over text (such as U+00A0) that + // is also in the trimmedAffix. + i = skipUWhiteSpace(trimmedAffix, i); + } else { + UBool match = FALSE; + while (pos < inputLength) { + UChar32 ic = input.char32At(pos); + if (!match && ic == c) { + i += len; + pos += len; + match = TRUE; + } else if (IS_BIDI_MARK(ic)) { + pos++; // just skip over this input text + } else { + break; + } + } + if (!match) { + return -1; + } + } + } + } else { + UBool match = FALSE; + + affixSet = fStaticSets->fDashEquivalents; + + if (affixCharLength == affixLength && affixSet->contains(affixChar)) { + pos = skipUWhiteSpaceAndMarks(input, pos); + UChar32 ic = input.char32At(pos); + + if (affixSet->contains(ic)) { + pos += U16_LENGTH(ic); + pos = skipBidiMarks(input, pos); + return pos - start; + } + } + + for (int32_t i = 0; i < affixLength; ) + { + //i = skipRuleWhiteSpace(trimmedAffix, i); + i = skipUWhiteSpace(trimmedAffix, i); + pos = skipUWhiteSpaceAndMarks(input, pos); + + if (i >= affixLength || pos >= inputLength) { + break; + } + + UChar32 c = trimmedAffix.char32At(i); + UChar32 ic = input.char32At(pos); + + if (!equalWithSignCompatibility(ic, c)) { + return -1; + } + + match = TRUE; + i += U16_LENGTH(c); + pos += U16_LENGTH(ic); + pos = skipBidiMarks(input, pos); + } + + if (affixLength > 0 && ! match) { + return -1; + } + } + return pos - start; +} + +/** + * Skip over a run of zero or more Pattern_White_Space characters at + * pos in text. + */ +int32_t DecimalFormat::skipPatternWhiteSpace(const UnicodeString& text, int32_t pos) { + const UChar* s = text.getBuffer(); + return (int32_t)(PatternProps::skipWhiteSpace(s + pos, text.length() - pos) - s); +} + +/** + * Skip over a run of zero or more isUWhiteSpace() characters at pos + * in text. + */ +int32_t DecimalFormat::skipUWhiteSpace(const UnicodeString& text, int32_t pos) { + while (pos < text.length()) { + UChar32 c = text.char32At(pos); + if (!u_isUWhiteSpace(c)) { + break; + } + pos += U16_LENGTH(c); + } + return pos; +} + +/** + * Skip over a run of zero or more isUWhiteSpace() characters or bidi marks at pos + * in text. + */ +int32_t DecimalFormat::skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos) { + while (pos < text.length()) { + UChar32 c = text.char32At(pos); + if (!u_isUWhiteSpace(c) && !IS_BIDI_MARK(c)) { // u_isUWhiteSpace doesn't include LRM,RLM,ALM + break; + } + pos += U16_LENGTH(c); + } + return pos; +} + +/** + * Skip over a run of zero or more bidi marks at pos in text. + */ +int32_t DecimalFormat::skipBidiMarks(const UnicodeString& text, int32_t pos) { + while (pos < text.length()) { + UChar c = text.charAt(pos); + if (!IS_BIDI_MARK(c)) { + break; + } + pos++; + } + return pos; +} + +/** + * Return the length matched by the given affix, or -1 if none. + * @param affixPat pattern string + * @param input input text + * @param pos offset into input at which to begin matching + * @param type the currency type to parse against, LONG_NAME only or not. + * @param currency return value for parsed currency, for generic + * currency parsing mode, or null for normal parsing. In generic + * currency parsing mode, any currency is parsed, not just the + * currency that this formatter is set to. + * @return length of input that matches, or -1 if match failure + */ +int32_t DecimalFormat::compareComplexAffix(const UnicodeString& affixPat, + const UnicodeString& text, + int32_t pos, + int8_t type, + UChar* currency) const +{ + int32_t start = pos; + U_ASSERT(currency != NULL || fImpl->fMonetary); + + for (int32_t i=0; + i<affixPat.length() && pos >= 0; ) { + UChar32 c = affixPat.char32At(i); + i += U16_LENGTH(c); + + if (c == kQuote) { + U_ASSERT(i <= affixPat.length()); + c = affixPat.char32At(i); + i += U16_LENGTH(c); + + const UnicodeString* affix = NULL; + + switch (c) { + case kCurrencySign: { + // since the currency names in choice format is saved + // the same way as other currency names, + // do not need to do currency choice parsing here. + // the general currency parsing parse against all names, + // including names in choice format. + UBool intl = i<affixPat.length() && + affixPat.char32At(i) == kCurrencySign; + if (intl) { + ++i; + } + UBool plural = i<affixPat.length() && + affixPat.char32At(i) == kCurrencySign; + if (plural) { + ++i; + intl = FALSE; + } + // Parse generic currency -- anything for which we + // have a display name, or any 3-letter ISO code. + // Try to parse display name for our locale; first + // determine our locale. + const char* loc = fCurrencyPluralInfo->getLocale().getName(); + ParsePosition ppos(pos); + UChar curr[4]; + UErrorCode ec = U_ZERO_ERROR; + // Delegate parse of display name => ISO code to Currency + uprv_parseCurrency(loc, text, ppos, type, curr, ec); + + // If parse succeeds, populate currency[0] + if (U_SUCCESS(ec) && ppos.getIndex() != pos) { + if (currency) { + u_strcpy(currency, curr); + } else { + // The formatter is currency-style but the client has not requested + // the value of the parsed currency. In this case, if that value does + // not match the formatter's current value, then the parse fails. + UChar effectiveCurr[4]; + getEffectiveCurrency(effectiveCurr, ec); + if ( U_FAILURE(ec) || u_strncmp(curr,effectiveCurr,4) != 0 ) { + pos = -1; + continue; + } + } + pos = ppos.getIndex(); + } else if (!isLenient()){ + pos = -1; + } + continue; + } + case kPatternPercent: + affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kPercentSymbol); + break; + case kPatternPerMill: + affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kPerMillSymbol); + break; + case kPatternPlus: + affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol); + break; + case kPatternMinus: + affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol); + break; + default: + // fall through to affix!=0 test, which will fail + break; + } + + if (affix != NULL) { + pos = match(text, pos, *affix); + continue; + } + } + + pos = match(text, pos, c); + if (PatternProps::isWhiteSpace(c)) { + i = skipPatternWhiteSpace(affixPat, i); + } + } + return pos - start; +} + +/** + * Match a single character at text[pos] and return the index of the + * next character upon success. Return -1 on failure. If + * ch is a Pattern_White_Space then match a run of white space in text. + */ +int32_t DecimalFormat::match(const UnicodeString& text, int32_t pos, UChar32 ch) { + if (PatternProps::isWhiteSpace(ch)) { + // Advance over run of white space in input text + // Must see at least one white space char in input + int32_t s = pos; + pos = skipPatternWhiteSpace(text, pos); + if (pos == s) { + return -1; + } + return pos; + } + return (pos >= 0 && text.char32At(pos) == ch) ? + (pos + U16_LENGTH(ch)) : -1; +} + +/** + * Match a string at text[pos] and return the index of the next + * character upon success. Return -1 on failure. Match a run of + * white space in str with a run of white space in text. + */ +int32_t DecimalFormat::match(const UnicodeString& text, int32_t pos, const UnicodeString& str) { + for (int32_t i=0; i<str.length() && pos >= 0; ) { + UChar32 ch = str.char32At(i); + i += U16_LENGTH(ch); + if (PatternProps::isWhiteSpace(ch)) { + i = skipPatternWhiteSpace(str, i); + } + pos = match(text, pos, ch); + } + return pos; +} + +UBool DecimalFormat::matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol, + UnicodeSet *sset, UChar32 schar) +{ + if (sset != NULL) { + return sset->contains(schar); + } + + return text.compare(position, length, symbol) == 0; +} + +UBool DecimalFormat::matchDecimal(UChar32 symbolChar, + UBool sawDecimal, UChar32 sawDecimalChar, + const UnicodeSet *sset, UChar32 schar) { + if(sawDecimal) { + return schar==sawDecimalChar; + } else if(schar==symbolChar) { + return TRUE; + } else if(sset!=NULL) { + return sset->contains(schar); + } else { + return FALSE; + } +} + +UBool DecimalFormat::matchGrouping(UChar32 groupingChar, + UBool sawGrouping, UChar32 sawGroupingChar, + const UnicodeSet *sset, + UChar32 /*decimalChar*/, const UnicodeSet *decimalSet, + UChar32 schar) { + if(sawGrouping) { + return schar==sawGroupingChar; // previously found + } else if(schar==groupingChar) { + return TRUE; // char from symbols + } else if(sset!=NULL) { + return sset->contains(schar) && // in groupingSet but... + ((decimalSet==NULL) || !decimalSet->contains(schar)); // Exclude decimalSet from groupingSet + } else { + return FALSE; + } +} + + + +//------------------------------------------------------------------------------ +// Gets the pointer to the localized decimal format symbols + +const DecimalFormatSymbols* +DecimalFormat::getDecimalFormatSymbols() const +{ + return &fImpl->getDecimalFormatSymbols(); +} + +//------------------------------------------------------------------------------ +// De-owning the current localized symbols and adopt the new symbols. + +void +DecimalFormat::adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt) +{ + if (symbolsToAdopt == NULL) { + return; // do not allow caller to set fSymbols to NULL + } + fImpl->adoptDecimalFormatSymbols(symbolsToAdopt); +} +//------------------------------------------------------------------------------ +// Setting the symbols is equlivalent to adopting a newly created localized +// symbols. + +void +DecimalFormat::setDecimalFormatSymbols(const DecimalFormatSymbols& symbols) +{ + adoptDecimalFormatSymbols(new DecimalFormatSymbols(symbols)); +} + + +const CurrencyPluralInfo* +DecimalFormat::getCurrencyPluralInfo(void) const +{ + return fCurrencyPluralInfo; +} + + +void +DecimalFormat::adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt) +{ + if (toAdopt != NULL) { + delete fCurrencyPluralInfo; + fCurrencyPluralInfo = toAdopt; + // re-set currency affix patterns and currency affixes. + if (fImpl->fMonetary) { + UErrorCode status = U_ZERO_ERROR; + if (fAffixPatternsForCurrency) { + deleteHashForAffixPattern(); + } + setupCurrencyAffixPatterns(status); + } + } +} + +void +DecimalFormat::setCurrencyPluralInfo(const CurrencyPluralInfo& info) +{ + adoptCurrencyPluralInfo(info.clone()); +} + + +//------------------------------------------------------------------------------ +// Gets the positive prefix of the number pattern. + +UnicodeString& +DecimalFormat::getPositivePrefix(UnicodeString& result) const +{ + return fImpl->getPositivePrefix(result); +} + +//------------------------------------------------------------------------------ +// Sets the positive prefix of the number pattern. + +void +DecimalFormat::setPositivePrefix(const UnicodeString& newValue) +{ + fImpl->setPositivePrefix(newValue); +} + +//------------------------------------------------------------------------------ +// Gets the negative prefix of the number pattern. + +UnicodeString& +DecimalFormat::getNegativePrefix(UnicodeString& result) const +{ + return fImpl->getNegativePrefix(result); +} + +//------------------------------------------------------------------------------ +// Gets the negative prefix of the number pattern. + +void +DecimalFormat::setNegativePrefix(const UnicodeString& newValue) +{ + fImpl->setNegativePrefix(newValue); +} + +//------------------------------------------------------------------------------ +// Gets the positive suffix of the number pattern. + +UnicodeString& +DecimalFormat::getPositiveSuffix(UnicodeString& result) const +{ + return fImpl->getPositiveSuffix(result); +} + +//------------------------------------------------------------------------------ +// Sets the positive suffix of the number pattern. + +void +DecimalFormat::setPositiveSuffix(const UnicodeString& newValue) +{ + fImpl->setPositiveSuffix(newValue); +} + +//------------------------------------------------------------------------------ +// Gets the negative suffix of the number pattern. + +UnicodeString& +DecimalFormat::getNegativeSuffix(UnicodeString& result) const +{ + return fImpl->getNegativeSuffix(result); +} + +//------------------------------------------------------------------------------ +// Sets the negative suffix of the number pattern. + +void +DecimalFormat::setNegativeSuffix(const UnicodeString& newValue) +{ + fImpl->setNegativeSuffix(newValue); +} + +//------------------------------------------------------------------------------ +// Gets the multiplier of the number pattern. +// Multipliers are stored as decimal numbers (DigitLists) because that +// is the most convenient for muliplying or dividing the numbers to be formatted. +// A NULL multiplier implies one, and the scaling operations are skipped. + +int32_t +DecimalFormat::getMultiplier() const +{ + return fImpl->getMultiplier(); +} + +//------------------------------------------------------------------------------ +// Sets the multiplier of the number pattern. +void +DecimalFormat::setMultiplier(int32_t newValue) +{ + fImpl->setMultiplier(newValue); +} + +/** + * Get the rounding increment. + * @return A positive rounding increment, or 0.0 if rounding + * is not in effect. + * @see #setRoundingIncrement + * @see #getRoundingMode + * @see #setRoundingMode + */ +double DecimalFormat::getRoundingIncrement() const { + return fImpl->getRoundingIncrement(); +} + +/** + * Set the rounding increment. This method also controls whether + * rounding is enabled. + * @param newValue A positive rounding increment, or 0.0 to disable rounding. + * Negative increments are equivalent to 0.0. + * @see #getRoundingIncrement + * @see #getRoundingMode + * @see #setRoundingMode + */ +void DecimalFormat::setRoundingIncrement(double newValue) { + fImpl->setRoundingIncrement(newValue); +} + +/** + * Get the rounding mode. + * @return A rounding mode + * @see #setRoundingIncrement + * @see #getRoundingIncrement + * @see #setRoundingMode + */ +DecimalFormat::ERoundingMode DecimalFormat::getRoundingMode() const { + return fImpl->getRoundingMode(); +} + +/** + * Set the rounding mode. This has no effect unless the rounding + * increment is greater than zero. + * @param roundingMode A rounding mode + * @see #setRoundingIncrement + * @see #getRoundingIncrement + * @see #getRoundingMode + */ +void DecimalFormat::setRoundingMode(ERoundingMode roundingMode) { + fImpl->setRoundingMode(roundingMode); +} + +/** + * Get the width to which the output of <code>format()</code> is padded. + * @return the format width, or zero if no padding is in effect + * @see #setFormatWidth + * @see #getPadCharacter + * @see #setPadCharacter + * @see #getPadPosition + * @see #setPadPosition + */ +int32_t DecimalFormat::getFormatWidth() const { + return fImpl->getFormatWidth(); +} + +/** + * Set the width to which the output of <code>format()</code> is padded. + * This method also controls whether padding is enabled. + * @param width the width to which to pad the result of + * <code>format()</code>, or zero to disable padding. A negative + * width is equivalent to 0. + * @see #getFormatWidth + * @see #getPadCharacter + * @see #setPadCharacter + * @see #getPadPosition + * @see #setPadPosition + */ +void DecimalFormat::setFormatWidth(int32_t width) { + int32_t formatWidth = (width > 0) ? width : 0; + fImpl->setFormatWidth(formatWidth); +} + +UnicodeString DecimalFormat::getPadCharacterString() const { + return UnicodeString(fImpl->getPadCharacter()); +} + +void DecimalFormat::setPadCharacter(const UnicodeString &padChar) { + UChar pad; + if (padChar.length() > 0) { + pad = padChar.char32At(0); + } + else { + pad = kDefaultPad; + } + fImpl->setPadCharacter(pad); +} + +static DecimalFormat::EPadPosition fromPadPosition(DigitAffixesAndPadding::EPadPosition padPos) { + switch (padPos) { + case DigitAffixesAndPadding::kPadBeforePrefix: + return DecimalFormat::kPadBeforePrefix; + case DigitAffixesAndPadding::kPadAfterPrefix: + return DecimalFormat::kPadAfterPrefix; + case DigitAffixesAndPadding::kPadBeforeSuffix: + return DecimalFormat::kPadBeforeSuffix; + case DigitAffixesAndPadding::kPadAfterSuffix: + return DecimalFormat::kPadAfterSuffix; + default: + U_ASSERT(FALSE); + break; + } + return DecimalFormat::kPadBeforePrefix; +} + +/** + * Get the position at which padding will take place. This is the location + * at which padding will be inserted if the result of <code>format()</code> + * is shorter than the format width. + * @return the pad position, one of <code>kPadBeforePrefix</code>, + * <code>kPadAfterPrefix</code>, <code>kPadBeforeSuffix</code>, or + * <code>kPadAfterSuffix</code>. + * @see #setFormatWidth + * @see #getFormatWidth + * @see #setPadCharacter + * @see #getPadCharacter + * @see #setPadPosition + * @see #kPadBeforePrefix + * @see #kPadAfterPrefix + * @see #kPadBeforeSuffix + * @see #kPadAfterSuffix + */ +DecimalFormat::EPadPosition DecimalFormat::getPadPosition() const { + return fromPadPosition(fImpl->getPadPosition()); +} + +static DigitAffixesAndPadding::EPadPosition toPadPosition(DecimalFormat::EPadPosition padPos) { + switch (padPos) { + case DecimalFormat::kPadBeforePrefix: + return DigitAffixesAndPadding::kPadBeforePrefix; + case DecimalFormat::kPadAfterPrefix: + return DigitAffixesAndPadding::kPadAfterPrefix; + case DecimalFormat::kPadBeforeSuffix: + return DigitAffixesAndPadding::kPadBeforeSuffix; + case DecimalFormat::kPadAfterSuffix: + return DigitAffixesAndPadding::kPadAfterSuffix; + default: + U_ASSERT(FALSE); + break; + } + return DigitAffixesAndPadding::kPadBeforePrefix; +} + +/** + * <strong><font face=helvetica color=red>NEW</font></strong> + * Set the position at which padding will take place. This is the location + * at which padding will be inserted if the result of <code>format()</code> + * is shorter than the format width. This has no effect unless padding is + * enabled. + * @param padPos the pad position, one of <code>kPadBeforePrefix</code>, + * <code>kPadAfterPrefix</code>, <code>kPadBeforeSuffix</code>, or + * <code>kPadAfterSuffix</code>. + * @see #setFormatWidth + * @see #getFormatWidth + * @see #setPadCharacter + * @see #getPadCharacter + * @see #getPadPosition + * @see #kPadBeforePrefix + * @see #kPadAfterPrefix + * @see #kPadBeforeSuffix + * @see #kPadAfterSuffix + */ +void DecimalFormat::setPadPosition(EPadPosition padPos) { + fImpl->setPadPosition(toPadPosition(padPos)); +} + +/** + * Return whether or not scientific notation is used. + * @return TRUE if this object formats and parses scientific notation + * @see #setScientificNotation + * @see #getMinimumExponentDigits + * @see #setMinimumExponentDigits + * @see #isExponentSignAlwaysShown + * @see #setExponentSignAlwaysShown + */ +UBool DecimalFormat::isScientificNotation() const { + return fImpl->isScientificNotation(); +} + +/** + * Set whether or not scientific notation is used. + * @param useScientific TRUE if this object formats and parses scientific + * notation + * @see #isScientificNotation + * @see #getMinimumExponentDigits + * @see #setMinimumExponentDigits + * @see #isExponentSignAlwaysShown + * @see #setExponentSignAlwaysShown + */ +void DecimalFormat::setScientificNotation(UBool useScientific) { + fImpl->setScientificNotation(useScientific); +} + +/** + * Return the minimum exponent digits that will be shown. + * @return the minimum exponent digits that will be shown + * @see #setScientificNotation + * @see #isScientificNotation + * @see #setMinimumExponentDigits + * @see #isExponentSignAlwaysShown + * @see #setExponentSignAlwaysShown + */ +int8_t DecimalFormat::getMinimumExponentDigits() const { + return fImpl->getMinimumExponentDigits(); +} + +/** + * Set the minimum exponent digits that will be shown. This has no + * effect unless scientific notation is in use. + * @param minExpDig a value >= 1 indicating the fewest exponent digits + * that will be shown. Values less than 1 will be treated as 1. + * @see #setScientificNotation + * @see #isScientificNotation + * @see #getMinimumExponentDigits + * @see #isExponentSignAlwaysShown + * @see #setExponentSignAlwaysShown + */ +void DecimalFormat::setMinimumExponentDigits(int8_t minExpDig) { + int32_t minExponentDigits = (int8_t)((minExpDig > 0) ? minExpDig : 1); + fImpl->setMinimumExponentDigits(minExponentDigits); +} + +/** + * Return whether the exponent sign is always shown. + * @return TRUE if the exponent is always prefixed with either the + * localized minus sign or the localized plus sign, false if only negative + * exponents are prefixed with the localized minus sign. + * @see #setScientificNotation + * @see #isScientificNotation + * @see #setMinimumExponentDigits + * @see #getMinimumExponentDigits + * @see #setExponentSignAlwaysShown + */ +UBool DecimalFormat::isExponentSignAlwaysShown() const { + return fImpl->isExponentSignAlwaysShown(); +} + +/** + * Set whether the exponent sign is always shown. This has no effect + * unless scientific notation is in use. + * @param expSignAlways TRUE if the exponent is always prefixed with either + * the localized minus sign or the localized plus sign, false if only + * negative exponents are prefixed with the localized minus sign. + * @see #setScientificNotation + * @see #isScientificNotation + * @see #setMinimumExponentDigits + * @see #getMinimumExponentDigits + * @see #isExponentSignAlwaysShown + */ +void DecimalFormat::setExponentSignAlwaysShown(UBool expSignAlways) { + fImpl->setExponentSignAlwaysShown(expSignAlways); +} + +//------------------------------------------------------------------------------ +// Gets the grouping size of the number pattern. For example, thousand or 10 +// thousand groupings. + +int32_t +DecimalFormat::getGroupingSize() const +{ + return fImpl->getGroupingSize(); +} + +//------------------------------------------------------------------------------ +// Gets the grouping size of the number pattern. + +void +DecimalFormat::setGroupingSize(int32_t newValue) +{ + fImpl->setGroupingSize(newValue); +} + +//------------------------------------------------------------------------------ + +int32_t +DecimalFormat::getSecondaryGroupingSize() const +{ + return fImpl->getSecondaryGroupingSize(); +} + +//------------------------------------------------------------------------------ + +void +DecimalFormat::setSecondaryGroupingSize(int32_t newValue) +{ + fImpl->setSecondaryGroupingSize(newValue); +} + +//------------------------------------------------------------------------------ + +int32_t +DecimalFormat::getMinimumGroupingDigits() const +{ + return fImpl->getMinimumGroupingDigits(); +} + +//------------------------------------------------------------------------------ + +void +DecimalFormat::setMinimumGroupingDigits(int32_t newValue) +{ + fImpl->setMinimumGroupingDigits(newValue); +} + +//------------------------------------------------------------------------------ +// Checks if to show the decimal separator. + +UBool +DecimalFormat::isDecimalSeparatorAlwaysShown() const +{ + return fImpl->isDecimalSeparatorAlwaysShown(); +} + +//------------------------------------------------------------------------------ +// Sets to always show the decimal separator. + +void +DecimalFormat::setDecimalSeparatorAlwaysShown(UBool newValue) +{ + fImpl->setDecimalSeparatorAlwaysShown(newValue); +} + +//------------------------------------------------------------------------------ +// Checks if decimal point pattern match is required +UBool +DecimalFormat::isDecimalPatternMatchRequired(void) const +{ + return fBoolFlags.contains(UNUM_PARSE_DECIMAL_MARK_REQUIRED); +} + +//------------------------------------------------------------------------------ +// Checks if decimal point pattern match is required + +void +DecimalFormat::setDecimalPatternMatchRequired(UBool newValue) +{ + fBoolFlags.set(UNUM_PARSE_DECIMAL_MARK_REQUIRED, newValue); +} + + +//------------------------------------------------------------------------------ +// Emits the pattern of this DecimalFormat instance. + +UnicodeString& +DecimalFormat::toPattern(UnicodeString& result) const +{ + return fImpl->toPattern(result); +} + +//------------------------------------------------------------------------------ +// Emits the localized pattern this DecimalFormat instance. + +UnicodeString& +DecimalFormat::toLocalizedPattern(UnicodeString& result) const +{ + // toLocalizedPattern is deprecated, so we just make it the same as + // toPattern. + return fImpl->toPattern(result); +} + +//------------------------------------------------------------------------------ + +void +DecimalFormat::applyPattern(const UnicodeString& pattern, UErrorCode& status) +{ + fImpl->applyPattern(pattern, status); +} + +//------------------------------------------------------------------------------ + +void +DecimalFormat::applyPattern(const UnicodeString& pattern, + UParseError& parseError, + UErrorCode& status) +{ + fImpl->applyPattern(pattern, parseError, status); +} +//------------------------------------------------------------------------------ + +void +DecimalFormat::applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status) +{ + fImpl->applyLocalizedPattern(pattern, status); +} + +//------------------------------------------------------------------------------ + +void +DecimalFormat::applyLocalizedPattern(const UnicodeString& pattern, + UParseError& parseError, + UErrorCode& status) +{ + fImpl->applyLocalizedPattern(pattern, parseError, status); +} + +//------------------------------------------------------------------------------ + +/** + * Sets the maximum number of digits allowed in the integer portion of a + * number. + * @see NumberFormat#setMaximumIntegerDigits + */ +void DecimalFormat::setMaximumIntegerDigits(int32_t newValue) { + newValue = _min(newValue, gDefaultMaxIntegerDigits); + NumberFormat::setMaximumIntegerDigits(newValue); + fImpl->updatePrecision(); +} + +/** + * Sets the minimum number of digits allowed in the integer portion of a + * number. This override limits the integer digit count to 309. + * @see NumberFormat#setMinimumIntegerDigits + */ +void DecimalFormat::setMinimumIntegerDigits(int32_t newValue) { + newValue = _min(newValue, kDoubleIntegerDigits); + NumberFormat::setMinimumIntegerDigits(newValue); + fImpl->updatePrecision(); +} + +/** + * Sets the maximum number of digits allowed in the fraction portion of a + * number. This override limits the fraction digit count to 340. + * @see NumberFormat#setMaximumFractionDigits + */ +void DecimalFormat::setMaximumFractionDigits(int32_t newValue) { + newValue = _min(newValue, kDoubleFractionDigits); + NumberFormat::setMaximumFractionDigits(newValue); + fImpl->updatePrecision(); +} + +/** + * Sets the minimum number of digits allowed in the fraction portion of a + * number. This override limits the fraction digit count to 340. + * @see NumberFormat#setMinimumFractionDigits + */ +void DecimalFormat::setMinimumFractionDigits(int32_t newValue) { + newValue = _min(newValue, kDoubleFractionDigits); + NumberFormat::setMinimumFractionDigits(newValue); + fImpl->updatePrecision(); +} + +int32_t DecimalFormat::getMinimumSignificantDigits() const { + return fImpl->getMinimumSignificantDigits(); +} + +int32_t DecimalFormat::getMaximumSignificantDigits() const { + return fImpl->getMaximumSignificantDigits(); +} + +void DecimalFormat::setMinimumSignificantDigits(int32_t min) { + if (min < 1) { + min = 1; + } + // pin max sig dig to >= min + int32_t max = _max(fImpl->fMaxSigDigits, min); + fImpl->setMinMaxSignificantDigits(min, max); +} + +void DecimalFormat::setMaximumSignificantDigits(int32_t max) { + if (max < 1) { + max = 1; + } + // pin min sig dig to 1..max + U_ASSERT(fImpl->fMinSigDigits >= 1); + int32_t min = _min(fImpl->fMinSigDigits, max); + fImpl->setMinMaxSignificantDigits(min, max); +} + +UBool DecimalFormat::areSignificantDigitsUsed() const { + return fImpl->areSignificantDigitsUsed(); +} + +void DecimalFormat::setSignificantDigitsUsed(UBool useSignificantDigits) { + fImpl->setSignificantDigitsUsed(useSignificantDigits); +} + +void DecimalFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) { + // set the currency before compute affixes to get the right currency names + NumberFormat::setCurrency(theCurrency, ec); + fImpl->updateCurrency(ec); +} + +void DecimalFormat::setCurrencyUsage(UCurrencyUsage newContext, UErrorCode* ec){ + fImpl->setCurrencyUsage(newContext, *ec); +} + +UCurrencyUsage DecimalFormat::getCurrencyUsage() const { + return fImpl->getCurrencyUsage(); +} + +// Deprecated variant with no UErrorCode parameter +void DecimalFormat::setCurrency(const UChar* theCurrency) { + UErrorCode ec = U_ZERO_ERROR; + setCurrency(theCurrency, ec); +} + +void DecimalFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const { + if (fImpl->fSymbols == NULL) { + ec = U_MEMORY_ALLOCATION_ERROR; + return; + } + ec = U_ZERO_ERROR; + const UChar* c = getCurrency(); + if (*c == 0) { + const UnicodeString &intl = + fImpl->getConstSymbol(DecimalFormatSymbols::kIntlCurrencySymbol); + c = intl.getBuffer(); // ok for intl to go out of scope + } + u_strncpy(result, c, 3); + result[3] = 0; +} + +Hashtable* +DecimalFormat::initHashForAffixPattern(UErrorCode& status) { + if ( U_FAILURE(status) ) { + return NULL; + } + Hashtable* hTable; + if ( (hTable = new Hashtable(TRUE, status)) == NULL ) { + status = U_MEMORY_ALLOCATION_ERROR; + return NULL; + } + if ( U_FAILURE(status) ) { + delete hTable; + return NULL; + } + hTable->setValueComparator(decimfmtAffixPatternValueComparator); + return hTable; +} + +void +DecimalFormat::deleteHashForAffixPattern() +{ + if ( fAffixPatternsForCurrency == NULL ) { + return; + } + int32_t pos = UHASH_FIRST; + const UHashElement* element = NULL; + while ( (element = fAffixPatternsForCurrency->nextElement(pos)) != NULL ) { + const UHashTok valueTok = element->value; + const AffixPatternsForCurrency* value = (AffixPatternsForCurrency*)valueTok.pointer; + delete value; + } + delete fAffixPatternsForCurrency; + fAffixPatternsForCurrency = NULL; +} + + +void +DecimalFormat::copyHashForAffixPattern(const Hashtable* source, + Hashtable* target, + UErrorCode& status) { + if ( U_FAILURE(status) ) { + return; + } + int32_t pos = UHASH_FIRST; + const UHashElement* element = NULL; + if ( source ) { + while ( (element = source->nextElement(pos)) != NULL ) { + const UHashTok keyTok = element->key; + const UnicodeString* key = (UnicodeString*)keyTok.pointer; + const UHashTok valueTok = element->value; + const AffixPatternsForCurrency* value = (AffixPatternsForCurrency*)valueTok.pointer; + AffixPatternsForCurrency* copy = new AffixPatternsForCurrency( + value->negPrefixPatternForCurrency, + value->negSuffixPatternForCurrency, + value->posPrefixPatternForCurrency, + value->posSuffixPatternForCurrency, + value->patternType); + target->put(UnicodeString(*key), copy, status); + if ( U_FAILURE(status) ) { + return; + } + } + } +} + +void +DecimalFormat::setGroupingUsed(UBool newValue) { + NumberFormat::setGroupingUsed(newValue); + fImpl->updateGrouping(); +} + +void +DecimalFormat::setParseIntegerOnly(UBool newValue) { + NumberFormat::setParseIntegerOnly(newValue); +} + +void +DecimalFormat::setContext(UDisplayContext value, UErrorCode& status) { + NumberFormat::setContext(value, status); +} + +DecimalFormat& DecimalFormat::setAttribute( UNumberFormatAttribute attr, + int32_t newValue, + UErrorCode &status) { + if(U_FAILURE(status)) return *this; + + switch(attr) { + case UNUM_LENIENT_PARSE: + setLenient(newValue!=0); + break; + + case UNUM_PARSE_INT_ONLY: + setParseIntegerOnly(newValue!=0); + break; + + case UNUM_GROUPING_USED: + setGroupingUsed(newValue!=0); + break; + + case UNUM_DECIMAL_ALWAYS_SHOWN: + setDecimalSeparatorAlwaysShown(newValue!=0); + break; + + case UNUM_MAX_INTEGER_DIGITS: + setMaximumIntegerDigits(newValue); + break; + + case UNUM_MIN_INTEGER_DIGITS: + setMinimumIntegerDigits(newValue); + break; + + case UNUM_INTEGER_DIGITS: + setMinimumIntegerDigits(newValue); + setMaximumIntegerDigits(newValue); + break; + + case UNUM_MAX_FRACTION_DIGITS: + setMaximumFractionDigits(newValue); + break; + + case UNUM_MIN_FRACTION_DIGITS: + setMinimumFractionDigits(newValue); + break; + + case UNUM_FRACTION_DIGITS: + setMinimumFractionDigits(newValue); + setMaximumFractionDigits(newValue); + break; + + case UNUM_SIGNIFICANT_DIGITS_USED: + setSignificantDigitsUsed(newValue!=0); + break; + + case UNUM_MAX_SIGNIFICANT_DIGITS: + setMaximumSignificantDigits(newValue); + break; + + case UNUM_MIN_SIGNIFICANT_DIGITS: + setMinimumSignificantDigits(newValue); + break; + + case UNUM_MULTIPLIER: + setMultiplier(newValue); + break; + + case UNUM_GROUPING_SIZE: + setGroupingSize(newValue); + break; + + case UNUM_ROUNDING_MODE: + setRoundingMode((DecimalFormat::ERoundingMode)newValue); + break; + + case UNUM_FORMAT_WIDTH: + setFormatWidth(newValue); + break; + + case UNUM_PADDING_POSITION: + /** The position at which padding will take place. */ + setPadPosition((DecimalFormat::EPadPosition)newValue); + break; + + case UNUM_SECONDARY_GROUPING_SIZE: + setSecondaryGroupingSize(newValue); + break; + +#if UCONFIG_HAVE_PARSEALLINPUT + case UNUM_PARSE_ALL_INPUT: + setParseAllInput((UNumberFormatAttributeValue)newValue); + break; +#endif + + /* These are stored in fBoolFlags */ + case UNUM_PARSE_NO_EXPONENT: + case UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS: + case UNUM_PARSE_DECIMAL_MARK_REQUIRED: + if(!fBoolFlags.isValidValue(newValue)) { + status = U_ILLEGAL_ARGUMENT_ERROR; + } else { + if (attr == UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS) { + fImpl->setFailIfMoreThanMaxDigits((UBool) newValue); + } + fBoolFlags.set(attr, newValue); + } + break; + + case UNUM_SCALE: + fImpl->setScale(newValue); + break; + + case UNUM_CURRENCY_USAGE: + setCurrencyUsage((UCurrencyUsage)newValue, &status); + break; + + case UNUM_MINIMUM_GROUPING_DIGITS: + setMinimumGroupingDigits(newValue); + break; + + default: + status = U_UNSUPPORTED_ERROR; + break; + } + return *this; +} + +int32_t DecimalFormat::getAttribute( UNumberFormatAttribute attr, + UErrorCode &status ) const { + if(U_FAILURE(status)) return -1; + switch(attr) { + case UNUM_LENIENT_PARSE: + return isLenient(); + + case UNUM_PARSE_INT_ONLY: + return isParseIntegerOnly(); + + case UNUM_GROUPING_USED: + return isGroupingUsed(); + + case UNUM_DECIMAL_ALWAYS_SHOWN: + return isDecimalSeparatorAlwaysShown(); + + case UNUM_MAX_INTEGER_DIGITS: + return getMaximumIntegerDigits(); + + case UNUM_MIN_INTEGER_DIGITS: + return getMinimumIntegerDigits(); + + case UNUM_INTEGER_DIGITS: + // TBD: what should this return? + return getMinimumIntegerDigits(); + + case UNUM_MAX_FRACTION_DIGITS: + return getMaximumFractionDigits(); + + case UNUM_MIN_FRACTION_DIGITS: + return getMinimumFractionDigits(); + + case UNUM_FRACTION_DIGITS: + // TBD: what should this return? + return getMinimumFractionDigits(); + + case UNUM_SIGNIFICANT_DIGITS_USED: + return areSignificantDigitsUsed(); + + case UNUM_MAX_SIGNIFICANT_DIGITS: + return getMaximumSignificantDigits(); + + case UNUM_MIN_SIGNIFICANT_DIGITS: + return getMinimumSignificantDigits(); + + case UNUM_MULTIPLIER: + return getMultiplier(); + + case UNUM_GROUPING_SIZE: + return getGroupingSize(); + + case UNUM_ROUNDING_MODE: + return getRoundingMode(); + + case UNUM_FORMAT_WIDTH: + return getFormatWidth(); + + case UNUM_PADDING_POSITION: + return getPadPosition(); + + case UNUM_SECONDARY_GROUPING_SIZE: + return getSecondaryGroupingSize(); + + /* These are stored in fBoolFlags */ + case UNUM_PARSE_NO_EXPONENT: + case UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS: + case UNUM_PARSE_DECIMAL_MARK_REQUIRED: + return fBoolFlags.get(attr); + + case UNUM_SCALE: + return fImpl->fScale; + + case UNUM_CURRENCY_USAGE: + return fImpl->getCurrencyUsage(); + + case UNUM_MINIMUM_GROUPING_DIGITS: + return getMinimumGroupingDigits(); + + default: + status = U_UNSUPPORTED_ERROR; + break; + } + + return -1; /* undefined */ +} + +#if UCONFIG_HAVE_PARSEALLINPUT +void DecimalFormat::setParseAllInput(UNumberFormatAttributeValue value) { + fParseAllInput = value; +} +#endif + +U_NAMESPACE_END + +#endif /* #if !UCONFIG_NO_FORMATTING */ + +//eof |