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