ndk/sources/cxx-stl/stlport/src/num_get_float.cpp

   1 /*
   2  * Copyright (c) 1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18
  19 #include "stlport_prefix.h"
  20
  21 #include <limits>
  22 #include <locale>
  23 #include <istream>
  24
  25 #if (defined (__GNUC__) && !defined (__sun) && !defined (__hpux)) || \
  26     defined (__DMC__)
  27 #  include <stdint.h>
  28 #endif
  29
  30 #if defined (__linux__) || defined (__MINGW32__) || defined (__CYGWIN__) || \
  31     defined (__BORLANDC__) || defined (__DMC__) || defined (__HP_aCC)
  32
  33 #  if defined (__BORLANDC__)
  34 typedef unsigned int uint32_t;
  35 typedef unsigned __int64 uint64_t;
  36 #  endif
  37
  38 union _ll {
  39   uint64_t i64;
  40   struct {
  41 #  if defined (_STLP_BIG_ENDIAN)
  42     uint32_t hi;
  43     uint32_t lo;
  44 #  elif defined (_STLP_LITTLE_ENDIAN)
  45     uint32_t lo;
  46     uint32_t hi;
  47 #  else
  48 #    error Unknown endianess
  49 #  endif
  50   } i32;
  51 };
  52
  53 #  if defined (__linux__) && !defined (ANDROID)
  54 #    include <ieee754.h>
  55 #  else
  56 union ieee854_long_double {
  57   long double d;
  58
  59   /* This is the IEEE 854 double-extended-precision format.  */
  60   struct {
  61     unsigned int mantissa1:32;
  62     unsigned int mantissa0:32;
  63     unsigned int exponent:15;
  64     unsigned int negative:1;
  65     unsigned int empty:16;
  66   } ieee;
  67 };
  68
  69 #    define IEEE854_LONG_DOUBLE_BIAS 0x3fff
  70 #  endif
  71 #endif
  72
  73 _STLP_BEGIN_NAMESPACE
  74 _STLP_MOVE_TO_PRIV_NAMESPACE
  75
  76 //----------------------------------------------------------------------
  77 // num_get
  78
  79 // Helper functions for _M_do_get_float.
  80
  81 #if !defined (_STLP_NO_WCHAR_T)
  82 void  _STLP_CALL
  83 _Initialize_get_float( const ctype<wchar_t>& ct,
  84                        wchar_t& Plus, wchar_t& Minus,
  85                        wchar_t& pow_e, wchar_t& pow_E,
  86                        wchar_t* digits) {
  87   char ndigits[11] = "0123456789";
  88   Plus  = ct.widen('+');
  89   Minus = ct.widen('-');
  90   pow_e = ct.widen('e');
  91   pow_E = ct.widen('E');
  92   ct.widen(ndigits + 0, ndigits + 10, digits);
  93 }
  94 #endif /* WCHAR_T */
  95
  96 /*
  97  * __string_to_double is just lifted from atof, the difference being
  98  * that we just use '.' for the decimal point, rather than let it
  99  * be taken from the current C locale, which of course is not accessible
 100  * to us.
 101  */
 102 #if defined (_STLP_MSVC) || defined (__BORLANDC__) || defined (__ICL)
 103 typedef unsigned long uint32;
 104 typedef unsigned __int64 uint64;
 105 #  define ULL(x) x##Ui64
 106 #elif defined (__unix) || defined (__MINGW32__) || \
 107       (defined (__DMC__) && (__LONGLONG)) || defined (__WATCOMC__) || \
 108       defined (ANDROID)
 109 typedef uint32_t uint32;
 110 typedef uint64_t uint64;
 111 #  define ULL(x) x##ULL
 112 #else
 113 #  error There should be some unsigned 64-bit integer on the system!
 114 #endif
 115
 116 // Multiplication of two 64-bit integers, giving a 128-bit result.
 117 // Taken from Algorithm M in Knuth section 4.3.1, with the loop
 118 // hand-unrolled.
 119 static void _Stl_mult64(const uint64 u, const uint64 v,
 120                         uint64& high, uint64& low) {
 121   const uint64 low_mask = ULL(0xffffffff);
 122   const uint64 u0 = u & low_mask;
 123   const uint64 u1 = u >> 32;
 124   const uint64 v0 = v & low_mask;
 125   const uint64 v1 = v >> 32;
 126
 127   uint64 t = u0 * v0;
 128   low = t & low_mask;
 129
 130   t = u1 * v0 + (t >> 32);
 131   uint64 w1 = t & low_mask;
 132   uint64 w2 = t >> 32;
 133
 134   uint64 x = u0 * v1 + w1;
 135   low += (x & low_mask) << 32;
 136   high = u1 * v1 + w2 + (x >> 32);
 137 }
 138
 139 #if !defined (__linux__) || defined (ANDROID)
 140
 141 #  define bit11 ULL(0x7ff)
 142 #  define exponent_mask (bit11 << 52)
 143
 144 #  if !defined (__GNUC__) || (__GNUC__ != 3) || (__GNUC_MINOR__ != 4) || \
 145       (!defined (__CYGWIN__) && !defined (__MINGW32__))
 146 //Generate bad code when compiled with -O2 option.
 147 inline
 148 #  endif
 149 void _Stl_set_exponent(uint64 &val, uint64 exp)
 150 { val = (val & ~exponent_mask) | ((exp & bit11) << 52); }
 151
 152 #endif // __linux__
 153
 154 /* Power of ten fractions for tenscale*/
 155 /* The constants are factored so that at most two constants
 156  * and two multiplies are needed. Furthermore, one of the constants
 157  * is represented exactly - 10**n where 1<= n <= 27.
 158  */
 159
 160 static const uint64 _Stl_tenpow[80] = {
 161 ULL(0xa000000000000000), /* _Stl_tenpow[0]=(10**1)/(2**4) */
 162 ULL(0xc800000000000000), /* _Stl_tenpow[1]=(10**2)/(2**7) */
 163 ULL(0xfa00000000000000), /* _Stl_tenpow[2]=(10**3)/(2**10) */
 164 ULL(0x9c40000000000000), /* _Stl_tenpow[3]=(10**4)/(2**14) */
 165 ULL(0xc350000000000000), /* _Stl_tenpow[4]=(10**5)/(2**17) */
 166 ULL(0xf424000000000000), /* _Stl_tenpow[5]=(10**6)/(2**20) */
 167 ULL(0x9896800000000000), /* _Stl_tenpow[6]=(10**7)/(2**24) */
 168 ULL(0xbebc200000000000), /* _Stl_tenpow[7]=(10**8)/(2**27) */
 169 ULL(0xee6b280000000000), /* _Stl_tenpow[8]=(10**9)/(2**30) */
 170 ULL(0x9502f90000000000), /* _Stl_tenpow[9]=(10**10)/(2**34) */
 171 ULL(0xba43b74000000000), /* _Stl_tenpow[10]=(10**11)/(2**37) */
 172 ULL(0xe8d4a51000000000), /* _Stl_tenpow[11]=(10**12)/(2**40) */
 173 ULL(0x9184e72a00000000), /* _Stl_tenpow[12]=(10**13)/(2**44) */
 174 ULL(0xb5e620f480000000), /* _Stl_tenpow[13]=(10**14)/(2**47) */
 175 ULL(0xe35fa931a0000000), /* _Stl_tenpow[14]=(10**15)/(2**50) */
 176 ULL(0x8e1bc9bf04000000), /* _Stl_tenpow[15]=(10**16)/(2**54) */
 177 ULL(0xb1a2bc2ec5000000), /* _Stl_tenpow[16]=(10**17)/(2**57) */
 178 ULL(0xde0b6b3a76400000), /* _Stl_tenpow[17]=(10**18)/(2**60) */
 179 ULL(0x8ac7230489e80000), /* _Stl_tenpow[18]=(10**19)/(2**64) */
 180 ULL(0xad78ebc5ac620000), /* _Stl_tenpow[19]=(10**20)/(2**67) */
 181 ULL(0xd8d726b7177a8000), /* _Stl_tenpow[20]=(10**21)/(2**70) */
 182 ULL(0x878678326eac9000), /* _Stl_tenpow[21]=(10**22)/(2**74) */
 183 ULL(0xa968163f0a57b400), /* _Stl_tenpow[22]=(10**23)/(2**77) */
 184 ULL(0xd3c21bcecceda100), /* _Stl_tenpow[23]=(10**24)/(2**80) */
 185 ULL(0x84595161401484a0), /* _Stl_tenpow[24]=(10**25)/(2**84) */
 186 ULL(0xa56fa5b99019a5c8), /* _Stl_tenpow[25]=(10**26)/(2**87) */
 187 ULL(0xcecb8f27f4200f3a), /* _Stl_tenpow[26]=(10**27)/(2**90) */
 188
 189 ULL(0xd0cf4b50cfe20766), /* _Stl_tenpow[27]=(10**55)/(2**183) */
 190 ULL(0xd2d80db02aabd62c), /* _Stl_tenpow[28]=(10**83)/(2**276) */
 191 ULL(0xd4e5e2cdc1d1ea96), /* _Stl_tenpow[29]=(10**111)/(2**369) */
 192 ULL(0xd6f8d7509292d603), /* _Stl_tenpow[30]=(10**139)/(2**462) */
 193 ULL(0xd910f7ff28069da4), /* _Stl_tenpow[31]=(10**167)/(2**555) */
 194 ULL(0xdb2e51bfe9d0696a), /* _Stl_tenpow[32]=(10**195)/(2**648) */
 195 ULL(0xdd50f1996b947519), /* _Stl_tenpow[33]=(10**223)/(2**741) */
 196 ULL(0xdf78e4b2bd342cf7), /* _Stl_tenpow[34]=(10**251)/(2**834) */
 197 ULL(0xe1a63853bbd26451), /* _Stl_tenpow[35]=(10**279)/(2**927) */
 198 ULL(0xe3d8f9e563a198e5), /* _Stl_tenpow[36]=(10**307)/(2**1020) */
 199
 200 // /* _Stl_tenpow[36]=(10**335)/(2**) */
 201 // /* _Stl_tenpow[36]=(10**335)/(2**) */
 202
 203 ULL(0xfd87b5f28300ca0e), /* _Stl_tenpow[37]=(10**-28)/(2**-93) */
 204 ULL(0xfb158592be068d2f), /* _Stl_tenpow[38]=(10**-56)/(2**-186) */
 205 ULL(0xf8a95fcf88747d94), /* _Stl_tenpow[39]=(10**-84)/(2**-279) */
 206 ULL(0xf64335bcf065d37d), /* _Stl_tenpow[40]=(10**-112)/(2**-372) */
 207 ULL(0xf3e2f893dec3f126), /* _Stl_tenpow[41]=(10**-140)/(2**-465) */
 208 ULL(0xf18899b1bc3f8ca2), /* _Stl_tenpow[42]=(10**-168)/(2**-558) */
 209 ULL(0xef340a98172aace5), /* _Stl_tenpow[43]=(10**-196)/(2**-651) */
 210 ULL(0xece53cec4a314ebe), /* _Stl_tenpow[44]=(10**-224)/(2**-744) */
 211 ULL(0xea9c227723ee8bcb), /* _Stl_tenpow[45]=(10**-252)/(2**-837)     */
 212 ULL(0xe858ad248f5c22ca), /* _Stl_tenpow[46]=(10**-280)/(2**-930) */
 213 ULL(0xe61acf033d1a45df), /* _Stl_tenpow[47]=(10**-308)/(2**-1023)    */
 214 ULL(0xe3e27a444d8d98b8), /* _Stl_tenpow[48]=(10**-336)/(2**-1116) */
 215 ULL(0xe1afa13afbd14d6e)  /* _Stl_tenpow[49]=(10**-364)/(2**-1209) */
 216 };
 217
 218 static const short _Stl_twoexp[80] = {
 219 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,
 220 183,276,369,462,555,648,741,834,927,1020,
 221 -93,-186,-279,-372,-465,-558,-651,-744,-837,-930,-1023,-1116,-1209
 222 };
 223
 224 #define  TEN_1  0           /* offset to 10 **   1 */
 225 #define  TEN_27   26        /* offset to 10 **  27 */
 226 #define  TEN_M28  37        /* offset to 10 ** -28 */
 227 #define  NUM_HI_P 11
 228 #define  NUM_HI_N 13
 229
 230 #define _Stl_HIBITULL (ULL(1) << 63)
 231
 232 static void _Stl_norm_and_round(uint64& p, int& norm, uint64 prodhi, uint64 prodlo) {
 233   norm = 0;
 234   if ((prodhi & _Stl_HIBITULL) == 0) {
 235                                 /* leading bit is a zero
 236                                  * may have to normalize
 237                                  */
 238     if ((prodhi == ~_Stl_HIBITULL) &&
 239         ((prodlo >> 62) == 0x3)) {  /* normalization followed by round
 240                                      * would cause carry to create
 241                                      * extra bit, so don't normalize
 242                                      */
 243       p = _Stl_HIBITULL;
 244       return;
 245     }
 246     p = (prodhi << 1) | (prodlo >> 63); /* normalize */
 247     norm = 1;
 248     prodlo <<= 1;
 249   }
 250   else {
 251     p = prodhi;
 252   }
 253
 254   if ((prodlo & _Stl_HIBITULL) != 0) {     /* first guard bit a one */
 255     if (((p & 0x1) != 0) ||
 256         prodlo != _Stl_HIBITULL ) {    /* not borderline for round to even */
 257       /* round */
 258       ++p;
 259       if (p == 0)
 260         ++p;
 261     }
 262   }
 263 }
 264
 265 // Convert a 64-bitb fraction * 10^exp to a 64-bit fraction * 2^bexp.
 266 // p:    64-bit fraction
 267 // exp:  base-10 exponent
 268 // bexp: base-2 exponent (output parameter)
 269 static void _Stl_tenscale(uint64& p, int exp, int& bexp) {
 270   bexp = 0;
 271
 272   if ( exp == 0 ) {              /* no scaling needed */
 273     return;
 274   }
 275
 276   int exp_hi = 0, exp_lo = exp; /* exp = exp_hi*32 + exp_lo */
 277   int tlo = TEN_1, thi;         /* offsets in power of ten table */
 278   int num_hi;                   /* number of high exponent powers */
 279
 280   if (exp > 0) {                /* split exponent */
 281     if (exp_lo > 27) {
 282       exp_lo++;
 283       while (exp_lo > 27) {
 284         exp_hi++;
 285         exp_lo -= 28;
 286       }
 287     }
 288     thi = TEN_27;
 289     num_hi = NUM_HI_P;
 290   } else { // exp < 0
 291     while (exp_lo < 0) {
 292       exp_hi++;
 293       exp_lo += 28;
 294     }
 295     thi = TEN_M28;
 296     num_hi = NUM_HI_N;
 297   }
 298
 299   uint64 prodhi, prodlo;        /* 128b product */
 300   int norm;                     /* number of bits of normalization */
 301
 302   int hi, lo;                   /* offsets in power of ten table */
 303   while (exp_hi) {              /* scale */
 304     hi = (min) (exp_hi, num_hi);    /* only a few large powers of 10 */
 305     exp_hi -= hi;               /* could iterate in extreme case */
 306     hi += thi-1;
 307     _Stl_mult64(p, _Stl_tenpow[hi], prodhi, prodlo);
 308     _Stl_norm_and_round(p, norm, prodhi, prodlo);
 309     bexp += _Stl_twoexp[hi] - norm;
 310   }
 311
 312   if (exp_lo) {
 313     lo = tlo + exp_lo -1;
 314     _Stl_mult64(p, _Stl_tenpow[lo], prodhi, prodlo);
 315     _Stl_norm_and_round(p, norm, prodhi, prodlo);
 316     bexp += _Stl_twoexp[lo] - norm;
 317   }
 318
 319   return;
 320 }
 321
 322 // First argument is a buffer of values from 0 to 9, NOT ascii.
 323 // Second argument is number of digits in buffer, 1 <= digits <= 17.
 324 // Third argument is base-10 exponent.
 325
 326 /* IEEE representation */
 327 #if !defined (__linux__) || defined (ANDROID)
 328
 329 union _Double_rep {
 330   uint64 ival;
 331   double val;
 332 };
 333
 334 static double _Stl_atod(char *buffer, ptrdiff_t ndigit, int dexp) {
 335   typedef numeric_limits<double> limits;
 336   _Double_rep drep;
 337   uint64 &value = drep.ival;  /* Value develops as follows:
 338                                  * 1) decimal digits as an integer
 339                                  * 2) left adjusted fraction
 340                                  * 3) right adjusted fraction
 341                                  * 4) exponent and fraction
 342                                  */
 343
 344   uint32 guard;         /* First guard bit */
 345   uint64 rest;          /* Remaining guard bits */
 346
 347   int bexp;             /* binary exponent */
 348   int nzero;            /* number of non-zero bits */
 349   int sexp;             /* scaling exponent */
 350
 351   char *bufferend;              /* pointer to char after last digit */
 352
 353   /* Convert the decimal digits to a binary integer. */
 354   bufferend = buffer + ndigit;
 355   value = 0;
 356
 357   while (buffer < bufferend) {
 358     value *= 10;
 359     value += *buffer++;
 360   }
 361
 362   /* Check for zero and treat it as a special case */
 363   if (value == 0) {
 364     return 0.0;
 365   }
 366
 367   /* Normalize value */
 368   bexp = 64;                    /* convert from 64b int to fraction */
 369
 370   /* Count number of non-zeroes in value */
 371   nzero = 0;
 372   if ((value >> 32) != 0) { nzero  = 32; }    //*TY 03/25/2000 - added explicit comparison to zero to avoid uint64 to bool conversion operator
 373   if ((value >> (16 + nzero)) != 0) { nzero += 16; }
 374   if ((value >> ( 8 + nzero)) != 0) { nzero +=  8; }
 375   if ((value >> ( 4 + nzero)) != 0) { nzero +=  4; }
 376   if ((value >> ( 2 + nzero)) != 0) { nzero +=  2; }
 377   if ((value >> ( 1 + nzero)) != 0) { nzero +=  1; }
 378   if ((value >> (     nzero)) != 0) { nzero +=  1; }
 379
 380   /* Normalize */
 381   value <<= /*(uint64)*/ (64 - nzero);    //*TY 03/25/2000 - removed extraneous cast to uint64
 382   bexp -= 64 - nzero;
 383
 384   /* At this point we have a 64b fraction and a binary exponent
 385    * but have yet to incorporate the decimal exponent.
 386    */
 387
 388   /* multiply by 10^dexp */
 389   _Stl_tenscale(value, dexp, sexp);
 390   bexp += sexp;
 391
 392   if (bexp <= -1022) {          /* HI denorm or underflow */
 393     bexp += 1022;
 394     if (bexp < -53) {          /* guaranteed underflow */
 395       value = 0;
 396     }
 397     else {                      /* denorm or possible underflow */
 398       int lead0 = 12 - bexp;          /* 12 sign and exponent bits */
 399
 400       /* we must special case right shifts of more than 63 */
 401       if (lead0 > 64) {
 402         rest = value;
 403         guard = 0;
 404         value = 0;
 405       }
 406       else if (lead0 == 64) {
 407         rest = value & ((ULL(1)<< 63)-1);
 408         guard = (uint32) ((value>> 63) & 1 );
 409         value = 0;
 410       }
 411       else {
 412         rest = value & (((ULL(1) << lead0)-1)-1);
 413         guard = (uint32) (((value>> lead0)-1) & 1);
 414         value >>= /*(uint64)*/ lead0; /* exponent is zero */
 415       }
 416
 417       /* Round */
 418       if (guard && ((value & 1) || rest) ) {
 419         ++value;
 420         if (value == (ULL(1) << (limits::digits - 1))) { /* carry created normal number */
 421           value = 0;
 422           _Stl_set_exponent(value, 1);
 423         }
 424       }
 425     }
 426   }
 427   else {                        /* not zero or denorm */
 428     /* Round to 53 bits */
 429     rest = value & ((1 << 10) - 1);
 430     value >>= 10;
 431     guard = (uint32) value & 1;
 432     value >>= 1;
 433
 434     /*  value&1 guard   rest    Action
 435      *
 436      *  dc      0       dc      none
 437      *  1       1       dc      round
 438      *  0       1       0       none
 439      *  0       1       !=0     round
 440      */
 441     if (guard) {
 442       if (((value&1)!=0) || (rest!=0)) {
 443         ++value;                        /* round */
 444         if ((value >> 53) != 0) {       /* carry all the way across */
 445           value >>= 1;          /* renormalize */
 446           ++bexp;
 447         }
 448       }
 449     }
 450     /*
 451      * Check for overflow
 452      * IEEE Double Precision Format
 453      * (From Table 7-8 of Kane and Heinrich)
 454      *
 455      * Fraction bits               52
 456      * Emax                     +1023
 457      * Emin                     -1022
 458      * Exponent bias            +1023
 459      * Exponent bits               11
 460      * Integer bit             hidden
 461      * Total width in bits         64
 462      */
 463
 464     if (bexp > limits::max_exponent) {          /* overflow */
 465       return limits::infinity();
 466     }
 467     else {                      /* value is normal */
 468       value &= ~(ULL(1) << (limits::digits - 1));   /* hide hidden bit */
 469       _Stl_set_exponent(value, bexp + 1022); /* add bias */
 470     }
 471   }
 472
 473   _STLP_STATIC_ASSERT(sizeof(uint64) >= sizeof(double))
 474   return drep.val;
 475 }
 476
 477 #endif
 478
 479 #if defined (__linux__) || defined (__MINGW32__) || defined (__CYGWIN__) || \
 480     defined (__BORLANDC__) || defined (__DMC__) || defined (__HP_aCC)
 481
 482 template <class D, class IEEE, int M, int BIAS>
 483 D _Stl_atodT(char *buffer, ptrdiff_t ndigit, int dexp)
 484 {
 485   typedef numeric_limits<D> limits;
 486
 487   /* Convert the decimal digits to a binary integer. */
 488   char *bufferend = buffer + ndigit; /* pointer to char after last digit */
 489   _ll vv;
 490   vv.i64 = 0L;
 491
 492   while ( buffer < bufferend ) {
 493     vv.i64 *= 10;
 494     vv.i64 += *buffer++;
 495   }
 496
 497   if ( vv.i64 == ULL(0) ) { /* Check for zero and treat it as a special case */
 498     return D(0.0);
 499   }
 500
 501   /* Normalize value */
 502
 503   int bexp = 64; /* convert from 64b int to fraction */
 504
 505   /* Count number of non-zeroes in value */
 506   int nzero = 0;
 507   if ((vv.i64 >> 32) != 0) { nzero = 32; }
 508   if ((vv.i64 >> (16 + nzero)) != 0) { nzero += 16; }
 509   if ((vv.i64 >> ( 8 + nzero)) != 0) { nzero +=  8; }
 510   if ((vv.i64 >> ( 4 + nzero)) != 0) { nzero +=  4; }
 511   if ((vv.i64 >> ( 2 + nzero)) != 0) { nzero +=  2; }
 512   if ((vv.i64 >> ( 1 + nzero)) != 0) { nzero +=  1; }
 513   if ((vv.i64 >> (     nzero)) != 0) { nzero +=  1; }
 514
 515   /* Normalize */
 516   nzero = 64 - nzero;
 517   vv.i64 <<= nzero;    // * TY 03/25/2000 - removed extraneous cast to uint64
 518   bexp -= nzero;
 519
 520   /* At this point we have a 64b fraction and a binary exponent
 521    * but have yet to incorporate the decimal exponent.
 522    */
 523
 524   /* multiply by 10^dexp */
 525   int sexp;
 526   _Stl_tenscale(vv.i64, dexp, sexp);
 527   bexp += sexp;
 528
 529   if ( bexp >= limits::min_exponent ) { /* not zero or denorm */
 530     if ( limits::digits < 64 ) {
 531       /* Round to (64 - M + 1) bits */
 532       uint64_t rest = vv.i64 & ((~ULL(0) / ULL(2)) >> (limits::digits - 1));
 533       vv.i64 >>= M - 2;
 534       uint32_t guard = (uint32) vv.i64 & 1;
 535       vv.i64 >>= 1;
 536
 537       /*  value&1 guard   rest    Action
 538        *
 539        *  dc      0       dc      none
 540        *  1       1       dc      round
 541        *  0       1       0       none
 542        *  0       1       !=0     round
 543        */
 544
 545       if (guard) {
 546         if ( ((vv.i64 & 1) != 0) || (rest != 0) ) {
 547           vv.i64++;       /* round */
 548           if ( (vv.i64 >> (limits::digits < 64 ? limits::digits : 0)) != 0 ) { /* carry all the way across */
 549             vv.i64 >>= 1; /* renormalize */
 550             ++bexp;
 551           }
 552         }
 553       }
 554
 555       vv.i64 &= ~(ULL(1) << (limits::digits - 1)); /* hide hidden bit */
 556     }
 557     /*
 558      * Check for overflow
 559      * IEEE Double Precision Format
 560      * (From Table 7-8 of Kane and Heinrich)
 561      *
 562      * Fraction bits               52
 563      * Emax                     +1023
 564      * Emin                     -1022
 565      * Exponent bias            +1023
 566      * Exponent bits               11
 567      * Integer bit             hidden
 568      * Total width in bits         64
 569      */
 570
 571     if (bexp > limits::max_exponent) { /* overflow */
 572       return limits::infinity();
 573     }
 574
 575     /* value is normal */
 576
 577     IEEE v;
 578
 579     v.ieee.mantissa0 = vv.i32.hi;
 580     v.ieee.mantissa1 = vv.i32.lo;
 581     v.ieee.negative = 0;
 582     v.ieee.exponent = bexp + BIAS - 1;
 583
 584     return v.d;
 585   }
 586
 587   /* HI denorm or underflow */
 588   bexp += BIAS - 1;
 589   if (bexp < -limits::digits) { /* guaranteed underflow */
 590     vv.i64 = 0;
 591   } else {  /* denorm or possible underflow */
 592
 593     /*
 594      * Problem point for long double: looks like this code reflect shareing of mantissa
 595      * and exponent in 64b int; not so for long double
 596      */
 597
 598     int lead0 = M - bexp; /* M = 12 sign and exponent bits */
 599     uint64_t rest;
 600     uint32_t guard;
 601
 602     /* we must special case right shifts of more than 63 */
 603
 604     if (lead0 > 64) {
 605       rest = vv.i64;
 606       guard = 0;
 607       vv.i64 = 0;
 608     } else if (lead0 == 64) {
 609       rest = vv.i64 & ((ULL(1) << 63)-1);
 610       guard = (uint32) ((vv.i64 >> 63) & 1 );
 611       vv.i64 = 0;
 612     } else {
 613       rest = vv.i64 & (((ULL(1) << lead0)-1)-1);
 614       guard = (uint32) (((vv.i64 >> lead0)-1) & 1);
 615       vv.i64 >>= /*(uint64)*/ lead0; /* exponent is zero */
 616     }
 617
 618     /* Round */
 619     if (guard && ( (vv.i64 & 1) || rest)) {
 620       vv.i64++;
 621       if (vv.i64 == (ULL(1) << (limits::digits - 1))) { /* carry created normal number */
 622         IEEE v;
 623
 624         v.ieee.mantissa0 = 0;
 625         v.ieee.mantissa1 = 0;
 626         v.ieee.negative = 0;
 627         v.ieee.exponent = 1;
 628         return v.d;
 629       }
 630     }
 631   }
 632
 633   IEEE v;
 634
 635   v.ieee.mantissa0 = vv.i32.hi;
 636   v.ieee.mantissa1 = vv.i32.lo;
 637   v.ieee.negative = 0;
 638   v.ieee.exponent = 0;
 639
 640   return v.d;
 641 }
 642 #endif // __linux__
 643
 644 #if !defined (__linux__) || defined (ANDROID)
 645 static double _Stl_string_to_double(const char *s) {
 646   typedef numeric_limits<double> limits;
 647   const int max_digits = limits::digits10 + 2;
 648   unsigned c;
 649   unsigned Negate, decimal_point;
 650   char *d;
 651   int exp;
 652   int dpchar;
 653   char digits[max_digits];
 654
 655   c = *s++;
 656
 657   /* process sign */
 658   Negate = 0;
 659   if (c == '+') {
 660     c = *s++;
 661   } else if (c == '-') {
 662     Negate = 1;
 663     c = *s++;
 664   }
 665
 666   d = digits;
 667   dpchar = '.' - '0';
 668   decimal_point = 0;
 669   exp = 0;
 670
 671   for (;;) {
 672     c -= '0';
 673     if (c < 10) {
 674       if (d == digits + max_digits) {
 675         /* ignore more than max_digits digits, but adjust exponent */
 676         exp += (decimal_point ^ 1);
 677       } else {
 678         if (c == 0 && d == digits) {
 679           /* ignore leading zeros */
 680         } else {
 681           *d++ = (char) c;
 682         }
 683         exp -= decimal_point;
 684       }
 685     } else if (c == (unsigned int) dpchar && !decimal_point) { /* INTERNATIONAL */
 686       decimal_point = 1;
 687     } else {
 688       break;
 689     }
 690     c = *s++;
 691   }
 692
 693   /* strtod cant return until it finds the end of the exponent */
 694   if (d == digits) {
 695     return 0.0;
 696   }
 697
 698   if (c == 'e' - '0' || c == 'E' - '0') {
 699     register unsigned negate_exp = 0;
 700     register int e = 0;
 701     c = *s++;
 702     if (c == '+' || c == ' ') {
 703       c = *s++;
 704     } else if (c == '-') {
 705       negate_exp = 1;
 706       c = *s++;
 707     }
 708     if (c -= '0', c < 10) {
 709       do {
 710         e = e * 10 + (int)c;
 711         c = *s++;
 712       } while (c -= '0', c < 10);
 713
 714       if (negate_exp) {
 715         e = -e;
 716       }
 717       exp += e;
 718     }
 719   }
 720
 721   double x;
 722   ptrdiff_t n = d - digits;
 723   if ((exp + n - 1) < limits::min_exponent10) {
 724     x = 0;
 725   }
 726   else if ((exp + n - 1) > limits::max_exponent10) {
 727     x = limits::infinity();
 728   }
 729   else {
 730     /* Let _Stl_atod diagnose under- and over-flows.
 731      * If the input was == 0.0, we have already returned,
 732      * so retval of +-Inf signals OVERFLOW, 0.0 UNDERFLOW */
 733     x = _Stl_atod(digits, n, exp);
 734   }
 735
 736   if (Negate) {
 737     x = -x;
 738   }
 739
 740   return x;
 741 }
 742
 743 #endif
 744
 745 #if defined (__linux__) || defined (__MINGW32__) || defined (__CYGWIN__) || \
 746     defined (__BORLANDC__) || defined (__DMC__) || defined (__HP_aCC)
 747
 748 template <class D, class IEEE, int M, int BIAS>
 749 D _Stl_string_to_doubleT(const char *s)
 750 {
 751   typedef numeric_limits<D> limits;
 752   const int max_digits = limits::digits10; /* + 2 17 */;
 753   unsigned c;
 754   unsigned decimal_point;
 755   char *d;
 756   int exp;
 757   D x;
 758   int dpchar;
 759   char digits[max_digits];
 760
 761   c = *s++;
 762
 763   /* process sign */
 764   bool Negate = false;
 765   if (c == '+') {
 766     c = *s++;
 767   } else if (c == '-') {
 768     Negate = true;
 769     c = *s++;
 770   }
 771
 772   d = digits;
 773   dpchar = '.' - '0';
 774   decimal_point = 0;
 775   exp = 0;
 776
 777   for (;;) {
 778     c -= '0';
 779     if (c < 10) {
 780       if (d == digits + max_digits) {
 781         /* ignore more than max_digits digits, but adjust exponent */
 782         exp += (decimal_point ^ 1);
 783       } else {
 784         if (c == 0 && d == digits) {
 785           /* ignore leading zeros */
 786         } else {
 787           *d++ = (char) c;
 788         }
 789         exp -= decimal_point;
 790       }
 791     } else if (c == (unsigned int) dpchar && !decimal_point) {    /* INTERNATIONAL */
 792       decimal_point = 1;
 793     } else {
 794       break;
 795     }
 796     c = *s++;
 797   }
 798   /* strtod cant return until it finds the end of the exponent */
 799   if (d == digits) {
 800     return D(0.0);
 801   }
 802
 803   if (c == 'e'-'0' || c == 'E'-'0') {
 804     bool negate_exp = false;
 805     register int e = 0;
 806     c = *s++;
 807     if (c == '+' || c == ' ') {
 808       c = *s++;
 809     } else if (c == '-') {
 810       negate_exp = true;
 811       c = *s++;
 812     }
 813     if (c -= '0', c < 10) {
 814       do {
 815         e = e * 10 + (int)c;
 816         c = *s++;
 817       } while (c -= '0', c < 10);
 818
 819       if (negate_exp) {
 820         e = -e;
 821       }
 822       exp += e;
 823     }
 824   }
 825
 826   ptrdiff_t n = d - digits;
 827   if ((exp + n - 1) < limits::min_exponent10) {
 828     return D(0.0); // +0.0 is the same as -0.0
 829   } else if ((exp + n - 1) > limits::max_exponent10 ) {
 830     // not good, because of x = -x below; this may lead to portability problems
 831     x = limits::infinity();
 832   } else {
 833     /* let _Stl_atod diagnose under- and over-flows */
 834     /* if the input was == 0.0, we have already returned,
 835        so retval of +-Inf signals OVERFLOW, 0.0 UNDERFLOW
 836     */
 837     x = _Stl_atodT<D,IEEE,M,BIAS>(digits, n, exp);
 838   }
 839
 840   return Negate ? -x : x;
 841 }
 842
 843 #endif // __linux__
 844
 845 void _STLP_CALL
 846 __string_to_float(const __iostring& v, float& val)
 847 {
 848 #if !defined (__linux__) || defined (ANDROID)
 849   val = (float)_Stl_string_to_double(v.c_str());
 850 #else
 851   val = (float)_Stl_string_to_doubleT<double,ieee754_double,12,IEEE754_DOUBLE_BIAS>(v.c_str());
 852 #endif
 853 }
 854
 855 void _STLP_CALL
 856 __string_to_float(const __iostring& v, double& val)
 857 {
 858 #if !defined (__linux__) || defined (ANDROID)
 859   val = _Stl_string_to_double(v.c_str());
 860 #else
 861   val = _Stl_string_to_doubleT<double,ieee754_double,12,IEEE754_DOUBLE_BIAS>(v.c_str());
 862 #endif
 863 }
 864
 865 #if !defined (_STLP_NO_LONG_DOUBLE)
 866 void _STLP_CALL
 867 __string_to_float(const __iostring& v, long double& val) {
 868 #if !defined (__linux__) && !defined (__MINGW32__) && !defined (__CYGWIN__) && \
 869     !defined (__BORLANDC__) && !defined (__DMC__) && !defined (__HP_aCC)
 870   //The following function is valid only if long double is an alias for double.
 871   _STLP_STATIC_ASSERT( sizeof(long double) <= sizeof(double) )
 872   val = _Stl_string_to_double(v.c_str());
 873 #else
 874   val = _Stl_string_to_doubleT<long double,ieee854_long_double,16,IEEE854_LONG_DOUBLE_BIAS>(v.c_str());
 875 #endif
 876 }
 877 #endif
 878
 879 _STLP_MOVE_TO_STD_NAMESPACE
 880 _STLP_END_NAMESPACE
 881
 882 // Local Variables:
 883 // mode:C++
 884 // End: