third_party/icu/source/i18n/number_utils.cpp - cobalt - Git at Google

 // © 2018 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_FORMATTING

 // Allow implicit conversion from char16_t* to UnicodeString for this file:
 // Helpful in toString methods and elsewhere.
 #define UNISTR_FROM_STRING_EXPLICIT

 #include <stdlib.h>
 #include <cmath>
 #include "number_decnum.h"
 #include "number_types.h"
 #include "number_utils.h"
 #include "charstr.h"
 #include "decContext.h"
 #include "decNumber.h"
 #include "double-conversion.h"
 #include "fphdlimp.h"
 #include "uresimp.h"
 #include "ureslocs.h"

 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;

 using icu::double_conversion::DoubleToStringConverter;


 namespace {

 const char16_t*
 doGetPattern(UResourceBundle* res, const char* nsName, const char* patternKey, UErrorCode& publicStatus,
              UErrorCode& localStatus) {
     // Construct the path into the resource bundle
     CharString key;
     key.append("NumberElements/", publicStatus);
     key.append(nsName, publicStatus);
     key.append("/patterns/", publicStatus);
     key.append(patternKey, publicStatus);
     if (U_FAILURE(publicStatus)) {
         return u"";
     }
     return ures_getStringByKeyWithFallback(res, key.data(), nullptr, &localStatus);
 }

 }


 const char16_t* utils::getPatternForStyle(const Locale& locale, const char* nsName, CldrPatternStyle style,
                                           UErrorCode& status) {
     const char* patternKey;
     switch (style) {
         case CLDR_PATTERN_STYLE_DECIMAL:
             patternKey = "decimalFormat";
             break;
         case CLDR_PATTERN_STYLE_CURRENCY:
             patternKey = "currencyFormat";
             break;
         case CLDR_PATTERN_STYLE_ACCOUNTING:
             patternKey = "accountingFormat";
             break;
         case CLDR_PATTERN_STYLE_PERCENT:
             patternKey = "percentFormat";
             break;
         case CLDR_PATTERN_STYLE_SCIENTIFIC:
             patternKey = "scientificFormat";
             break;
         default:
             patternKey = "decimalFormat"; // silence compiler error
             UPRV_UNREACHABLE;
     }
     LocalUResourceBundlePointer res(ures_open(nullptr, locale.getName(), &status));
     if (U_FAILURE(status)) { return u""; }

     // Attempt to get the pattern with the native numbering system.
     UErrorCode localStatus = U_ZERO_ERROR;
     const char16_t* pattern;
     pattern = doGetPattern(res.getAlias(), nsName, patternKey, status, localStatus);
     if (U_FAILURE(status)) { return u""; }

     // Fall back to latn if native numbering system does not have the right pattern
     if (U_FAILURE(localStatus) && uprv_strcmp("latn", nsName) != 0) {
         localStatus = U_ZERO_ERROR;
         pattern = doGetPattern(res.getAlias(), "latn", patternKey, status, localStatus);
         if (U_FAILURE(status)) { return u""; }
     }

     return pattern;
 }


 DecNum::DecNum() {
     uprv_decContextDefault(&fContext, DEC_INIT_BASE);
     uprv_decContextSetRounding(&fContext, DEC_ROUND_HALF_EVEN);
     fContext.traps = 0; // no traps, thank you (what does this even mean?)
 }

 DecNum::DecNum(const DecNum& other, UErrorCode& status)
         : fContext(other.fContext) {
     // Allocate memory for the new DecNum.
     U_ASSERT(fContext.digits == other.fData.getCapacity());
     if (fContext.digits > kDefaultDigits) {
         void* p = fData.resize(fContext.digits, 0);
         if (p == nullptr) {
             status = U_MEMORY_ALLOCATION_ERROR;
             return;
         }
     }

     // Copy the data from the old DecNum to the new one.
     uprv_memcpy(fData.getAlias(), other.fData.getAlias(), sizeof(decNumber));
     uprv_memcpy(fData.getArrayStart(),
             other.fData.getArrayStart(),
             other.fData.getArrayLimit() - other.fData.getArrayStart());
 }

 void DecNum::setTo(StringPiece str, UErrorCode& status) {
     // We need NUL-terminated for decNumber; CharString guarantees this, but not StringPiece.
     CharString cstr(str, status);
     if (U_FAILURE(status)) { return; }
     _setTo(cstr.data(), str.length(), status);
 }

 void DecNum::setTo(const char* str, UErrorCode& status) {
     _setTo(str, static_cast<int32_t>(uprv_strlen(str)), status);
 }

 void DecNum::setTo(double d, UErrorCode& status) {
     // Need to check for NaN and Infinity before going into DoubleToStringConverter
     if (std::isnan(d) != 0 || std::isfinite(d) == 0) {
         status = U_UNSUPPORTED_ERROR;
         return;
     }

     // First convert from double to string, then string to DecNum.
     // Allocate enough room for: all digits, "E-324", and NUL-terminator.
     char buffer[DoubleToStringConverter::kBase10MaximalLength + 6];
     bool sign; // unused; always positive
     int32_t length;
     int32_t point;
     DoubleToStringConverter::DoubleToAscii(
             d,
             DoubleToStringConverter::DtoaMode::SHORTEST,
             0,
             buffer,
             sizeof(buffer),
             &sign,
             &length,
             &point
     );

     // Read initial result as a string.
     _setTo(buffer, length, status);

     // Set exponent and bitmask. Note that DoubleToStringConverter does not do negatives.
     fData.getAlias()->exponent += point - length;
     fData.getAlias()->bits |= static_cast<uint8_t>(std::signbit(d) ? DECNEG : 0);
 }

 void DecNum::_setTo(const char* str, int32_t maxDigits, UErrorCode& status) {
     if (maxDigits > kDefaultDigits) {
         fData.resize(maxDigits, 0);
         fContext.digits = maxDigits;
     } else {
         fContext.digits = kDefaultDigits;
     }

     static_assert(DECDPUN == 1, "Assumes that DECDPUN is set to 1");
     uprv_decNumberFromString(fData.getAlias(), str, &fContext);

     // Check for invalid syntax and set the corresponding error code.
     if ((fContext.status & DEC_Conversion_syntax) != 0) {
         status = U_DECIMAL_NUMBER_SYNTAX_ERROR;
         return;
     } else if (fContext.status != 0) {
         // Not a syntax error, but some other error, like an exponent that is too large.
         status = U_UNSUPPORTED_ERROR;
         return;
     }

     // For consistency with Java BigDecimal, no support for DecNum that is NaN or Infinity!
     if (decNumberIsSpecial(fData.getAlias())) {
         status = U_UNSUPPORTED_ERROR;
         return;
     }
 }

 void
 DecNum::setTo(const uint8_t* bcd, int32_t length, int32_t scale, bool isNegative, UErrorCode& status) {
     if (length > kDefaultDigits) {
         fData.resize(length, 0);
         fContext.digits = length;
     } else {
         fContext.digits = kDefaultDigits;
     }

     // "digits is of type int32_t, and must have a value in the range 1 through 999,999,999."
     if (length < 1 || length > 999999999) {
         // Too large for decNumber
         status = U_UNSUPPORTED_ERROR;
         return;
     }
     // "The exponent field holds the exponent of the number. Its range is limited by the requirement that
     // "the range of the adjusted exponent of the number be balanced and fit within a whole number of
     // "decimal digits (in this implementation, be –999,999,999 through +999,999,999). The adjusted
     // "exponent is the exponent that would result if the number were expressed with a single digit before
     // "the decimal point, and is therefore given by exponent+digits-1."
     if (scale > 999999999 - length + 1 || scale < -999999999 - length + 1) {
         // Too large for decNumber
         status = U_UNSUPPORTED_ERROR;
         return;
     }

     fData.getAlias()->digits = length;
     fData.getAlias()->exponent = scale;
     fData.getAlias()->bits = static_cast<uint8_t>(isNegative ? DECNEG : 0);
     uprv_decNumberSetBCD(fData, bcd, static_cast<uint32_t>(length));
     if (fContext.status != 0) {
         // Some error occurred while constructing the decNumber.
         status = U_INTERNAL_PROGRAM_ERROR;
     }
 }

 void DecNum::normalize() {
     uprv_decNumberReduce(fData, fData, &fContext);
 }

 void DecNum::multiplyBy(const DecNum& rhs, UErrorCode& status) {
     uprv_decNumberMultiply(fData, fData, rhs.fData, &fContext);
     if (fContext.status != 0) {
         status = U_INTERNAL_PROGRAM_ERROR;
     }
 }

 void DecNum::divideBy(const DecNum& rhs, UErrorCode& status) {
     uprv_decNumberDivide(fData, fData, rhs.fData, &fContext);
     if ((fContext.status & DEC_Inexact) != 0) {
         // Ignore.
     } else if (fContext.status != 0) {
         status = U_INTERNAL_PROGRAM_ERROR;
     }
 }

 bool DecNum::isNegative() const {
     return decNumberIsNegative(fData.getAlias());
 }

 bool DecNum::isZero() const {
     return decNumberIsZero(fData.getAlias());
 }

 void DecNum::toString(ByteSink& output, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     // "string must be at least dn->digits+14 characters long"
     int32_t minCapacity = fData.getAlias()->digits + 14;
     MaybeStackArray<char, 30> buffer(minCapacity, status);
     if (U_FAILURE(status)) {
         return;
     }
     uprv_decNumberToString(fData, buffer.getAlias());
     output.Append(buffer.getAlias(), static_cast<int32_t>(uprv_strlen(buffer.getAlias())));
 }

 #endif /* #if !UCONFIG_NO_FORMATTING */
	// © 2018 and later: Unicode, Inc. and others.
	// License & terms of use: http://www.unicode.org/copyright.html

	#include "unicode/utypes.h"

	#if !UCONFIG_NO_FORMATTING

	// Allow implicit conversion from char16_t* to UnicodeString for this file:
	// Helpful in toString methods and elsewhere.
	#define UNISTR_FROM_STRING_EXPLICIT

	#include <stdlib.h>
	#include <cmath>
	#include "number_decnum.h"
	#include "number_types.h"
	#include "number_utils.h"
	#include "charstr.h"
	#include "decContext.h"
	#include "decNumber.h"
	#include "double-conversion.h"
	#include "fphdlimp.h"
	#include "uresimp.h"
	#include "ureslocs.h"

	using namespace icu;
	using namespace icu::number;
	using namespace icu::number::impl;

	using icu::double_conversion::DoubleToStringConverter;


	namespace {

	const char16_t*
	doGetPattern(UResourceBundle* res, const char* nsName, const char* patternKey, UErrorCode& publicStatus,
	UErrorCode& localStatus) {
	// Construct the path into the resource bundle
	CharString key;
	key.append("NumberElements/", publicStatus);
	key.append(nsName, publicStatus);
	key.append("/patterns/", publicStatus);
	key.append(patternKey, publicStatus);
	if (U_FAILURE(publicStatus)) {
	return u"";
	}
	return ures_getStringByKeyWithFallback(res, key.data(), nullptr, &localStatus);
	}

	}


	const char16_t* utils::getPatternForStyle(const Locale& locale, const char* nsName, CldrPatternStyle style,
	UErrorCode& status) {
	const char* patternKey;
	switch (style) {
	case CLDR_PATTERN_STYLE_DECIMAL:
	patternKey = "decimalFormat";
	break;
	case CLDR_PATTERN_STYLE_CURRENCY:
	patternKey = "currencyFormat";
	break;
	case CLDR_PATTERN_STYLE_ACCOUNTING:
	patternKey = "accountingFormat";
	break;
	case CLDR_PATTERN_STYLE_PERCENT:
	patternKey = "percentFormat";
	break;
	case CLDR_PATTERN_STYLE_SCIENTIFIC:
	patternKey = "scientificFormat";
	break;
	default:
	patternKey = "decimalFormat"; // silence compiler error
	UPRV_UNREACHABLE;
	}
	LocalUResourceBundlePointer res(ures_open(nullptr, locale.getName(), &status));
	if (U_FAILURE(status)) { return u""; }

	// Attempt to get the pattern with the native numbering system.
	UErrorCode localStatus = U_ZERO_ERROR;
	const char16_t* pattern;
	pattern = doGetPattern(res.getAlias(), nsName, patternKey, status, localStatus);
	if (U_FAILURE(status)) { return u""; }

	// Fall back to latn if native numbering system does not have the right pattern
	if (U_FAILURE(localStatus) && uprv_strcmp("latn", nsName) != 0) {
	localStatus = U_ZERO_ERROR;
	pattern = doGetPattern(res.getAlias(), "latn", patternKey, status, localStatus);
	if (U_FAILURE(status)) { return u""; }
	}

	return pattern;
	}


	DecNum::DecNum() {
	uprv_decContextDefault(&fContext, DEC_INIT_BASE);
	uprv_decContextSetRounding(&fContext, DEC_ROUND_HALF_EVEN);
	fContext.traps = 0; // no traps, thank you (what does this even mean?)
	}

	DecNum::DecNum(const DecNum& other, UErrorCode& status)
	: fContext(other.fContext) {
	// Allocate memory for the new DecNum.
	U_ASSERT(fContext.digits == other.fData.getCapacity());
	if (fContext.digits > kDefaultDigits) {
	void* p = fData.resize(fContext.digits, 0);
	if (p == nullptr) {
	status = U_MEMORY_ALLOCATION_ERROR;
	return;
	}
	}

	// Copy the data from the old DecNum to the new one.
	uprv_memcpy(fData.getAlias(), other.fData.getAlias(), sizeof(decNumber));
	uprv_memcpy(fData.getArrayStart(),
	other.fData.getArrayStart(),
	other.fData.getArrayLimit() - other.fData.getArrayStart());
	}

	void DecNum::setTo(StringPiece str, UErrorCode& status) {
	// We need NUL-terminated for decNumber; CharString guarantees this, but not StringPiece.
	CharString cstr(str, status);
	if (U_FAILURE(status)) { return; }
	_setTo(cstr.data(), str.length(), status);
	}

	void DecNum::setTo(const char* str, UErrorCode& status) {
	_setTo(str, static_cast<int32_t>(uprv_strlen(str)), status);
	}

	void DecNum::setTo(double d, UErrorCode& status) {
	// Need to check for NaN and Infinity before going into DoubleToStringConverter
	if (std::isnan(d) != 0 \|\| std::isfinite(d) == 0) {
	status = U_UNSUPPORTED_ERROR;
	return;
	}

	// First convert from double to string, then string to DecNum.
	// Allocate enough room for: all digits, "E-324", and NUL-terminator.
	char buffer[DoubleToStringConverter::kBase10MaximalLength + 6];
	bool sign; // unused; always positive
	int32_t length;
	int32_t point;
	DoubleToStringConverter::DoubleToAscii(
	d,
	DoubleToStringConverter::DtoaMode::SHORTEST,
	0,
	buffer,
	sizeof(buffer),
	&sign,
	&length,
	&point
	);

	// Read initial result as a string.
	_setTo(buffer, length, status);

	// Set exponent and bitmask. Note that DoubleToStringConverter does not do negatives.
	fData.getAlias()->exponent += point - length;
	fData.getAlias()->bits \|= static_cast<uint8_t>(std::signbit(d) ? DECNEG : 0);
	}

	void DecNum::_setTo(const char* str, int32_t maxDigits, UErrorCode& status) {
	if (maxDigits > kDefaultDigits) {
	fData.resize(maxDigits, 0);
	fContext.digits = maxDigits;
	} else {
	fContext.digits = kDefaultDigits;
	}

	static_assert(DECDPUN == 1, "Assumes that DECDPUN is set to 1");
	uprv_decNumberFromString(fData.getAlias(), str, &fContext);

	// Check for invalid syntax and set the corresponding error code.
	if ((fContext.status & DEC_Conversion_syntax) != 0) {
	status = U_DECIMAL_NUMBER_SYNTAX_ERROR;
	return;
	} else if (fContext.status != 0) {
	// Not a syntax error, but some other error, like an exponent that is too large.
	status = U_UNSUPPORTED_ERROR;
	return;
	}

	// For consistency with Java BigDecimal, no support for DecNum that is NaN or Infinity!
	if (decNumberIsSpecial(fData.getAlias())) {
	status = U_UNSUPPORTED_ERROR;
	return;
	}
	}

	void
	DecNum::setTo(const uint8_t* bcd, int32_t length, int32_t scale, bool isNegative, UErrorCode& status) {
	if (length > kDefaultDigits) {
	fData.resize(length, 0);
	fContext.digits = length;
	} else {
	fContext.digits = kDefaultDigits;
	}

	// "digits is of type int32_t, and must have a value in the range 1 through 999,999,999."
	if (length < 1 \|\| length > 999999999) {
	// Too large for decNumber
	status = U_UNSUPPORTED_ERROR;
	return;
	}
	// "The exponent field holds the exponent of the number. Its range is limited by the requirement that
	// "the range of the adjusted exponent of the number be balanced and fit within a whole number of
	// "decimal digits (in this implementation, be –999,999,999 through +999,999,999). The adjusted
	// "exponent is the exponent that would result if the number were expressed with a single digit before
	// "the decimal point, and is therefore given by exponent+digits-1."
	if (scale > 999999999 - length + 1 \|\| scale < -999999999 - length + 1) {
	// Too large for decNumber
	status = U_UNSUPPORTED_ERROR;
	return;
	}

	fData.getAlias()->digits = length;
	fData.getAlias()->exponent = scale;
	fData.getAlias()->bits = static_cast<uint8_t>(isNegative ? DECNEG : 0);
	uprv_decNumberSetBCD(fData, bcd, static_cast<uint32_t>(length));
	if (fContext.status != 0) {
	// Some error occurred while constructing the decNumber.
	status = U_INTERNAL_PROGRAM_ERROR;
	}
	}

	void DecNum::normalize() {
	uprv_decNumberReduce(fData, fData, &fContext);
	}

	void DecNum::multiplyBy(const DecNum& rhs, UErrorCode& status) {
	uprv_decNumberMultiply(fData, fData, rhs.fData, &fContext);
	if (fContext.status != 0) {
	status = U_INTERNAL_PROGRAM_ERROR;
	}
	}

	void DecNum::divideBy(const DecNum& rhs, UErrorCode& status) {
	uprv_decNumberDivide(fData, fData, rhs.fData, &fContext);
	if ((fContext.status & DEC_Inexact) != 0) {
	// Ignore.
	} else if (fContext.status != 0) {
	status = U_INTERNAL_PROGRAM_ERROR;
	}
	}

	bool DecNum::isNegative() const {
	return decNumberIsNegative(fData.getAlias());
	}

	bool DecNum::isZero() const {
	return decNumberIsZero(fData.getAlias());
	}

	void DecNum::toString(ByteSink& output, UErrorCode& status) const {
	if (U_FAILURE(status)) {
	return;
	}
	// "string must be at least dn->digits+14 characters long"
	int32_t minCapacity = fData.getAlias()->digits + 14;
	MaybeStackArray<char, 30> buffer(minCapacity, status);
	if (U_FAILURE(status)) {
	return;
	}
	uprv_decNumberToString(fData, buffer.getAlias());
	output.Append(buffer.getAlias(), static_cast<int32_t>(uprv_strlen(buffer.getAlias())));
	}

	#endif /* #if !UCONFIG_NO_FORMATTING */