From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- intl/icu/source/i18n/winnmfmt.cpp | 461 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 461 insertions(+) create mode 100644 intl/icu/source/i18n/winnmfmt.cpp (limited to 'intl/icu/source/i18n/winnmfmt.cpp') diff --git a/intl/icu/source/i18n/winnmfmt.cpp b/intl/icu/source/i18n/winnmfmt.cpp new file mode 100644 index 0000000000..6efa9a63d8 --- /dev/null +++ b/intl/icu/source/i18n/winnmfmt.cpp @@ -0,0 +1,461 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* +******************************************************************************** +* Copyright (C) 2005-2016, International Business Machines +* Corporation and others. All Rights Reserved. +******************************************************************************** +* +* File WINNMFMT.CPP +* +******************************************************************************** +*/ + +#include "unicode/utypes.h" + +#if U_PLATFORM_USES_ONLY_WIN32_API + +#if !UCONFIG_NO_FORMATTING + +#include "winnmfmt.h" + +#include "unicode/format.h" +#include "unicode/numfmt.h" +#include "unicode/locid.h" +#include "unicode/ustring.h" + +#include "cmemory.h" +#include "uassert.h" +#include "locmap.h" + +#ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif +# define VC_EXTRALEAN +# define NOUSER +# define NOSERVICE +# define NOIME +# define NOMCX +#include +#include + +U_NAMESPACE_BEGIN + +union FormatInfo +{ + NUMBERFMTW number; + CURRENCYFMTW currency; +}; + +UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Win32NumberFormat) + +#define NEW_ARRAY(type,count) (type *) uprv_malloc((count) * sizeof(type)) +#define DELETE_ARRAY(array) uprv_free((void *) (array)) + +#define STACK_BUFFER_SIZE 32 + +/* + * Turns a string of the form "3;2;0" into the grouping UINT + * needed for NUMBERFMT and CURRENCYFMT. If the string does not + * end in ";0" then the return value should be multiplied by 10. + * (e.g. "3" => 30, "3;2" => 320) + */ +static UINT getGrouping(const wchar_t *grouping) +{ + UINT g = 0; + const wchar_t *s; + + for (s = grouping; *s != L'\0'; s += 1) { + if (*s > L'0' && *s < L'9') { + g = g * 10 + (*s - L'0'); + } else if (*s != L';') { + break; + } + } + + if (*s != L'0') { + g *= 10; + } + + return g; +} + +static void getNumberFormat(NUMBERFMTW *fmt, const wchar_t *windowsLocaleName) +{ + wchar_t buf[10]; + + GetLocaleInfoEx(windowsLocaleName, LOCALE_RETURN_NUMBER|LOCALE_IDIGITS, (LPWSTR) &fmt->NumDigits, sizeof(UINT)); + GetLocaleInfoEx(windowsLocaleName, LOCALE_RETURN_NUMBER|LOCALE_ILZERO, (LPWSTR) &fmt->LeadingZero, sizeof(UINT)); + + GetLocaleInfoEx(windowsLocaleName, LOCALE_SGROUPING, (LPWSTR)buf, 10); + fmt->Grouping = getGrouping(buf); + + fmt->lpDecimalSep = NEW_ARRAY(wchar_t, 6); + GetLocaleInfoEx(windowsLocaleName, LOCALE_SDECIMAL, fmt->lpDecimalSep, 6); + + fmt->lpThousandSep = NEW_ARRAY(wchar_t, 6); + GetLocaleInfoEx(windowsLocaleName, LOCALE_STHOUSAND, fmt->lpThousandSep, 6); + + GetLocaleInfoEx(windowsLocaleName, LOCALE_RETURN_NUMBER|LOCALE_INEGNUMBER, (LPWSTR) &fmt->NegativeOrder, sizeof(UINT)); +} + +static void freeNumberFormat(NUMBERFMTW *fmt) +{ + if (fmt != nullptr) { + DELETE_ARRAY(fmt->lpThousandSep); + DELETE_ARRAY(fmt->lpDecimalSep); + } +} + +static void getCurrencyFormat(CURRENCYFMTW *fmt, const wchar_t *windowsLocaleName) +{ + wchar_t buf[10]; + + GetLocaleInfoEx(windowsLocaleName, LOCALE_RETURN_NUMBER|LOCALE_ICURRDIGITS, (LPWSTR) &fmt->NumDigits, sizeof(UINT)); + GetLocaleInfoEx(windowsLocaleName, LOCALE_RETURN_NUMBER|LOCALE_ILZERO, (LPWSTR) &fmt->LeadingZero, sizeof(UINT)); + + GetLocaleInfoEx(windowsLocaleName, LOCALE_SMONGROUPING, (LPWSTR)buf, sizeof(buf)); + fmt->Grouping = getGrouping(buf); + + fmt->lpDecimalSep = NEW_ARRAY(wchar_t, 6); + GetLocaleInfoEx(windowsLocaleName, LOCALE_SMONDECIMALSEP, fmt->lpDecimalSep, 6); + + fmt->lpThousandSep = NEW_ARRAY(wchar_t, 6); + GetLocaleInfoEx(windowsLocaleName, LOCALE_SMONTHOUSANDSEP, fmt->lpThousandSep, 6); + + GetLocaleInfoEx(windowsLocaleName, LOCALE_RETURN_NUMBER|LOCALE_INEGCURR, (LPWSTR) &fmt->NegativeOrder, sizeof(UINT)); + GetLocaleInfoEx(windowsLocaleName, LOCALE_RETURN_NUMBER|LOCALE_ICURRENCY, (LPWSTR) &fmt->PositiveOrder, sizeof(UINT)); + + fmt->lpCurrencySymbol = NEW_ARRAY(wchar_t, 8); + GetLocaleInfoEx(windowsLocaleName, LOCALE_SCURRENCY, (LPWSTR) fmt->lpCurrencySymbol, 8); +} + +static void freeCurrencyFormat(CURRENCYFMTW *fmt) +{ + if (fmt != nullptr) { + DELETE_ARRAY(fmt->lpCurrencySymbol); + DELETE_ARRAY(fmt->lpThousandSep); + DELETE_ARRAY(fmt->lpDecimalSep); + } +} + +// TODO: This is copied in both winnmfmt.cpp and windtfmt.cpp, but really should +// be factored out into a common helper for both. +static UErrorCode GetEquivalentWindowsLocaleName(const Locale& locale, UnicodeString** buffer) +{ + UErrorCode status = U_ZERO_ERROR; + char asciiBCP47Tag[LOCALE_NAME_MAX_LENGTH] = {}; + + // Convert from names like "en_CA" and "de_DE@collation=phonebook" to "en-CA" and "de-DE-u-co-phonebk". + (void) uloc_toLanguageTag(locale.getName(), asciiBCP47Tag, UPRV_LENGTHOF(asciiBCP47Tag), false, &status); + + if (U_SUCCESS(status)) + { + // Need it to be UTF-16, not 8-bit + // TODO: This seems like a good thing for a helper + wchar_t bcp47Tag[LOCALE_NAME_MAX_LENGTH] = {}; + int32_t i; + for (i = 0; i < UPRV_LENGTHOF(bcp47Tag); i++) + { + if (asciiBCP47Tag[i] == '\0') + { + break; + } + else + { + // normally just copy the character + bcp47Tag[i] = static_cast(asciiBCP47Tag[i]); + } + } + + // Ensure it's null terminated + if (i < (UPRV_LENGTHOF(bcp47Tag) - 1)) + { + bcp47Tag[i] = L'\0'; + } + else + { + // Ran out of room. + bcp47Tag[UPRV_LENGTHOF(bcp47Tag) - 1] = L'\0'; + } + + + wchar_t windowsLocaleName[LOCALE_NAME_MAX_LENGTH] = {}; + + // Note: On Windows versions below 10, there is no support for locale name aliases. + // This means that it will fail for locales where ICU has a completely different + // name (like ku vs ckb), and it will also not work for alternate sort locale + // names like "de-DE-u-co-phonebk". + + // TODO: We could add some sort of exception table for cases like ku vs ckb. + + int length = ResolveLocaleName(bcp47Tag, windowsLocaleName, UPRV_LENGTHOF(windowsLocaleName)); + + if (length > 0) + { + *buffer = new UnicodeString(windowsLocaleName); + } + else + { + status = U_UNSUPPORTED_ERROR; + } + } + return status; +} + +Win32NumberFormat::Win32NumberFormat(const Locale &locale, UBool currency, UErrorCode &status) + : NumberFormat(), fCurrency(currency), fFormatInfo(nullptr), fFractionDigitsSet(false), fWindowsLocaleName(nullptr) +{ + if (!U_FAILURE(status)) { + fLCID = locale.getLCID(); + + GetEquivalentWindowsLocaleName(locale, &fWindowsLocaleName); + // Note: In the previous code, it would look up the LCID for the locale, and if + // the locale was not recognized then it would get an LCID of 0, which is a + // synonym for LOCALE_USER_DEFAULT on Windows. + // If the above method fails, then fWindowsLocaleName will remain as nullptr, and + // then we will pass nullptr to API GetLocaleInfoEx, which is the same as passing + // LOCALE_USER_DEFAULT. + + // Resolve actual locale to be used later + UErrorCode tmpsts = U_ZERO_ERROR; + char tmpLocID[ULOC_FULLNAME_CAPACITY]; + int32_t len = uloc_getLocaleForLCID(fLCID, tmpLocID, UPRV_LENGTHOF(tmpLocID) - 1, &tmpsts); + if (U_SUCCESS(tmpsts)) { + tmpLocID[len] = 0; + fLocale = Locale((const char*)tmpLocID); + } + + const wchar_t *localeName = nullptr; + + if (fWindowsLocaleName != nullptr) + { + localeName = reinterpret_cast(toOldUCharPtr(fWindowsLocaleName->getTerminatedBuffer())); + } + + fFormatInfo = (FormatInfo*)uprv_malloc(sizeof(FormatInfo)); + + if (fCurrency) { + getCurrencyFormat(&fFormatInfo->currency, localeName); + } else { + getNumberFormat(&fFormatInfo->number, localeName); + } + } +} + +Win32NumberFormat::Win32NumberFormat(const Win32NumberFormat &other) + : NumberFormat(other), fFormatInfo((FormatInfo*)uprv_malloc(sizeof(FormatInfo))) +{ + if (fFormatInfo != nullptr) { + uprv_memset(fFormatInfo, 0, sizeof(*fFormatInfo)); + } + *this = other; +} + +Win32NumberFormat::~Win32NumberFormat() +{ + if (fFormatInfo != nullptr) { + if (fCurrency) { + freeCurrencyFormat(&fFormatInfo->currency); + } else { + freeNumberFormat(&fFormatInfo->number); + } + + uprv_free(fFormatInfo); + } + delete fWindowsLocaleName; +} + +Win32NumberFormat &Win32NumberFormat::operator=(const Win32NumberFormat &other) +{ + if (this == &other) { return *this; } // self-assignment: no-op + NumberFormat::operator=(other); + + this->fCurrency = other.fCurrency; + this->fLocale = other.fLocale; + this->fLCID = other.fLCID; + this->fFractionDigitsSet = other.fFractionDigitsSet; + this->fWindowsLocaleName = other.fWindowsLocaleName == nullptr ? nullptr : new UnicodeString(*other.fWindowsLocaleName); + + const wchar_t *localeName = nullptr; + + if (fWindowsLocaleName != nullptr) + { + localeName = reinterpret_cast(toOldUCharPtr(fWindowsLocaleName->getTerminatedBuffer())); + } + + if (fCurrency) { + freeCurrencyFormat(&fFormatInfo->currency); + getCurrencyFormat(&fFormatInfo->currency, localeName); + } else { + freeNumberFormat(&fFormatInfo->number); + getNumberFormat(&fFormatInfo->number, localeName); + } + + return *this; +} + +Win32NumberFormat *Win32NumberFormat::clone() const +{ + return new Win32NumberFormat(*this); +} + +UnicodeString& Win32NumberFormat::format(double number, UnicodeString& appendTo, FieldPosition& /* pos */) const +{ + return format(getMaximumFractionDigits(), appendTo, L"%.16f", number); +} + +UnicodeString& Win32NumberFormat::format(int32_t number, UnicodeString& appendTo, FieldPosition& /* pos */) const +{ + return format(getMinimumFractionDigits(), appendTo, L"%I32d", number); +} + +UnicodeString& Win32NumberFormat::format(int64_t number, UnicodeString& appendTo, FieldPosition& /* pos */) const +{ + return format(getMinimumFractionDigits(), appendTo, L"%I64d", number); +} + +void Win32NumberFormat::parse(const UnicodeString& text, Formattable& result, ParsePosition& parsePosition) const +{ + UErrorCode status = U_ZERO_ERROR; + NumberFormat *nf = fCurrency? NumberFormat::createCurrencyInstance(fLocale, status) : NumberFormat::createInstance(fLocale, status); + + nf->parse(text, result, parsePosition); + delete nf; +} +void Win32NumberFormat::setMaximumFractionDigits(int32_t newValue) +{ + fFractionDigitsSet = true; + NumberFormat::setMaximumFractionDigits(newValue); +} + +void Win32NumberFormat::setMinimumFractionDigits(int32_t newValue) +{ + fFractionDigitsSet = true; + NumberFormat::setMinimumFractionDigits(newValue); +} + +UnicodeString &Win32NumberFormat::format(int32_t numDigits, UnicodeString &appendTo, const wchar_t *fmt, ...) const +{ + wchar_t nStackBuffer[STACK_BUFFER_SIZE]; + wchar_t *nBuffer = nStackBuffer; + va_list args; + int result; + + nBuffer[0] = 0x0000; + + /* Due to the arguments causing a result to be <= 23 characters (+2 for nullptr and minus), + we don't need to reallocate the buffer. */ + va_start(args, fmt); + result = _vsnwprintf(nBuffer, STACK_BUFFER_SIZE, fmt, args); + va_end(args); + + /* Just to make sure of the above statement, we add this assert */ + U_ASSERT(result >=0); + // The following code is not used because _vscwprintf isn't available on MinGW at the moment. + /*if (result < 0) { + int newLength; + + va_start(args, fmt); + newLength = _vscwprintf(fmt, args); + va_end(args); + + nBuffer = NEW_ARRAY(char16_t, newLength + 1); + + va_start(args, fmt); + result = _vsnwprintf(nBuffer, newLength + 1, fmt, args); + va_end(args); + }*/ + + // vswprintf is sensitive to the locale set by setlocale. For some locales + // it doesn't use "." as the decimal separator, which is what GetNumberFormatW + // and GetCurrencyFormatW both expect to see. + // + // To fix this, we scan over the string and replace the first non-digits, except + // for a leading "-", with a "." + // + // Note: (nBuffer[0] == L'-') will evaluate to 1 if there is a leading '-' in the + // number, and 0 otherwise. + for (wchar_t *p = &nBuffer[nBuffer[0] == L'-']; *p != L'\0'; p += 1) { + if (*p < L'0' || *p > L'9') { + *p = L'.'; + break; + } + } + + wchar_t stackBuffer[STACK_BUFFER_SIZE]; + wchar_t *buffer = stackBuffer; + FormatInfo formatInfo; + + formatInfo = *fFormatInfo; + buffer[0] = 0x0000; + + const wchar_t *localeName = nullptr; + + if (fWindowsLocaleName != nullptr) + { + localeName = reinterpret_cast(toOldUCharPtr(fWindowsLocaleName->getTerminatedBuffer())); + } + + if (fCurrency) { + if (fFractionDigitsSet) { + formatInfo.currency.NumDigits = (UINT) numDigits; + } + + if (!isGroupingUsed()) { + formatInfo.currency.Grouping = 0; + } + + result = GetCurrencyFormatEx(localeName, 0, nBuffer, &formatInfo.currency, buffer, STACK_BUFFER_SIZE); + + if (result == 0) { + DWORD lastError = GetLastError(); + + if (lastError == ERROR_INSUFFICIENT_BUFFER) { + int newLength = GetCurrencyFormatEx(localeName, 0, nBuffer, &formatInfo.currency, nullptr, 0); + + buffer = NEW_ARRAY(wchar_t, newLength); + buffer[0] = 0x0000; + GetCurrencyFormatEx(localeName, 0, nBuffer, &formatInfo.currency, buffer, newLength); + } + } + } else { + if (fFractionDigitsSet) { + formatInfo.number.NumDigits = (UINT) numDigits; + } + + if (!isGroupingUsed()) { + formatInfo.number.Grouping = 0; + } + + result = GetNumberFormatEx(localeName, 0, nBuffer, &formatInfo.number, buffer, STACK_BUFFER_SIZE); + + if (result == 0) { + if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { + int newLength = GetNumberFormatEx(localeName, 0, nBuffer, &formatInfo.number, nullptr, 0); + + buffer = NEW_ARRAY(wchar_t, newLength); + buffer[0] = 0x0000; + GetNumberFormatEx(localeName, 0, nBuffer, &formatInfo.number, buffer, newLength); + } + } + } + + appendTo.append((char16_t *)buffer, (int32_t) wcslen(buffer)); + + if (buffer != stackBuffer) { + DELETE_ARRAY(buffer); + } + + /*if (nBuffer != nStackBuffer) { + DELETE_ARRAY(nBuffer); + }*/ + + return appendTo; +} + +U_NAMESPACE_END + +#endif /* #if !UCONFIG_NO_FORMATTING */ + +#endif // U_PLATFORM_USES_ONLY_WIN32_API -- cgit v1.2.3