Skip to content

M
mariadb
Commit c80bf763 authored by Alexey Kopytov's avatar Alexey Kopytov
Browse files
Options

Bug #45882: dtoa.c might not work with gcc 4.4.0 

- Ported relevant changes from the upstream version to not
break strict-aliasing rules and to fix compiler warnings and
and infinite loops caused by that issue.

- Fixed compilation with Honor_FLT_ROUNDS defined.

- Fixed an unused variable warning.
parent ec4033b5
Hide whitespace changes
Inline Side-by-side
Showing with 192 additions and 181 deletions
strings/dtoa.c
View file @ c80bf763
......@@ -551,14 +551,14 @@ typedef union { double d; ULong L[2]; } U;
#if defined(WORDS_BIGENDIAN) || (defined(__FLOAT_WORD_ORDER) && \
(__FLOAT_WORD_ORDER == __BIG_ENDIAN))
#define word0(x) ((U*)&x)->L[0]
#define word1(x) ((U*)&x)->L[1]
#define word0(x) (x)->L[0]
#define word1(x) (x)->L[1]
#else
#define word0(x) ((U*)&x)->L[1]
#define word1(x) ((U*)&x)->L[0]
#define word0(x) (x)->L[1]
#define word1(x) (x)->L[0]
#endif
#define dval(x) ((U*)&x)->d
#define dval(x) (x)->d
/* #define P DBL_MANT_DIG */
/* Ten_pmax= floor(P*log(2)/log(5)) */
......@@ -1159,15 +1159,15 @@ static Bigint *diff(Bigint *a, Bigint *b, Stack_alloc *alloc)
}
static double ulp(double x)
static double ulp(U *x)
{
register Long L;
double a;
U u;
L= (word0(x) & Exp_mask) - (P - 1)*Exp_msk1;
word0(a) = L;
word1(a) = 0;
return dval(a);
word0(&u) = L;
word1(&u) = 0;
return dval(&u);
}
......@@ -1175,9 +1175,9 @@ static double b2d(Bigint *a, int *e)
{
ULong *xa, *xa0, w, y, z;
int k;
double d;
#define d0 word0(d)
#define d1 word1(d)
U d;
#define d0 word0(&d)
#define d1 word1(&d)
xa0= a->p.x;
xa= xa0 + a->wds;
......@@ -1206,11 +1206,11 @@ static double b2d(Bigint *a, int *e)
ret_d:
#undef d0
#undef d1
return dval(d);
return dval(&d);
}
static Bigint *d2b(double d, int *e, int *bits, Stack_alloc *alloc)
static Bigint *d2b(U *d, int *e, int *bits, Stack_alloc *alloc)
{
Bigint *b;
int de, k;
......@@ -1262,20 +1262,20 @@ static Bigint *d2b(double d, int *e, int *bits, Stack_alloc *alloc)
static double ratio(Bigint *a, Bigint *b)
{
double da, db;
U da, db;
int k, ka, kb;
dval(da)= b2d(a, &ka);
dval(db)= b2d(b, &kb);
dval(&da)= b2d(a, &ka);
dval(&db)= b2d(b, &kb);
k= ka - kb + 32*(a->wds - b->wds);
if (k > 0)
word0(da)+= k*Exp_msk1;
word0(&da)+= k*Exp_msk1;
else
{
k= -k;
word0(db)+= k*Exp_msk1;
word0(&db)+= k*Exp_msk1;
}
return dval(da) / dval(db);
return dval(&da) / dval(&db);
}
static const double tens[] =
......@@ -1329,10 +1329,11 @@ static const double tinytens[]=
static double my_strtod_int(const char *s00, char **se, int *error, char *buf, size_t buf_size)
{
int scale;
int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, UNINIT_VAR(c), dsign,
e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
const char *s, *s0, *s1, *end = *se;
double aadj, aadj1, adj, rv, rv0;
double aadj, aadj1;
U aadj2, adj, rv, rv0;
Long L;
ULong y, z;
Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
......@@ -1343,7 +1344,6 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
int rounding;
#endif
Stack_alloc alloc;
LINT_INIT(c);
*error= 0;
......@@ -1352,7 +1352,7 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
memset(alloc.freelist, 0, sizeof(alloc.freelist));
sign= nz0= nz= 0;
dval(rv)= 0.;
dval(&rv)= 0.;
for (s= s00; s < end; s++)
switch (*s) {
case '-':
......@@ -1488,14 +1488,14 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
if (!nd0)
nd0= nd;
k= nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
dval(rv)= y;
dval(&rv)= y;
if (k > 9)
{
#ifdef SET_INEXACT
if (k > DBL_DIG)
oldinexact = get_inexact();
#endif
dval(rv)= tens[k - 9] * dval(rv) + z;
dval(&rv)= tens[k - 9] * dval(&rv) + z;
}
bd0= 0;
if (nd <= DBL_DIG
......@@ -1514,11 +1514,11 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
/* round correctly FLT_ROUNDS = 2 or 3 */
if (sign)
{
rv= -rv;
rv.d= -rv.d;
sign= 0;
}
#endif
/* rv = */ rounded_product(dval(rv), tens[e]);
/* rv = */ rounded_product(dval(&rv), tens[e]);
goto ret;
}
i= DBL_DIG - nd;
......@@ -1532,13 +1532,13 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
/* round correctly FLT_ROUNDS = 2 or 3 */
if (sign)
{
rv= -rv;
rv.d= -rv.d;
sign= 0;
}
#endif
e-= i;
dval(rv)*= tens[i];
/* rv = */ rounded_product(dval(rv), tens[e]);
dval(&rv)*= tens[i];
/* rv = */ rounded_product(dval(&rv), tens[e]);
goto ret;
}
}
......@@ -1549,11 +1549,11 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
/* round correctly FLT_ROUNDS = 2 or 3 */
if (sign)
{
rv= -rv;
rv.d= -rv.d;
sign= 0;
}
#endif
/* rv = */ rounded_quotient(dval(rv), tens[-e]);
/* rv = */ rounded_quotient(dval(&rv), tens[-e]);
goto ret;
}
#endif
......@@ -1582,7 +1582,7 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
if (e1 > 0)
{
if ((i= e1 & 15))
dval(rv)*= tens[i];
dval(&rv)*= tens[i];
if (e1&= ~15)
{
if (e1 > DBL_MAX_10_EXP)
......@@ -1595,21 +1595,21 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
{
case 0: /* toward 0 */
case 3: /* toward -infinity */
word0(rv)= Big0;
word1(rv)= Big1;
word0(&rv)= Big0;
word1(&rv)= Big1;
break;
default:
word0(rv)= Exp_mask;
word1(rv)= 0;
word0(&rv)= Exp_mask;
word1(&rv)= 0;
}
#else /*Honor_FLT_ROUNDS*/
word0(rv)= Exp_mask;
word1(rv)= 0;
word0(&rv)= Exp_mask;
word1(&rv)= 0;
#endif /*Honor_FLT_ROUNDS*/
#ifdef SET_INEXACT
/* set overflow bit */
dval(rv0)= 1e300;
dval(rv0)*= dval(rv0);
dval(&rv0)= 1e300;
dval(&rv0)*= dval(&rv0);
#endif
if (bd0)
goto retfree;
......@@ -1618,27 +1618,27 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
e1>>= 4;
for(j= 0; e1 > 1; j++, e1>>= 1)
if (e1 & 1)
dval(rv)*= bigtens[j];
dval(&rv)*= bigtens[j];
/* The last multiplication could overflow. */
word0(rv)-= P*Exp_msk1;
dval(rv)*= bigtens[j];
if ((z= word0(rv) & Exp_mask) > Exp_msk1 * (DBL_MAX_EXP + Bias - P))
word0(&rv)-= P*Exp_msk1;
dval(&rv)*= bigtens[j];
if ((z= word0(&rv) & Exp_mask) > Exp_msk1 * (DBL_MAX_EXP + Bias - P))
goto ovfl;
if (z > Exp_msk1 * (DBL_MAX_EXP + Bias - 1 - P))
{
/* set to largest number (Can't trust DBL_MAX) */
word0(rv)= Big0;
word1(rv)= Big1;
word0(&rv)= Big0;
word1(&rv)= Big1;
}
else
word0(rv)+= P*Exp_msk1;
word0(&rv)+= P*Exp_msk1;
}
}
else if (e1 < 0)
{
e1= -e1;
if ((i= e1 & 15))
dval(rv)/= tens[i];
dval(&rv)/= tens[i];
if ((e1>>= 4))
{
if (e1 >= 1 << n_bigtens)
......@@ -1647,25 +1647,25 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
scale= 2 * P;
for(j= 0; e1 > 0; j++, e1>>= 1)
if (e1 & 1)
dval(rv)*= tinytens[j];
if (scale && (j = 2 * P + 1 - ((word0(rv) & Exp_mask) >> Exp_shift)) > 0)
dval(&rv)*= tinytens[j];
if (scale && (j = 2 * P + 1 - ((word0(&rv) & Exp_mask) >> Exp_shift)) > 0)
{
/* scaled rv is denormal; zap j low bits */
if (j >= 32)
{
word1(rv)= 0;
word1(&rv)= 0;
if (j >= 53)
word0(rv)= (P + 2) * Exp_msk1;
word0(&rv)= (P + 2) * Exp_msk1;
else
word0(rv)&= 0xffffffff << (j - 32);
word0(&rv)&= 0xffffffff << (j - 32);
}
else
word1(rv)&= 0xffffffff << j;
word1(&rv)&= 0xffffffff << j;
}
if (!dval(rv))
if (!dval(&rv))
{
undfl:
dval(rv)= 0.;
dval(&rv)= 0.;
if (bd0)
goto retfree;
goto ret;
......@@ -1683,7 +1683,7 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
{
bd= Balloc(bd0->k, &alloc);
Bcopy(bd, bd0);
bb= d2b(dval(rv), &bbe, &bbbits, &alloc); /* rv = bb * 2^bbe */
bb= d2b(&rv, &bbe, &bbbits, &alloc); /* rv = bb * 2^bbe */
bs= i2b(1, &alloc);
if (e >= 0)
......@@ -1748,7 +1748,7 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
if (i < 0)
{
/* Error is less than an ulp */
if (!delta->x[0] && delta->wds <= 1)
if (!delta->p.x[0] && delta->wds <= 1)
{
/* exact */
#ifdef SET_INEXACT
......@@ -1760,51 +1760,51 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
{
if (dsign)
{
adj= 1.;
adj.d= 1.;
goto apply_adj;
}
}
else if (!dsign)
{
adj= -1.;
if (!word1(rv) && !(word0(rv) & Frac_mask))
adj.d= -1.;
if (!word1(&rv) && !(word0(&rv) & Frac_mask))
{
y= word0(rv) & Exp_mask;
y= word0(&rv) & Exp_mask;
if (!scale || y > 2*P*Exp_msk1)
{
delta= lshift(delta,Log2P);
delta= lshift(delta, Log2P, &alloc);
if (cmp(delta, bs) <= 0)
adj= -0.5;
adj.d= -0.5;
}
}
apply_adj:
if (scale && (y= word0(rv) & Exp_mask) <= 2 * P * Exp_msk1)
word0(adj)+= (2 * P + 1) * Exp_msk1 - y;
dval(rv)+= adj * ulp(dval(rv));
if (scale && (y= word0(&rv) & Exp_mask) <= 2 * P * Exp_msk1)
word0(&adj)+= (2 * P + 1) * Exp_msk1 - y;
dval(&rv)+= adj.d * ulp(&rv);
}
break;
}
adj= ratio(delta, bs);
if (adj < 1.)
adj= 1.;
if (adj <= 0x7ffffffe)
adj.d= ratio(delta, bs);
if (adj.d < 1.)
adj.d= 1.;
if (adj.d <= 0x7ffffffe)
{
/* adj = rounding ? ceil(adj) : floor(adj); */
y= adj;
if (y != adj)
y= adj.d;
if (y != adj.d)
{
if (!((rounding >> 1) ^ dsign))
y++;
adj= y;
adj.d= y;
}
}
if (scale && (y= word0(rv) & Exp_mask) <= 2 * P * Exp_msk1)
word0(adj)+= (2 * P + 1) * Exp_msk1 - y;
adj*= ulp(dval(rv));
if (scale && (y= word0(&rv) & Exp_mask) <= 2 * P * Exp_msk1)
word0(&adj)+= (2 * P + 1) * Exp_msk1 - y;
adj.d*= ulp(&rv);
if (dsign)
dval(rv)+= adj;
dval(&rv)+= adj.d;
else
dval(rv)-= adj;
dval(&rv)-= adj.d;
goto cont;
}
#endif /*Honor_FLT_ROUNDS*/
......@@ -1815,8 +1815,8 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
Error is less than half an ulp -- check for special case of mantissa
a power of two.
*/
if (dsign || word1(rv) || word0(rv) & Bndry_mask ||
(word0(rv) & Exp_mask) <= (2 * P + 1) * Exp_msk1)
if (dsign || word1(&rv) || word0(&rv) & Bndry_mask ||
(word0(&rv) & Exp_mask) <= (2 * P + 1) * Exp_msk1)
{
#ifdef SET_INEXACT
if (!delta->x[0] && delta->wds <= 1)
......@@ -1842,26 +1842,26 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
/* exactly half-way between */
if (dsign)
{
if ((word0(rv) & Bndry_mask1) == Bndry_mask1 &&
word1(rv) ==
((scale && (y = word0(rv) & Exp_mask) <= 2 * P * Exp_msk1) ?
if ((word0(&rv) & Bndry_mask1) == Bndry_mask1 &&
word1(&rv) ==
((scale && (y = word0(&rv) & Exp_mask) <= 2 * P * Exp_msk1) ?
(0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
0xffffffff))
{
/*boundary case -- increment exponent*/
word0(rv)= (word0(rv) & Exp_mask) + Exp_msk1;
word1(rv) = 0;
word0(&rv)= (word0(&rv) & Exp_mask) + Exp_msk1;
word1(&rv) = 0;
dsign = 0;
break;
}
}
else if (!(word0(rv) & Bndry_mask) && !word1(rv))
else if (!(word0(&rv) & Bndry_mask) && !word1(&rv))
{
drop_down:
/* boundary case -- decrement exponent */
if (scale)
{
L= word0(rv) & Exp_mask;
L= word0(&rv) & Exp_mask;
if (L <= (2 *P + 1) * Exp_msk1)
{
if (L > (P + 2) * Exp_msk1)
......@@ -1871,19 +1871,19 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
goto undfl;
}
}
L= (word0(rv) & Exp_mask) - Exp_msk1;
word0(rv)= L | Bndry_mask1;
word1(rv)= 0xffffffff;
L= (word0(&rv) & Exp_mask) - Exp_msk1;
word0(&rv)= L | Bndry_mask1;
word1(&rv)= 0xffffffff;
break;
}
if (!(word1(rv) & LSB))
if (!(word1(&rv) & LSB))
break;
if (dsign)
dval(rv)+= ulp(dval(rv));
dval(&rv)+= ulp(&rv);
else
{
dval(rv)-= ulp(dval(rv));
if (!dval(rv))
dval(&rv)-= ulp(&rv);
if (!dval(&rv))
goto undfl;
}
dsign= 1 - dsign;
......@@ -1893,9 +1893,9 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
{
if (dsign)
aadj= aadj1= 1.;
else if (word1(rv) || word0(rv) & Bndry_mask)
else if (word1(&rv) || word0(&rv) & Bndry_mask)
{
if (word1(rv) == Tiny1 && !word0(rv))
if (word1(&rv) == Tiny1 && !word0(&rv))
goto undfl;
aadj= 1.;
aadj1= -1.;
......@@ -1929,26 +1929,26 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
aadj1+= 0.5;
#endif /*Check_FLT_ROUNDS*/
}
y= word0(rv) & Exp_mask;
y= word0(&rv) & Exp_mask;
/* Check for overflow */
if (y == Exp_msk1 * (DBL_MAX_EXP + Bias - 1))
{
dval(rv0)= dval(rv);
word0(rv)-= P * Exp_msk1;
adj= aadj1 * ulp(dval(rv));
dval(rv)+= adj;
if ((word0(rv) & Exp_mask) >= Exp_msk1 * (DBL_MAX_EXP + Bias - P))
dval(&rv0)= dval(&rv);
word0(&rv)-= P * Exp_msk1;
adj.d= aadj1 * ulp(&rv);
dval(&rv)+= adj.d;
if ((word0(&rv) & Exp_mask) >= Exp_msk1 * (DBL_MAX_EXP + Bias - P))
{
if (word0(rv0) == Big0 && word1(rv0) == Big1)
if (word0(&rv0) == Big0 && word1(&rv0) == Big1)
goto ovfl;
word0(rv)= Big0;
word1(rv)= Big1;
word0(&rv)= Big0;
word1(&rv)= Big1;
goto cont;
}
else
word0(rv)+= P * Exp_msk1;
word0(&rv)+= P * Exp_msk1;
}
else
{
......@@ -1961,12 +1961,21 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
aadj= z;
aadj1= dsign ? aadj : -aadj;
}
word0(aadj1)+= (2 * P + 1) * Exp_msk1 - y;
dval(&aadj2) = aadj1;
word0(&aadj2)+= (2 * P + 1) * Exp_msk1 - y;
aadj1= dval(&aadj2);
adj.d= aadj1 * ulp(&rv);
dval(&rv)+= adj.d;
if (rv.d == 0.)
goto undfl;
}
else
{
adj.d= aadj1 * ulp(&rv);
dval(&rv)+= adj.d;
}
adj = aadj1 * ulp(dval(rv));
dval(rv) += adj;
}
z= word0(rv) & Exp_mask;
z= word0(&rv) & Exp_mask;
#ifndef SET_INEXACT
if (!scale)
if (y == z)
......@@ -1975,7 +1984,7 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
L= (Long)aadj;
aadj-= L;
/* The tolerances below are conservative. */
if (dsign || word1(rv) || word0(rv) & Bndry_mask)
if (dsign || word1(&rv) || word0(&rv) & Bndry_mask)
{
if (aadj < .4999999 || aadj > .5000001)
break;
......@@ -1995,9 +2004,9 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
{
if (!oldinexact)
{
word0(rv0)= Exp_1 + (70 << Exp_shift);
word1(rv0)= 0;
dval(rv0)+= 1.;
word0(&rv0)= Exp_1 + (70 << Exp_shift);
word1(&rv0)= 0;
dval(&rv0)+= 1.;
}
}
else if (!oldinexact)
......@@ -2005,16 +2014,16 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
#endif
if (scale)
{
word0(rv0)= Exp_1 - 2 * P * Exp_msk1;
word1(rv0)= 0;
dval(rv)*= dval(rv0);
word0(&rv0)= Exp_1 - 2 * P * Exp_msk1;
word1(&rv0)= 0;
dval(&rv)*= dval(&rv0);
}
#ifdef SET_INEXACT
if (inexact && !(word0(rv) & Exp_mask))
if (inexact && !(word0(&rv) & Exp_mask))
{
/* set underflow bit */
dval(rv0)= 1e-300;
dval(rv0)*= dval(rv0);
dval(&rv0)= 1e-300;
dval(&rv0)*= dval(&rv0);
}
#endif
retfree:
......@@ -2025,7 +2034,7 @@ static double my_strtod_int(const char *s00, char **se, int *error, char *buf, s
Bfree(delta, &alloc);
ret:
*se= (char *)s;
return sign ? -dval(rv) : dval(rv);
return sign ? -dval(&rv) : dval(&rv);
}
......@@ -2128,7 +2137,7 @@ static int quorem(Bigint *b, Bigint *S)
calculation.
*/
static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
static char *dtoa(double dd, int mode, int ndigits, int *decpt, int *sign,
char **rve, char *buf, size_t buf_size)
{
/*
......@@ -2173,7 +2182,8 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
int denorm;
ULong x;
Bigint *b, *b1, *delta, *mlo, *mhi, *S;
double d2, ds, eps;
U d2, eps, u;
double ds;
char *s, *s0;
#ifdef Honor_FLT_ROUNDS
int rounding;
......@@ -2184,18 +2194,19 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
alloc.end= buf + buf_size;
memset(alloc.freelist, 0, sizeof(alloc.freelist));
if (word0(d) & Sign_bit)
u.d= dd;
if (word0(&u) & Sign_bit)
{
/* set sign for everything, including 0's and NaNs */
*sign= 1;
word0(d) &= ~Sign_bit; /* clear sign bit */
word0(&u) &= ~Sign_bit; /* clear sign bit */
}
else
*sign= 0;
/* If infinity, set decpt to DTOA_OVERFLOW, if 0 set it to 1 */
if (((word0(d) & Exp_mask) == Exp_mask && (*decpt= DTOA_OVERFLOW)) ||
(!dval(d) && (*decpt= 1)))
if (((word0(&u) & Exp_mask) == Exp_mask && (*decpt= DTOA_OVERFLOW)) ||
(!dval(&u) && (*decpt= 1)))
{
/* Infinity, NaN, 0 */
char *res= (char*) dtoa_alloc(2, &alloc);
......@@ -2217,12 +2228,12 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
}
#endif
b= d2b(dval(d), &be, &bbits, &alloc);
if ((i= (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))))
b= d2b(&u, &be, &bbits, &alloc);
if ((i= (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1))))
{
dval(d2)= dval(d);
word0(d2) &= Frac_mask1;
word0(d2) |= Exp_11;
dval(&d2)= dval(&u);
word0(&d2) &= Frac_mask1;
word0(&d2) |= Exp_11;
/*
log(x) ~=~ log(1.5) + (x-1.5)/1.5
......@@ -2255,21 +2266,21 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
/* d is denormalized */
i= bbits + be + (Bias + (P-1) - 1);
x= i > 32 ? word0(d) << (64 - i) | word1(d) >> (i - 32)
: word1(d) << (32 - i);
dval(d2)= x;
word0(d2)-= 31*Exp_msk1; /* adjust exponent */
x= i > 32 ? word0(&u) << (64 - i) | word1(&u) >> (i - 32)
: word1(&u) << (32 - i);
dval(&d2)= x;
word0(&d2)-= 31*Exp_msk1; /* adjust exponent */
i-= (Bias + (P-1) - 1) + 1;
denorm= 1;
}
ds= (dval(d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
ds= (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
k= (int)ds;
if (ds < 0. && ds != k)
k--; /* want k= floor(ds) */
k_check= 1;
if (k >= 0 && k <= Ten_pmax)
{
if (dval(d) < tens[k])
if (dval(&u) < tens[k])
k--;
k_check= 0;
}
......@@ -2347,7 +2358,7 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
{
/* Try to get by with floating-point arithmetic. */
i= 0;
dval(d2)= dval(d);
dval(&d2)= dval(&u);
k0= k;
ilim0= ilim;
ieps= 2; /* conservative */
......@@ -2359,7 +2370,7 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
{
/* prevent overflows */
j&= Bletch - 1;
dval(d)/= bigtens[n_bigtens-1];
dval(&u)/= bigtens[n_bigtens-1];
ieps++;
}
for (; j; j>>= 1, i++)
......@@ -2370,75 +2381,75 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
ds*= bigtens[i];
}
}
dval(d)/= ds;
dval(&u)/= ds;
}
else if ((j1= -k))
{
dval(d)*= tens[j1 & 0xf];
dval(&u)*= tens[j1 & 0xf];
for (j= j1 >> 4; j; j>>= 1, i++)
{
if (j & 1)
{
ieps++;
dval(d)*= bigtens[i];
dval(&u)*= bigtens[i];
}
}
}
if (k_check && dval(d) < 1. && ilim > 0)
if (k_check && dval(&u) < 1. && ilim > 0)
{
if (ilim1 <= 0)
goto fast_failed;
ilim= ilim1;
k--;
dval(d)*= 10.;
dval(&u)*= 10.;
ieps++;
}
dval(eps)= ieps*dval(d) + 7.;
word0(eps)-= (P-1)*Exp_msk1;
dval(&eps)= ieps*dval(&u) + 7.;
word0(&eps)-= (P-1)*Exp_msk1;
if (ilim == 0)
{
S= mhi= 0;
dval(d)-= 5.;
if (dval(d) > dval(eps))
dval(&u)-= 5.;
if (dval(&u) > dval(&eps))
goto one_digit;
if (dval(d) < -dval(eps))
if (dval(&u) < -dval(&eps))
goto no_digits;
goto fast_failed;
}
if (leftright)
{
/* Use Steele & White method of only generating digits needed. */
dval(eps)= 0.5/tens[ilim-1] - dval(eps);
dval(&eps)= 0.5/tens[ilim-1] - dval(&eps);
for (i= 0;;)
{
L= (Long) dval(d);
dval(d)-= L;
L= (Long) dval(&u);
dval(&u)-= L;
*s++= '0' + (int)L;
if (dval(d) < dval(eps))
if (dval(&u) < dval(&eps))
goto ret1;
if (1. - dval(d) < dval(eps))
if (1. - dval(&u) < dval(&eps))
goto bump_up;
if (++i >= ilim)
break;
dval(eps)*= 10.;
dval(d)*= 10.;
dval(&eps)*= 10.;
dval(&u)*= 10.;
}
}
else
{
/* Generate ilim digits, then fix them up. */
dval(eps)*= tens[ilim-1];
for (i= 1;; i++, dval(d)*= 10.)
dval(&eps)*= tens[ilim-1];
for (i= 1;; i++, dval(&u)*= 10.)
{
L= (Long)(dval(d));
if (!(dval(d)-= L))
L= (Long)(dval(&u));
if (!(dval(&u)-= L))
ilim= i;
*s++= '0' + (int)L;
if (i == ilim)
{
if (dval(d) > 0.5 + dval(eps))
if (dval(&u) > 0.5 + dval(&eps))
goto bump_up;
else if (dval(d) < 0.5 - dval(eps))
else if (dval(&u) < 0.5 - dval(&eps))
{
while (*--s == '0');
s++;
......@@ -2450,7 +2461,7 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
}
fast_failed:
s= s0;
dval(d)= dval(d2);
dval(&u)= dval(&d2);
k= k0;
ilim= ilim0;
}
......@@ -2464,24 +2475,24 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
if (ndigits < 0 && ilim <= 0)
{
S= mhi= 0;
if (ilim < 0 || dval(d) <= 5*ds)
if (ilim < 0 || dval(&u) <= 5*ds)
goto no_digits;
goto one_digit;
}
for (i= 1;; i++, dval(d)*= 10.)
for (i= 1;; i++, dval(&u)*= 10.)
{
L= (Long)(dval(d) / ds);
dval(d)-= L*ds;
L= (Long)(dval(&u) / ds);
dval(&u)-= L*ds;
#ifdef Check_FLT_ROUNDS
/* If FLT_ROUNDS == 2, L will usually be high by 1 */
if (dval(d) < 0)
if (dval(&u) < 0)
{
L--;
dval(d)+= ds;
dval(&u)+= ds;
}
#endif
*s++= '0' + (int)L;
if (!dval(d))
if (!dval(&u))
{
break;
}
......@@ -2496,8 +2507,8 @@ static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
}
}
#endif
dval(d)+= dval(d);
if (dval(d) > ds || (dval(d) == ds && L & 1))
dval(&u)+= dval(&u);
if (dval(&u) > ds || (dval(&u) == ds && L & 1))
{
bump_up:
while (*--s == '9')
......@@ -2562,8 +2573,8 @@ bump_up:
#endif
)
{
if (!word1(d) && !(word0(d) & Bndry_mask) &&
word0(d) & (Exp_mask & ~Exp_msk1)
if (!word1(&u) && !(word0(&u) & Bndry_mask) &&
word0(&u) & (Exp_mask & ~Exp_msk1)
)
{
/* The special case */
......@@ -2652,7 +2663,7 @@ one_digit:
delta= diff(S, mhi, &alloc);
j1= delta->sign ? 1 : cmp(b, delta);
Bfree(delta, &alloc);
if (j1 == 0 && mode != 1 && !(word1(d) & 1)
if (j1 == 0 && mode != 1 && !(word1(&u) & 1)
#ifdef Honor_FLT_ROUNDS
&& rounding >= 1
#endif
......@@ -2665,7 +2676,7 @@ one_digit:
*s++= dig;
goto ret;
}
if (j < 0 || (j == 0 && mode != 1 && !(word1(d) & 1)))
if (j < 0 || (j == 0 && mode != 1 && !(word1(&u) & 1)))
{
if (!b->p.x[0] && b->wds <= 1)
{
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7