1569 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1570 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1571 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1572 16,17,18,19,20,21,22,23,24,25,0,0,0,0,0,0,
1573 0,26,27,28,29,30,31,0,0,0,0,0,0,0,0,0,
1574 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1575 0,26,27,28,29,30,31,0,0,0,0,0,0,0,0,0,
1576 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1577 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1578 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1579 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1580 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1581 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1582 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1583 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1584 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
2539 (s00, se)
CONST char *s00;
char **se;
2541 (
const char *s00,
char **se)
2544 int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1;
2545 int esign, i, j,
k, nd, nd0, nf, nz, nz0, nz1,
sign;
2546 CONST char *s, *s0, *s1;
2549 U aadj2, adj, rv, rv0;
2552 Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
2553#ifdef Avoid_Underflow
2559#ifndef NO_STRTOD_BIGCOMP
2560 int req_bigcomp = 0;
2562#ifdef Honor_FLT_ROUNDS
2563#ifdef Trust_FLT_ROUNDS
2567 switch(fegetround()) {
2568 case FE_TOWARDZERO: bc.
rounding = 0;
break;
2569 case FE_UPWARD: bc.
rounding = 2;
break;
2580 for(s = s00;;s++)
switch(*s) {
2606#ifdef Honor_FLT_ROUNDS
2615 while(*++s ==
'0') ;
2621 for(nd = nf = 0; (c = *s) >=
'0' && c <=
'9'; nd++, s++)
2627 bc.
dp0 = bc.
dp1 = s - s0;
2628 for(s1 = s; s1 > s0 && *--s1 ==
'0'; )
2631 s1 = localeconv()->decimal_point;
2654 for(; c ==
'0'; c = *++s)
2656 if (c >
'0' && c <=
'9') {
2666 for(; c >=
'0' && c <=
'9'; c = *++s) {
2671 for(i = 1; i < nz; i++)
2674 else if (nd <= DBL_DIG + 1)
2678 else if (nd <= DBL_DIG + 1)
2686 if (c ==
'e' || c ==
'E') {
2687 if (!nd && !nz && !nz0) {
2698 if (c >=
'0' && c <=
'9') {
2701 if (c >
'0' && c <=
'9') {
2704 while((c = *++s) >=
'0' && c <=
'9')
2706 if (s - s1 > 8 || L > 19999)
2730 if (
match(&s,
"nf")) {
2732 if (!
match(&s,
"inity"))
2734 word0(&rv) = 0x7ff00000;
2741 if (
match(&s,
"an")) {
2758 bc.
e0 = e1 = e -= nf;
2767 k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
2772 oldinexact = get_inexact();
2779#ifndef Honor_FLT_ROUNDS
2786#ifndef ROUND_BIASED_without_Round_Up
2790 goto vax_ovfl_check;
2792#ifdef Honor_FLT_ROUNDS
2808#ifdef Honor_FLT_ROUNDS
2834#ifndef Inaccurate_Divide
2836#ifdef Honor_FLT_ROUNDS
2855 oldinexact = get_inexact();
2857#ifdef Avoid_Underflow
2860#ifdef Honor_FLT_ROUNDS
2877 if (e1 > DBL_MAX_10_EXP) {
2881#ifdef Honor_FLT_ROUNDS
2919 for(j = 0; e1 > 1; j++, e1 >>= 1)
2945#ifdef Avoid_Underflow
2948 for(j = 0; e1 > 0; j++, e1 >>= 1)
2961 word0(&rv) &= 0xffffffff << (j-32);
2964 word1(&rv) &= 0xffffffff << j;
2967 for(j = 0; e1 > 1; j++, e1 >>= 1)
2982#ifndef Avoid_Underflow
2998#ifndef NO_STRTOD_BIGCOMP
3010 if (--j < bc.dp1 && j >= bc.
dp0)
3022 for(i = 0; i < nd0; ++i)
3023 y = 10*y + s0[i] -
'0';
3024 for(j = bc.
dp1; i < nd; ++i)
3025 y = 10*y + s0[j++] -
'0';
3029 bd0 =
s2b(s0, nd0, nd, y, bc.
dplen);
3034 bb =
d2b(&rv, &bbe, &bbbits);
3050#ifdef Honor_FLT_ROUNDS
3054#ifdef Avoid_Underflow
3066 Lsb1 = Lsb << (i-32);
3071#ifdef Sudden_Underflow
3073 j = 1 + 4*
P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
3088#ifdef Avoid_Underflow
3091 i = bb2 < bd2 ? bb2 : bd2;
3113 delta =
diff(bb, bd);
3117#ifndef NO_STRTOD_BIGCOMP
3118 if (bc.
nd > nd && i <= 0) {
3124#ifdef Honor_FLT_ROUNDS
3136#ifdef Honor_FLT_ROUNDS
3140 if (!delta->
x[0] && delta->
wds <= 1) {
3153 else if (!bc.
dsign) {
3158#ifdef Avoid_Underflow
3165 if (
cmp(delta, bs) <= 0)
3170#ifdef Avoid_Underflow
3175#ifdef Sudden_Underflow
3189 adj.
d =
ratio(delta, bs);
3192 if (adj.
d <= 0x7ffffffe) {
3201#ifdef Avoid_Underflow
3205#ifdef Sudden_Underflow
3244 if (!delta->
x[0] && delta->
wds <= 1)
3249 if (!delta->
x[0] && delta->
wds <= 1) {
3257 if (
cmp(delta, bs) > 0)
3268 ? (0xffffffff & (0xffffffff << (2*
P+1-(y>>
Exp_shift)))) :
3281#ifdef Avoid_Underflow
3290#ifdef Sudden_Underflow
3295#ifdef Avoid_Underflow
3310#ifdef Avoid_Underflow
3330 word1(&rv) = 0xffffffff;
3334#ifndef NO_STRTOD_BIGCOMP
3342#ifdef Avoid_Underflow
3344 if (!(
word0(&rv) & Lsb1))
3347 else if (!(
word1(&rv) & Lsb))
3355#ifdef Avoid_Underflow
3362#ifdef Avoid_Underflow
3367#ifndef Sudden_Underflow
3377#ifdef Avoid_Underflow
3383 if ((aadj =
ratio(delta, bs)) <= 2.) {
3387#ifndef Sudden_Underflow
3403 if (aadj < 2./FLT_RADIX)
3404 aadj = 1./FLT_RADIX;
3412 aadj1 = bc.
dsign ? aadj : -aadj;
3413#ifdef Check_FLT_ROUNDS
3434 adj.
d = aadj1 *
ulp(&rv);
3448#ifdef Avoid_Underflow
3450 if (aadj <= 0x7fffffff) {
3451 if ((z = aadj) <= 0)
3454 aadj1 = bc.
dsign ? aadj : -aadj;
3456 dval(&aadj2) = aadj1;
3458 aadj1 =
dval(&aadj2);
3459 adj.
d = aadj1 *
ulp(&rv);
3462#ifdef NO_STRTOD_BIGCOMP
3473 adj.
d = aadj1 *
ulp(&rv);
3477#ifdef Sudden_Underflow
3481 adj.
d = aadj1 *
ulp(&rv);
3505 adj.
d = aadj1 *
ulp(&rv);
3517 aadj1 = (double)(
int)(aadj + 0.5);
3521 adj.
d = aadj1 *
ulp(&rv);
3529#ifdef Avoid_Underflow
3538 if (aadj < .4999999 || aadj > .5000001)
3541 else if (aadj < .4999999/FLT_RADIX)
3557#ifndef NO_STRTOD_BIGCOMP
3565 if (y == 0 && rv.
d == 0.)
3577 else if (!oldinexact)
3580#ifdef Avoid_Underflow
3599 dval(&rv0) = 1e-300;
3711 (dd, mode, ndigits, decpt,
sign, rve)
3712 double dd;
int mode, ndigits, *decpt, *
sign;
char **rve;
3714 (
double dd,
int mode,
int ndigits,
int *decpt,
int *
sign,
char **rve)
3751 int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
3752 j, j1,
k, k0, k_check, leftright, m2, m5, s2, s5,
3753 spec_case, try_quick;
3755#ifndef Sudden_Underflow
3759 Bigint *b, *b1, *delta, *mlo, *mhi, *S;
3769 int inexact, oldinexact;
3771#ifdef Honor_FLT_ROUNDS
3773#ifdef Trust_FLT_ROUNDS
3777 switch(fegetround()) {
3778 case FE_TOWARDZERO:
Rounding = 0;
break;
3779 case FE_UPWARD:
Rounding = 2;
break;
3785#ifndef MULTIPLE_THREADS
3796 word0(&u) &= ~Sign_bit;
3801#if defined(IEEE_Arith) + defined(VAX)
3805 if (
word0(&u) == 0x8000)
3826 try_quick = oldinexact = get_inexact();
3829#ifdef Honor_FLT_ROUNDS
3839 b =
d2b(&u, &be, &bbits);
3840#ifdef Sudden_Underflow
3850 dval(&d2) /= 1 << j;
3880#ifndef Sudden_Underflow
3886 i = bbits + be + (
Bias + (
P-1) - 1);
3887 x = i > 32 ?
word0(&u) << (64 - i) |
word1(&u) >> (i - 32)
3888 :
word1(&u) << (32 - i);
3891 i -= (
Bias + (
P-1) - 1) + 1;
3895 ds = (
dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
3897 if (ds < 0. && ds !=
k)
3924 if (mode < 0 || mode > 9)
3928#ifdef Check_FLT_ROUNDS
3954 ilim = ilim1 = i = ndigits;
3960 i = ndigits +
k + 1;
3968#ifdef Honor_FLT_ROUNDS
3973 if (ilim >= 0 && ilim <=
Quick_max && try_quick) {
3992 for(; j; j >>= 1, i++)
3999 else if ((j1 = -
k)) {
4001 for(j = j1 >> 4; j; j >>= 1, i++)
4007 if (k_check &&
dval(&u) < 1. && ilim > 0) {
4033 if (k0 < 0 && j1 >= 307) {
4037 for(i = 0, j = (j1-256) >> 4; j; j >>= 1, i++)
4047 *s++ =
'0' + (int)L;
4062 for(i = 1;; i++,
dval(&u) *= 10.) {
4064 if (!(
dval(&u) -= L))
4066 *s++ =
'0' + (int)L;
4070 else if (
dval(&u) < 0.5 -
dval(&eps)) {
4093 if (ndigits < 0 && ilim <= 0) {
4095 if (ilim < 0 ||
dval(&u) <= 5*ds)
4099 for(i = 1;; i++,
dval(&u) *= 10.) {
4102#ifdef Check_FLT_ROUNDS
4109 *s++ =
'0' + (int)L;
4117#ifdef Honor_FLT_ROUNDS
4121 case 2:
goto bump_up;
4128 if (
dval(&u) > ds || (
dval(&u) == ds && L & 1))
4151#ifndef Sudden_Underflow
4152 denorm ? be + (
Bias + (
P-1) - 1 + 1) :
4155 1 + 4*
P - 3 - bbits + ((bbits + be - 1) & 3);
4163 if (m2 > 0 && s2 > 0) {
4164 i = m2 < s2 ? m2 : s2;
4190 if ((mode < 2 || leftright)
4191#ifdef Honor_FLT_ROUNDS
4196#ifndef Sudden_Underflow
4231 if (ilim <= 0 && (mode == 3 || mode == 5)) {
4232 if (ilim < 0 ||
cmp(b,S =
multadd(S,5,0)) <= 0) {
4264 delta =
diff(S, mhi);
4265 j1 = delta->
sign ? 1 :
cmp(b, delta);
4268 if (j1 == 0 && mode != 1 && !(
word1(&u) & 1)
4269#ifdef Honor_FLT_ROUNDS
4278 else if (!b->
x[0] && b->
wds <= 1)
4285 if (j < 0 || (j == 0 && mode != 1
4290 if (!b->
x[0] && b->
wds <= 1) {
4296#ifdef Honor_FLT_ROUNDS
4299 case 0:
goto accept_dig;
4300 case 2:
goto keep_dig;
4309 if ((j1 > 0 || (j1 == 0 && dig & 1))
4319#ifdef Honor_FLT_ROUNDS
4331#ifdef Honor_FLT_ROUNDS
4339 mlo = mhi =
multadd(mhi, 10, 0);
4348 *s++ = dig =
quorem(b,S) +
'0';
4349 if (!b->
x[0] && b->
wds <= 1) {
4362#ifdef Honor_FLT_ROUNDS
4364 case 0:
goto trimzeros;
4365 case 2:
goto roundoff;
4373 if (j > 0 || (j == 0 && dig & 1))
4386#ifdef Honor_FLT_ROUNDS
4395 if (mlo && mlo != mhi)
4408 else if (!oldinexact)