[apple/icu.git] / icuSources / i18n / winnmfmt.cpp

/*
********************************************************************************
*   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"

#   define WIN32_LEAN_AND_MEAN
#   define VC_EXTRALEAN
#   define NOUSER
#   define NOSERVICE
#   define NOIME
#   define NOMCX
#include <windows.h>
#include <stdio.h>

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 char *grouping)
{
    UINT g = 0;
	const char *s;

    for (s = grouping; *s != '\0'; s += 1) {
        if (*s > '0' && *s < '9') {
            g = g * 10 + (*s - '0');
        } else if (*s != ';') {
            break;
        }
    }

    if (*s != '0') {
        g *= 10;
    }

    return g;
}

static void getNumberFormat(NUMBERFMTW *fmt, int32_t lcid)
{
    char buf[10];

    GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER|LOCALE_IDIGITS, (LPWSTR) &fmt->NumDigits, sizeof(UINT));
    GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER|LOCALE_ILZERO,  (LPWSTR) &fmt->LeadingZero, sizeof(UINT));

    GetLocaleInfoA(lcid, LOCALE_SGROUPING, buf, 10);
    fmt->Grouping = getGrouping(buf);

    fmt->lpDecimalSep = NEW_ARRAY(UChar, 6);
    GetLocaleInfoW(lcid, LOCALE_SDECIMAL,  fmt->lpDecimalSep,  6);

    fmt->lpThousandSep = NEW_ARRAY(UChar, 6);
    GetLocaleInfoW(lcid, LOCALE_STHOUSAND, fmt->lpThousandSep, 6);

    GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER|LOCALE_INEGNUMBER, (LPWSTR) &fmt->NegativeOrder, sizeof(UINT));
}

static void freeNumberFormat(NUMBERFMTW *fmt)
{
    if (fmt != NULL) {
        DELETE_ARRAY(fmt->lpThousandSep);
        DELETE_ARRAY(fmt->lpDecimalSep);
    }
}

static void getCurrencyFormat(CURRENCYFMTW *fmt, int32_t lcid)
{
    char buf[10];

    GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER|LOCALE_ICURRDIGITS, (LPWSTR) &fmt->NumDigits, sizeof(UINT));
    GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER|LOCALE_ILZERO, (LPWSTR) &fmt->LeadingZero, sizeof(UINT));

    GetLocaleInfoA(lcid, LOCALE_SMONGROUPING, buf, sizeof(buf));
    fmt->Grouping = getGrouping(buf);

    fmt->lpDecimalSep = NEW_ARRAY(UChar, 6);
    GetLocaleInfoW(lcid, LOCALE_SMONDECIMALSEP,  fmt->lpDecimalSep,  6);

    fmt->lpThousandSep = NEW_ARRAY(UChar, 6);
    GetLocaleInfoW(lcid, LOCALE_SMONTHOUSANDSEP, fmt->lpThousandSep, 6);

    GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER|LOCALE_INEGCURR,  (LPWSTR) &fmt->NegativeOrder, sizeof(UINT));
    GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER|LOCALE_ICURRENCY, (LPWSTR) &fmt->PositiveOrder, sizeof(UINT));

    fmt->lpCurrencySymbol = NEW_ARRAY(UChar, 8);
    GetLocaleInfoW(lcid, LOCALE_SCURRENCY, (LPWSTR) fmt->lpCurrencySymbol, 8);
}

static void freeCurrencyFormat(CURRENCYFMTW *fmt)
{
    if (fmt != NULL) {
        DELETE_ARRAY(fmt->lpCurrencySymbol);
        DELETE_ARRAY(fmt->lpThousandSep);
        DELETE_ARRAY(fmt->lpDecimalSep);
    }
}

Win32NumberFormat::Win32NumberFormat(const Locale &locale, UBool currency, UErrorCode &status)
  : NumberFormat(), fCurrency(currency), fFormatInfo(NULL), fFractionDigitsSet(FALSE)
{
    if (!U_FAILURE(status)) {
        fLCID = locale.getLCID();

        // 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);
        }

        fFormatInfo = (FormatInfo*)uprv_malloc(sizeof(FormatInfo));

        if (fCurrency) {
            getCurrencyFormat(&fFormatInfo->currency, fLCID);
        } else {
            getNumberFormat(&fFormatInfo->number, fLCID);
        }
    }
}

Win32NumberFormat::Win32NumberFormat(const Win32NumberFormat &other)
  : NumberFormat(other), fFormatInfo((FormatInfo*)uprv_malloc(sizeof(FormatInfo)))
{
    if (fFormatInfo != NULL) {
        uprv_memset(fFormatInfo, 0, sizeof(*fFormatInfo));
    }
    *this = other;
}

Win32NumberFormat::~Win32NumberFormat()
{
    if (fFormatInfo != NULL) {
        if (fCurrency) {
            freeCurrencyFormat(&fFormatInfo->currency);
        } else {
            freeNumberFormat(&fFormatInfo->number);
        }

        uprv_free(fFormatInfo);
    }
}

Win32NumberFormat &Win32NumberFormat::operator=(const Win32NumberFormat &other)
{
    NumberFormat::operator=(other);

    this->fCurrency          = other.fCurrency;
    this->fLocale            = other.fLocale;
    this->fLCID              = other.fLCID;
    this->fFractionDigitsSet = other.fFractionDigitsSet;

    if (fCurrency) {
        freeCurrencyFormat(&fFormatInfo->currency);
        getCurrencyFormat(&fFormatInfo->currency, fLCID);
    } else {
        freeNumberFormat(&fFormatInfo->number);
        getNumberFormat(&fFormatInfo->number, fLCID);
    }

    return *this;
}

Format *Win32NumberFormat::clone(void) 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 NULL 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(UChar, 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;
        }
    }

    UChar stackBuffer[STACK_BUFFER_SIZE];
    UChar *buffer = stackBuffer;
    FormatInfo formatInfo;

    formatInfo = *fFormatInfo;
    buffer[0] = 0x0000;

    if (fCurrency) {
        if (fFractionDigitsSet) {
            formatInfo.currency.NumDigits = (UINT) numDigits;
        }

        if (!isGroupingUsed()) {
            formatInfo.currency.Grouping = 0;
        }

        result = GetCurrencyFormatW(fLCID, 0, nBuffer, &formatInfo.currency, buffer, STACK_BUFFER_SIZE);

        if (result == 0) {
            DWORD lastError = GetLastError();

            if (lastError == ERROR_INSUFFICIENT_BUFFER) {
                int newLength = GetCurrencyFormatW(fLCID, 0, nBuffer, &formatInfo.currency, NULL, 0);

                buffer = NEW_ARRAY(UChar, newLength);
                buffer[0] = 0x0000;
                GetCurrencyFormatW(fLCID, 0, nBuffer,  &formatInfo.currency, buffer, newLength);
            }
        }
    } else {
        if (fFractionDigitsSet) {
            formatInfo.number.NumDigits = (UINT) numDigits;
        }

        if (!isGroupingUsed()) {
            formatInfo.number.Grouping = 0;
        }

        result = GetNumberFormatW(fLCID, 0, nBuffer, &formatInfo.number, buffer, STACK_BUFFER_SIZE);

        if (result == 0) {
            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
                int newLength = GetNumberFormatW(fLCID, 0, nBuffer, &formatInfo.number, NULL, 0);

                buffer = NEW_ARRAY(UChar, newLength);
                buffer[0] = 0x0000;
                GetNumberFormatW(fLCID, 0, nBuffer, &formatInfo.number, buffer, newLength);
            }
        }
    }

    appendTo.append(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
Commit	Line	Data
73c04bcf A	1	/*
73c04bcf A	2	********************************************************************************
2ca993e8	3	* Copyright (C) 2005-2016, International Business Machines
73c04bcf A	4	* Corporation and others. All Rights Reserved.
	5	********************************************************************************
	6	*
	7	* File WINNMFMT.CPP
	8	*
	9	********************************************************************************
	10	*/
	11
	12	#include "unicode/utypes.h"
	13
4388f060	14	#if U_PLATFORM_USES_ONLY_WIN32_API
73c04bcf A	15
	16	#if !UCONFIG_NO_FORMATTING
	17
	18	#include "winnmfmt.h"
	19
	20	#include "unicode/format.h"
	21	#include "unicode/numfmt.h"
	22	#include "unicode/locid.h"
	23	#include "unicode/ustring.h"
	24
	25	#include "cmemory.h"
	26	#include "uassert.h"
	27	#include "locmap.h"
	28
	29	# define WIN32_LEAN_AND_MEAN
	30	# define VC_EXTRALEAN
	31	# define NOUSER
	32	# define NOSERVICE
	33	# define NOIME
	34	# define NOMCX
	35	#include <windows.h>
	36	#include <stdio.h>
	37
	38	U_NAMESPACE_BEGIN
	39
	40	union FormatInfo
	41	{
	42	NUMBERFMTW number;
	43	CURRENCYFMTW currency;
	44	};
	45
	46	UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Win32NumberFormat)
	47
	48	#define NEW_ARRAY(type,count) (type ) uprv_malloc((count) sizeof(type))
	49	#define DELETE_ARRAY(array) uprv_free((void *) (array))
	50
	51	#define STACK_BUFFER_SIZE 32
	52
	53	/*
	54	* Turns a string of the form "3;2;0" into the grouping UINT
	55	* needed for NUMBERFMT and CURRENCYFMT. If the string does not
	56	* end in ";0" then the return value should be multiplied by 10.
	57	* (e.g. "3" => 30, "3;2" => 320)
	58	*/
	59	static UINT getGrouping(const char *grouping)
	60	{
	61	UINT g = 0;
	62	const char *s;
	63
	64	for (s = grouping; *s != '\0'; s += 1) {
	65	if (s > '0' && s < '9') {
	66	g = g * 10 + (*s - '0');
	67	} else if (*s != ';') {
	68	break;
	69	}
	70	}
	71
	72	if (*s != '0') {
	73	g *= 10;
	74	}
	75
	76	return g;
	77	}
	78
79	static void getNumberFormat(NUMBERFMTW *fmt, int32_t lcid)
80	{
81	char buf[10];
82
83	GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER\|LOCALE_IDIGITS, (LPWSTR) &fmt->NumDigits, sizeof(UINT));
84	GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER\|LOCALE_ILZERO, (LPWSTR) &fmt->LeadingZero, sizeof(UINT));
85
86	GetLocaleInfoA(lcid, LOCALE_SGROUPING, buf, 10);
87	fmt->Grouping = getGrouping(buf);
88
89	fmt->lpDecimalSep = NEW_ARRAY(UChar, 6);
90	GetLocaleInfoW(lcid, LOCALE_SDECIMAL, fmt->lpDecimalSep, 6);
91
92	fmt->lpThousandSep = NEW_ARRAY(UChar, 6);
93	GetLocaleInfoW(lcid, LOCALE_STHOUSAND, fmt->lpThousandSep, 6);
94
95	GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER\|LOCALE_INEGNUMBER, (LPWSTR) &fmt->NegativeOrder, sizeof(UINT));
96	}
97
98	static void freeNumberFormat(NUMBERFMTW *fmt)
99	{
46f4442e A	100	if (fmt != NULL) {
	101	DELETE_ARRAY(fmt->lpThousandSep);
	102	DELETE_ARRAY(fmt->lpDecimalSep);
	103	}
73c04bcf A	104	}
	105
	106	static void getCurrencyFormat(CURRENCYFMTW *fmt, int32_t lcid)
	107	{
	108	char buf[10];
	109
	110	GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER\|LOCALE_ICURRDIGITS, (LPWSTR) &fmt->NumDigits, sizeof(UINT));
	111	GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER\|LOCALE_ILZERO, (LPWSTR) &fmt->LeadingZero, sizeof(UINT));
	112
	113	GetLocaleInfoA(lcid, LOCALE_SMONGROUPING, buf, sizeof(buf));
	114	fmt->Grouping = getGrouping(buf);
	115
	116	fmt->lpDecimalSep = NEW_ARRAY(UChar, 6);
	117	GetLocaleInfoW(lcid, LOCALE_SMONDECIMALSEP, fmt->lpDecimalSep, 6);
	118
	119	fmt->lpThousandSep = NEW_ARRAY(UChar, 6);
	120	GetLocaleInfoW(lcid, LOCALE_SMONTHOUSANDSEP, fmt->lpThousandSep, 6);
	121
	122	GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER\|LOCALE_INEGCURR, (LPWSTR) &fmt->NegativeOrder, sizeof(UINT));
	123	GetLocaleInfoW(lcid, LOCALE_RETURN_NUMBER\|LOCALE_ICURRENCY, (LPWSTR) &fmt->PositiveOrder, sizeof(UINT));
	124
	125	fmt->lpCurrencySymbol = NEW_ARRAY(UChar, 8);
	126	GetLocaleInfoW(lcid, LOCALE_SCURRENCY, (LPWSTR) fmt->lpCurrencySymbol, 8);
	127	}
	128
	129	static void freeCurrencyFormat(CURRENCYFMTW *fmt)
	130	{
46f4442e A	131	if (fmt != NULL) {
	132	DELETE_ARRAY(fmt->lpCurrencySymbol);
	133	DELETE_ARRAY(fmt->lpThousandSep);
	134	DELETE_ARRAY(fmt->lpDecimalSep);
	135	}
73c04bcf A	136	}
73c04bcf A	137
73c04bcf	138	Win32NumberFormat::Win32NumberFormat(const Locale &locale, UBool currency, UErrorCode &status)
2ca993e8	139	: NumberFormat(), fCurrency(currency), fFormatInfo(NULL), fFractionDigitsSet(FALSE)
73c04bcf A	140	{
	141	if (!U_FAILURE(status)) {
	142	fLCID = locale.getLCID();
	143
57a6839d A	144	// Resolve actual locale to be used later
	145	UErrorCode tmpsts = U_ZERO_ERROR;
	146	char tmpLocID[ULOC_FULLNAME_CAPACITY];
2ca993e8	147	int32_t len = uloc_getLocaleForLCID(fLCID, tmpLocID, UPRV_LENGTHOF(tmpLocID) - 1, &tmpsts);
57a6839d A	148	if (U_SUCCESS(tmpsts)) {
	149	tmpLocID[len] = 0;
	150	fLocale = Locale((const char*)tmpLocID);
	151	}
	152
73c04bcf A	153	fFormatInfo = (FormatInfo*)uprv_malloc(sizeof(FormatInfo));
	154
	155	if (fCurrency) {
	156	getCurrencyFormat(&fFormatInfo->currency, fLCID);
	157	} else {
	158	getNumberFormat(&fFormatInfo->number, fLCID);
	159	}
	160	}
	161	}
	162
	163	Win32NumberFormat::Win32NumberFormat(const Win32NumberFormat &other)
46f4442e	164	: NumberFormat(other), fFormatInfo((FormatInfo*)uprv_malloc(sizeof(FormatInfo)))
73c04bcf	165	{
46f4442e A	166	if (fFormatInfo != NULL) {
	167	uprv_memset(fFormatInfo, 0, sizeof(*fFormatInfo));
	168	}
73c04bcf A	169	*this = other;
	170	}
	171
	172	Win32NumberFormat::~Win32NumberFormat()
	173	{
46f4442e A	174	if (fFormatInfo != NULL) {
	175	if (fCurrency) {
	176	freeCurrencyFormat(&fFormatInfo->currency);
	177	} else {
	178	freeNumberFormat(&fFormatInfo->number);
	179	}
73c04bcf	180
46f4442e A	181	uprv_free(fFormatInfo);
46f4442e A	182	}
73c04bcf A	183	}
	184
	185	Win32NumberFormat &Win32NumberFormat::operator=(const Win32NumberFormat &other)
	186	{
	187	NumberFormat::operator=(other);
	188
	189	this->fCurrency = other.fCurrency;
57a6839d	190	this->fLocale = other.fLocale;
73c04bcf A	191	this->fLCID = other.fLCID;
	192	this->fFractionDigitsSet = other.fFractionDigitsSet;
	193
	194	if (fCurrency) {
	195	freeCurrencyFormat(&fFormatInfo->currency);
	196	getCurrencyFormat(&fFormatInfo->currency, fLCID);
	197	} else {
	198	freeNumberFormat(&fFormatInfo->number);
	199	getNumberFormat(&fFormatInfo->number, fLCID);
	200	}
	201
	202	return *this;
	203	}
	204
	205	Format *Win32NumberFormat::clone(void) const
	206	{
	207	return new Win32NumberFormat(*this);
	208	}
	209
	210	UnicodeString& Win32NumberFormat::format(double number, UnicodeString& appendTo, FieldPosition& pos) const
	211	{
	212	return format(getMaximumFractionDigits(), appendTo, L"%.16f", number);
	213	}
	214
	215	UnicodeString& Win32NumberFormat::format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const
	216	{
	217	return format(getMinimumFractionDigits(), appendTo, L"%I32d", number);
	218	}
	219
	220	UnicodeString& Win32NumberFormat::format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const
	221	{
	222	return format(getMinimumFractionDigits(), appendTo, L"%I64d", number);
	223	}
	224
73c04bcf A	225	void Win32NumberFormat::parse(const UnicodeString& text, Formattable& result, ParsePosition& parsePosition) const
	226	{
	227	UErrorCode status = U_ZERO_ERROR;
57a6839d	228	NumberFormat *nf = fCurrency? NumberFormat::createCurrencyInstance(fLocale, status) : NumberFormat::createInstance(fLocale, status);
73c04bcf A	229
	230	nf->parse(text, result, parsePosition);
	231	delete nf;
	232	}
	233	void Win32NumberFormat::setMaximumFractionDigits(int32_t newValue)
	234	{
	235	fFractionDigitsSet = TRUE;
	236	NumberFormat::setMaximumFractionDigits(newValue);
	237	}
	238
	239	void Win32NumberFormat::setMinimumFractionDigits(int32_t newValue)
	240	{
	241	fFractionDigitsSet = TRUE;
	242	NumberFormat::setMinimumFractionDigits(newValue);
	243	}
	244
b331163b	245	UnicodeString &Win32NumberFormat::format(int32_t numDigits, UnicodeString &appendTo, const wchar_t *fmt, ...) const
73c04bcf A	246	{
	247	wchar_t nStackBuffer[STACK_BUFFER_SIZE];
	248	wchar_t *nBuffer = nStackBuffer;
	249	va_list args;
	250	int result;
	251
	252	nBuffer[0] = 0x0000;
	253
	254	/* Due to the arguments causing a result to be <= 23 characters (+2 for NULL and minus),
	255	we don't need to reallocate the buffer. */
	256	va_start(args, fmt);
	257	result = _vsnwprintf(nBuffer, STACK_BUFFER_SIZE, fmt, args);
	258	va_end(args);
	259
	260	/* Just to make sure of the above statement, we add this assert */
	261	U_ASSERT(result >=0);
	262	// The following code is not used because _vscwprintf isn't available on MinGW at the moment.
	263	/*if (result < 0) {
	264	int newLength;
	265
	266	va_start(args, fmt);
	267	newLength = _vscwprintf(fmt, args);
	268	va_end(args);
	269
	270	nBuffer = NEW_ARRAY(UChar, newLength + 1);
	271
	272	va_start(args, fmt);
	273	result = _vsnwprintf(nBuffer, newLength + 1, fmt, args);
	274	va_end(args);
	275	}*/
	276
	277	// vswprintf is sensitive to the locale set by setlocale. For some locales
	278	// it doesn't use "." as the decimal separator, which is what GetNumberFormatW
	279	// and GetCurrencyFormatW both expect to see.
	280	//
	281	// To fix this, we scan over the string and replace the first non-digits, except
	282	// for a leading "-", with a "."
	283	//
	284	// Note: (nBuffer[0] == L'-') will evaluate to 1 if there is a leading '-' in the
	285	// number, and 0 otherwise.
	286	for (wchar_t p = &nBuffer[nBuffer[0] == L'-']; p != L'\0'; p += 1) {
	287	if (p < L'0' \|\| p > L'9') {
	288	*p = L'.';
	289	break;
	290	}
	291	}
	292
	293	UChar stackBuffer[STACK_BUFFER_SIZE];
	294	UChar *buffer = stackBuffer;
	295	FormatInfo formatInfo;
	296
	297	formatInfo = *fFormatInfo;
	298	buffer[0] = 0x0000;
	299
	300	if (fCurrency) {
	301	if (fFractionDigitsSet) {
	302	formatInfo.currency.NumDigits = (UINT) numDigits;
	303	}
	304
	305	if (!isGroupingUsed()) {
	306	formatInfo.currency.Grouping = 0;
	307	}
	308
	309	result = GetCurrencyFormatW(fLCID, 0, nBuffer, &formatInfo.currency, buffer, STACK_BUFFER_SIZE);
310
311	if (result == 0) {
312	DWORD lastError = GetLastError();
313
314	if (lastError == ERROR_INSUFFICIENT_BUFFER) {
315	int newLength = GetCurrencyFormatW(fLCID, 0, nBuffer, &formatInfo.currency, NULL, 0);
316
317	buffer = NEW_ARRAY(UChar, newLength);
318	buffer[0] = 0x0000;
319	GetCurrencyFormatW(fLCID, 0, nBuffer, &formatInfo.currency, buffer, newLength);
320	}
321	}
322	} else {
323	if (fFractionDigitsSet) {
324	formatInfo.number.NumDigits = (UINT) numDigits;
325	}
326
327	if (!isGroupingUsed()) {
328	formatInfo.number.Grouping = 0;
329	}
330
331	result = GetNumberFormatW(fLCID, 0, nBuffer, &formatInfo.number, buffer, STACK_BUFFER_SIZE);
332
333	if (result == 0) {
334	if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
335	int newLength = GetNumberFormatW(fLCID, 0, nBuffer, &formatInfo.number, NULL, 0);
336
337	buffer = NEW_ARRAY(UChar, newLength);
338	buffer[0] = 0x0000;
339	GetNumberFormatW(fLCID, 0, nBuffer, &formatInfo.number, buffer, newLength);
340	}
341	}
342	}
343
344	appendTo.append(buffer, (int32_t) wcslen(buffer));
345
346	if (buffer != stackBuffer) {
347	DELETE_ARRAY(buffer);
348	}
349
350	/*if (nBuffer != nStackBuffer) {
351	DELETE_ARRAY(nBuffer);
352	}*/
353
354	return appendTo;
355	}
356
357	U_NAMESPACE_END
358
359	#endif /* #if !UCONFIG_NO_FORMATTING */
360
4388f060	361	#endif // U_PLATFORM_USES_ONLY_WIN32_API