Numeric.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <errno.h>
#include <stdio.h>
#include <math.h>   // HUGE_VAL
#include <float.h>  // FLT_MAX, FLT_MIN
#include <ctype.h>
#include <wctype.h>
#include <wchar.h>      // wcstol, wcstoul
 
#include <dcl/_stdlib.h>
 
#include <dcl/Object.h>
#include <dcl/Numeric.h>
#include "__xtoa.h"
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/Numeric.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
#if 0
static void formatHelper(String& strResult,
        const String& strNumber, 
        const String& strFormat,
        bool bThousandsSep /* = */
        )
{
    if (strFormat.isEmpty())
    {
        strResult += strNumber;
        return;
    }
 
    int nNumber = strNumber.length();
    int nFormat = strFormat.length();
    const char* psz = strNumber.cstr();
    const char* pszFormat = strFormat.cstr();
    if (/* *psz != '\0' && */ *psz == '-')
    {
        strResult += *psz;
        psz++;
        nNumber--;
    }
    if (*pszFormat != '\0' && *pszFormat != '#' && *pszFormat != '0')
    {
        // currency symbol
        strResult += *pszFormat;
        pszFormat++;
        nFormat--;
    }
 
    int nGreateFormat = nFormat - nNumber;
    if (nGreateFormat > 0)
    {
        int nThousandsPos = nFormat % 3;
        int i = 0;
        bool bEmpty = true;
        for (; nGreateFormat--; i++)
        {
            if (*pszFormat == '0') 
            {
                if (!bEmpty && bThousandsSep && ((i % 3) == nThousandsPos))
                    strResult += ',';
 
                strResult += '0';
                bEmpty = false;
            }
            else if (*pszFormat == '#')
            {
                if (!bEmpty && bThousandsSep && ((i % 3) == nThousandsPos))
                {
                    strResult += ',';
                }
            }
            pszFormat++;
        }
 
        for(; *psz ; i++)
        {
            if (!bEmpty && bThousandsSep && ((i % 3) == nThousandsPos))
                strResult += ',';
            strResult += *psz++;
            bEmpty = false;
        }
    }
    else
    {
        int nThousandsPos = nNumber % 3;
        for(int i = 0; *psz ; i++)
        {
            if (i != 0 && bThousandsSep && ((i % 3) == nThousandsPos))
                strResult += ',';
            strResult += *psz++;
        }
    }
}
 
String formatDouble(double value, const char* pszFormat)
{
    __DCL_ASSERT(pszFormat != NULL);
    String strFormat = pszFormat;
    String strResult;
    // 유효숫자리 계산
 
    int nDigit = 17;
    int nDecimalPoint = 0;
    int nSign = 0;
 
    char szBuf[_CVTBUFSIZE];
    __DCL_VERIFY(_ecvt_s(szBuf, sizeof(szBuf), value, nDigit, &nDecimalPoint, &nSign) == 0);
 
    if (nDecimalPoint <= 0)
        nDigit = 0;
    else
        nDigit = nDecimalPoint;
 
    int nFormatDecimalPoint = strFormat.find('.');
    if (nFormatDecimalPoint >= 0)
        nDigit += strFormat.length() - nFormatDecimalPoint - 1;
 
    if (nDigit > 17)    // double precision
        nDigit = 17;
 
    __DCL_VERIFY(_ecvt_s(szBuf, sizeof(szBuf), value, nDigit, &nDecimalPoint, &nSign) == 0);
    String strDouble = szBuf;
 
    if (nDecimalPoint < 0)
    {
        String strZero('0', abs(nDecimalPoint));
        strDouble.insert(0, strZero);
        strDouble.setLength(nDigit);
        nDecimalPoint = 0;
    }
    else
    {
        if (nDigit < nDecimalPoint)
            strDouble.append('0', nDecimalPoint - nDigit);
    }
 
    // 여기서부터는 문자열 처리
    String strInt(strDouble, 0, nDecimalPoint);
    String strDecimal(strDouble, nDecimalPoint, strDouble.length() - nDecimalPoint);
 
    if (nSign)
        strResult = '-';
 
    if (!strDecimal.isEmpty() && strInt.isEmpty())
        strInt = "0";
 
    String strIntFormat;
    String strDecimalFormat;
 
    strIntFormat.assign(strFormat, 0, nFormatDecimalPoint);
    strDecimalFormat.assign(strFormat, 
        nFormatDecimalPoint + 1, strFormat.length() - nFormatDecimalPoint - 1);
 
    formatHelper(strResult, strInt, strIntFormat, (int)strFormat.find(',') >= 0);
 
    // 소수부분의 마지막 부분부터 '0' 인 문자를 삭제한다.
    strDecimal.trimRight('0');
 
    // 소수부분이 비어있지 않으면..
    if (!strDecimal.isEmpty() || nFormatDecimalPoint >= 0)
    {
        if (!(strDecimal.isEmpty() 
            && !strDecimalFormat.isEmpty() 
            && strDecimalFormat.at(0) == '#'))
        {
            strResult += '.';
            formatHelper(strResult, strDecimal, strDecimalFormat, false);
        }
    }
    return strResult;
}
 
// 이 함수는 소수점 아래에 대하여 포멧을 수행하지 않는다.
// 이 함수를 호출하기전에 반드시 precision을 정해야 한다.
// 가급적 이 함수를 호출하지 말것 .. Oracle NUMBER 의 경우 사용하기 위함.
String formatDecimalString(const String& strNumber, const char* pszFormat)
{
    __DCL_ASSERT(pszFormat != NULL);
 
    String strFormat = pszFormat;
    String strResult;
 
    int nDecimalPoint = strNumber.find('.');
    int nFormatDecimalPoint = strFormat.find('.');
 
    String strInt;
    String strIntFormat;
 
    if (nDecimalPoint >= 0)
        strInt.assign(strNumber, 0, nDecimalPoint);
    else
        strInt = strNumber;
 
    if (nFormatDecimalPoint >= 0)
        strIntFormat.assign(strFormat, 0, nFormatDecimalPoint);
    else
        strIntFormat = strFormat;
 
    formatHelper(strResult, strInt, strIntFormat, (int)strFormat.find(',') >= 0);
 
    // 소수부분이 비어있지 않으면..
    // 소부부분의 포멧팅을 수행하지 않는다 단지 복사한다.
    if (nDecimalPoint >= 0 && (int)strNumber.length() > nDecimalPoint + 1)
    {
        strResult.append(strNumber, nDecimalPoint, strNumber.length() - nDecimalPoint);
    }
 
    return strResult;
}
 
String formatIntegerString(const char* pszIntegerValue, const char* pszFormat)
{
    __DCL_ASSERT(pszIntegerValue != NULL);
    __DCL_ASSERT(pszFormat != NULL);
 
    String strInt = pszIntegerValue;
    String strFormat = pszFormat;
    String strResult;
 
    if (strInt == "0")
        strInt.clear();
 
    String strIntFormat;
    String strDecimalFormat;
    int nFormatDecimalPoint = strFormat.find('.');
    if (nFormatDecimalPoint >= 0)
    {
        strIntFormat.assign(strFormat, 0, nFormatDecimalPoint);
        strDecimalFormat.assign(strFormat, 
            nFormatDecimalPoint + 1, strFormat.length() - nFormatDecimalPoint - 1);
    }
    else
        strIntFormat = strFormat;
 
    formatHelper(strResult, strInt, strIntFormat, (int)strFormat.find(',') >= 0);
    if (!strDecimalFormat.isEmpty() && strDecimalFormat.at(0) == '0')
    {
        strResult += '.';
        formatHelper(strResult, "", strDecimalFormat, false);
    }
    return strResult;
}
#endif
 

 

 
String Int32::toString(int32_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    CharBuffer* buf = CharBuffer::create(40);
    __int32tow(_n, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String Int32::toString(int32_t _n, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%ld");
 
    __DCL_ASSERT_PARAM(*_format != '\0');
 
    return String::format(_format, _n);
}
 
int32_t Int32::parse(const wchar_t* _number, unsigned _base)
        __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    long n = wcstol(_number, &endptr, _base);
    if (LONG_MIN == n) {
        error = NumericConvertException::Underflow;
    } else if (LONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
#if __WORDSIZE > 32
    else if (n < INT32_MIN) {
        error = NumericConvertException::Underflow;
    } else if (INT32_MAX < n) {
        error = NumericConvertException::Overflow;
    }
#endif
    
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            _base
            );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
            );
    }
 
    return (int32_t)n;
}
 
int32_t Int32::parse(const wchar_t* _number, unsigned _base, int32_t _default)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    long n = wcstol(_number, &endptr, _base);
    if (LONG_MIN == n) {
        error = NumericConvertException::Underflow;
    } else if (LONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
    #if __WORDSIZE > 32
    else if (n < INT32_MIN) {
        error = NumericConvertException::Underflow;
    } else if (INT32_MAX < n) {
        error = NumericConvertException::Overflow;
    }
    #endif
    
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (int32_t)n;
}
 
ByteString Int32::toByteString(int32_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(40);
    __int32toa(_n, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}

 
String UInt32::toString(uint32_t _u, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    CharBuffer* buf = CharBuffer::create(40);
    __uint32tow(_u, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String UInt32::toString(uint32_t _u, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%lu");
 
    __DCL_ASSERT_PARAM(*_format != '\0');
 
    return String::format(_format, _u);
}
 
uint32_t UInt32::parse(const wchar_t* _number, unsigned _base)
        __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    unsigned long n = wcstoul(_number, &endptr, _base);
    if (ULONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
#if __WORDSIZE > 32
    else if (UINT32_MAX < n) {
        error = NumericConvertException::Overflow;
    }
#endif
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            _base
            );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
            );
    }
 
    return (uint32_t) n;
}
 
uint32_t UInt32::parse(const wchar_t* _number, unsigned _base, uint32_t _default)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    unsigned long n = wcstoul(_number, &endptr, _base);
    if (ULONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
#if __WORDSIZE > 32
    else if (UINT32_MAX < n) {
        error = NumericConvertException::Overflow;
    }
#endif
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (uint32_t) n;
}
 
ByteString UInt32::toByteString(uint32_t _u, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(40);
    __uint32toa(_u, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}

 
String Int64::toString(int64_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
     // 2진수일경우 64 + sign = 65
    CharBuffer* buf = CharBuffer::create(70);
    __int64tow(_n, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String Int64::toString(int64_t _n, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%lld");
 
    __DCL_ASSERT_PARAM(*_format != '\0');
 
    return String::format(_format, _n);
}
 
#if __DCL_WINDOWS
#define wcstoll(nptr, endptr, base) _wcstoi64(nptr, endptr, base)
#define wcstoull(nptr, endptr, base) _wcstoui64(nptr, endptr, base)
#endif
 
int64_t Int64::parse(const wchar_t* _number, unsigned _base)
        __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    long long n = wcstoll(_number, &endptr, _base);
    if (LLONG_MIN == n) {
        error = NumericConvertException::Underflow;
    } else if (LLONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            _base
            );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
            );
    }
 
    return (int64_t) n;
}
 
int64_t Int64::parse(const wchar_t* _number, unsigned _base, int64_t _default)
        __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    long long n = wcstoll(_number, &endptr, _base);
    if (LLONG_MIN == n) {
        error = NumericConvertException::Underflow;
    } else if (LLONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (int64_t) n;
}
 
ByteString Int64::toByteString(int64_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(70);
    __int64toa(_n, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}

 
String UInt64::toString(uint64_t _u, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
     // 2진수일경우 64 + sign = 65
    CharBuffer* buf = CharBuffer::create(70);
    __uint64tow(_u, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String UInt64::toString(uint64_t _u, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%ull");
 
    __DCL_ASSERT(*_format != '\0');
 
    return String::format(_format, _u);
}
 
uint64_t UInt64::parse(const wchar_t* _number, unsigned _base)
        __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    unsigned long long n = wcstoull(_number, &endptr, _base);
    if (ULLONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            _base
            );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
            );
    }
 
    return (uint64_t) n;
}
 
uint64_t UInt64::parse(const wchar_t* _number, unsigned _base, uint64_t _default)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    unsigned long long n = wcstoull(_number, &endptr, _base);
    if (ULONG_MAX == n) {
        error = NumericConvertException::Overflow;
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (uint64_t) n;
}
 
ByteString UInt64::toByteString(uint64_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(70);
    __uint64toa(_n, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}
 
// Lengths of Exponents and Mantissas
// Type     |Exponent length    |Mantissa length    |   문자열 길이
//          |                   |                   | 가수    | 지수
//--------------------------------------------------------------------------------
// float    |   8 bits          |   23 bits         |   3   |   7
// double   |   11 bits         |   52 bits         |   4   |   15
// 
 
//Range of Floating-Point Types
//Type      |   Minimum value               |   Maximum value 
//--------------------------------------------------------------------------------
//float     |   1.175494351 E - 38          |   3.402823466 E + 38 
//double    |   2.2250738585072014 E - 308  |   1.7976931348623158 E + 308 

#if 0
String Single::toString(float _f)
{
    String s;
    char* psz = s.getBuffer(_CVTBUFSIZE);   // 9 + '.' + 'E' + '-' + 3 ==> 15
    _gcvt_s(psz, _CVTBUFSIZE, f, 8);
    s.releaseBuffer();
    return s;
}
#endif
 
String Single::toString(float _f, const wchar_t* _format)
{
    if (!_format)
        _format = _f < INT64_MIN || INT64_MAX < _f ? __T("%e") : __T("%f");
 
    __DCL_ASSERT(*_format != '\0');
 
    return String::format(_format, _f);
}
 
float Single::parse(const wchar_t* _number)
        __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, 0, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    float n = wcstof(_number, &endptr);
    if (+HUGE_VALF == n || -HUGE_VALF == n) {
        error = NumericConvertException::Overflow;
    } else if (!(FLT_MIN < n)) {
        error = NumericConvertException::Underflow;
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            0
            );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            0,
            endptr ? (endptr - _number) : 0
            );
    }
 
    return (float) n;
}
 
float Single::parse(const wchar_t* _number, float _default)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    float n = wcstof(_number, &endptr);
    if (+HUGE_VALF == n || -HUGE_VALF == n) {
        error = NumericConvertException::Overflow;
    } else if (!(FLT_MIN < n)) {
        error = NumericConvertException::Underflow;
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (float) n;
}
 
ByteString Single::toByteString(float _f, const char* _format)
{
    if (!_format)
        _format = _f < INT64_MIN || INT64_MAX < _f ? "%e" : "%f";
 
    __DCL_ASSERT(*_format != '\0');
 
    return ByteString::format(_format, _f);
}

 
#if 0
String Double::toString(double _d)
{
    String s;
    char* psz = s.getBuffer(_CVTBUFSIZE);   // 17 + '.' + 'E' + '-' + 3 ==> 23
    _gcvt_s(psz, _CVTBUFSIZE, value, 16);
    s.releaseBuffer();
    return s;
}
#endif
 
String Double::toString(double _d, const wchar_t* _format)
{
    if (!_format)
        _format = _d < INT64_MIN || INT64_MAX < _d ? __T("%e") : __T("%f");
 
    __DCL_ASSERT(*_format != '\0');
 
    return String::format(_format, _d);
}
 
double Double::parse(const wchar_t* _number)
        __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, 0, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    double n = wcstod(_number, &endptr);
    if (+HUGE_VAL == n || -HUGE_VAL == n) {
        error = NumericConvertException::Overflow;
    } else if (!(DBL_MIN < n)) {
        error = NumericConvertException::Underflow;
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            0
            );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            0,
            endptr ? (endptr - _number) : 0
            );
    }
 
    return (double) n;
}
 
double Double::parse(const wchar_t* _number, double _default)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    wchar_t* endptr = NULL;
    double n = wcstod(_number, &endptr);
    if (+HUGE_VAL == n || -HUGE_VAL == n) {
        error = NumericConvertException::Overflow;
    } else if (!(DBL_MIN < n)) {
        error = NumericConvertException::Underflow;
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (double) n;
}
 
ByteString Double::toByteString(double _d, const char* _format)
{
    if (!_format)
        _format = _d < INT64_MIN || INT64_MAX < _d ? "%e" : "%f";
 
    __DCL_ASSERT(*_format != '\0');
 
    return ByteString::format(_format, _d);
}

 
const char* Decimal::FORMAT_STRING = "#,###.####";
 
static String __GetDecimalString(double d)
{
#if 0
    int nDigit = 16;    // double procision
    int nDecimalPoint = 0;
    int nSign = 0;
    char* psz = NULL;
 
    char szBuf[_CVTBUFSIZE];    // buf[22];
    __DCL_VERIFY(_ecvt_s(szBuf, sizeof(szBuf), d, nDigit, &nDecimalPoint, &nSign) == 0);
 
    psz = szBuf;
 
    char* p = psz + nDigit;
    while(psz <= --p)
    {
        if (*p != '0')
            break;
    }
 
    *(++p) = '\0';
 
    int nLen = p - psz;
 
    String str;
    if (nLen > 0)
    {
        if (nSign)
            str = '-';
 
        if (nDecimalPoint < 0)
        {
            str += "0.";
            str.append('0', -nDecimalPoint);
            str += psz;
        }
        else
        {
            if (nDecimalPoint >= nLen)
            {
                str.append(psz);
                if (nDecimalPoint > nLen)
                    str.append('0', nDecimalPoint - nLen);
                str.append(".0");
            }
            else
            {
                str.append(psz, nDecimalPoint);
                str.append('.');
                str.append(psz + nDecimalPoint);
            }
        }
    }
    else
        str = "0.0";
 
    return str;
#endif
    return String();
}
 
const Decimal& Decimal::operator = (float value)
{
    m_value = __GetDecimalString(value);
    return *this;
}
 
const Decimal& Decimal::operator = (double value)
{
    m_value = __GetDecimalString(value);
    return *this;
}
 
String Decimal::toStringF(const Decimal& value, 
        const char* pszDecimalFormat // = NULL
        )
{
#if 0
    if (!pszDecimalFormat)
        pszDecimalFormat = FORMAT_STRING;
 
    __DCL_ASSERT(*pszDecimalFormat != '\0');
 
    return formatDecimalString(
                value.m_value, 
                pszDecimalFormat
                );
#endif
    return String();
}
 
/*
int32_t Decimal::toInt32() const
{
    return atoi(m_value);
}
 
int64_t Decimal::toInt64() const
{
#if __DCL_WINDOWS
    return _atoi64(m_value);
#else
    return atoll(m_value);
#endif
}
 
double Decimal::toDouble() const
{
    return atof(m_value);
}
*/
 
__DCL_END_NAMESPACE