re: What's wrong with one of GetNumberFormat's callers? And what's wrong with GetNumberFormat?

Igor Levicki — Tue, 11 Mar 2008 23:22:46 GMT

This is how I would write GetDoubleFormat():

#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif

#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include <windows.h>

#define MSEP_MAX 5    // 4 characters + NULL, actual Windows XP limit
#define TSEP_MAX 4    // 3 characters + NULL, actual Windows XP limit
#define DSEP_MAX 4    // 3 characters + NULL, actual Windows XP limit
#define NDEC_MAX 9    // 9 decimal places, actual Windows XP limit
#define PDBL_MAX 320 // 1.7976931348623158e+308
#define PDBL_MAX2 640
// Copyright (c) 2008 by Igor Levicki. All Bugs Reserved. :-)

LPCTSTR GetDoubleFormat(const double Value, const UINT DecimalPlaces) {
    static TCHAR Formatted[MAX_PATH];
    TCHAR StrValue[MAX_PATH];
    TCHAR StrFraction[MAX_PATH];
    TCHAR MSep[MSEP_MAX] = _T("-");
    TCHAR TSep[TSEP_MAX] = _T(",");
    TCHAR DSep[DSEP_MAX] = _T(".");

    const TCHAR Dot = _T('.');
    const TCHAR Zero = _T('0');

    LPTSTR FracPtr;
    size_t Cch, Mod, Idx;

    if (DecimalPlaces > NDEC_MAX) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }

    if (Value > DBL_MAX) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }

    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SNEGATIVESIGN, MSep, MSEP_MAX);
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, TSep, TSEP_MAX);
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, DSep, DSEP_MAX);

    Formatted[0] = 0;

    switch (_fpclass(Value)) {
        case _FPCLASS_SNAN:
        case _FPCLASS_QNAN:
        case _FPCLASS_NINF:
        case _FPCLASS_ND;
        case _FPCLASS_PD:
        case _FPCLASS_PINF:
            SetLastError(ERROR_INVALID_PARAMETER); // or ERROR_INVALID_DATA
            return NULL; // or ERROR_NOT_SUPPORTED

        case _FPCLASS_NZ:
            _tcscat_s(Formatted, MAX_PATH, MSep);

        case _FPCLASS_PZ:
            _tcsncat_s(Formatted, MAX_PATH, &Zero, 1);
            if (DecimalPlaces > 0) {
                _tcscat_s(Formatted, MAX_PATH, DSep);
                size_t Len = _tcslen(Formatted);
                for (UINT i = 0; i < DecimalPlaces; i++) {
                    Formatted[Len + i] = Zero;
                }
                Formatted[Len + DecimalPlaces] = 0;
            }
            return Formatted;
        }

        _stprintf_s(StrValue, PDBL_MAX, _T("%0.*f"), DecimalPlaces, abs(Value));
        FracPtr = _tcsrchr(StrValue, Dot);

        if (FracPtr != NULL) {
            *FracPtr++ = 0;
            _tcscpy_s(StrFraction, PDBL_MAX, FracPtr);
        } else {
            StrFraction[0] = 0;
        }

        Cch = _tcslen(StrValue);
        Mod = (Cch % 3);
        Idx = (Mod == 0) ? 3 : Mod;
        Formatted[0] = 0;

        if (Value < 0.0) {
            _tcscat_s(Formatted, PDBL_MAX2, MSep);
        }

        for (size_t i = 0; i < Cch; i++) {
            if (i == Idx) {
                _tcscat_s(Formatted, PDBL_MAX2, TSep);
                Idx += 3;
            }

            _tcsncat_s(Formatted, MAX_PATH, &StrValue[i], 1);
        }

    if (DecimalPlaces > 0) {
        _tcscat_s(Formatted, PDBL_MAX2, DSep);
        _tcscat_s(Formatted, PDBL_MAX2, StrFraction);
    }

    return Formatted;
}

int _tmain(int argc, _TCHAR* argv[]) {
    if (--argc != 2) {
        printf("Usage : %s <decimal_number> <places>\n", argv[0]);
        return 1;
    }

    double Value = _tstof(argv[1]);
    int DecimalPlaces = _tstoi(argv[2]);

    _tprintf(_T("DecimalPlaces = %ld, Formatted : %s"), DecimalPlaces, GetDoubleFormat(Value, DecimalPlaces));

    return 0;
}

It properly handles user overrides for minus sign (up to 4 characters), thousand separator and decimal separator (up to 3 characters each), and it allows showing more decimal places than the original which could only chop the fractional part, not extend it.

Function could be easily expanded to handle +/- Infinity (and use locale supplied strings for that), to handle denormals and to display SNaN and QNaN text if needed. A bit more challenging task would be to handle digit replacement correctly and to use digit grouping other than 3.

re: What's wrong with one of GetNumberFormat's callers? And what's wrong with GetNumberFormat?

Michael S. Kaplan — Tue, 11 Mar 2008 16:06:53 GMT

I guess the lack of clarity on that point could be considered a fourth problem to fix? :-)

re: What's wrong with one of GetNumberFormat's callers? And what's wrong with GetNumberFormat?

Leo Davidson — Tue, 11 Mar 2008 10:58:29 GMT

"GetNumberFormatW assumes that space for the NULL is included in the buffer -- why allocate a wchar_t array of 256 if you are only going to pass 255 for the length?"

Because MSDN is almost always vague about what the length arguments mean. MSDN typically talks about the length of the string, but doesn't say if it means the length as in what strlen (etc.) would return, or if it means the number of characters in the string including the null.

I expect most APIs do include the null in their lengths but it only takes one bad API call to cause a crash or corrupt memory when the string happens to be the same length as the buffer and the null either doesn't get written or gets written off the end of the buffer...

So I almost always, unless the MSDN documentation is very explicit, allocate that one extra character. It's just two bytes of memory, so why not? Not everyone has the advantage of being able to look in the API source when the documentation falls short and it's quicker to waste 2 bytes (for the millisecond that stack frame is in scope) than to run tests on every API to see how it behaves when the result fills the buffer exactly.

re: What's wrong with one of GetNumberFormat's callers? And what's wrong with GetNumberFormat?

Michael S. Kaplan — Tue, 11 Mar 2008 07:37:18 GMT

Not sure how this gets all the user 's preferences?

re: What's wrong with one of GetNumberFormat's callers? And what's wrong with GetNumberFormat?

Pseudo — Mon, 10 Mar 2008 20:16:51 GMT

The simplest way would seem to be:

set f = 10^DecimalPlaces

multiply Value by f

round or truncate to an integer

divide by f

wsprintf to get the string