diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericopenlibs/cppstdlib/stl/src/num_get_float.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericopenlibs/cppstdlib/stl/src/num_get_float.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1000 @@ +/* + * Portions Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. + * + * Copyright (c) 1999 + * Silicon Graphics Computer Systems, Inc. + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +#include "stlport_prefix.h" + +#include +#include +#include + +#if defined (__GNUC__) && !defined (__sun) || \ + defined (__DMC__) +# include +#endif + +#if defined (__linux__) +# include + +union _ll { + uint64_t i64; + struct { +# if defined (_STLP_BIG_ENDIAN) + uint32_t hi; + uint32_t lo; +# elif defined (_STLP_LITTLE_ENDIAN) + uint32_t lo; + uint32_t hi; +# else +# error Unknown endianess +# endif + } i32; +}; +#endif + +#if defined (N_PLAT_NLM) +# include + +# if defined (INT64) +typedef unsigned INT64 uint64_t; +# else +// #error "Can't find INT64" +// 64-bit int really not defined in headers +// (_INTEGRAL_MAX_BITS < 64 in any case?), but compiler indeed know __int64 +// - ptr, 2005-05-06 +typedef unsigned __int64 uint64_t; +# endif + +# if defined (INT32) +typedef unsigned INT32 uint32_t; +# else +# error Can not find INT32 +# endif + +union _ll { + uint64_t i64; + struct { + uint32_t lo; + uint32_t hi; + } i32; +}; +#endif + +_STLP_BEGIN_NAMESPACE +_STLP_MOVE_TO_PRIV_NAMESPACE + +//---------------------------------------------------------------------- +// num_get + +// Helper functions for _M_do_get_float. + +#if !defined (_STLP_NO_WCHAR_T) +void _STLP_DECLSPEC _STLP_CALL +_Initialize_get_float( const ctype& ct, + wchar_t& Plus, wchar_t& Minus, + wchar_t& pow_e, wchar_t& pow_E, + wchar_t* digits) { + char ndigits[11] = "0123456789"; + Plus = ct.widen('+'); + Minus = ct.widen('-'); + pow_e = ct.widen('e'); + pow_E = ct.widen('E'); + ct.widen(ndigits + 0, ndigits + 10, digits); +} +#endif /* WCHAR_T */ + +/* + * __string_to_double is just lifted from atof, the difference being + * that we just use '.' for the decimal point, rather than let it + * be taken from the current C locale, which of course is not accessible + * to us. + */ +#if defined (_STLP_MSVC) || defined (__BORLANDC__) || defined (__ICL) +typedef unsigned long uint32; +typedef unsigned __int64 uint64; +# define ULL(x) x##Ui64 +#elif defined (__MRC__) || defined (__SC__) +typedef unsigned long uint32; +# include "uint64.h" //*TY 03/25/2000 - added 64bit math type definition +#elif defined (__unix) || defined (__MINGW32__) || defined (N_PLAT_NLM) || \ + (defined (__DMC__) && (__LONGLONG)) || defined(__SYMBIAN32__) +#if defined(__SYMBIAN32__) +# include +#endif +typedef uint32_t uint32; +typedef uint64_t uint64; +# define ULL(x) x##ULL +#else +# error There should be some unsigned 64-bit integer on the system! +#endif + +// Multiplication of two 64-bit integers, giving a 128-bit result. +// Taken from Algorithm M in Knuth section 4.3.1, with the loop +// hand-unrolled. +static void _Stl_mult64(const uint64 u, const uint64 v, + uint64& high, uint64& low) { + const uint64 low_mask = ULL(0xffffffff); + const uint64 u0 = u & low_mask; + const uint64 u1 = u >> 32; + const uint64 v0 = v & low_mask; + const uint64 v1 = v >> 32; + + uint64 t = u0 * v0; + low = t & low_mask; + + t = u1 * v0 + (t >> 32); + uint64 w1 = t & low_mask; + uint64 w2 = t >> 32; + + uint64 x = u0 * v1 + w1; + low += (x & low_mask) << 32; + high = u1 * v1 + w2 + (x >> 32); +} + +#define bit11 ULL(0x7ff) +#define exponent_mask (bit11 << 52) + +#if !defined (__GNUC__) || (__GNUC__ != 3) || (__GNUC_MINOR__ != 4) || \ + (!defined (__CYGWIN__) && !defined (__MINGW32__)) +//Generate bad code when compiled with -O2 option. +inline +#endif +void _Stl_set_exponent(uint64 &val, uint64 exp) +{ val = (val & ~exponent_mask) | ((exp & bit11) << 52); } + +/* Power of ten fractions for tenscale*/ +/* The constants are factored so that at most two constants + * and two multiplies are needed. Furthermore, one of the constants + * is represented exactly - 10**n where 1<= n <= 27. + */ + +#if !defined (__SC__) //*TY 03/25/2000 - no native 64bit integer under SCpp +static const uint64 _Stl_tenpow[80] = { +ULL(0xa000000000000000), /* _Stl_tenpow[0]=(10**1)/(2**4) */ +ULL(0xc800000000000000), /* _Stl_tenpow[1]=(10**2)/(2**7) */ +ULL(0xfa00000000000000), /* _Stl_tenpow[2]=(10**3)/(2**10) */ +ULL(0x9c40000000000000), /* _Stl_tenpow[3]=(10**4)/(2**14) */ +ULL(0xc350000000000000), /* _Stl_tenpow[4]=(10**5)/(2**17) */ +ULL(0xf424000000000000), /* _Stl_tenpow[5]=(10**6)/(2**20) */ +ULL(0x9896800000000000), /* _Stl_tenpow[6]=(10**7)/(2**24) */ +ULL(0xbebc200000000000), /* _Stl_tenpow[7]=(10**8)/(2**27) */ +ULL(0xee6b280000000000), /* _Stl_tenpow[8]=(10**9)/(2**30) */ +ULL(0x9502f90000000000), /* _Stl_tenpow[9]=(10**10)/(2**34) */ +ULL(0xba43b74000000000), /* _Stl_tenpow[10]=(10**11)/(2**37) */ +ULL(0xe8d4a51000000000), /* _Stl_tenpow[11]=(10**12)/(2**40) */ +ULL(0x9184e72a00000000), /* _Stl_tenpow[12]=(10**13)/(2**44) */ +ULL(0xb5e620f480000000), /* _Stl_tenpow[13]=(10**14)/(2**47) */ +ULL(0xe35fa931a0000000), /* _Stl_tenpow[14]=(10**15)/(2**50) */ +ULL(0x8e1bc9bf04000000), /* _Stl_tenpow[15]=(10**16)/(2**54) */ +ULL(0xb1a2bc2ec5000000), /* _Stl_tenpow[16]=(10**17)/(2**57) */ +ULL(0xde0b6b3a76400000), /* _Stl_tenpow[17]=(10**18)/(2**60) */ +ULL(0x8ac7230489e80000), /* _Stl_tenpow[18]=(10**19)/(2**64) */ +ULL(0xad78ebc5ac620000), /* _Stl_tenpow[19]=(10**20)/(2**67) */ +ULL(0xd8d726b7177a8000), /* _Stl_tenpow[20]=(10**21)/(2**70) */ +ULL(0x878678326eac9000), /* _Stl_tenpow[21]=(10**22)/(2**74) */ +ULL(0xa968163f0a57b400), /* _Stl_tenpow[22]=(10**23)/(2**77) */ +ULL(0xd3c21bcecceda100), /* _Stl_tenpow[23]=(10**24)/(2**80) */ +ULL(0x84595161401484a0), /* _Stl_tenpow[24]=(10**25)/(2**84) */ +ULL(0xa56fa5b99019a5c8), /* _Stl_tenpow[25]=(10**26)/(2**87) */ +ULL(0xcecb8f27f4200f3a), /* _Stl_tenpow[26]=(10**27)/(2**90) */ + +ULL(0xd0cf4b50cfe20766), /* _Stl_tenpow[27]=(10**55)/(2**183) */ +ULL(0xd2d80db02aabd62c), /* _Stl_tenpow[28]=(10**83)/(2**276) */ +ULL(0xd4e5e2cdc1d1ea96), /* _Stl_tenpow[29]=(10**111)/(2**369) */ +ULL(0xd6f8d7509292d603), /* _Stl_tenpow[30]=(10**139)/(2**462) */ +ULL(0xd910f7ff28069da4), /* _Stl_tenpow[31]=(10**167)/(2**555) */ +ULL(0xdb2e51bfe9d0696a), /* _Stl_tenpow[32]=(10**195)/(2**648) */ +ULL(0xdd50f1996b947519), /* _Stl_tenpow[33]=(10**223)/(2**741) */ +ULL(0xdf78e4b2bd342cf7), /* _Stl_tenpow[34]=(10**251)/(2**834) */ +ULL(0xe1a63853bbd26451), /* _Stl_tenpow[35]=(10**279)/(2**927) */ +ULL(0xe3d8f9e563a198e5), /* _Stl_tenpow[36]=(10**307)/(2**1020) */ + +ULL(0xfd87b5f28300ca0e), /* _Stl_tenpow[37]=(10**-28)/(2**-93) */ +ULL(0xfb158592be068d2f), /* _Stl_tenpow[38]=(10**-56)/(2**-186) */ +ULL(0xf8a95fcf88747d94), /* _Stl_tenpow[39]=(10**-84)/(2**-279) */ +ULL(0xf64335bcf065d37d), /* _Stl_tenpow[40]=(10**-112)/(2**-372) */ +ULL(0xf3e2f893dec3f126), /* _Stl_tenpow[41]=(10**-140)/(2**-465) */ +ULL(0xf18899b1bc3f8ca2), /* _Stl_tenpow[42]=(10**-168)/(2**-558) */ +ULL(0xef340a98172aace5), /* _Stl_tenpow[43]=(10**-196)/(2**-651) */ +ULL(0xece53cec4a314ebe), /* _Stl_tenpow[44]=(10**-224)/(2**-744) */ +ULL(0xea9c227723ee8bcb), /* _Stl_tenpow[45]=(10**-252)/(2**-837) */ +ULL(0xe858ad248f5c22ca), /* _Stl_tenpow[46]=(10**-280)/(2**-930) */ +ULL(0xe61acf033d1a45df), /* _Stl_tenpow[47]=(10**-308)/(2**-1023) */ +ULL(0xe3e27a444d8d98b8), /* _Stl_tenpow[48]=(10**-336)/(2**-1116) */ +ULL(0xe1afa13afbd14d6e) /* _Stl_tenpow[49]=(10**-364)/(2**-1209) */ + +#else //*TY 03/20/2000 - added support for SCpp which lacks native 64bit integer type +static const UnsignedWide _Stl_tenpow[80] = { +ULL2(0xa0000000,0x00000000), /* _Stl_tenpow[0]=(10**1)/(2**4) */ +ULL2(0xc8000000,0x00000000), /* _Stl_tenpow[1]=(10**2)/(2**7) */ +ULL2(0xfa000000,0x00000000), /* _Stl_tenpow[2]=(10**3)/(2**10) */ +ULL2(0x9c400000,0x00000000), /* _Stl_tenpow[3]=(10**4)/(2**14) */ +ULL2(0xc3500000,0x00000000), /* _Stl_tenpow[4]=(10**5)/(2**17) */ +ULL2(0xf4240000,0x00000000), /* _Stl_tenpow[5]=(10**6)/(2**20) */ +ULL2(0x98968000,0x00000000), /* _Stl_tenpow[6]=(10**7)/(2**24) */ +ULL2(0xbebc2000,0x00000000), /* _Stl_tenpow[7]=(10**8)/(2**27) */ +ULL2(0xee6b2800,0x00000000), /* _Stl_tenpow[8]=(10**9)/(2**30) */ +ULL2(0x9502f900,0x00000000), /* _Stl_tenpow[9]=(10**10)/(2**34) */ +ULL2(0xba43b740,0x00000000), /* _Stl_tenpow[10]=(10**11)/(2**37) */ +ULL2(0xe8d4a510,0x00000000), /* _Stl_tenpow[11]=(10**12)/(2**40) */ +ULL2(0x9184e72a,0x00000000), /* _Stl_tenpow[12]=(10**13)/(2**44) */ +ULL2(0xb5e620f4,0x80000000), /* _Stl_tenpow[13]=(10**14)/(2**47) */ +ULL2(0xe35fa931,0xa0000000), /* _Stl_tenpow[14]=(10**15)/(2**50) */ +ULL2(0x8e1bc9bf,0x04000000), /* _Stl_tenpow[15]=(10**16)/(2**54) */ +ULL2(0xb1a2bc2e,0xc5000000), /* _Stl_tenpow[16]=(10**17)/(2**57) */ +ULL2(0xde0b6b3a,0x76400000), /* _Stl_tenpow[17]=(10**18)/(2**60) */ +ULL2(0x8ac72304,0x89e80000), /* _Stl_tenpow[18]=(10**19)/(2**64) */ +ULL2(0xad78ebc5,0xac620000), /* _Stl_tenpow[19]=(10**20)/(2**67) */ +ULL2(0xd8d726b7,0x177a8000), /* _Stl_tenpow[20]=(10**21)/(2**70) */ +ULL2(0x87867832,0x6eac9000), /* _Stl_tenpow[21]=(10**22)/(2**74) */ +ULL2(0xa968163f,0x0a57b400), /* _Stl_tenpow[22]=(10**23)/(2**77) */ +ULL2(0xd3c21bce,0xcceda100), /* _Stl_tenpow[23]=(10**24)/(2**80) */ +ULL2(0x84595161,0x401484a0), /* _Stl_tenpow[24]=(10**25)/(2**84) */ +ULL2(0xa56fa5b9,0x9019a5c8), /* _Stl_tenpow[25]=(10**26)/(2**87) */ +ULL2(0xcecb8f27,0xf4200f3a), /* _Stl_tenpow[26]=(10**27)/(2**90) */ + +ULL2(0xd0cf4b50,0xcfe20766), /* _Stl_tenpow[27]=(10**55)/(2**183) */ +ULL2(0xd2d80db0,0x2aabd62c), /* _Stl_tenpow[28]=(10**83)/(2**276) */ +ULL2(0xd4e5e2cd,0xc1d1ea96), /* _Stl_tenpow[29]=(10**111)/(2**369) */ +ULL2(0xd6f8d750,0x9292d603), /* _Stl_tenpow[30]=(10**139)/(2**462) */ +ULL2(0xd910f7ff,0x28069da4), /* _Stl_tenpow[31]=(10**167)/(2**555) */ +ULL2(0xdb2e51bf,0xe9d0696a), /* _Stl_tenpow[32]=(10**195)/(2**648) */ +ULL2(0xdd50f199,0x6b947519), /* _Stl_tenpow[33]=(10**223)/(2**741) */ +ULL2(0xdf78e4b2,0xbd342cf7), /* _Stl_tenpow[34]=(10**251)/(2**834) */ +ULL2(0xe1a63853,0xbbd26451), /* _Stl_tenpow[35]=(10**279)/(2**927) */ +ULL2(0xe3d8f9e5,0x63a198e5), /* _Stl_tenpow[36]=(10**307)/(2**1020) */ + +ULL2(0xfd87b5f2,0x8300ca0e), /* _Stl_tenpow[37]=(10**-28)/(2**-93) */ +ULL2(0xfb158592,0xbe068d2f), /* _Stl_tenpow[38]=(10**-56)/(2**-186) */ +ULL2(0xf8a95fcf,0x88747d94), /* _Stl_tenpow[39]=(10**-84)/(2**-279) */ +ULL2(0xf64335bc,0xf065d37d), /* _Stl_tenpow[40]=(10**-112)/(2**-372) */ +ULL2(0xf3e2f893,0xdec3f126), /* _Stl_tenpow[41]=(10**-140)/(2**-465) */ +ULL2(0xf18899b1,0xbc3f8ca2), /* _Stl_tenpow[42]=(10**-168)/(2**-558) */ +ULL2(0xef340a98,0x172aace5), /* _Stl_tenpow[43]=(10**-196)/(2**-651) */ +ULL2(0xece53cec,0x4a314ebe), /* _Stl_tenpow[44]=(10**-224)/(2**-744) */ +ULL2(0xea9c2277,0x23ee8bcb), /* _Stl_tenpow[45]=(10**-252)/(2**-837) */ +ULL2(0xe858ad24,0x8f5c22ca), /* _Stl_tenpow[46]=(10**-280)/(2**-930) */ +ULL2(0xe61acf03,0x3d1a45df), /* _Stl_tenpow[47]=(10**-308)/(2**-1023) */ +ULL2(0xe3e27a44,0x4d8d98b8), /* _Stl_tenpow[48]=(10**-336)/(2**-1116) */ +ULL2(0xe1afa13a,0xfbd14d6e) /* _Stl_tenpow[49]=(10**-364)/(2**-1209) */ +#endif +}; + +static const short _Stl_twoexp[80] = { +4,7,10,14,17,20,24,27,30,34,37,40,44,47,50,54,57,60,64,67,70,74,77,80,84,87,90, +183,276,369,462,555,648,741,834,927,1020, +-93,-186,-279,-372,-465,-558,-651,-744,-837,-930,-1023,-1116,-1209 +}; + +#define TEN_1 0 /* offset to 10 ** 1 */ +#define TEN_27 26 /* offset to 10 ** 27 */ +#define TEN_M28 37 /* offset to 10 ** -28 */ +#define NUM_HI_P 11 +#define NUM_HI_N 13 + +#define _Stl_HIBITULL (ULL(1) << 63) + +static void _Stl_norm_and_round(uint64& p, int& norm, uint64 prodhi, uint64 prodlo) { + norm = 0; + if ((prodhi & _Stl_HIBITULL) == 0) { + /* leading bit is a zero + * may have to normalize + */ + if ((prodhi == ~_Stl_HIBITULL) && + ((prodlo >> 62) == 0x3)) { /* normalization followed by round + * would cause carry to create + * extra bit, so don't normalize + */ + p = _Stl_HIBITULL; + return; + } + p = (prodhi << 1) | (prodlo >> 63); /* normalize */ + norm = 1; + prodlo <<= 1; + } + else { + p = prodhi; + } + + if ((prodlo & _Stl_HIBITULL) != 0) { /* first guard bit a one */ //*TY 03/25/2000 - added explicit comparison to zero to avoid reliance to the implicit conversion from uint64 to bool +#if !defined (__SC__) //*TY 03/25/2000 - + if (((p & 0x1) != 0) || + prodlo != _Stl_HIBITULL ) { /* not borderline for round to even */ +#else //*TY 03/25/2000 - added workaround for SCpp compiler + bool b1 = ((p & 0x1) != 0); + if (b1 || prodlo != _Stl_HIBITULL) { //*TY 03/25/2000 - SCpp confuses on this particular original boolean expression +#endif //*TY 03/25/2000 - + /* round */ + ++p; + if (p == 0) + ++p; + } + } + + return; +} + +// Convert a 64-bitb fraction * 10^exp to a 64-bit fraction * 2^bexp. +// p: 64-bit fraction +// exp: base-10 exponent +// bexp: base-2 exponent (output parameter) +static void _Stl_tenscale(uint64& p, int exp, int& bexp) { + uint64 prodhi, prodlo; /* 128b product */ + int exp_hi, exp_lo; /* exp = exp_hi*32 + exp_lo */ + int hi, lo, tlo, thi; /* offsets in power of ten table */ + int norm; /* number of bits of normalization */ + int num_hi; /* number of high exponent powers */ + + bexp = 0; + if (exp > 0) { /* split exponent */ + exp_lo = exp; + exp_hi = 0; + if (exp_lo > 27) { + exp_lo++; + while (exp_lo > 27) { + exp_hi++; + exp_lo -= 28; + } + } + tlo = TEN_1; + thi = TEN_27; + num_hi = NUM_HI_P; + } + else if (exp < 0) { + exp_lo = exp; + exp_hi = 0; + while (exp_lo < 0) { + exp_hi++; + exp_lo += 28; + } + tlo = TEN_1; + thi = TEN_M28; + num_hi = NUM_HI_N; + } + else { /* no scaling needed */ + return; + } + while (exp_hi) { /* scale */ + hi = (min) (exp_hi, num_hi); /* only a few large powers of 10 */ + exp_hi -= hi; /* could iterate in extreme case */ + hi += thi-1; + _Stl_mult64(p, _Stl_tenpow[hi], prodhi, prodlo); + _Stl_norm_and_round(p, norm, prodhi, prodlo); + bexp += _Stl_twoexp[hi] - norm; + } + if (exp_lo) { + lo = tlo + exp_lo -1; + _Stl_mult64(p, _Stl_tenpow[lo], prodhi, prodlo); + _Stl_norm_and_round(p, norm, prodhi, prodlo); + bexp += _Stl_twoexp[lo] - norm; + } + + return; +} + +// First argument is a buffer of values from 0 to 9, NOT ascii. +// Second argument is number of digits in buffer, 1 <= digits <= 17. +// Third argument is base-10 exponent. + +#if defined (__SC__) || defined (__MRC__) + +//*TY 04/06/2000 - powermac's 68K emulator utilizes apple's SANE floating point, which is not compatible with IEEE format. +_STLP_MOVE_TO_STD_NAMESPACE +_STLP_END_NAMESPACE + +# include + +_STLP_BEGIN_NAMESPACE +_STLP_MOVE_TO_PRIV_NAMESPACE + +static inline double _Stl_atod(char *buffer, int ndigit, int dexp) { + decimal d; // ref. inside macintosh powerpc numerics p.9-13 + + d.sgn = 0; + d.exp = dexp; + d.sig.length = ndigit; + for (int i = 0; i < ndigit; ++i) { + d.sig.text[i] = buffer[i] + '0'; + } + return dec2num(&d); +} + +#else /* IEEE representation */ + +# if !defined (__linux__) +static double _Stl_atod(char *buffer, int ndigit, int dexp) { + uint64 value; /* Value develops as follows: + * 1) decimal digits as an integer + * 2) left adjusted fraction + * 3) right adjusted fraction + * 4) exponent and fraction + */ + + uint32 guard; /* First guard bit */ + uint64 rest; /* Remaining guard bits */ + + int bexp; /* binary exponent */ + int nzero; /* number of non-zero bits */ + int sexp; /* scaling exponent */ + + char *bufferend; /* pointer to char after last digit */ + + /* Check for zero and treat it as a special case */ + if (buffer == 0){ + return 0.0; + } + + /* Convert the decimal digits to a binary integer. */ + + bufferend = buffer + ndigit; + value = 0; + + while (buffer < bufferend) { + value *= 10; + value += *buffer++; + } + + /* Check for zero and treat it as a special case */ + if (value == 0) { + return 0.0; + } + + /* Normalize value */ + bexp = 64; /* convert from 64b int to fraction */ + + /* Count number of non-zeroes in value */ + nzero = 0; + if ((value >> 32) != 0) { nzero = 32; } //*TY 03/25/2000 - added explicit comparison to zero to avoid uint64 to bool conversion operator + if ((value >> (16 + nzero)) != 0) { nzero += 16; } + if ((value >> ( 8 + nzero)) != 0) { nzero += 8; } + if ((value >> ( 4 + nzero)) != 0) { nzero += 4; } + if ((value >> ( 2 + nzero)) != 0) { nzero += 2; } + if ((value >> ( 1 + nzero)) != 0) { nzero += 1; } + if ((value >> ( nzero)) != 0) { nzero += 1; } + + /* Normalize */ + value <<= /*(uint64)*/ (64 - nzero); //*TY 03/25/2000 - removed extraneous cast to uint64 + bexp -= 64 - nzero; + + /* At this point we have a 64b fraction and a binary exponent + * but have yet to incorporate the decimal exponent. + */ + + /* multiply by 10^dexp */ + _Stl_tenscale(value, dexp, sexp); + bexp += sexp; + + if (bexp <= -1022) { /* HI denorm or underflow */ + bexp += 1022; + if (bexp < -53) { /* guaranteed underflow */ + value = 0; + } + else { /* denorm or possible underflow */ + int lead0 = 12 - bexp; /* 12 sign and exponent bits */ + + /* we must special case right shifts of more than 63 */ + if (lead0 > 64) { + rest = value; + guard = 0; + value = 0; + } + else if (lead0 == 64) { + rest = value & ((ULL(1)<< 63)-1); +#if !defined(__SC__) + guard = (uint32) ((value>> 63) & 1 ); +#else + guard = to_ulong((value>> 63) & 1 ); //*TY 03/25/2000 - use member function instead of problematic conversion operator utilization +#endif + value = 0; + } + else { + rest = value & (((ULL(1) << lead0)-1)-1); +#if !defined(__SC__) + guard = (uint32) (((value>> lead0)-1) & 1); +#else //*TY 03/25/2000 - + guard = to_ulong(((value>> lead0)-1) & 1); +#endif //*TY 03/25/2000 - + value >>= /*(uint64)*/ lead0; /* exponent is zero */ + } + + /* Round */ + if (guard && ((value & 1) || rest) ) { + ++value; + if (value == (ULL(1) << 52)) { /* carry created normal number */ + value = 0; + _Stl_set_exponent(value, 1); + } + } + } + } + else { /* not zero or denorm */ + /* Round to 53 bits */ + rest = value & (1<<10)-1; + value >>= 10; +#if !defined(__SC__) + guard = (uint32) value & 1; +#else //*TY 03/25/2000 - + guard = to_ulong(value & 1); +#endif + value >>= 1; + + /* value&1 guard rest Action + * + * dc 0 dc none + * 1 1 dc round + * 0 1 0 none + * 0 1 !=0 round + */ + if (guard) { + if (((value&1)!=0) || (rest!=0)) { + ++value; /* round */ + if ((value >> 53) != 0) { /* carry all the way across */ + value >>= 1; /* renormalize */ + ++bexp; + } + } + } + /* + * Check for overflow + * IEEE Double Precision Format + * (From Table 7-8 of Kane and Heinrich) + * + * Fraction bits 52 + * Emax +1023 + * Emin -1022 + * Exponent bias +1023 + * Exponent bits 11 + * Integer bit hidden + * Total width in bits 64 + */ + + if (bexp > 1024) { /* overflow */ + return numeric_limits::infinity(); + } + else { /* value is normal */ + value &= ~(ULL(1) << 52); /* hide hidden bit */ + _Stl_set_exponent(value, bexp + 1022); /* add bias */ + } + } + + _STLP_STATIC_ASSERT(sizeof(value) == sizeof(double)) + return *((double *) &value); +} + +# else // __linux__ + +static double _Stl_atod(char *buffer, int ndigit, int dexp) { + ieee754_double v; + + char *bufferend; /* pointer to char after last digit */ + + /* Check for zero and treat it as a special case */ + + if (buffer == 0) { + return 0.0; + } + + /* Convert the decimal digits to a binary integer. */ + + bufferend = buffer + ndigit; + _ll vv; + vv.i64 = 0L; + + while (buffer < bufferend) { + vv.i64 *= 10; + vv.i64 += *buffer++; + } + + /* Check for zero and treat it as a special case */ + if (vv.i64 == 0){ + return 0.0; + } + + /* Normalize value */ + int bexp = 64; /* convert from 64b int to fraction */ + + /* Count number of non-zeroes in value */ + int nzero = 0; + if ((vv.i64 >> 32) !=0 ) { nzero = 32; } //*TY 03/25/2000 - added explicit comparison to zero to avoid uint64 to bool conversion operator + if ((vv.i64 >> (16 + nzero)) != 0) { nzero += 16; } + if ((vv.i64 >> ( 8 + nzero)) != 0) { nzero += 8; } + if ((vv.i64 >> ( 4 + nzero)) != 0) { nzero += 4; } + if ((vv.i64 >> ( 2 + nzero)) != 0) { nzero += 2; } + if ((vv.i64 >> ( 1 + nzero)) != 0) { nzero += 1; } + if ((vv.i64 >> ( nzero)) != 0) { nzero += 1; } + + /* Normalize */ + nzero = 64 - nzero; + vv.i64 <<= nzero; //*TY 03/25/2000 - removed extraneous cast to uint64 + bexp -= nzero; + + /* At this point we have a 64b fraction and a binary exponent + * but have yet to incorporate the decimal exponent. + */ + + /* multiply by 10^dexp */ + int sexp; + _Stl_tenscale(vv.i64, dexp, sexp); + bexp += sexp; + + if (bexp <= -1022) { /* HI denorm or underflow */ + bexp += 1022; + if (bexp < -53) { /* guaranteed underflow */ + vv.i64 = 0; + } + else { /* denorm or possible underflow */ + int lead0; + uint64_t rest; + uint32_t guard; + + lead0 = 12-bexp; /* 12 sign and exponent bits */ + + /* we must special case right shifts of more than 63 */ + if (lead0 > 64) { + rest = vv.i64; + guard = 0; + vv.i64 = 0; + } + else if (lead0 == 64) { + rest = vv.i64 & ((ULL(1) << 63)-1); +#if !defined(__SC__) + guard = (uint32) ((vv.i64 >> 63) & 1 ); +#else + guard = to_ulong((vv.i64 >> 63) & 1 ); //*TY 03/25/2000 - use member function instead of problematic conversion operator utilization +#endif + vv.i64 = 0; + } + else { + rest = vv.i64 & (((ULL(1) << lead0)-1)-1); +#if !defined(__SC__) + guard = (uint32) (((vv.i64 >> lead0)-1) & 1); +#else //*TY 03/25/2000 - + guard = to_ulong(((vv.i64 >> lead0)-1) & 1); +#endif //*TY 03/25/2000 - + vv.i64 >>= /*(uint64)*/ lead0; /* exponent is zero */ + } + + /* Round */ + if (guard && ( (vv.i64 & 1) || rest)) { + vv.i64++; + if (vv.i64 == (ULL(1) << 52)) { /* carry created normal number */ + v.ieee.mantissa0 = 0; + v.ieee.mantissa1 = 0; + v.ieee.negative = 0; + v.ieee.exponent = 1; + return v.d; + } + } + } + } + else { /* not zero or denorm */ + /* Round to 53 bits */ + uint64_t rest = vv.i64 & (1<<10)-1; + vv.i64 >>= 10; +#if !defined(__SC__) + uint32_t guard = (uint32) vv.i64 & 1; +#else //*TY 03/25/2000 - + uint32_t guard = to_ulong(vv.i64 & 1); +#endif + vv.i64 >>= 1; + + /* value&1 guard rest Action + * + * dc 0 dc none + * 1 1 dc round + * 0 1 0 none + * 0 1 !=0 round + */ + if (guard) { + if (((vv.i64&1)!=0) || (rest!=0)) { + vv.i64++; /* round */ + if ((vv.i64>>53)!=0) { /* carry all the way across */ + vv.i64 >>= 1; /* renormalize */ + ++bexp; + } + } + } + /* + * Check for overflow + * IEEE Double Precision Format + * (From Table 7-8 of Kane and Heinrich) + * + * Fraction bits 52 + * Emax +1023 + * Emin -1022 + * Exponent bias +1023 + * Exponent bits 11 + * Integer bit hidden + * Total width in bits 64 + */ + + if (bexp > 1024) { /* overflow */ + return numeric_limits::infinity(); + } + else { /* value is normal */ + vv.i64 &= ~(ULL(1) << 52); /* hide hidden bit */ + v.ieee.mantissa0 = vv.i32.hi; + v.ieee.mantissa1 = vv.i32.lo; + v.ieee.negative = 0; + v.ieee.exponent = bexp + 1022; + return v.d; + } + } + + v.ieee.mantissa0 = vv.i32.hi; + v.ieee.mantissa1 = vv.i32.lo; + v.ieee.negative = 0; + v.ieee.exponent = 0; + + return v.d; +} +# endif // __linux__ + +#endif + +static double _Stl_string_to_double(const char *s) { + const int max_digits = 17; + unsigned c; + unsigned Negate, decimal_point; + char *d; + int exp; + double x; + int dpchar; + char digits[max_digits]; + + // Skip leading whitespace, if any. + const ctype& ct = use_facet >(locale::classic()); + while (c = *s++, ct.is(ctype_base::space, char(c))) {} + + /* process sign */ + Negate = 0; + if (c == '+') { + c = *s++; + } + else if (c == '-') { + Negate = 1; + c = *s++; + } + d = digits; + dpchar = '.' - '0'; + decimal_point = 0; + exp = 0; + for (;;) { + c -= '0'; + if (c < 10) { + if (d == digits + max_digits) { + /* ignore more than 17 digits, but adjust exponent */ + exp += (decimal_point ^ 1); + } + else { + if (c == 0 && d == digits) { + /* ignore leading zeros */ + } + else { + *d++ = (char) c; + } + exp -= decimal_point; + } + } + else if (c == (unsigned int) dpchar && !decimal_point) { /* INTERNATIONAL */ + decimal_point = 1; + } + else { + break; + } + c = *s++; + } + /* strtod cant return until it finds the end of the exponent */ + if (d == digits) { + return 0.0; + } + + if (c == 'e'-'0' || c == 'E'-'0') { + register unsigned negate_exp = 0; + register int e = 0; + c = *s++; + if (c == '+' || c == ' ') { + c = *s++; + } + else if (c == '-') { + negate_exp = 1; + c = *s++; + } + if (c -= '0', c < 10) { + do { + if (e <= 340) + e = e * 10 + (int)c; + else break; + c = *s++; + } + while (c -= '0', c < 10); + if (negate_exp) { + e = -e; + } + if (e < -340 || e > 340) + exp = e; + else + exp += e; + } + } + + if (exp < -340) { + x = 0; + } + else if (exp > 308) { + x = numeric_limits::infinity(); + } + else { + /* let _Stl_atod diagnose under- and over-flows */ + /* if the input was == 0.0, we have already returned, + so retval of +-Inf signals OVERFLOW, 0.0 UNDERFLOW + */ + x = _Stl_atod(digits, (int)(d - digits), exp); + } + if (Negate) { + x = -x; + } + return x; +} + + +#if !defined (_STLP_NO_LONG_DOUBLE) +/* + * __string_to_long_double is just lifted from atold, the difference being + * that we just use '.' for the decimal point, rather than let it + * be taken from the current C locale, which of course is not accessible + * to us. + */ + +static long double +_Stl_string_to_long_double(const char * s) { + const int max_digits = 34; + register unsigned c; + register unsigned Negate, decimal_point; + register char *d; + register int exp; + long double x; + register int dpchar; + char digits[max_digits]; + + const ctype& ct = use_facet >(locale::classic()); + while (c = *s++, ct.is(ctype_base::space, char(c))) + ; + + /* process sign */ + Negate = 0; + if (c == '+') { + c = *s++; + } + else if (c == '-') { + Negate = 1; + c = *s++; + } + + d = digits; + dpchar = '.' - '0'; + decimal_point = 0; + exp = 0; + + for (;;) { + c -= '0'; + if (c < 10) { + if (d == digits+max_digits) { + /* ignore more than 34 digits, but adjust exponent */ + exp += (decimal_point ^ 1); + } + else { + if (c == 0 && d == digits) { + /* ignore leading zeros */ + ; + } + else { + *d++ = (char)c; + } + exp -= decimal_point; + } + } + else if ((char)c == dpchar && !decimal_point) { /* INTERNATIONAL */ + decimal_point = 1; + } + else { + break; + } + c = *s++; + } /* for */ + + if (d == digits) { + return 0.0L; + } + if (c == 'e'-'0' || c == 'E'-'0') { + register unsigned negate_exp = 0; + register int e = 0; + c = *s++; + if (c == '+' || c == ' ') { + c = *s++; + } + else if (c == '-') { + negate_exp = 1; + c = *s++; + } + if (c -= '0', c < 10) { + do { + if (e <= 340) + e = e * 10 + c; + else break; + c = *s++; + } + while (c -= '0', c < 10); + if (negate_exp) { + e = -e; + } + if (e < -(323+max_digits) || e > 308) + exp = e; + else + exp += e; + } + } + + if (exp < -(324+max_digits)) { + x = 0; + } + else if (exp > 308) { + x = numeric_limits::infinity(); + } + else { + /* let _Stl_atod diagnose under- and over-flows */ + /* if the input was == 0.0, we have already returned, + so retval of +-Inf signals OVERFLOW, 0.0 UNDERFLOW + */ + + // x = _Stl_atod (digits, (int)(d - digits), exp); // TEMPORARY!!:1 + double tmp = _Stl_atod (digits, (int)(d - digits), exp); // TEMPORARY!!:1 + x = tmp == numeric_limits::infinity() + ? numeric_limits::infinity() + : tmp; + } + + if (Negate) { + x = -x; + } + + return x; +} +#endif + +void _STLP_DECLSPEC _STLP_CALL +__string_to_float(const __iostring& v, float& val) +{ val = (float)_Stl_string_to_double(v.c_str()); } + +void _STLP_DECLSPEC _STLP_CALL +__string_to_float(const __iostring& v, double& val) +{ val = _Stl_string_to_double(v.c_str()); } + +#if !defined (_STLP_NO_LONG_DOUBLE) +void _STLP_DECLSPEC _STLP_CALL +__string_to_float(const __iostring& v, long double& val) +{ val = _Stl_string_to_long_double(v.c_str()); } +#endif + +_STLP_MOVE_TO_STD_NAMESPACE +_STLP_END_NAMESPACE + +// Local Variables: +// mode:C++ +// End: