Google Git
Sign in
skia / external / github.com / unicode-org / icu / 17d273742559a77aae6c4ebfe82f2cd4ecb0262e / . / source / i18n / decimfmt.cpp
blob: c9d8b0c43a685c4d5c774415402acda55270d33b [file] [log] [blame]
/*
*******************************************************************************
* Copyright (C) 1997-2013, 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 "fphdlimp.h"
#include "unicode/decimfmt.h"
#include "unicode/choicfmt.h"
#include "unicode/ucurr.h"
#include "unicode/ustring.h"
#include "unicode/dcfmtsym.h"
#include "unicode/ures.h"
#include "unicode/uchar.h"
#include "unicode/uniset.h"
#include "unicode/curramt.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 "cmemory.h"
#include "patternprops.h"
#include "digitlst.h"
#include "cstring.h"
#include "umutex.h"
#include "uassert.h"
#include "putilimp.h"
#include <math.h>
#include "hash.h"
#include "decfmtst.h"
#include "dcfmtimp.h"
#include "plurrule_impl.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
/* == Fastpath calculation. ==
*/
#if UCONFIG_FORMAT_FASTPATHS_49
inline DecimalFormatInternal& internalData(uint8_t *reserved) {
return *reinterpret_cast<DecimalFormatInternal*>(reserved);
}
inline const DecimalFormatInternal& internalData(const uint8_t *reserved) {
return *reinterpret_cast<const DecimalFormatInternal*>(reserved);
}
#else
#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 decimfmtAffixValueComparator(UHashTok val1, UHashTok val2);
/**
* @internal ICU 4.2
*/
static UBool U_CALLCONV decimfmtAffixPatternValueComparator(UHashTok val1, UHashTok val2);
static UBool
U_CALLCONV decimfmtAffixValueComparator(UHashTok val1, UHashTok val2) {
const AffixesForCurrency* affix_1 =
(AffixesForCurrency*)val1.pointer;
const AffixesForCurrency* affix_2 =
(AffixesForCurrency*)val2.pointer;
return affix_1->negPrefixForCurrency == affix_2->negPrefixForCurrency &&
affix_1->negSuffixForCurrency == affix_2->negSuffixForCurrency &&
affix_1->posPrefixForCurrency == affix_2->posPrefixForCurrency &&
affix_1->posSuffixForCurrency == affix_2->posSuffixForCurrency;
}
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";
static const UChar fgTripleCurrencySign[] = {0xA4, 0xA4, 0xA4, 0};
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() {
fPosPrefixPattern = 0;
fPosSuffixPattern = 0;
fNegPrefixPattern = 0;
fNegSuffixPattern = 0;
fCurrencyChoice = 0;
fMultiplier = NULL;
fScale = 0;
fGroupingSize = 0;
fGroupingSize2 = 0;
fDecimalSeparatorAlwaysShown = FALSE;
fSymbols = NULL;
fUseSignificantDigits = FALSE;
fMinSignificantDigits = 1;
fMaxSignificantDigits = 6;
fUseExponentialNotation = FALSE;
fMinExponentDigits = 0;
fExponentSignAlwaysShown = FALSE;
fBoolFlags.clear();
fRoundingIncrement = 0;
fRoundingMode = kRoundHalfEven;
fPad = 0;
fFormatWidth = 0;
fPadPosition = kPadBeforePrefix;
fStyle = UNUM_DECIMAL;
fCurrencySignCount = fgCurrencySignCountZero;
fAffixPatternsForCurrency = NULL;
fAffixesForCurrency = NULL;
fPluralAffixesForCurrency = NULL;
fCurrencyPluralInfo = NULL;
#if UCONFIG_HAVE_PARSEALLINPUT
fParseAllInput = UNUM_MAYBE;
#endif
#if UCONFIG_FORMAT_FASTPATHS_49
DecimalFormatInternal &data = internalData(fReserved);
data.fFastFormatStatus=kFastpathUNKNOWN; // don't try to calculate the fastpath until later.
data.fFastParseStatus=kFastpathUNKNOWN; // don't try to calculate the fastpath until later.
#endif
fStaticSets = 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)
{
fSymbols = symbolsToAdopt; // Do this BEFORE aborting on status failure!!!
fRoundingIncrement = NULL;
fRoundingMode = kRoundHalfEven;
fPad = kPatternPadEscape;
fPadPosition = kPadBeforePrefix;
if (U_FAILURE(status))
return;
fPosPrefixPattern = fPosSuffixPattern = NULL;
fNegPrefixPattern = fNegSuffixPattern = NULL;
setMultiplier(1);
fGroupingSize = 3;
fGroupingSize2 = 0;
fDecimalSeparatorAlwaysShown = FALSE;
fUseExponentialNotation = FALSE;
fMinExponentDigits = 0;
if (fSymbols == NULL)
{
fSymbols = new DecimalFormatSymbols(Locale::getDefault(), status);
if (fSymbols == 0) {
status = U_MEMORY_ALLOCATION_ERROR;
return;
}
}
fStaticSets = DecimalFormatStaticSets::getStaticSets(status);
if (U_FAILURE(status)) {
return;
}
UErrorCode nsStatus = U_ZERO_ERROR;
NumberingSystem *ns = NumberingSystem::createInstance(nsStatus);
if (U_FAILURE(nsStatus)) {
status = nsStatus;
return;
}
UnicodeString str;
// Uses the default locale's number format pattern if there isn't
// one specified.
if (pattern == NULL)
{
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);
}
delete ns;
if (U_FAILURE(status))
{
return;
}
if (pattern->indexOf((UChar)kCurrencySign) >= 0) {
// If it looks like we are going to use a currency pattern
// then do the time consuming lookup.
setCurrencyForSymbols();
} else {
setCurrencyInternally(NULL, status);
}
const UnicodeString* patternUsed;
UnicodeString currencyPluralPatternForOther;
// apply pattern
if (fStyle == UNUM_CURRENCY_PLURAL) {
fCurrencyPluralInfo = new CurrencyPluralInfo(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);
patternUsed = &currencyPluralPatternForOther;
// TODO: not needed?
setCurrencyForSymbols();
} 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(fSymbols->getLocale(), status);
if (U_FAILURE(status)) {
return;
}
}
// need it for mix parsing
setupCurrencyAffixPatterns(status);
// expanded affixes for plural names
if (patternUsed->indexOf(fgTripleCurrencySign, 3, 0) != -1) {
setupCurrencyAffixes(*patternUsed, TRUE, TRUE, status);
}
}
applyPatternWithoutExpandAffix(*patternUsed,FALSE, parseErr, status);
// expand affixes
if (fCurrencySignCount != fgCurrencySignCountInPluralFormat) {
expandAffixAdjustWidth(NULL);
}
// If it was a currency format, apply the appropriate rounding by
// resetting the currency. NOTE: this copies fCurrency on top of itself.
if (fCurrencySignCount != fgCurrencySignCountZero) {
setCurrencyInternally(getCurrency(), status);
}
#if UCONFIG_FORMAT_FASTPATHS_49
DecimalFormatInternal &data = internalData(fReserved);
data.fFastFormatStatus = kFastpathNO; // allow it to be calculated
data.fFastParseStatus = kFastpathNO; // allow it to be calculated
handleChanged();
#endif
}
void
DecimalFormat::setupCurrencyAffixPatterns(UErrorCode& status) {
if (U_FAILURE(status)) {
return;
}
UParseError parseErr;
fAffixPatternsForCurrency = initHashForAffixPattern(status);
if (U_FAILURE(status)) {
return;
}
NumberingSystem *ns = NumberingSystem::createInstance(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, 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)) {
applyPatternWithoutExpandAffix(UnicodeString(patResStr, patLen), false,
parseErr, status);
AffixPatternsForCurrency* affixPtn = new AffixPatternsForCurrency(
*fNegPrefixPattern,
*fNegSuffixPattern,
*fPosPrefixPattern,
*fPosSuffixPattern,
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 = -1;
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) {
pluralPatternSet.puti(*value, 1, status);
applyPatternWithoutExpandAffix(*value, false, parseErr, status);
AffixPatternsForCurrency* affixPtn = new AffixPatternsForCurrency(
*fNegPrefixPattern,
*fNegSuffixPattern,
*fPosPrefixPattern,
*fPosSuffixPattern,
UCURR_LONG_NAME);
fAffixPatternsForCurrency->put(*key, affixPtn, status);
}
}
}
void
DecimalFormat::setupCurrencyAffixes(const UnicodeString& pattern,
UBool setupForCurrentPattern,
UBool setupForPluralPattern,
UErrorCode& status) {
if (U_FAILURE(status)) {
return;
}
UParseError parseErr;
if (setupForCurrentPattern) {
if (fAffixesForCurrency) {
deleteHashForAffix(fAffixesForCurrency);
}
fAffixesForCurrency = initHashForAffix(status);
if (U_SUCCESS(status)) {
applyPatternWithoutExpandAffix(pattern, false, parseErr, status);
const PluralRules* pluralRules = fCurrencyPluralInfo->getPluralRules();
StringEnumeration* keywords = pluralRules->getKeywords(status);
if (U_SUCCESS(status)) {
const UnicodeString* pluralCount;
while ((pluralCount = keywords->snext(status)) != NULL) {
if ( U_SUCCESS(status) ) {
expandAffixAdjustWidth(pluralCount);
AffixesForCurrency* affix = new AffixesForCurrency(
fNegativePrefix, fNegativeSuffix, fPositivePrefix, fPositiveSuffix);
fAffixesForCurrency->put(*pluralCount, affix, status);
}
}
}
delete keywords;
}
}
if (U_FAILURE(status)) {
return;
}
if (setupForPluralPattern) {
if (fPluralAffixesForCurrency) {
deleteHashForAffix(fPluralAffixesForCurrency);
}
fPluralAffixesForCurrency = initHashForAffix(status);
if (U_SUCCESS(status)) {
const PluralRules* pluralRules = fCurrencyPluralInfo->getPluralRules();
StringEnumeration* keywords = pluralRules->getKeywords(status);
if (U_SUCCESS(status)) {
const UnicodeString* pluralCount;
while ((pluralCount = keywords->snext(status)) != NULL) {
if ( U_SUCCESS(status) ) {
UnicodeString ptn;
fCurrencyPluralInfo->getCurrencyPluralPattern(*pluralCount, ptn);
applyPatternInternally(*pluralCount, ptn, false, parseErr, status);
AffixesForCurrency* affix = new AffixesForCurrency(
fNegativePrefix, fNegativeSuffix, fPositivePrefix, fPositiveSuffix);
fPluralAffixesForCurrency->put(*pluralCount, affix, status);
}
}
}
delete keywords;
}
}
}
//------------------------------------------------------------------------------
DecimalFormat::~DecimalFormat()
{
delete fPosPrefixPattern;
delete fPosSuffixPattern;
delete fNegPrefixPattern;
delete fNegSuffixPattern;
delete fCurrencyChoice;
delete fMultiplier;
delete fSymbols;
delete fRoundingIncrement;
deleteHashForAffixPattern();
deleteHashForAffix(fAffixesForCurrency);
deleteHashForAffix(fPluralAffixesForCurrency);
delete fCurrencyPluralInfo;
}
//------------------------------------------------------------------------------
// copy constructor
DecimalFormat::DecimalFormat(const DecimalFormat &source) :
NumberFormat(source) {
init();
*this = source;
}
//------------------------------------------------------------------------------
// assignment operator
template <class T>
static void _copy_ptr(T** pdest, const T* source) {
if (source == NULL) {
delete *pdest;
*pdest = NULL;
} else if (*pdest == NULL) {
*pdest = new T(*source);
} else {
**pdest = *source;
}
}
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);
fStaticSets = DecimalFormatStaticSets::getStaticSets(status);
fPositivePrefix = rhs.fPositivePrefix;
fPositiveSuffix = rhs.fPositiveSuffix;
fNegativePrefix = rhs.fNegativePrefix;
fNegativeSuffix = rhs.fNegativeSuffix;
_copy_ptr(&fPosPrefixPattern, rhs.fPosPrefixPattern);
_copy_ptr(&fPosSuffixPattern, rhs.fPosSuffixPattern);
_copy_ptr(&fNegPrefixPattern, rhs.fNegPrefixPattern);
_copy_ptr(&fNegSuffixPattern, rhs.fNegSuffixPattern);
_clone_ptr(&fCurrencyChoice, rhs.fCurrencyChoice);
setRoundingIncrement(rhs.getRoundingIncrement());
fRoundingMode = rhs.fRoundingMode;
setMultiplier(rhs.getMultiplier());
fGroupingSize = rhs.fGroupingSize;
fGroupingSize2 = rhs.fGroupingSize2;
fDecimalSeparatorAlwaysShown = rhs.fDecimalSeparatorAlwaysShown;
_copy_ptr(&fSymbols, rhs.fSymbols);
fUseExponentialNotation = rhs.fUseExponentialNotation;
fExponentSignAlwaysShown = rhs.fExponentSignAlwaysShown;
fBoolFlags = rhs.fBoolFlags;
/*Bertrand A. D. Update 98.03.17*/
fCurrencySignCount = rhs.fCurrencySignCount;
/*end of Update*/
fMinExponentDigits = rhs.fMinExponentDigits;
/* sfb 990629 */
fFormatWidth = rhs.fFormatWidth;
fPad = rhs.fPad;
fPadPosition = rhs.fPadPosition;
/* end sfb */
fMinSignificantDigits = rhs.fMinSignificantDigits;
fMaxSignificantDigits = rhs.fMaxSignificantDigits;
fUseSignificantDigits = rhs.fUseSignificantDigits;
fFormatPattern = rhs.fFormatPattern;
fStyle = rhs.fStyle;
fCurrencySignCount = rhs.fCurrencySignCount;
_clone_ptr(&fCurrencyPluralInfo, rhs.fCurrencyPluralInfo);
deleteHashForAffixPattern();
if (rhs.fAffixPatternsForCurrency) {
UErrorCode status = U_ZERO_ERROR;
fAffixPatternsForCurrency = initHashForAffixPattern(status);
copyHashForAffixPattern(rhs.fAffixPatternsForCurrency,
fAffixPatternsForCurrency, status);
}
deleteHashForAffix(fAffixesForCurrency);
if (rhs.fAffixesForCurrency) {
UErrorCode status = U_ZERO_ERROR;
fAffixesForCurrency = initHashForAffixPattern(status);
copyHashForAffix(rhs.fAffixesForCurrency, fAffixesForCurrency, status);
}
deleteHashForAffix(fPluralAffixesForCurrency);
if (rhs.fPluralAffixesForCurrency) {
UErrorCode status = U_ZERO_ERROR;
fPluralAffixesForCurrency = initHashForAffixPattern(status);
copyHashForAffix(rhs.fPluralAffixesForCurrency, fPluralAffixesForCurrency, status);
}
}
#if UCONFIG_FORMAT_FASTPATHS_49
handleChanged();
#endif
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;
#ifdef FMT_DEBUG
// This code makes it easy to determine why two format objects that should
// be equal aren't.
UBool first = TRUE;
if (!NumberFormat::operator==(that)) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("NumberFormat::!=");
} else {
if (!((fPosPrefixPattern == other->fPosPrefixPattern && // both null
fPositivePrefix == other->fPositivePrefix)
|| (fPosPrefixPattern != 0 && other->fPosPrefixPattern != 0 &&
*fPosPrefixPattern == *other->fPosPrefixPattern))) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Pos Prefix !=");
}
if (!((fPosSuffixPattern == other->fPosSuffixPattern && // both null
fPositiveSuffix == other->fPositiveSuffix)
|| (fPosSuffixPattern != 0 && other->fPosSuffixPattern != 0 &&
*fPosSuffixPattern == *other->fPosSuffixPattern))) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Pos Suffix !=");
}
if (!((fNegPrefixPattern == other->fNegPrefixPattern && // both null
fNegativePrefix == other->fNegativePrefix)
|| (fNegPrefixPattern != 0 && other->fNegPrefixPattern != 0 &&
*fNegPrefixPattern == *other->fNegPrefixPattern))) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Neg Prefix ");
if (fNegPrefixPattern == NULL) {
debug("NULL(");
debugout(fNegativePrefix);
debug(")");
} else {
debugout(*fNegPrefixPattern);
}
debug(" != ");
if (other->fNegPrefixPattern == NULL) {
debug("NULL(");
debugout(other->fNegativePrefix);
debug(")");
} else {
debugout(*other->fNegPrefixPattern);
}
}
if (!((fNegSuffixPattern == other->fNegSuffixPattern && // both null
fNegativeSuffix == other->fNegativeSuffix)
|| (fNegSuffixPattern != 0 && other->fNegSuffixPattern != 0 &&
*fNegSuffixPattern == *other->fNegSuffixPattern))) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Neg Suffix ");
if (fNegSuffixPattern == NULL) {
debug("NULL(");
debugout(fNegativeSuffix);
debug(")");
} else {
debugout(*fNegSuffixPattern);
}
debug(" != ");
if (other->fNegSuffixPattern == NULL) {
debug("NULL(");
debugout(other->fNegativeSuffix);
debug(")");
} else {
debugout(*other->fNegSuffixPattern);
}
}
if (!((fRoundingIncrement == other->fRoundingIncrement) // both null
|| (fRoundingIncrement != NULL &&
other->fRoundingIncrement != NULL &&
*fRoundingIncrement == *other->fRoundingIncrement))) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Rounding Increment !=");
}
if (getMultiplier() != other->getMultiplier()) {
if (first) { printf("[ "); first = FALSE; }
printf("Multiplier %ld != %ld", getMultiplier(), other->getMultiplier());
}
if (fGroupingSize != other->fGroupingSize) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
printf("Grouping Size %ld != %ld", fGroupingSize, other->fGroupingSize);
}
if (fGroupingSize2 != other->fGroupingSize2) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
printf("Secondary Grouping Size %ld != %ld", fGroupingSize2, other->fGroupingSize2);
}
if (fDecimalSeparatorAlwaysShown != other->fDecimalSeparatorAlwaysShown) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
printf("Dec Sep Always %d != %d", fDecimalSeparatorAlwaysShown, other->fDecimalSeparatorAlwaysShown);
}
if (fUseExponentialNotation != other->fUseExponentialNotation) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Use Exp !=");
}
if (!(!fUseExponentialNotation ||
fMinExponentDigits != other->fMinExponentDigits)) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Exp Digits !=");
}
if (*fSymbols != *(other->fSymbols)) {
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
debug("Symbols !=");
}
// TODO Add debug stuff for significant digits here
if (fUseSignificantDigits != other->fUseSignificantDigits) {
debug("fUseSignificantDigits !=");
}
if (fUseSignificantDigits &&
fMinSignificantDigits != other->fMinSignificantDigits) {
debug("fMinSignificantDigits !=");
}
if (fUseSignificantDigits &&
fMaxSignificantDigits != other->fMaxSignificantDigits) {
debug("fMaxSignificantDigits !=");
}
if (!first) { printf(" ]"); }
if (fCurrencySignCount != other->fCurrencySignCount) {
debug("fCurrencySignCount !=");
}
if (fCurrencyPluralInfo == other->fCurrencyPluralInfo) {
debug("fCurrencyPluralInfo == ");
if (fCurrencyPluralInfo == NULL) {
debug("fCurrencyPluralInfo == NULL");
}
}
if (fCurrencyPluralInfo != NULL && other->fCurrencyPluralInfo != NULL &&
*fCurrencyPluralInfo != *(other->fCurrencyPluralInfo)) {
debug("fCurrencyPluralInfo !=");
}
if (fCurrencyPluralInfo != NULL && other->fCurrencyPluralInfo == NULL ||
fCurrencyPluralInfo == NULL && other->fCurrencyPluralInfo != NULL) {
debug("fCurrencyPluralInfo one NULL, the other not");
}
if (fCurrencyPluralInfo == NULL && other->fCurrencyPluralInfo == NULL) {
debug("fCurrencyPluralInfo == ");
}
}
#endif
return (NumberFormat::operator==(that) &&
((fCurrencySignCount == fgCurrencySignCountInPluralFormat) ?
(fAffixPatternsForCurrency->equals(*other->fAffixPatternsForCurrency)) :
(((fPosPrefixPattern == other->fPosPrefixPattern && // both null
fPositivePrefix == other->fPositivePrefix)
|| (fPosPrefixPattern != 0 && other->fPosPrefixPattern != 0 &&
*fPosPrefixPattern == *other->fPosPrefixPattern)) &&
((fPosSuffixPattern == other->fPosSuffixPattern && // both null
fPositiveSuffix == other->fPositiveSuffix)
|| (fPosSuffixPattern != 0 && other->fPosSuffixPattern != 0 &&
*fPosSuffixPattern == *other->fPosSuffixPattern)) &&
((fNegPrefixPattern == other->fNegPrefixPattern && // both null
fNegativePrefix == other->fNegativePrefix)
|| (fNegPrefixPattern != 0 && other->fNegPrefixPattern != 0 &&
*fNegPrefixPattern == *other->fNegPrefixPattern)) &&
((fNegSuffixPattern == other->fNegSuffixPattern && // both null
fNegativeSuffix == other->fNegativeSuffix)
|| (fNegSuffixPattern != 0 && other->fNegSuffixPattern != 0 &&
*fNegSuffixPattern == *other->fNegSuffixPattern)))) &&
((fRoundingIncrement == other->fRoundingIncrement) // both null
|| (fRoundingIncrement != NULL &&
other->fRoundingIncrement != NULL &&
*fRoundingIncrement == *other->fRoundingIncrement)) &&
getMultiplier() == other->getMultiplier() &&
fGroupingSize == other->fGroupingSize &&
fGroupingSize2 == other->fGroupingSize2 &&
fDecimalSeparatorAlwaysShown == other->fDecimalSeparatorAlwaysShown &&
fUseExponentialNotation == other->fUseExponentialNotation &&
(!fUseExponentialNotation ||
fMinExponentDigits == other->fMinExponentDigits) &&
*fSymbols == *(other->fSymbols) &&
fUseSignificantDigits == other->fUseSignificantDigits &&
(!fUseSignificantDigits ||
(fMinSignificantDigits == other->fMinSignificantDigits &&
fMaxSignificantDigits == other->fMaxSignificantDigits)) &&
fCurrencySignCount == other->fCurrencySignCount &&
((fCurrencyPluralInfo == other->fCurrencyPluralInfo &&
fCurrencyPluralInfo == NULL) ||
(fCurrencyPluralInfo != NULL && other->fCurrencyPluralInfo != NULL &&
*fCurrencyPluralInfo == *(other->fCurrencyPluralInfo))));
}
//------------------------------------------------------------------------------
Format*
DecimalFormat::clone() const
{
return new DecimalFormat(*this);
}
FixedDecimal
DecimalFormat::getFixedDecimal(double number, UErrorCode &status) const {
FixedDecimal result;
if (U_FAILURE(status)) {
return result;
}
if (uprv_isNaN(number) || uprv_isPositiveInfinity(fabs(number))) {
// For NaN and Infinity the state of the formatter is ignored.
result.init(number);
return result;
}
if (fMultiplier == NULL && fScale == 0 && fRoundingIncrement == 0 && areSignificantDigitsUsed() == FALSE &&
result.quickInit(number) && result.visibleDecimalDigitCount <= getMaximumFractionDigits()) {
// Fast Path. Construction of an exact FixedDecimal directly from the double, without passing
// through a DigitList, was successful, and the formatter is doing nothing tricky with rounding.
// printf("getFixedDecimal(%g): taking fast path.\n", number);
result.adjustForMinFractionDigits(getMinimumFractionDigits());
} else {
// Slow path. Create a DigitList, and have this formatter round it according to the
// requirements of the format, and fill the fixedDecimal from that.
DigitList digits;
digits.set(number);
result = getFixedDecimal(digits, status);
}
return result;
}
// MSVC optimizer bug?
// turn off optimization as it causes different behavior in the int64->double->int64 conversion
#if defined (_MSC_VER)
#pragma optimize ( "", off )
#endif
FixedDecimal
DecimalFormat::getFixedDecimal(const Formattable &number, UErrorCode &status) const {
if (U_FAILURE(status)) {
return FixedDecimal();
}
if (!number.isNumeric()) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return FixedDecimal();
}
DigitList *dl = number.getDigitList();
if (dl != NULL) {
DigitList clonedDL(*dl);
return getFixedDecimal(clonedDL, status);
}
Formattable::Type type = number.getType();
if (type == Formattable::kDouble || type == Formattable::kLong) {
return getFixedDecimal(number.getDouble(status), status);
}
if (type == Formattable::kInt64) {
// "volatile" here is a workaround to avoid optimization issues.
volatile double fdv = number.getDouble(status);
// Note: conversion of int64_t -> double rounds with some compilers to
// values beyond what can be represented as a 64 bit int. Subsequent
// testing or conversion with int64_t produces bad results.
// So filter the problematic values, route them to DigitList.
if (fdv != (double)U_INT64_MAX && fdv != (double)U_INT64_MIN &&
number.getInt64() == (int64_t)fdv) {
return getFixedDecimal(number.getDouble(status), status);
}
}
// The only case left is type==int64_t, with a value with more digits than a double can represent.
// Any formattable originating as a big decimal will have had a pre-existing digit list.
// Any originating as a double or int32 will have been handled as a double.
U_ASSERT(type == Formattable::kInt64);
DigitList digits;
digits.set(number.getInt64());
return getFixedDecimal(digits, status);
}
// end workaround MSVC optimizer bug
#if defined (_MSC_VER)
#pragma optimize ( "", on )
#endif
// Create a fixed decimal from a DigitList.
// The digit list may be modified.
// Internal function only.
FixedDecimal
DecimalFormat::getFixedDecimal(DigitList &number, UErrorCode &status) const {
// Round the number according to the requirements of this Format.
FixedDecimal result;
_round(number, number, result.isNegative, status);
// The int64_t fields in FixedDecimal can easily overflow.
// In deciding what to discard in this event, consider that fixedDecimal
// is being used only with PluralRules, and those rules mostly look at least significant
// few digits of the integer part, and whether the fraction part is zero or not.
//
// So, in case of overflow when filling in the fields of the FixedDecimal object,
// for the integer part, discard the most significant digits.
// for the fraction part, discard the least significant digits,
// don't truncate the fraction value to zero.
// For simplicity, the int64_t fields are limited to 18 decimal digits, even
// though they could hold most (but not all) 19 digit values.
// Integer Digits.
int32_t di = number.getDecimalAt()-18; // Take at most 18 digits.
if (di < 0) {
di = 0;
}
result.intValue = 0;
for (; di<number.getDecimalAt(); di++) {
result.intValue = result.intValue * 10 + (number.getDigit(di) & 0x0f);
}
if (result.intValue == 0 && number.getDecimalAt()-18 > 0) {
// The number is something like 100000000000000000000000.
// More than 18 digits integer digits, but the least significant 18 are all zero.
// We don't want to return zero as the int part, but want to keep zeros
// for several of the least significant digits.
result.intValue = 100000000000000000LL;
}
// Fraction digits.
result.decimalDigits = result.decimalDigitsWithoutTrailingZeros = result.visibleDecimalDigitCount = 0;
for (di = number.getDecimalAt(); di < number.getCount(); di++) {
result.visibleDecimalDigitCount++;
if (result.decimalDigits < 100000000000000000LL) {
// 9223372036854775807 Largest 64 bit signed integer
int32_t digitVal = number.getDigit(di) & 0x0f; // getDigit() returns a char, '0'-'9'.
result.decimalDigits = result.decimalDigits * 10 + digitVal;
if (digitVal > 0) {
result.decimalDigitsWithoutTrailingZeros = result.decimalDigits;
}
}
}
result.hasIntegerValue = (result.decimalDigits == 0);
// Trailing fraction zeros. The format specification may require more trailing
// zeros than the numeric value. Add any such on now.
int32_t minFractionDigits;
if (areSignificantDigitsUsed()) {
minFractionDigits = getMinimumSignificantDigits() - number.getDecimalAt();
if (minFractionDigits < 0) {
minFractionDigits = 0;
}
} else {
minFractionDigits = getMinimumFractionDigits();
}
result.adjustForMinFractionDigits(minFractionDigits);
return result;
}
//------------------------------------------------------------------------------
UnicodeString&
DecimalFormat::format(int32_t number,
UnicodeString& appendTo,
FieldPosition& fieldPosition) const
{
return format((int64_t)number, appendTo, fieldPosition);
}
UnicodeString&
DecimalFormat::format(int32_t number,
UnicodeString& appendTo,
FieldPosition& fieldPosition,
UErrorCode& status) const
{
return format((int64_t)number, appendTo, fieldPosition, status);
}
UnicodeString&
DecimalFormat::format(int32_t number,
UnicodeString& appendTo,
FieldPositionIterator* posIter,
UErrorCode& status) const
{
return format((int64_t)number, appendTo, posIter, status);
}
#if UCONFIG_FORMAT_FASTPATHS_49
void DecimalFormat::handleChanged() {
DecimalFormatInternal &data = internalData(fReserved);
if(data.fFastFormatStatus == kFastpathUNKNOWN || data.fFastParseStatus == kFastpathUNKNOWN) {
return; // still constructing. Wait.
}
data.fFastParseStatus = data.fFastFormatStatus = kFastpathNO;
#if UCONFIG_HAVE_PARSEALLINPUT
if(fParseAllInput == UNUM_NO) {
debug("No Parse fastpath: fParseAllInput==UNUM_NO");
} else
#endif
if (fFormatWidth!=0) {
debug("No Parse fastpath: fFormatWidth");
} else if(fPositivePrefix.length()>0) {
debug("No Parse fastpath: positive prefix");
} else if(fPositiveSuffix.length()>0) {
debug("No Parse fastpath: positive suffix");
} else if(fNegativePrefix.length()>1
|| ((fNegativePrefix.length()==1) && (fNegativePrefix.charAt(0)!=0x002D))) {
debug("No Parse fastpath: negative prefix that isn't '-'");
} else if(fNegativeSuffix.length()>0) {
debug("No Parse fastpath: negative suffix");
} else {
data.fFastParseStatus = kFastpathYES;
debug("parse fastpath: YES");
}
if (fGroupingSize!=0 && isGroupingUsed()) {
debug("No format fastpath: fGroupingSize!=0 and grouping is used");
#ifdef FMT_DEBUG
printf("groupingsize=%d\n", fGroupingSize);
#endif
} else if(fGroupingSize2!=0 && isGroupingUsed()) {
debug("No format fastpath: fGroupingSize2!=0");
} else if(fUseExponentialNotation) {
debug("No format fastpath: fUseExponentialNotation");
} else if(fFormatWidth!=0) {
debug("No format fastpath: fFormatWidth!=0");
} else if(fMinSignificantDigits!=1) {
debug("No format fastpath: fMinSignificantDigits!=1");
} else if(fMultiplier!=NULL) {
debug("No format fastpath: fMultiplier!=NULL");
} else if(fScale!=0) {
debug("No format fastpath: fScale!=0");
} else if(0x0030 != getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0)) {
debug("No format fastpath: 0x0030 != getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0)");
} else if(fDecimalSeparatorAlwaysShown) {
debug("No format fastpath: fDecimalSeparatorAlwaysShown");
} else if(getMinimumFractionDigits()>0) {
debug("No format fastpath: fMinFractionDigits>0");
} else if(fCurrencySignCount != fgCurrencySignCountZero) {
debug("No format fastpath: fCurrencySignCount != fgCurrencySignCountZero");
} else if(fRoundingIncrement!=0) {
debug("No format fastpath: fRoundingIncrement!=0");
} else {
data.fFastFormatStatus = kFastpathYES;
debug("format:kFastpathYES!");
}
}
#endif
//------------------------------------------------------------------------------
UnicodeString&
DecimalFormat::format(int64_t number,
UnicodeString& appendTo,
FieldPosition& fieldPosition) const
{
UErrorCode status = U_ZERO_ERROR; /* ignored */
FieldPositionOnlyHandler handler(fieldPosition);
return _format(number, appendTo, handler, status);
}
UnicodeString&
DecimalFormat::format(int64_t number,
UnicodeString& appendTo,
FieldPosition& fieldPosition,
UErrorCode& status) const
{
FieldPositionOnlyHandler handler(fieldPosition);
return _format(number, appendTo, handler, status);
}
UnicodeString&
DecimalFormat::format(int64_t number,
UnicodeString& appendTo,
FieldPositionIterator* posIter,
UErrorCode& status) const
{
FieldPositionIteratorHandler handler(posIter, status);
return _format(number, appendTo, handler, status);
}
UnicodeString&
DecimalFormat::_format(int64_t number,
UnicodeString& appendTo,
FieldPositionHandler& handler,
UErrorCode &status) const
{
// Bottleneck function for formatting int64_t
if (U_FAILURE(status)) {
return appendTo;
}
#if UCONFIG_FORMAT_FASTPATHS_49
// const UnicodeString *posPrefix = fPosPrefixPattern;
// const UnicodeString *posSuffix = fPosSuffixPattern;
// const UnicodeString *negSuffix = fNegSuffixPattern;
const DecimalFormatInternal &data = internalData(fReserved);
#ifdef FMT_DEBUG
data.dump();
printf("fastpath? [%d]\n", number);
#endif
if( data.fFastFormatStatus==kFastpathYES) {
#define kZero 0x0030
const int32_t MAX_IDX = MAX_DIGITS+2;
UChar outputStr[MAX_IDX];
int32_t destIdx = MAX_IDX;
outputStr[--destIdx] = 0; // term
int64_t n = number;
if (number < 1) {
// Negative numbers are slightly larger than positive
// output the first digit (or the leading zero)
outputStr[--destIdx] = (-(n % 10) + kZero);
n /= -10;
}
// get any remaining digits
while (n > 0) {
outputStr[--destIdx] = (n % 10) + kZero;
n /= 10;
}
// Slide the number to the start of the output str
U_ASSERT(destIdx >= 0);
int32_t length = MAX_IDX - destIdx -1;
/*int32_t prefixLen = */ appendAffix(appendTo, number, handler, number<0, TRUE);
int32_t maxIntDig = getMaximumIntegerDigits();
int32_t destlength = length<=maxIntDig?length:maxIntDig; // dest length pinned to max int digits
if(length>maxIntDig && fBoolFlags.contains(UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS)) {
status = U_ILLEGAL_ARGUMENT_ERROR;
}
int32_t prependZero = getMinimumIntegerDigits() - destlength;
#ifdef FMT_DEBUG
printf("prependZero=%d, length=%d, minintdig=%d maxintdig=%d destlength=%d skip=%d\n", prependZero, length, getMinimumIntegerDigits(), maxIntDig, destlength, length-destlength);
#endif
int32_t intBegin = appendTo.length();
while((prependZero--)>0) {
appendTo.append((UChar)0x0030); // '0'
}
appendTo.append(outputStr+destIdx+
(length-destlength), // skip any leading digits
destlength);
handler.addAttribute(kIntegerField, intBegin, appendTo.length());
/*int32_t suffixLen =*/ appendAffix(appendTo, number, handler, number<0, FALSE);
//outputStr[length]=0;
#ifdef FMT_DEBUG
printf("Writing [%s] length [%d] max %d for [%d]\n", outputStr+destIdx, length, MAX_IDX, number);
#endif
#undef kZero
return appendTo;
} // end fastpath
#endif
// Else the slow way - via DigitList
DigitList digits;
digits.set(number);
return _format(digits, appendTo, handler, status);
}
//------------------------------------------------------------------------------
UnicodeString&
DecimalFormat::format( double number,
UnicodeString& appendTo,
FieldPosition& fieldPosition) const
{
UErrorCode status = U_ZERO_ERROR; /* ignored */
FieldPositionOnlyHandler handler(fieldPosition);
return _format(number, appendTo, handler, status);
}
UnicodeString&
DecimalFormat::format( double number,
UnicodeString& appendTo,
FieldPosition& fieldPosition,
UErrorCode& status) const
{
FieldPositionOnlyHandler handler(fieldPosition);
return _format(number, appendTo, handler, status);
}
UnicodeString&
DecimalFormat::format( double number,
UnicodeString& appendTo,
FieldPositionIterator* posIter,
UErrorCode& status) const
{
FieldPositionIteratorHandler handler(posIter, status);
return _format(number, appendTo, handler, status);
}
UnicodeString&
DecimalFormat::_format( double number,
UnicodeString& appendTo,
FieldPositionHandler& handler,
UErrorCode &status) const
{
if (U_FAILURE(status)) {
return appendTo;
}
// Special case for NaN, sets the begin and end index to be the
// the string length of localized name of NaN.
// TODO: let NaNs go through DigitList.
if (uprv_isNaN(number))
{
int begin = appendTo.length();
appendTo += getConstSymbol(DecimalFormatSymbols::kNaNSymbol);
handler.addAttribute(kIntegerField, begin, appendTo.length());
addPadding(appendTo, handler, 0, 0);
return appendTo;
}
DigitList digits;
digits.set(number);
_format(digits, appendTo, handler, status);
// No way to return status from here.
return appendTo;
}
//------------------------------------------------------------------------------
UnicodeString&
DecimalFormat::format(const StringPiece &number,
UnicodeString &toAppendTo,
FieldPositionIterator *posIter,
UErrorCode &status) const
{
#if UCONFIG_FORMAT_FASTPATHS_49
// don't bother if the int64 path is not optimized
int32_t len = number.length();
if(len>0&&len<10) { /* 10 or more digits may not be an int64 */
const char *data = number.data();
int64_t num = 0;
UBool neg = FALSE;
UBool ok = TRUE;
int32_t start = 0;
if(data[start]=='+') {
start++;
} else if(data[start]=='-') {
neg=TRUE;
start++;
}
int32_t place = 1; /* 1, 10, ... */
for(int32_t i=len-1;i>=start;i--) {
if(data[i]>='0'&&data[i]<='9') {
num+=place*(int64_t)(data[i]-'0');
} else {
ok=FALSE;
break;
}
place *= 10;
}
if(ok) {
if(neg) {
num = -num;// add minus bit
}
// format as int64_t
return format(num, toAppendTo, posIter, status);
}
// else fall through
}
#endif
DigitList dnum;
dnum.set(number, status);
if (U_FAILURE(status)) {
return toAppendTo;
}
FieldPositionIteratorHandler handler(posIter, status);
_format(dnum, toAppendTo, handler, status);
return toAppendTo;
}
UnicodeString&
DecimalFormat::format(const DigitList &number,
UnicodeString &appendTo,
FieldPositionIterator *posIter,
UErrorCode &status) const {
FieldPositionIteratorHandler handler(posIter, status);
_format(number, appendTo, handler, status);
return appendTo;
}
UnicodeString&
DecimalFormat::format(const DigitList &number,
UnicodeString& appendTo,
FieldPosition& pos,
UErrorCode &status) const {
FieldPositionOnlyHandler handler(pos);
_format(number, appendTo, handler, status);
return appendTo;
}
DigitList&
DecimalFormat::_round(const DigitList &number, DigitList &adjustedNum, UBool& isNegative, UErrorCode &status) const {
if (U_FAILURE(status)) {
return adjustedNum;
}
// note: number and adjustedNum may refer to the same DigitList, in cases where a copy
// is not needed by the caller.
adjustedNum = number;
isNegative = false;
if (number.isNaN()) {
return adjustedNum;
}
// Do this BEFORE checking to see if value is infinite or negative! Sets the
// begin and end index to be length of the string composed of
// localized name of Infinite and the positive/negative localized
// signs.
adjustedNum.setRoundingMode(fRoundingMode);
if (fMultiplier != NULL) {
adjustedNum.mult(*fMultiplier, status);
if (U_FAILURE(status)) {
return adjustedNum;
}
}
if (fScale != 0) {
DigitList ten;
ten.set((int32_t)10);
if (fScale > 0) {
for (int32_t i = fScale ; i > 0 ; i--) {
adjustedNum.mult(ten, status);
if (U_FAILURE(status)) {
return adjustedNum;
}
}
} else {
for (int32_t i = fScale ; i < 0 ; i++) {
adjustedNum.div(ten, status);
if (U_FAILURE(status)) {
return adjustedNum;
}
}
}
}
/*
* Note: sign is important for zero as well as non-zero numbers.
* Proper detection of -0.0 is needed to deal with the
* issues raised by bugs 4106658, 4106667, and 4147706. Liu 7/6/98.
*/
isNegative = !adjustedNum.isPositive();
// Apply rounding after multiplier
adjustedNum.fContext.status &= ~DEC_Inexact;
if (fRoundingIncrement != NULL) {
adjustedNum.div(*fRoundingIncrement, status);
adjustedNum.toIntegralValue();
adjustedNum.mult(*fRoundingIncrement, status);
adjustedNum.trim();
if (U_FAILURE(status)) {
return adjustedNum;
}
}
if (fRoundingMode == kRoundUnnecessary && (adjustedNum.fContext.status & DEC_Inexact)) {
status = U_FORMAT_INEXACT_ERROR;
return adjustedNum;
}
if (adjustedNum.isInfinite()) {
return adjustedNum;
}
if (fUseExponentialNotation || areSignificantDigitsUsed()) {
int32_t sigDigits = precision();
if (sigDigits > 0) {
adjustedNum.round(sigDigits);
}
} else {
// Fixed point format. Round to a set number of fraction digits.
int32_t numFractionDigits = precision();
adjustedNum.roundFixedPoint(numFractionDigits);
}
if (fRoundingMode == kRoundUnnecessary && (adjustedNum.fContext.status & DEC_Inexact)) {
status = U_FORMAT_INEXACT_ERROR;
return adjustedNum;
}
return adjustedNum;
}
UnicodeString&
DecimalFormat::_format(const DigitList &number,
UnicodeString& appendTo,
FieldPositionHandler& handler,
UErrorCode &status) const
{
if (U_FAILURE(status)) {
return appendTo;
}
// Special case for NaN, sets the begin and end index to be the
// the string length of localized name of NaN.
if (number.isNaN())
{
int begin = appendTo.length();
appendTo += getConstSymbol(DecimalFormatSymbols::kNaNSymbol);
handler.addAttribute(kIntegerField, begin, appendTo.length());
addPadding(appendTo, handler, 0, 0);
return appendTo;
}
DigitList adjustedNum;
UBool isNegative;
_round(number, adjustedNum, isNegative, status);
if (U_FAILURE(status)) {
return appendTo;
}
// Special case for INFINITE,
if (adjustedNum.isInfinite()) {
int32_t prefixLen = appendAffix(appendTo, adjustedNum.getDouble(), handler, isNegative, TRUE);
int begin = appendTo.length();
appendTo += getConstSymbol(DecimalFormatSymbols::kInfinitySymbol);
handler.addAttribute(kIntegerField, begin, appendTo.length());
int32_t suffixLen = appendAffix(appendTo, adjustedNum.getDouble(), handler, isNegative, FALSE);
addPadding(appendTo, handler, prefixLen, suffixLen);
return appendTo;
}
return subformat(appendTo, handler, adjustedNum, FALSE, status);
}
/**
* Return true if a grouping separator belongs at the given
* position, based on whether grouping is in use and the values of
* the primary and secondary grouping interval.
* @param pos the number of integer digits to the right of
* the current position. Zero indicates the position after the
* rightmost integer digit.
* @return true if a grouping character belongs at the current
* position.
*/
UBool DecimalFormat::isGroupingPosition(int32_t pos) const {
UBool result = FALSE;
if (isGroupingUsed() && (pos > 0) && (fGroupingSize > 0)) {
if ((fGroupingSize2 > 0) && (pos > fGroupingSize)) {
result = ((pos - fGroupingSize) % fGroupingSize2) == 0;
} else {
result = pos % fGroupingSize == 0;
}
}
return result;
}
//------------------------------------------------------------------------------
/**
* Complete the formatting of a finite number. On entry, the DigitList must
* be filled in with the correct digits.
*/
UnicodeString&
DecimalFormat::subformat(UnicodeString& appendTo,
FieldPositionHandler& handler,
DigitList& digits,
UBool isInteger,
UErrorCode& status) const
{
// char zero = '0';
// DigitList returns digits as '0' thru '9', so we will need to
// always need to subtract the character 0 to get the numeric value to use for indexing.
UChar32 localizedDigits[10];
localizedDigits[0] = getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0);
localizedDigits[1] = getConstSymbol(DecimalFormatSymbols::kOneDigitSymbol).char32At(0);
localizedDigits[2] = getConstSymbol(DecimalFormatSymbols::kTwoDigitSymbol).char32At(0);
localizedDigits[3] = getConstSymbol(DecimalFormatSymbols::kThreeDigitSymbol).char32At(0);
localizedDigits[4] = getConstSymbol(DecimalFormatSymbols::kFourDigitSymbol).char32At(0);
localizedDigits[5] = getConstSymbol(DecimalFormatSymbols::kFiveDigitSymbol).char32At(0);
localizedDigits[6] = getConstSymbol(DecimalFormatSymbols::kSixDigitSymbol).char32At(0);
localizedDigits[7] = getConstSymbol(DecimalFormatSymbols::kSevenDigitSymbol).char32At(0);
localizedDigits[8] = getConstSymbol(DecimalFormatSymbols::kEightDigitSymbol).char32At(0);
localizedDigits[9] = getConstSymbol(DecimalFormatSymbols::kNineDigitSymbol).char32At(0);
const UnicodeString *grouping ;
if(fCurrencySignCount == fgCurrencySignCountZero) {
grouping = &getConstSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
}else{
grouping = &getConstSymbol(DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol);
}
const UnicodeString *decimal;
if(fCurrencySignCount == fgCurrencySignCountZero) {
decimal = &getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
} else {
decimal = &getConstSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol);
}
UBool useSigDig = areSignificantDigitsUsed();
int32_t maxIntDig = getMaximumIntegerDigits();
int32_t minIntDig = getMinimumIntegerDigits();
// Appends the prefix.
double doubleValue = digits.getDouble();
int32_t prefixLen = appendAffix(appendTo, doubleValue, handler, !digits.isPositive(), TRUE);
if (fUseExponentialNotation)
{
int currentLength = appendTo.length();
int intBegin = currentLength;
int intEnd = -1;
int fracBegin = -1;
int32_t minFracDig = 0;
if (useSigDig) {
maxIntDig = minIntDig = 1;
minFracDig = getMinimumSignificantDigits() - 1;
} else {
minFracDig = getMinimumFractionDigits();
if (maxIntDig > kMaxScientificIntegerDigits) {
maxIntDig = 1;
if (maxIntDig < minIntDig) {
maxIntDig = minIntDig;
}
}
if (maxIntDig > minIntDig) {
minIntDig = 1;
}
}
// Minimum integer digits are handled in exponential format by
// adjusting the exponent. For example, 0.01234 with 3 minimum
// integer digits is "123.4E-4".
// Maximum integer digits are interpreted as indicating the
// repeating range. This is useful for engineering notation, in
// which the exponent is restricted to a multiple of 3. For
// example, 0.01234 with 3 maximum integer digits is "12.34e-3".
// If maximum integer digits are defined and are larger than
// minimum integer digits, then minimum integer digits are
// ignored.
digits.reduce(); // Removes trailing zero digits.
int32_t exponent = digits.getDecimalAt();
if (maxIntDig > 1 && maxIntDig != minIntDig) {
// A exponent increment is defined; adjust to it.
exponent = (exponent > 0) ? (exponent - 1) / maxIntDig
: (exponent / maxIntDig) - 1;
exponent *= maxIntDig;
} else {
// No exponent increment is defined; use minimum integer digits.
// If none is specified, as in "#E0", generate 1 integer digit.
exponent -= (minIntDig > 0 || minFracDig > 0)
? minIntDig : 1;
}
// We now output a minimum number of digits, and more if there
// are more digits, up to the maximum number of digits. We
// place the decimal point after the "integer" digits, which
// are the first (decimalAt - exponent) digits.
int32_t minimumDigits = minIntDig + minFracDig;
// The number of integer digits is handled specially if the number
// is zero, since then there may be no digits.
int32_t integerDigits = digits.isZero() ? minIntDig :
digits.getDecimalAt() - exponent;
int32_t totalDigits = digits.getCount();
if (minimumDigits > totalDigits)
totalDigits = minimumDigits;
if (integerDigits > totalDigits)
totalDigits = integerDigits;
// totalDigits records total number of digits needs to be processed
int32_t i;
for (i=0; i<totalDigits; ++i)
{
if (i == integerDigits)
{
intEnd = appendTo.length();
handler.addAttribute(kIntegerField, intBegin, intEnd);
appendTo += *decimal;
fracBegin = appendTo.length();
handler.addAttribute(kDecimalSeparatorField, fracBegin - 1, fracBegin);
}
// Restores the digit character or pads the buffer with zeros.
UChar32 c = (UChar32)((i < digits.getCount()) ?
localizedDigits[digits.getDigitValue(i)] :
localizedDigits[0]);
appendTo += c;
}
currentLength = appendTo.length();
if (intEnd < 0) {
handler.addAttribute(kIntegerField, intBegin, currentLength);
}
if (fracBegin > 0) {
handler.addAttribute(kFractionField, fracBegin, currentLength);
}
// The exponent is output using the pattern-specified minimum
// exponent digits. There is no maximum limit to the exponent
// digits, since truncating the exponent would appendTo in an
// unacceptable inaccuracy.
appendTo += getConstSymbol(DecimalFormatSymbols::kExponentialSymbol);
handler.addAttribute(kExponentSymbolField, currentLength, appendTo.length());
currentLength = appendTo.length();
// For zero values, we force the exponent to zero. We
// must do this here, and not earlier, because the value
// is used to determine integer digit count above.
if (digits.isZero())
exponent = 0;
if (exponent < 0) {
appendTo += getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
handler.addAttribute(kExponentSignField, currentLength, appendTo.length());
} else if (fExponentSignAlwaysShown) {
appendTo += getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
handler.addAttribute(kExponentSignField, currentLength, appendTo.length());
}
currentLength = appendTo.length();
DigitList expDigits;
expDigits.set(exponent);
{
int expDig = fMinExponentDigits;
if (fUseExponentialNotation && expDig < 1) {
expDig = 1;
}
for (i=expDigits.getDecimalAt(); i<expDig; ++i)
appendTo += (localizedDigits[0]);
}
for (i=0; i<expDigits.getDecimalAt(); ++i)
{
UChar32 c = (UChar32)((i < expDigits.getCount()) ?
localizedDigits[expDigits.getDigitValue(i)] :
localizedDigits[0]);
appendTo += c;
}
handler.addAttribute(kExponentField, currentLength, appendTo.length());
}
else // Not using exponential notation
{
int currentLength = appendTo.length();
int intBegin = currentLength;
int32_t sigCount = 0;
int32_t minSigDig = getMinimumSignificantDigits();
int32_t maxSigDig = getMaximumSignificantDigits();
if (!useSigDig) {
minSigDig = 0;
maxSigDig = INT32_MAX;
}
// Output the integer portion. Here 'count' is the total
// number of integer digits we will display, including both
// leading zeros required to satisfy getMinimumIntegerDigits,
// and actual digits present in the number.
int32_t count = useSigDig ?
_max(1, digits.getDecimalAt()) : minIntDig;
if (digits.getDecimalAt() > 0 && count < digits.getDecimalAt()) {
count = digits.getDecimalAt();
}
// Handle the case where getMaximumIntegerDigits() is smaller
// than the real number of integer digits. If this is so, we
// output the least significant max integer digits. For example,
// the value 1997 printed with 2 max integer digits is just "97".
int32_t digitIndex = 0; // Index into digitList.fDigits[]
if (count > maxIntDig && maxIntDig >= 0) {
count = maxIntDig;
digitIndex = digits.getDecimalAt() - count;
if(fBoolFlags.contains(UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS)) {
status = U_ILLEGAL_ARGUMENT_ERROR;
}
}
int32_t sizeBeforeIntegerPart = appendTo.length();
int32_t i;
for (i=count-1; i>=0; --i)
{
if (i < digits.getDecimalAt() && digitIndex < digits.getCount() &&
sigCount < maxSigDig) {
// Output a real digit
appendTo += (UChar32)localizedDigits[digits.getDigitValue(digitIndex++)];
++sigCount;
}
else
{
// Output a zero (leading or trailing)
appendTo += localizedDigits[0];
if (sigCount > 0) {
++sigCount;
}
}
// Output grouping separator if necessary.
if (isGroupingPosition(i)) {
currentLength = appendTo.length();
appendTo.append(*grouping);
handler.addAttribute(kGroupingSeparatorField, currentLength, appendTo.length());
}
}
// This handles the special case of formatting 0. For zero only, we count the
// zero to the left of the decimal point as one signficant digit. Ordinarily we
// do not count any leading 0's as significant. If the number we are formatting
// is not zero, then either sigCount or digits.getCount() will be non-zero.
if (sigCount == 0 && digits.getCount() == 0) {
sigCount = 1;
}
// TODO(dlf): this looks like it was a bug, we marked the int field as ending
// before the zero was generated.
// Record field information for caller.
// if (fieldPosition.getField() == NumberFormat::kIntegerField)
// fieldPosition.setEndIndex(appendTo.length());
// Determine whether or not there are any printable fractional
// digits. If we've used up the digits we know there aren't.
UBool fractionPresent = (!isInteger && digitIndex < digits.getCount()) ||
(useSigDig ? (sigCount < minSigDig) : (getMinimumFractionDigits() > 0));
// If there is no fraction present, and we haven't printed any
// integer digits, then print a zero. Otherwise we won't print
// _any_ digits, and we won't be able to parse this string.
if (!fractionPresent && appendTo.length() == sizeBeforeIntegerPart)
appendTo += localizedDigits[0];
currentLength = appendTo.length();
handler.addAttribute(kIntegerField, intBegin, currentLength);
// Output the decimal separator if we always do so.
if (fDecimalSeparatorAlwaysShown || fractionPresent) {
appendTo += *decimal;
handler.addAttribute(kDecimalSeparatorField, currentLength, appendTo.length());
currentLength = appendTo.length();
}
int fracBegin = currentLength;
count = useSigDig ? INT32_MAX : getMaximumFractionDigits();
if (useSigDig && (sigCount == maxSigDig ||
(sigCount >= minSigDig && digitIndex == digits.getCount()))) {
count = 0;
}
for (i=0; i < count; ++i) {
// Here is where we escape from the loop. We escape
// if we've output the maximum fraction digits
// (specified in the for expression above). We also
// stop when we've output the minimum digits and
// either: we have an integer, so there is no
// fractional stuff to display, or we're out of
// significant digits.
if (!useSigDig && i >= getMinimumFractionDigits() &&
(isInteger || digitIndex >= digits.getCount())) {
break;
}
// Output leading fractional zeros. These are zeros
// that come after the decimal but before any
// significant digits. These are only output if
// abs(number being formatted) < 1.0.
if (-1-i > (digits.getDecimalAt()-1)) {
appendTo += localizedDigits[0];
continue;
}
// Output a digit, if we have any precision left, or a
// zero if we don't. We don't want to output noise digits.
if (!isInteger && digitIndex < digits.getCount()) {
appendTo += (UChar32)localizedDigits[digits.getDigitValue(digitIndex++)];
} else {
appendTo += localizedDigits[0];
}
// If we reach the maximum number of significant
// digits, or if we output all the real digits and
// reach the minimum, then we are done.
++sigCount;
if (useSigDig &&
(sigCount == maxSigDig ||
(digitIndex == digits.getCount() && sigCount >= minSigDig))) {
break;
}
}
handler.addAttribute(kFractionField, fracBegin, appendTo.length());
}
int32_t suffixLen = appendAffix(appendTo, doubleValue, handler, !digits.isPositive(), FALSE);
addPadding(appendTo, handler, prefixLen, suffixLen);
return appendTo;
}
/**
* Inserts the character fPad as needed to expand result to fFormatWidth.
* @param result the string to be padded
*/
void DecimalFormat::addPadding(UnicodeString& appendTo,
FieldPositionHandler& handler,
int32_t prefixLen,
int32_t suffixLen) const
{
if (fFormatWidth > 0) {
int32_t len = fFormatWidth - appendTo.length();
if (len > 0) {
UnicodeString padding;
for (int32_t i=0; i<len; ++i) {
padding += fPad;
}
switch (fPadPosition) {
case kPadAfterPrefix:
appendTo.insert(prefixLen, padding);
break;
case kPadBeforePrefix:
appendTo.insert(0, padding);
break;
case kPadBeforeSuffix:
appendTo.insert(appendTo.length() - suffixLen, padding);
break;
case kPadAfterSuffix:
appendTo += padding;
break;
}
if (fPadPosition == kPadBeforePrefix || fPadPosition == kPadAfterPrefix) {
handler.shiftLast(len);
}
}
}
}
//------------------------------------------------------------------------------
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));
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:
// Skip padding characters, if around prefix
if (fFormatWidth > 0 && (fPadPosition == kPadBeforePrefix ||
fPadPosition == 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 = &getConstSymbol(DecimalFormatSymbols::kNaNSymbol);
int32_t nanLen = (text.compare(i, nan->length(), *nan)
? 0 : nan->length());
if (nanLen) {
i += nanLen;
if (fFormatWidth > 0 && (fPadPosition == kPadBeforeSuffix ||
fPadPosition == 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 (fCurrencySignCount != fgCurrencySignCountZero) {
if (!parseForCurrency(text, parsePosition, *digits,
status, currency)) {
return;
}
} else {
if (!subparse(text,
fNegPrefixPattern, fNegSuffixPattern,
fPosPrefixPattern, fPosSuffixPattern,
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 (fMultiplier != NULL) {
UErrorCode ec = U_ZERO_ERROR;
digits->div(*fMultiplier, ec);
}
if (fScale != 0) {
DigitList ten;
ten.set((int32_t)10);
if (fScale > 0) {
for (int32_t i = fScale; i > 0; i--) {
UErrorCode ec = U_ZERO_ERROR;
digits->div(ten,ec);
}
} else {
for (int32_t i = 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 {
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,
fNegPrefixPattern, fNegSuffixPattern,
fPosPrefixPattern, fPosSuffixPattern,
TRUE, UCURR_LONG_NAME,
tmpPos, tmpDigitList, tmpStatus, currency);
} else {
found = subparse(text,
fNegPrefixPattern, fNegSuffixPattern,
fPosPrefixPattern, fPosSuffixPattern,
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 = -1;
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,
&fNegativePrefix, &fNegativeSuffix,
&fPositivePrefix, &fPositiveSuffix,
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 = getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0);
const UnicodeString *groupingString = &getConstSymbol(fCurrencySignCount == fgCurrencySignCountZero ?
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);
printf("currencyParsing=%d, fFormatWidth=%d, isParseIntegerOnly=%c text.length=%d negPrefLen=%d\n", currencyParsing, fFormatWidth, (isParseIntegerOnly())?'Y':'N', text.length(), negPrefix!=NULL?negPrefix->length():-1);
#endif
UBool fastParseOk = false; /* TRUE iff fast parse is OK */
// UBool fastParseHadDecimal = FALSE; /* true if fast parse saw a decimal point. */
const DecimalFormatInternal &data = internalData(fReserved);
if((data.fFastParseStatus==kFastpathYES) &&
fCurrencySignCount == fgCurrencySignCountZero &&
// (negPrefix!=NULL&&negPrefix->isEmpty()) ||
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 = &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
#ifdef FMT_DEBUG
printf("PP -> %d, good = [%s] digitcount=%d, fGroupingSize=%d fGroupingSize2=%d!\n", j, parsedNum.data(), digitCount, fGroupingSize, fGroupingSize2);
#endif
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("fFormatWidth=%d ", fFormatWidth);
printf("text.length()=%d ", text.length());
printf("posPrefix=%p posSuffix=%p ", posPrefix, posSuffix);
printf("\n");
#endif
}
if(!fastParseOk
#if UCONFIG_HAVE_PARSEALLINPUT
&& fParseAllInput!=UNUM_YES
#endif
)
{
// Match padding before prefix
if (fFormatWidth > 0 && fPadPosition == 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 (fFormatWidth > 0 && fPadPosition == kPadAfterPrefix) {
position = skipPadding(text, position);
}
if (! strictParse) {
position = skipUWhiteSpace(text, position);
}
// process digits or Inf, find decimal position
const UnicodeString *inf = &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