mirror of
https://github.com/MariaDB/server.git
synced 2025-01-29 02:05:57 +01:00
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.
This commit is contained in:
Alexey Kopytov
parent
46bc8970c9
commit
3e1a792c9b
1 changed files with 192 additions and 181 deletions
373
strings/dtoa.c
373
strings/dtoa.c
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue