| /* | |
| ********************************************************************** | |
| * Copyright (C) 1997-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ********************************************************************** | |
| * | |
| * File DIGITLST.CPP | |
| * | |
| * Modification History: | |
| * | |
| * Date Name Description | |
| * 03/21/97 clhuang Converted from java. | |
| * 03/21/97 clhuang Implemented with new APIs. | |
| * 03/27/97 helena Updated to pass the simple test after code review. | |
| * 03/31/97 aliu Moved isLONG_MIN to here, and fixed it. | |
| * 04/15/97 aliu Changed MAX_COUNT to DBL_DIG. Changed Digit to char. | |
| * Reworked representation by replacing fDecimalAt | |
| * with fExponent. | |
| * 04/16/97 aliu Rewrote set() and getDouble() to use sprintf/atof | |
| * to do digit conversion. | |
| * 09/09/97 aliu Modified for exponential notation support. | |
| * 08/02/98 stephen Added nearest/even rounding | |
| * Fixed bug in fitsIntoLong | |
| ****************************************************************************** | |
| */ | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/stdlib_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "digitlst.h" | |
| // Must go after digitlst.h, or a compile error occurs. | |
| #include "starboard/client_porting/poem/stdio_poem.h" | |
| #include "starboard/client_porting/poem/wchar_poem.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "unicode/putil.h" | |
| #include "charstr.h" | |
| #include "cmemory.h" | |
| #include "cstring.h" | |
| #include "mutex.h" | |
| #include "putilimp.h" | |
| #include "uassert.h" | |
| #include "digitinterval.h" | |
| #if !defined(STARBOARD) | |
| #include <stdlib.h> | |
| #include <limits.h> | |
| #include <string.h> | |
| #include <stdio.h> | |
| #endif | |
| #include <limits> | |
| // *************************************************************************** | |
| // class DigitList | |
| // A wrapper onto decNumber. | |
| // Used to be standalone. | |
| // *************************************************************************** | |
| /** | |
| * This is the zero digit. The base for the digits returned by getDigit() | |
| * Note that it is the platform invariant digit, and is not Unicode. | |
| */ | |
| #define kZero '0' | |
| /* Only for 32 bit numbers. Ignore the negative sign. */ | |
| //static const char LONG_MIN_REP[] = "2147483648"; | |
| //static const char I64_MIN_REP[] = "9223372036854775808"; | |
| U_NAMESPACE_BEGIN | |
| // ------------------------------------- | |
| // default constructor | |
| DigitList::DigitList() | |
| { | |
| uprv_decContextDefault(&fContext, DEC_INIT_BASE); | |
| fContext.traps = 0; | |
| uprv_decContextSetRounding(&fContext, DEC_ROUND_HALF_EVEN); | |
| fContext.digits = fStorage.getCapacity(); | |
| fDecNumber = fStorage.getAlias(); | |
| uprv_decNumberZero(fDecNumber); | |
| internalSetDouble(0.0); | |
| } | |
| // ------------------------------------- | |
| DigitList::~DigitList() | |
| { | |
| } | |
| // ------------------------------------- | |
| // copy constructor | |
| DigitList::DigitList(const DigitList &other) | |
| { | |
| fDecNumber = fStorage.getAlias(); | |
| *this = other; | |
| } | |
| // ------------------------------------- | |
| // assignment operator | |
| DigitList& | |
| DigitList::operator=(const DigitList& other) | |
| { | |
| if (this != &other) | |
| { | |
| uprv_memcpy(&fContext, &other.fContext, sizeof(decContext)); | |
| if (other.fStorage.getCapacity() > fStorage.getCapacity()) { | |
| fDecNumber = fStorage.resize(other.fStorage.getCapacity()); | |
| } | |
| // Always reset the fContext.digits, even if fDecNumber was not reallocated, | |
| // because above we copied fContext from other.fContext. | |
| fContext.digits = fStorage.getCapacity(); | |
| uprv_decNumberCopy(fDecNumber, other.fDecNumber); | |
| { | |
| // fDouble is lazily created and cached. | |
| // Avoid potential races with that happening with other.fDouble | |
| // while we are doing the assignment. | |
| Mutex mutex; | |
| if(other.fHave==kDouble) { | |
| fUnion.fDouble = other.fUnion.fDouble; | |
| } else if(other.fHave==kInt64) { | |
| fUnion.fInt64 = other.fUnion.fInt64; | |
| } | |
| fHave = other.fHave; | |
| } | |
| } | |
| return *this; | |
| } | |
| // ------------------------------------- | |
| // operator == (does not exactly match the old DigitList function) | |
| UBool | |
| DigitList::operator==(const DigitList& that) const | |
| { | |
| if (this == &that) { | |
| return TRUE; | |
| } | |
| decNumber n; // Has space for only a none digit value. | |
| decContext c; | |
| uprv_decContextDefault(&c, DEC_INIT_BASE); | |
| c.digits = 1; | |
| c.traps = 0; | |
| uprv_decNumberCompare(&n, this->fDecNumber, that.fDecNumber, &c); | |
| UBool result = decNumberIsZero(&n); | |
| return result; | |
| } | |
| // ------------------------------------- | |
| // comparison function. Returns | |
| // Not Comparable : -2 | |
| // < : -1 | |
| // == : 0 | |
| // > : +1 | |
| int32_t DigitList::compare(const DigitList &other) { | |
| decNumber result; | |
| int32_t savedDigits = fContext.digits; | |
| fContext.digits = 1; | |
| uprv_decNumberCompare(&result, this->fDecNumber, other.fDecNumber, &fContext); | |
| fContext.digits = savedDigits; | |
| if (decNumberIsZero(&result)) { | |
| return 0; | |
| } else if (decNumberIsSpecial(&result)) { | |
| return -2; | |
| } else if (result.bits & DECNEG) { | |
| return -1; | |
| } else { | |
| return 1; | |
| } | |
| } | |
| // ------------------------------------- | |
| // Reduce - remove trailing zero digits. | |
| void | |
| DigitList::reduce() { | |
| uprv_decNumberReduce(fDecNumber, fDecNumber, &fContext); | |
| } | |
| // ------------------------------------- | |
| // trim - remove trailing fraction zero digits. | |
| void | |
| DigitList::trim() { | |
| uprv_decNumberTrim(fDecNumber); | |
| } | |
| // ------------------------------------- | |
| // Resets the digit list; sets all the digits to zero. | |
| void | |
| DigitList::clear() | |
| { | |
| uprv_decNumberZero(fDecNumber); | |
| uprv_decContextSetRounding(&fContext, DEC_ROUND_HALF_EVEN); | |
| internalSetDouble(0.0); | |
| } | |
| /** | |
| * Formats a int64_t number into a base 10 string representation, and NULL terminates it. | |
| * @param number The number to format | |
| * @param outputStr The string to output to. Must be at least MAX_DIGITS+2 in length (21), | |
| * to hold the longest int64_t value. | |
| * @return the number of digits written, not including the sign. | |
| */ | |
| static int32_t | |
| formatBase10(int64_t number, char *outputStr) { | |
| // The number is output backwards, starting with the LSD. | |
| // Fill the buffer from the far end. After the number is complete, | |
| // slide the string contents to the front. | |
| const int32_t MAX_IDX = MAX_DIGITS+2; | |
| int32_t destIdx = MAX_IDX; | |
| outputStr[--destIdx] = 0; | |
| int64_t n = number; | |
| if (number < 0) { // Negative numbers are slightly larger than a postive | |
| outputStr[--destIdx] = (char)(-(n % 10) + kZero); | |
| n /= -10; | |
| } | |
| do { | |
| outputStr[--destIdx] = (char)(n % 10 + kZero); | |
| n /= 10; | |
| } while (n > 0); | |
| if (number < 0) { | |
| outputStr[--destIdx] = '-'; | |
| } | |
| // Slide the number to the start of the output str | |
| U_ASSERT(destIdx >= 0); | |
| int32_t length = MAX_IDX - destIdx; | |
| uprv_memmove(outputStr, outputStr+MAX_IDX-length, length); | |
| return length; | |
| } | |
| // ------------------------------------- | |
| // | |
| // setRoundingMode() | |
| // For most modes, the meaning and names are the same between the decNumber library | |
| // (which DigitList follows) and the ICU Formatting Rounding Mode values. | |
| // The flag constants are different, however. | |
| // | |
| // Note that ICU's kRoundingUnnecessary is not implemented directly by DigitList. | |
| // This mode, inherited from Java, means that numbers that would not format exactly | |
| // will return an error when formatting is attempted. | |
| void | |
| DigitList::setRoundingMode(DecimalFormat::ERoundingMode m) { | |
| enum rounding r; | |
| switch (m) { | |
| case DecimalFormat::kRoundCeiling: r = DEC_ROUND_CEILING; break; | |
| case DecimalFormat::kRoundFloor: r = DEC_ROUND_FLOOR; break; | |
| case DecimalFormat::kRoundDown: r = DEC_ROUND_DOWN; break; | |
| case DecimalFormat::kRoundUp: r = DEC_ROUND_UP; break; | |
| case DecimalFormat::kRoundHalfEven: r = DEC_ROUND_HALF_EVEN; break; | |
| case DecimalFormat::kRoundHalfDown: r = DEC_ROUND_HALF_DOWN; break; | |
| case DecimalFormat::kRoundHalfUp: r = DEC_ROUND_HALF_UP; break; | |
| case DecimalFormat::kRoundUnnecessary: r = DEC_ROUND_HALF_EVEN; break; | |
| default: | |
| // TODO: how to report the problem? | |
| // Leave existing mode unchanged. | |
| r = uprv_decContextGetRounding(&fContext); | |
| } | |
| uprv_decContextSetRounding(&fContext, r); | |
| } | |
| // ------------------------------------- | |
| void | |
| DigitList::setPositive(UBool s) { | |
| if (s) { | |
| fDecNumber->bits &= ~DECNEG; | |
| } else { | |
| fDecNumber->bits |= DECNEG; | |
| } | |
| internalClear(); | |
| } | |
| // ------------------------------------- | |
| void | |
| DigitList::setDecimalAt(int32_t d) { | |
| U_ASSERT((fDecNumber->bits & DECSPECIAL) == 0); // Not Infinity or NaN | |
| U_ASSERT(d-1>-999999999); | |
| U_ASSERT(d-1< 999999999); | |
| int32_t adjustedDigits = fDecNumber->digits; | |
| if (decNumberIsZero(fDecNumber)) { | |
| // Account for difference in how zero is represented between DigitList & decNumber. | |
| adjustedDigits = 0; | |
| } | |
| fDecNumber->exponent = d - adjustedDigits; | |
| internalClear(); | |
| } | |
| int32_t | |
| DigitList::getDecimalAt() { | |
| U_ASSERT((fDecNumber->bits & DECSPECIAL) == 0); // Not Infinity or NaN | |
| if (decNumberIsZero(fDecNumber) || ((fDecNumber->bits & DECSPECIAL) != 0)) { | |
| return fDecNumber->exponent; // Exponent should be zero for these cases. | |
| } | |
| return fDecNumber->exponent + fDecNumber->digits; | |
| } | |
| void | |
| DigitList::setCount(int32_t c) { | |
| U_ASSERT(c <= fContext.digits); | |
| if (c == 0) { | |
| // For a value of zero, DigitList sets all fields to zero, while | |
| // decNumber keeps one digit (with that digit being a zero) | |
| c = 1; | |
| fDecNumber->lsu[0] = 0; | |
| } | |
| fDecNumber->digits = c; | |
| internalClear(); | |
| } | |
| int32_t | |
| DigitList::getCount() const { | |
| if (decNumberIsZero(fDecNumber) && fDecNumber->exponent==0) { | |
| // The extra test for exponent==0 is needed because parsing sometimes appends | |
| // zero digits. It's bogus, decimalFormatter parsing needs to be cleaned up. | |
| return 0; | |
| } else { | |
| return fDecNumber->digits; | |
| } | |
| } | |
| void | |
| DigitList::setDigit(int32_t i, char v) { | |
| int32_t count = fDecNumber->digits; | |
| U_ASSERT(i<count); | |
| U_ASSERT(v>='0' && v<='9'); | |
| v &= 0x0f; | |
| fDecNumber->lsu[count-i-1] = v; | |
| internalClear(); | |
| } | |
| char | |
| DigitList::getDigit(int32_t i) { | |
| int32_t count = fDecNumber->digits; | |
| U_ASSERT(i<count); | |
| return fDecNumber->lsu[count-i-1] + '0'; | |
| } | |
| // copied from DigitList::getDigit() | |
| uint8_t | |
| DigitList::getDigitValue(int32_t i) { | |
| int32_t count = fDecNumber->digits; | |
| U_ASSERT(i<count); | |
| return fDecNumber->lsu[count-i-1]; | |
| } | |
| // ------------------------------------- | |
| // Appends the digit to the digit list if it's not out of scope. | |
| // Ignores the digit, otherwise. | |
| // | |
| // This function is horribly inefficient to implement with decNumber because | |
| // the digits are stored least significant first, which requires moving all | |
| // existing digits down one to make space for the new one to be appended. | |
| // | |
| void | |
| DigitList::append(char digit) | |
| { | |
| U_ASSERT(digit>='0' && digit<='9'); | |
| // Ignore digits which exceed the precision we can represent | |
| // And don't fix for larger precision. Fix callers instead. | |
| if (decNumberIsZero(fDecNumber)) { | |
| // Zero needs to be special cased because of the difference in the way | |
| // that the old DigitList and decNumber represent it. | |
| // digit cout was zero for digitList, is one for decNumber | |
| fDecNumber->lsu[0] = digit & 0x0f; | |
| fDecNumber->digits = 1; | |
| fDecNumber->exponent--; // To match the old digit list implementation. | |
| } else { | |
| int32_t nDigits = fDecNumber->digits; | |
| if (nDigits < fContext.digits) { | |
| int i; | |
| for (i=nDigits; i>0; i--) { | |
| fDecNumber->lsu[i] = fDecNumber->lsu[i-1]; | |
| } | |
| fDecNumber->lsu[0] = digit & 0x0f; | |
| fDecNumber->digits++; | |
| // DigitList emulation - appending doesn't change the magnitude of existing | |
| // digits. With decNumber's decimal being after the | |
| // least signficant digit, we need to adjust the exponent. | |
| fDecNumber->exponent--; | |
| } | |
| } | |
| internalClear(); | |
| } | |
| char DigitList::getStrtodDecimalSeparator() { | |
| // TODO: maybe use andy's pthread once. | |
| static char gDecimal = 0; | |
| char result; | |
| { | |
| Mutex mutex; | |
| result = gDecimal;; | |
| if (result == 0) { | |
| // We need to know the decimal separator character that will be used with strtod(). | |
| // Depends on the C runtime global locale. | |
| // Most commonly is '.' | |
| // TODO: caching could fail if the global locale is changed on the fly. | |
| char rep[MAX_DIGITS]; | |
| sprintf(rep, "%+1.1f", 1.0); | |
| result = rep[2]; | |
| gDecimal = result;; | |
| } | |
| } | |
| return result; | |
| } | |
| // ------------------------------------- | |
| /** | |
| * Currently, getDouble() depends on strtod() to do its conversion. | |
| * | |
| * WARNING!! | |
| * This is an extremely costly function. ~1/2 of the conversion time | |
| * can be linked to this function. | |
| */ | |
| double | |
| DigitList::getDouble() const | |
| { | |
| static char gDecimal = 0; | |
| char decimalSeparator; | |
| { | |
| Mutex mutex; | |
| if (fHave == kDouble) { | |
| return fUnion.fDouble; | |
| } else if(fHave == kInt64) { | |
| return (double)fUnion.fInt64; | |
| } | |
| decimalSeparator = gDecimal; | |
| } | |
| if (decimalSeparator == 0) { | |
| // We need to know the decimal separator character that will be used with strtod(). | |
| // Depends on the C runtime global locale. | |
| // Most commonly is '.' | |
| // TODO: caching could fail if the global locale is changed on the fly. | |
| char rep[MAX_DIGITS]; | |
| sprintf(rep, "%+1.1f", 1.0); | |
| decimalSeparator = rep[2]; | |
| } | |
| double tDouble = 0.0; | |
| if (isZero()) { | |
| tDouble = 0.0; | |
| if (decNumberIsNegative(fDecNumber)) { | |
| tDouble /= -1; | |
| } | |
| } else if (isInfinite()) { | |
| if (std::numeric_limits<double>::has_infinity) { | |
| tDouble = std::numeric_limits<double>::infinity(); | |
| } else { | |
| tDouble = std::numeric_limits<double>::max(); | |
| } | |
| if (!isPositive()) { | |
| tDouble = -tDouble; //this was incorrectly "-fDouble" originally. | |
| } | |
| } else { | |
| MaybeStackArray<char, MAX_DBL_DIGITS+18> s; | |
| // Note: 14 is a magic constant from the decNumber library documentation, | |
| // the max number of extra characters beyond the number of digits | |
| // needed to represent the number in string form. Add a few more | |
| // for the additional digits we retain. | |
| // Round down to appx. double precision, if the number is longer than that. | |
| // Copy the number first, so that we don't modify the original. | |
| if (getCount() > MAX_DBL_DIGITS + 3) { | |
| DigitList numToConvert(*this); | |
| numToConvert.reduce(); // Removes any trailing zeros, so that digit count is good. | |
| numToConvert.round(MAX_DBL_DIGITS+3); | |
| uprv_decNumberToString(numToConvert.fDecNumber, s.getAlias()); | |
| // TODO: how many extra digits should be included for an accurate conversion? | |
| } else { | |
| uprv_decNumberToString(this->fDecNumber, s.getAlias()); | |
| } | |
| U_ASSERT(uprv_strlen(&s[0]) < MAX_DBL_DIGITS+18); | |
| if (decimalSeparator != '.') { | |
| char *decimalPt = strchr(s.getAlias(), '.'); | |
| if (decimalPt != NULL) { | |
| *decimalPt = decimalSeparator; | |
| } | |
| } | |
| char *end = NULL; | |
| tDouble = uprv_strtod(s.getAlias(), &end); | |
| } | |
| { | |
| Mutex mutex; | |
| DigitList *nonConstThis = const_cast<DigitList *>(this); | |
| nonConstThis->internalSetDouble(tDouble); | |
| gDecimal = decimalSeparator; | |
| } | |
| return tDouble; | |
| } | |
| // ------------------------------------- | |
| /** | |
| * convert this number to an int32_t. Round if there is a fractional part. | |
| * Return zero if the number cannot be represented. | |
| */ | |
| int32_t DigitList::getLong() /*const*/ | |
| { | |
| int32_t result = 0; | |
| if (getUpperExponent() > 10) { | |
| // Overflow, absolute value too big. | |
| return result; | |
| } | |
| if (fDecNumber->exponent != 0) { | |
| // Force to an integer, with zero exponent, rounding if necessary. | |
| // (decNumberToInt32 will only work if the exponent is exactly zero.) | |
| DigitList copy(*this); | |
| DigitList zero; | |
| uprv_decNumberQuantize(copy.fDecNumber, copy.fDecNumber, zero.fDecNumber, &fContext); | |
| result = uprv_decNumberToInt32(copy.fDecNumber, &fContext); | |
| } else { | |
| result = uprv_decNumberToInt32(fDecNumber, &fContext); | |
| } | |
| return result; | |
| } | |
| /** | |
| * convert this number to an int64_t. Truncate if there is a fractional part. | |
| * Return zero if the number cannot be represented. | |
| */ | |
| int64_t DigitList::getInt64() /*const*/ { | |
| if(fHave==kInt64) { | |
| return fUnion.fInt64; | |
| } | |
| // Truncate if non-integer. | |
| // Return 0 if out of range. | |
| // Range of in64_t is -9223372036854775808 to 9223372036854775807 (19 digits) | |
| // | |
| if (getUpperExponent() > 19) { | |
| // Overflow, absolute value too big. | |
| return 0; | |
| } | |
| // The number of integer digits may differ from the number of digits stored | |
| // in the decimal number. | |
| // for 12.345 numIntDigits = 2, number->digits = 5 | |
| // for 12E4 numIntDigits = 6, number->digits = 2 | |
| // The conversion ignores the fraction digits in the first case, | |
| // and fakes up extra zero digits in the second. | |
| // TODO: It would be faster to store a table of powers of ten to multiply by | |
| // instead of looping over zero digits, multiplying each time. | |
| int32_t numIntDigits = getUpperExponent(); | |
| uint64_t value = 0; | |
| for (int32_t i = 0; i < numIntDigits; i++) { | |
| // Loop is iterating over digits starting with the most significant. | |
| // Numbers are stored with the least significant digit at index zero. | |
| int32_t digitIndex = fDecNumber->digits - i - 1; | |
| int32_t v = (digitIndex >= 0) ? fDecNumber->lsu[digitIndex] : 0; | |
| value = value * (uint64_t)10 + (uint64_t)v; | |
| } | |
| if (decNumberIsNegative(fDecNumber)) { | |
| value = ~value; | |
| value += 1; | |
| } | |
| int64_t svalue = (int64_t)value; | |
| // Check overflow. It's convenient that the MSD is 9 only on overflow, the amount of | |
| // overflow can't wrap too far. The test will also fail -0, but | |
| // that does no harm; the right answer is 0. | |
| if (numIntDigits == 19) { | |
| if (( decNumberIsNegative(fDecNumber) && svalue>0) || | |
| (!decNumberIsNegative(fDecNumber) && svalue<0)) { | |
| svalue = 0; | |
| } | |
| } | |
| return svalue; | |
| } | |
| /** | |
| * Return a string form of this number. | |
| * Format is as defined by the decNumber library, for interchange of | |
| * decimal numbers. | |
| */ | |
| void DigitList::getDecimal(CharString &str, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // A decimal number in string form can, worst case, be 14 characters longer | |
| // than the number of digits. So says the decNumber library doc. | |
| int32_t maxLength = fDecNumber->digits + 14; | |
| int32_t capacity = 0; | |
| char *buffer = str.clear().getAppendBuffer(maxLength, 0, capacity, status); | |
| if (U_FAILURE(status)) { | |
| return; // Memory allocation error on growing the string. | |
| } | |
| U_ASSERT(capacity >= maxLength); | |
| uprv_decNumberToString(this->fDecNumber, buffer); | |
| U_ASSERT((int32_t)uprv_strlen(buffer) <= maxLength); | |
| str.append(buffer, -1, status); | |
| } | |
| /** | |
| * Return true if this is an integer value that can be held | |
| * by an int32_t type. | |
| */ | |
| UBool | |
| DigitList::fitsIntoLong(UBool ignoreNegativeZero) /*const*/ | |
| { | |
| if (decNumberIsSpecial(this->fDecNumber)) { | |
| // NaN or Infinity. Does not fit in int32. | |
| return FALSE; | |
| } | |
| uprv_decNumberTrim(this->fDecNumber); | |
| if (fDecNumber->exponent < 0) { | |
| // Number contains fraction digits. | |
| return FALSE; | |
| } | |
| if (decNumberIsZero(this->fDecNumber) && !ignoreNegativeZero && | |
| (fDecNumber->bits & DECNEG) != 0) { | |
| // Negative Zero, not ingored. Cannot represent as a long. | |
| return FALSE; | |
| } | |
| if (getUpperExponent() < 10) { | |
| // The number is 9 or fewer digits. | |
| // The max and min int32 are 10 digts, so this number fits. | |
| // This is the common case. | |
| return TRUE; | |
| } | |
| // TODO: Should cache these constants; construction is relatively costly. | |
| // But not of huge consequence; they're only needed for 10 digit ints. | |
| UErrorCode status = U_ZERO_ERROR; | |
| DigitList min32; min32.set("-2147483648", status); | |
| if (this->compare(min32) < 0) { | |
| return FALSE; | |
| } | |
| DigitList max32; max32.set("2147483647", status); | |
| if (this->compare(max32) > 0) { | |
| return FALSE; | |
| } | |
| if (U_FAILURE(status)) { | |
| return FALSE; | |
| } | |
| return true; | |
| } | |
| /** | |
| * Return true if the number represented by this object can fit into | |
| * a long. | |
| */ | |
| UBool | |
| DigitList::fitsIntoInt64(UBool ignoreNegativeZero) /*const*/ | |
| { | |
| if (decNumberIsSpecial(this->fDecNumber)) { | |
| // NaN or Infinity. Does not fit in int32. | |
| return FALSE; | |
| } | |
| uprv_decNumberTrim(this->fDecNumber); | |
| if (fDecNumber->exponent < 0) { | |
| // Number contains fraction digits. | |
| return FALSE; | |
| } | |
| if (decNumberIsZero(this->fDecNumber) && !ignoreNegativeZero && | |
| (fDecNumber->bits & DECNEG) != 0) { | |
| // Negative Zero, not ingored. Cannot represent as a long. | |
| return FALSE; | |
| } | |
| if (getUpperExponent() < 19) { | |
| // The number is 18 or fewer digits. | |
| // The max and min int64 are 19 digts, so this number fits. | |
| // This is the common case. | |
| return TRUE; | |
| } | |
| // TODO: Should cache these constants; construction is relatively costly. | |
| // But not of huge consequence; they're only needed for 19 digit ints. | |
| UErrorCode status = U_ZERO_ERROR; | |
| DigitList min64; min64.set("-9223372036854775808", status); | |
| if (this->compare(min64) < 0) { | |
| return FALSE; | |
| } | |
| DigitList max64; max64.set("9223372036854775807", status); | |
| if (this->compare(max64) > 0) { | |
| return FALSE; | |
| } | |
| if (U_FAILURE(status)) { | |
| return FALSE; | |
| } | |
| return true; | |
| } | |
| // ------------------------------------- | |
| void | |
| DigitList::set(int32_t source) | |
| { | |
| set((int64_t)source); | |
| internalSetDouble(source); | |
| } | |
| // ------------------------------------- | |
| /** | |
| * Set an int64, via decnumber | |
| */ | |
| void | |
| DigitList::set(int64_t source) | |
| { | |
| char str[MAX_DIGITS+2]; // Leave room for sign and trailing nul. | |
| formatBase10(source, str); | |
| U_ASSERT(uprv_strlen(str) < sizeof(str)); | |
| uprv_decNumberFromString(fDecNumber, str, &fContext); | |
| internalSetDouble(static_cast<double>(source)); | |
| } | |
| /** | |
| * Set an int64, with no decnumber | |
| */ | |
| void | |
| DigitList::setInteger(int64_t source) | |
| { | |
| fDecNumber=NULL; | |
| internalSetInt64(source); | |
| } | |
| // ------------------------------------- | |
| /** | |
| * Set the DigitList from a decimal number string. | |
| * | |
| * The incoming string _must_ be nul terminated, even though it is arriving | |
| * as a StringPiece because that is what the decNumber library wants. | |
| * We can get away with this for an internal function; it would not | |
| * be acceptable for a public API. | |
| */ | |
| void | |
| DigitList::set(const StringPiece &source, UErrorCode &status, uint32_t /*fastpathBits*/) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| #if 0 | |
| if(fastpathBits==(kFastpathOk|kNoDecimal)) { | |
| int32_t size = source.size(); | |
| const char *data = source.data(); | |
| int64_t r = 0; | |
| int64_t m = 1; | |
| // fast parse | |
| while(size>0) { | |
| char ch = data[--size]; | |
| if(ch=='+') { | |
| break; | |
| } else if(ch=='-') { | |
| r = -r; | |
| break; | |
| } else { | |
| int64_t d = ch-'0'; | |
| //printf("CH[%d]=%c, %d, *=%d\n", size,ch, (int)d, (int)m); | |
| r+=(d)*m; | |
| m *= 10; | |
| } | |
| } | |
| //printf("R=%d\n", r); | |
| set(r); | |
| } else | |
| #endif | |
| { | |
| // Figure out a max number of digits to use during the conversion, and | |
| // resize the number up if necessary. | |
| int32_t numDigits = source.length(); | |
| if (numDigits > fContext.digits) { | |
| // fContext.digits == fStorage.getCapacity() | |
| decNumber *t = fStorage.resize(numDigits, fStorage.getCapacity()); | |
| if (t == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| fDecNumber = t; | |
| fContext.digits = numDigits; | |
| } | |
| fContext.status = 0; | |
| uprv_decNumberFromString(fDecNumber, source.data(), &fContext); | |
| if ((fContext.status & DEC_Conversion_syntax) != 0) { | |
| status = U_DECIMAL_NUMBER_SYNTAX_ERROR; | |
| } | |
| } | |
| internalClear(); | |
| } | |
| /** | |
| * Set the digit list to a representation of the given double value. | |
| * This method supports both fixed-point and exponential notation. | |
| * @param source Value to be converted. | |
| */ | |
| void | |
| DigitList::set(double source) | |
| { | |
| // for now, simple implementation; later, do proper IEEE stuff | |
| char rep[MAX_DIGITS + 8]; // Extra space for '+', '.', e+NNN, and '\0' (actually +8 is enough) | |
| // Generate a representation of the form /[+-][0-9].[0-9]+e[+-][0-9]+/ | |
| // Can also generate /[+-]nan/ or /[+-]inf/ | |
| // TODO: Use something other than sprintf() here, since it's behavior is somewhat platform specific. | |
| // That is why infinity is special cased here. | |
| if (uprv_isInfinite(source)) { | |
| if (uprv_isNegativeInfinity(source)) { | |
| uprv_strcpy(rep,"-inf"); // Handle negative infinity | |
| } else { | |
| uprv_strcpy(rep,"inf"); | |
| } | |
| } else { | |
| sprintf(rep, "%+1.*e", MAX_DBL_DIGITS - 1, source); | |
| } | |
| U_ASSERT(uprv_strlen(rep) < sizeof(rep)); | |
| // uprv_decNumberFromString() will parse the string expecting '.' as a | |
| // decimal separator, however sprintf() can use ',' in certain locales. | |
| // Overwrite a ',' with '.' here before proceeding. | |
| char *decimalSeparator = strchr(rep, ','); | |
| if (decimalSeparator != NULL) { | |
| *decimalSeparator = '.'; | |
| } | |
| // Create a decNumber from the string. | |
| uprv_decNumberFromString(fDecNumber, rep, &fContext); | |
| uprv_decNumberTrim(fDecNumber); | |
| internalSetDouble(source); | |
| } | |
| // ------------------------------------- | |
| /* | |
| * Multiply | |
| * The number will be expanded if need be to retain full precision. | |
| * In practice, for formatting, multiply is by 10, 100 or 1000, so more digits | |
| * will not be required for this use. | |
| */ | |
| void | |
| DigitList::mult(const DigitList &other, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| fContext.status = 0; | |
| int32_t requiredDigits = this->digits() + other.digits(); | |
| if (requiredDigits > fContext.digits) { | |
| reduce(); // Remove any trailing zeros | |
| int32_t requiredDigits = this->digits() + other.digits(); | |
| ensureCapacity(requiredDigits, status); | |
| } | |
| uprv_decNumberMultiply(fDecNumber, fDecNumber, other.fDecNumber, &fContext); | |
| internalClear(); | |
| } | |
| // ------------------------------------- | |
| /* | |
| * Divide | |
| * The number will _not_ be expanded for inexact results. | |
| * TODO: probably should expand some, for rounding increments that | |
| * could add a few digits, e.g. .25, but not expand arbitrarily. | |
| */ | |
| void | |
| DigitList::div(const DigitList &other, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| uprv_decNumberDivide(fDecNumber, fDecNumber, other.fDecNumber, &fContext); | |
| internalClear(); | |
| } | |
| // ------------------------------------- | |
| /* | |
| * ensureCapacity. Grow the digit storage for the number if it's less than the requested | |
| * amount. Never reduce it. Available size is kept in fContext.digits. | |
| */ | |
| void | |
| DigitList::ensureCapacity(int32_t requestedCapacity, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if (requestedCapacity <= 0) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| if (requestedCapacity > DEC_MAX_DIGITS) { | |
| // Don't report an error for requesting too much. | |
| // Arithemetic Results will be rounded to what can be supported. | |
| // At 999,999,999 max digits, exceeding the limit is not too likely! | |
| requestedCapacity = DEC_MAX_DIGITS; | |
| } | |
| if (requestedCapacity > fContext.digits) { | |
| decNumber *newBuffer = fStorage.resize(requestedCapacity, fStorage.getCapacity()); | |
| if (newBuffer == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| fContext.digits = requestedCapacity; | |
| fDecNumber = newBuffer; | |
| } | |
| } | |
| // ------------------------------------- | |
| /** | |
| * Round the representation to the given number of digits. | |
| * @param maximumDigits The maximum number of digits to be shown. | |
| * Upon return, count will be less than or equal to maximumDigits. | |
| */ | |
| void | |
| DigitList::round(int32_t maximumDigits) | |
| { | |
| reduce(); | |
| if (maximumDigits >= fDecNumber->digits) { | |
| return; | |
| } | |
| int32_t savedDigits = fContext.digits; | |
| fContext.digits = maximumDigits; | |
| uprv_decNumberPlus(fDecNumber, fDecNumber, &fContext); | |
| fContext.digits = savedDigits; | |
| uprv_decNumberTrim(fDecNumber); | |
| reduce(); | |
| internalClear(); | |
| } | |
| void | |
| DigitList::roundFixedPoint(int32_t maximumFractionDigits) { | |
| reduce(); // Remove trailing zeros. | |
| if (fDecNumber->exponent >= -maximumFractionDigits) { | |
| return; | |
| } | |
| decNumber scale; // Dummy decimal number, but with the desired number of | |
| uprv_decNumberZero(&scale); // fraction digits. | |
| scale.exponent = -maximumFractionDigits; | |
| scale.lsu[0] = 1; | |
| uprv_decNumberQuantize(fDecNumber, fDecNumber, &scale, &fContext); | |
| reduce(); | |
| internalClear(); | |
| } | |
| // ------------------------------------- | |
| void | |
| DigitList::toIntegralValue() { | |
| uprv_decNumberToIntegralValue(fDecNumber, fDecNumber, &fContext); | |
| } | |
| // ------------------------------------- | |
| UBool | |
| DigitList::isZero() const | |
| { | |
| return decNumberIsZero(fDecNumber); | |
| } | |
| // ------------------------------------- | |
| int32_t | |
| DigitList::getUpperExponent() const { | |
| return fDecNumber->digits + fDecNumber->exponent; | |
| } | |
| DigitInterval & | |
| DigitList::getSmallestInterval(DigitInterval &result) const { | |
| result.setLeastSignificantInclusive(fDecNumber->exponent); | |
| result.setMostSignificantExclusive(getUpperExponent()); | |
| return result; | |
| } | |
| uint8_t | |
| DigitList::getDigitByExponent(int32_t exponent) const { | |
| int32_t idx = exponent - fDecNumber->exponent; | |
| if (idx < 0 || idx >= fDecNumber->digits) { | |
| return 0; | |
| } | |
| return fDecNumber->lsu[idx]; | |
| } | |
| void | |
| DigitList::appendDigitsTo(CharString &str, UErrorCode &status) const { | |
| str.append((const char *) fDecNumber->lsu, fDecNumber->digits, status); | |
| } | |
| void | |
| DigitList::roundAtExponent(int32_t exponent, int32_t maxSigDigits) { | |
| reduce(); | |
| if (maxSigDigits < fDecNumber->digits) { | |
| int32_t minExponent = getUpperExponent() - maxSigDigits; | |
| if (exponent < minExponent) { | |
| exponent = minExponent; | |
| } | |
| } | |
| if (exponent <= fDecNumber->exponent) { | |
| return; | |
| } | |
| int32_t digits = getUpperExponent() - exponent; | |
| if (digits > 0) { | |
| round(digits); | |
| } else { | |
| roundFixedPoint(-exponent); | |
| } | |
| } | |
| void | |
| DigitList::quantize(const DigitList &quantity, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| div(quantity, status); | |
| roundAtExponent(0); | |
| mult(quantity, status); | |
| reduce(); | |
| } | |
| int32_t | |
| DigitList::getScientificExponent( | |
| int32_t minIntDigitCount, int32_t exponentMultiplier) const { | |
| // The exponent for zero is always zero. | |
| if (isZero()) { | |
| return 0; | |
| } | |
| int32_t intDigitCount = getUpperExponent(); | |
| int32_t exponent; | |
| if (intDigitCount >= minIntDigitCount) { | |
| int32_t maxAdjustment = intDigitCount - minIntDigitCount; | |
| exponent = (maxAdjustment / exponentMultiplier) * exponentMultiplier; | |
| } else { | |
| int32_t minAdjustment = minIntDigitCount - intDigitCount; | |
| exponent = ((minAdjustment + exponentMultiplier - 1) / exponentMultiplier) * -exponentMultiplier; | |
| } | |
| return exponent; | |
| } | |
| int32_t | |
| DigitList::toScientific( | |
| int32_t minIntDigitCount, int32_t exponentMultiplier) { | |
| int32_t exponent = getScientificExponent( | |
| minIntDigitCount, exponentMultiplier); | |
| shiftDecimalRight(-exponent); | |
| return exponent; | |
| } | |
| void | |
| DigitList::shiftDecimalRight(int32_t n) { | |
| fDecNumber->exponent += n; | |
| internalClear(); | |
| } | |
| U_NAMESPACE_END | |
| #endif // #if !UCONFIG_NO_FORMATTING | |
| //eof |