--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/src/num_get_float.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,830 @@
+/*
+ * © Portions copyright (c) 2006-2007 Nokia Corporation. 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 <stl/_limits.h>
+#include <stl/_num_get.h>
+#include <stl/_istream.h>
+#ifdef __SYMBIAN32__
+#include <stdlib.h>
+#include <errno.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// num_get
+
+
+/*
+ * __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.
+ */
+
+typedef unsigned int uint32;
+# if defined (_STLP_MSVC) || defined (__BORLANDC__) || defined (__ICL)
+# define ULL(x) x##Ui64
+typedef unsigned _STLP_LONG_LONG uint64;
+# elif defined (_STLP_LONG_LONG)
+typedef unsigned _STLP_LONG_LONG uint64;
+# define ULL(x) x##ULL
+# elif defined(__MRC__) || defined(__SC__) //*TY 02/25/2000 - added support for MPW compilers
+# include "uint64.h" //*TY 03/25/2000 - added 64bit math type definition
+# else
+# error "there should be some long long type on the system!"
+# define NUMERIC_NO_64 1
+# 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.
+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)
+
+inline 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)
+
+void _Stl_norm_and_round(uint64& p, int& norm, uint64 prodhi, uint64 prodlo)
+{
+ norm = 0;
+ if( ! (prodhi & _Stl_HIBITULL) ) {
+ /* 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)
+
+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_END_NAMESPACE
+# include <fp.h>
+_STLP_BEGIN_NAMESPACE
+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 0 // def __ICL
+// turn off optimization here
+# pragma optimize "off"
+#endif
+
+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;
+
+ 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<double>::infinity();
+ }
+ else { /* value is normal */
+ value &= ~(ULL(1) << 52); /* hide hidden bit */
+ _Stl_set_exponent(value, bexp + 1022); /* add bias */
+ }
+ }
+
+ return *((double *) &value);
+}
+
+#endif
+
+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<char>& ct = use_facet<ctype<char> >(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<double>::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;
+}
+
+
+#ifndef _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.
+ */
+
+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<char>& ct = use_facet<ctype<char> >(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++ = c;
+ }
+ exp -= decimal_point;
+ }
+ }
+ else if (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<long double>::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<double>::infinity()
+ ? numeric_limits<long double>::infinity()
+ : tmp;
+ }
+
+ if (Negate) {
+ x = -x;
+ }
+
+ return x;
+}
+#endif
+
+_STLP_EXP_DECLSPEC int _STLP_CALL
+__string_to_float(const string& v, float& val) {
+#ifdef __SYMBIAN32__
+ char *endpt = NULL;
+ unsigned c;
+ const char *s = v.data();
+ // Skip leading whitespace, if any.
+ const ctype<char>& ct = use_facet<ctype<char> >(locale::classic());
+ while (c = *s, ct.is(ctype_base::space, char(c)))
+ s++;
+ int prv_error = errno;
+ errno = 0;
+ val = strtof(s, &endpt);
+ bool __ok = (errno == 0);
+ int tt = errno;
+ errno= prv_error;
+ return (__ok);
+#else
+ val = _Stl_string_to_double(v.data());
+ return 0;
+#endif
+}
+
+_STLP_EXP_DECLSPEC int _STLP_CALL
+__string_to_float(const string& v, double& val) {
+#ifdef __SYMBIAN32__
+ char *endpt = NULL;
+ unsigned c;
+ const char *s = v.data();
+ // Skip leading whitespace, if any.
+ const ctype<char>& ct = use_facet<ctype<char> >(locale::classic());
+ while (c = *s, ct.is(ctype_base::space, char(c)))
+ s++;
+ int prv_error = errno;
+ errno = 0;
+ val = strtod(s, &endpt);
+ bool __ok = (errno == 0);
+ errno = prv_error;
+ return (__ok);
+#else
+ val = _Stl_string_to_double(v.data());
+ return 0;
+#endif
+}
+
+#ifndef _STLP_NO_LONG_DOUBLE
+_STLP_EXP_DECLSPEC int _STLP_CALL
+__string_to_float(const string& v, long double& val) {
+#ifdef __SYMBIAN32__
+ char *endpt = NULL;
+ unsigned c;
+ const char *s = v.data();
+ // Skip leading whitespace, if any.
+ const ctype<char>& ct = use_facet<ctype<char> >(locale::classic());
+ while (c = *s, ct.is(ctype_base::space, char(c)))
+ s++;
+ int prv_error = errno;
+ errno = 0;
+ val = strtold(s, &endpt);
+ bool __ok = (errno == 0);
+ errno = prv_error;
+ return (__ok);
+#else
+ val = _Stl_string_to_long_double(v.data());
+ return 0;
+#endif
+}
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End: