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: 885
