Deleted Added
sdiff udiff text old ( 182709 ) new ( 219557 )
full compact
dtoa.c (182709) dtoa.c (219557)
1/****************************************************************
2
3The author of this software is David M. Gay.
4
5Copyright (C) 1998, 1999 by Lucent Technologies
6All Rights Reserved
7
8Permission to use, copy, modify, and distribute this software and

--- 61 unchanged lines hidden (view full) ---

70#define Check_FLT_ROUNDS
71#else
72#define Rounding Flt_Rounds
73#endif
74
75 char *
76dtoa
77#ifdef KR_headers
1/****************************************************************
2
3The author of this software is David M. Gay.
4
5Copyright (C) 1998, 1999 by Lucent Technologies
6All Rights Reserved
7
8Permission to use, copy, modify, and distribute this software and

--- 61 unchanged lines hidden (view full) ---

70#define Check_FLT_ROUNDS
71#else
72#define Rounding Flt_Rounds
73#endif
74
75 char *
76dtoa
77#ifdef KR_headers
78 (d, mode, ndigits, decpt, sign, rve)
79 double d; int mode, ndigits, *decpt, *sign; char **rve;
78 (d0, mode, ndigits, decpt, sign, rve)
79 double d0; int mode, ndigits, *decpt, *sign; char **rve;
80#else
80#else
81 (double d, int mode, int ndigits, int *decpt, int *sign, char **rve)
81 (double d0, int mode, int ndigits, int *decpt, int *sign, char **rve)
82#endif
83{
84 /* Arguments ndigits, decpt, sign are similar to those
85 of ecvt and fcvt; trailing zeros are suppressed from
86 the returned string. If not null, *rve is set to point
87 to the end of the return value. If d is +-Infinity or NaN,
88 then *decpt is set to 9999.
89

--- 29 unchanged lines hidden (view full) ---

119 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
120 spec_case, try_quick;
121 Long L;
122#ifndef Sudden_Underflow
123 int denorm;
124 ULong x;
125#endif
126 Bigint *b, *b1, *delta, *mlo, *mhi, *S;
82#endif
83{
84 /* Arguments ndigits, decpt, sign are similar to those
85 of ecvt and fcvt; trailing zeros are suppressed from
86 the returned string. If not null, *rve is set to point
87 to the end of the return value. If d is +-Infinity or NaN,
88 then *decpt is set to 9999.
89

--- 29 unchanged lines hidden (view full) ---

119 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
120 spec_case, try_quick;
121 Long L;
122#ifndef Sudden_Underflow
123 int denorm;
124 ULong x;
125#endif
126 Bigint *b, *b1, *delta, *mlo, *mhi, *S;
127 double d2, ds, eps;
127 U d, d2, eps;
128 double ds;
128 char *s, *s0;
129#ifdef SET_INEXACT
130 int inexact, oldinexact;
131#endif
132#ifdef Honor_FLT_ROUNDS /*{*/
133 int Rounding;
134#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
135 Rounding = Flt_Rounds;

--- 8 unchanged lines hidden (view full) ---

144#endif /*}*/
145
146#ifndef MULTIPLE_THREADS
147 if (dtoa_result) {
148 freedtoa(dtoa_result);
149 dtoa_result = 0;
150 }
151#endif
129 char *s, *s0;
130#ifdef SET_INEXACT
131 int inexact, oldinexact;
132#endif
133#ifdef Honor_FLT_ROUNDS /*{*/
134 int Rounding;
135#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
136 Rounding = Flt_Rounds;

--- 8 unchanged lines hidden (view full) ---

145#endif /*}*/
146
147#ifndef MULTIPLE_THREADS
148 if (dtoa_result) {
149 freedtoa(dtoa_result);
150 dtoa_result = 0;
151 }
152#endif
152
153 if (word0(d) & Sign_bit) {
153 d.d = d0;
154 if (word0(&d) & Sign_bit) {
154 /* set sign for everything, including 0's and NaNs */
155 *sign = 1;
155 /* set sign for everything, including 0's and NaNs */
156 *sign = 1;
156 word0(d) &= ~Sign_bit; /* clear sign bit */
157 word0(&d) &= ~Sign_bit; /* clear sign bit */
157 }
158 else
159 *sign = 0;
160
161#if defined(IEEE_Arith) + defined(VAX)
162#ifdef IEEE_Arith
158 }
159 else
160 *sign = 0;
161
162#if defined(IEEE_Arith) + defined(VAX)
163#ifdef IEEE_Arith
163 if ((word0(d) & Exp_mask) == Exp_mask)
164 if ((word0(&d) & Exp_mask) == Exp_mask)
164#else
165#else
165 if (word0(d) == 0x8000)
166 if (word0(&d) == 0x8000)
166#endif
167 {
168 /* Infinity or NaN */
169 *decpt = 9999;
170#ifdef IEEE_Arith
167#endif
168 {
169 /* Infinity or NaN */
170 *decpt = 9999;
171#ifdef IEEE_Arith
171 if (!word1(d) && !(word0(d) & 0xfffff))
172 if (!word1(&d) && !(word0(&d) & 0xfffff))
172 return nrv_alloc("Infinity", rve, 8);
173#endif
174 return nrv_alloc("NaN", rve, 3);
175 }
176#endif
177#ifdef IBM
173 return nrv_alloc("Infinity", rve, 8);
174#endif
175 return nrv_alloc("NaN", rve, 3);
176 }
177#endif
178#ifdef IBM
178 dval(d) += 0; /* normalize */
179 dval(&d) += 0; /* normalize */
179#endif
180#endif
180 if (!dval(d)) {
181 if (!dval(&d)) {
181 *decpt = 1;
182 return nrv_alloc("0", rve, 1);
183 }
184
185#ifdef SET_INEXACT
186 try_quick = oldinexact = get_inexact();
187 inexact = 1;
188#endif
189#ifdef Honor_FLT_ROUNDS
190 if (Rounding >= 2) {
191 if (*sign)
192 Rounding = Rounding == 2 ? 0 : 2;
193 else
194 if (Rounding != 2)
195 Rounding = 0;
196 }
197#endif
198
182 *decpt = 1;
183 return nrv_alloc("0", rve, 1);
184 }
185
186#ifdef SET_INEXACT
187 try_quick = oldinexact = get_inexact();
188 inexact = 1;
189#endif
190#ifdef Honor_FLT_ROUNDS
191 if (Rounding >= 2) {
192 if (*sign)
193 Rounding = Rounding == 2 ? 0 : 2;
194 else
195 if (Rounding != 2)
196 Rounding = 0;
197 }
198#endif
199
199 b = d2b(dval(d), &be, &bbits);
200 b = d2b(dval(&d), &be, &bbits);
200#ifdef Sudden_Underflow
201#ifdef Sudden_Underflow
201 i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
202 i = (int)(word0(&d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
202#else
203#else
203 if (( i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1)) )!=0) {
204 if (( i = (int)(word0(&d) >> Exp_shift1 & (Exp_mask>>Exp_shift1)) )!=0) {
204#endif
205#endif
205 dval(d2) = dval(d);
206 word0(d2) &= Frac_mask1;
207 word0(d2) |= Exp_11;
206 dval(&d2) = dval(&d);
207 word0(&d2) &= Frac_mask1;
208 word0(&d2) |= Exp_11;
208#ifdef IBM
209#ifdef IBM
209 if (( j = 11 - hi0bits(word0(d2) & Frac_mask) )!=0)
210 dval(d2) /= 1 << j;
210 if (( j = 11 - hi0bits(word0(&d2) & Frac_mask) )!=0)
211 dval(&d2) /= 1 << j;
211#endif
212
213 /* log(x) ~=~ log(1.5) + (x-1.5)/1.5
214 * log10(x) = log(x) / log(10)
215 * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
212#endif
213
214 /* log(x) ~=~ log(1.5) + (x-1.5)/1.5
215 * log10(x) = log(x) / log(10)
216 * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
216 * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
217 * log10(&d) = (i-Bias)*log(2)/log(10) + log10(&d2)
217 *
218 *
218 * This suggests computing an approximation k to log10(d) by
219 * This suggests computing an approximation k to log10(&d) by
219 *
220 * k = (i - Bias)*0.301029995663981
221 * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
222 *
223 * We want k to be too large rather than too small.
224 * The error in the first-order Taylor series approximation
225 * is in our favor, so we just round up the constant enough
226 * to compensate for any error in the multiplication of

--- 12 unchanged lines hidden (view full) ---

239#endif
240#ifndef Sudden_Underflow
241 denorm = 0;
242 }
243 else {
244 /* d is denormalized */
245
246 i = bbits + be + (Bias + (P-1) - 1);
220 *
221 * k = (i - Bias)*0.301029995663981
222 * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
223 *
224 * We want k to be too large rather than too small.
225 * The error in the first-order Taylor series approximation
226 * is in our favor, so we just round up the constant enough
227 * to compensate for any error in the multiplication of

--- 12 unchanged lines hidden (view full) ---

240#endif
241#ifndef Sudden_Underflow
242 denorm = 0;
243 }
244 else {
245 /* d is denormalized */
246
247 i = bbits + be + (Bias + (P-1) - 1);
247 x = i > 32 ? word0(d) << 64 - i | word1(d) >> i - 32
248 : word1(d) << 32 - i;
249 dval(d2) = x;
250 word0(d2) -= 31*Exp_msk1; /* adjust exponent */
248 x = i > 32 ? word0(&d) << (64 - i) | word1(&d) >> (i - 32)
249 : word1(&d) << (32 - i);
250 dval(&d2) = x;
251 word0(&d2) -= 31*Exp_msk1; /* adjust exponent */
251 i -= (Bias + (P-1) - 1) + 1;
252 denorm = 1;
253 }
254#endif
252 i -= (Bias + (P-1) - 1) + 1;
253 denorm = 1;
254 }
255#endif
255 ds = (dval(d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
256 ds = (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
256 k = (int)ds;
257 if (ds < 0. && ds != k)
258 k--; /* want k = floor(ds) */
259 k_check = 1;
260 if (k >= 0 && k <= Ten_pmax) {
257 k = (int)ds;
258 if (ds < 0. && ds != k)
259 k--; /* want k = floor(ds) */
260 k_check = 1;
261 if (k >= 0 && k <= Ten_pmax) {
261 if (dval(d) < tens[k])
262 if (dval(&d) < tens[k])
262 k--;
263 k_check = 0;
264 }
265 j = bbits - i - 1;
266 if (j >= 0) {
267 b2 = 0;
268 s2 = j;
269 }

--- 22 unchanged lines hidden (view full) ---

292#endif
293#endif /*SET_INEXACT*/
294
295 if (mode > 5) {
296 mode -= 4;
297 try_quick = 0;
298 }
299 leftright = 1;
263 k--;
264 k_check = 0;
265 }
266 j = bbits - i - 1;
267 if (j >= 0) {
268 b2 = 0;
269 s2 = j;
270 }

--- 22 unchanged lines hidden (view full) ---

293#endif
294#endif /*SET_INEXACT*/
295
296 if (mode > 5) {
297 mode -= 4;
298 try_quick = 0;
299 }
300 leftright = 1;
301 ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */
302 /* silence erroneous "gcc -Wall" warning. */
300 switch(mode) {
301 case 0:
302 case 1:
303 switch(mode) {
304 case 0:
305 case 1:
303 ilim = ilim1 = -1;
304 i = 18;
305 ndigits = 0;
306 break;
307 case 2:
308 leftright = 0;
309 /* no break */
310 case 4:
311 if (ndigits <= 0)

--- 17 unchanged lines hidden (view full) ---

329 leftright = 0;
330#endif
331
332 if (ilim >= 0 && ilim <= Quick_max && try_quick) {
333
334 /* Try to get by with floating-point arithmetic. */
335
336 i = 0;
306 i = 18;
307 ndigits = 0;
308 break;
309 case 2:
310 leftright = 0;
311 /* no break */
312 case 4:
313 if (ndigits <= 0)

--- 17 unchanged lines hidden (view full) ---

331 leftright = 0;
332#endif
333
334 if (ilim >= 0 && ilim <= Quick_max && try_quick) {
335
336 /* Try to get by with floating-point arithmetic. */
337
338 i = 0;
337 dval(d2) = dval(d);
339 dval(&d2) = dval(&d);
338 k0 = k;
339 ilim0 = ilim;
340 ieps = 2; /* conservative */
341 if (k > 0) {
342 ds = tens[k&0xf];
343 j = k >> 4;
344 if (j & Bletch) {
345 /* prevent overflows */
346 j &= Bletch - 1;
340 k0 = k;
341 ilim0 = ilim;
342 ieps = 2; /* conservative */
343 if (k > 0) {
344 ds = tens[k&0xf];
345 j = k >> 4;
346 if (j & Bletch) {
347 /* prevent overflows */
348 j &= Bletch - 1;
347 dval(d) /= bigtens[n_bigtens-1];
349 dval(&d) /= bigtens[n_bigtens-1];
348 ieps++;
349 }
350 for(; j; j >>= 1, i++)
351 if (j & 1) {
352 ieps++;
353 ds *= bigtens[i];
354 }
350 ieps++;
351 }
352 for(; j; j >>= 1, i++)
353 if (j & 1) {
354 ieps++;
355 ds *= bigtens[i];
356 }
355 dval(d) /= ds;
357 dval(&d) /= ds;
356 }
357 else if (( j1 = -k )!=0) {
358 }
359 else if (( j1 = -k )!=0) {
358 dval(d) *= tens[j1 & 0xf];
360 dval(&d) *= tens[j1 & 0xf];
359 for(j = j1 >> 4; j; j >>= 1, i++)
360 if (j & 1) {
361 ieps++;
361 for(j = j1 >> 4; j; j >>= 1, i++)
362 if (j & 1) {
363 ieps++;
362 dval(d) *= bigtens[i];
364 dval(&d) *= bigtens[i];
363 }
364 }
365 }
366 }
365 if (k_check && dval(d) < 1. && ilim > 0) {
367 if (k_check && dval(&d) < 1. && ilim > 0) {
366 if (ilim1 <= 0)
367 goto fast_failed;
368 ilim = ilim1;
369 k--;
368 if (ilim1 <= 0)
369 goto fast_failed;
370 ilim = ilim1;
371 k--;
370 dval(d) *= 10.;
372 dval(&d) *= 10.;
371 ieps++;
372 }
373 ieps++;
374 }
373 dval(eps) = ieps*dval(d) + 7.;
374 word0(eps) -= (P-1)*Exp_msk1;
375 dval(&eps) = ieps*dval(&d) + 7.;
376 word0(&eps) -= (P-1)*Exp_msk1;
375 if (ilim == 0) {
376 S = mhi = 0;
377 if (ilim == 0) {
378 S = mhi = 0;
377 dval(d) -= 5.;
378 if (dval(d) > dval(eps))
379 dval(&d) -= 5.;
380 if (dval(&d) > dval(&eps))
379 goto one_digit;
381 goto one_digit;
380 if (dval(d) < -dval(eps))
382 if (dval(&d) < -dval(&eps))
381 goto no_digits;
382 goto fast_failed;
383 }
384#ifndef No_leftright
385 if (leftright) {
386 /* Use Steele & White method of only
387 * generating digits needed.
388 */
383 goto no_digits;
384 goto fast_failed;
385 }
386#ifndef No_leftright
387 if (leftright) {
388 /* Use Steele & White method of only
389 * generating digits needed.
390 */
389 dval(eps) = 0.5/tens[ilim-1] - dval(eps);
391 dval(&eps) = 0.5/tens[ilim-1] - dval(&eps);
390 for(i = 0;;) {
392 for(i = 0;;) {
391 L = dval(d);
392 dval(d) -= L;
393 L = dval(&d);
394 dval(&d) -= L;
393 *s++ = '0' + (int)L;
395 *s++ = '0' + (int)L;
394 if (dval(d) < dval(eps))
396 if (dval(&d) < dval(&eps))
395 goto ret1;
397 goto ret1;
396 if (1. - dval(d) < dval(eps))
398 if (1. - dval(&d) < dval(&eps))
397 goto bump_up;
398 if (++i >= ilim)
399 break;
399 goto bump_up;
400 if (++i >= ilim)
401 break;
400 dval(eps) *= 10.;
401 dval(d) *= 10.;
402 dval(&eps) *= 10.;
403 dval(&d) *= 10.;
402 }
403 }
404 else {
405#endif
406 /* Generate ilim digits, then fix them up. */
404 }
405 }
406 else {
407#endif
408 /* Generate ilim digits, then fix them up. */
407 dval(eps) *= tens[ilim-1];
408 for(i = 1;; i++, dval(d) *= 10.) {
409 L = (Long)(dval(d));
410 if (!(dval(d) -= L))
409 dval(&eps) *= tens[ilim-1];
410 for(i = 1;; i++, dval(&d) *= 10.) {
411 L = (Long)(dval(&d));
412 if (!(dval(&d) -= L))
411 ilim = i;
412 *s++ = '0' + (int)L;
413 if (i == ilim) {
413 ilim = i;
414 *s++ = '0' + (int)L;
415 if (i == ilim) {
414 if (dval(d) > 0.5 + dval(eps))
416 if (dval(&d) > 0.5 + dval(&eps))
415 goto bump_up;
417 goto bump_up;
416 else if (dval(d) < 0.5 - dval(eps)) {
418 else if (dval(&d) < 0.5 - dval(&eps)) {
417 while(*--s == '0');
418 s++;
419 goto ret1;
420 }
421 break;
422 }
423 }
424#ifndef No_leftright
425 }
426#endif
427 fast_failed:
428 s = s0;
419 while(*--s == '0');
420 s++;
421 goto ret1;
422 }
423 break;
424 }
425 }
426#ifndef No_leftright
427 }
428#endif
429 fast_failed:
430 s = s0;
429 dval(d) = dval(d2);
431 dval(&d) = dval(&d2);
430 k = k0;
431 ilim = ilim0;
432 }
433
434 /* Do we have a "small" integer? */
435
436 if (be >= 0 && k <= Int_max) {
437 /* Yes. */
438 ds = tens[k];
439 if (ndigits < 0 && ilim <= 0) {
440 S = mhi = 0;
432 k = k0;
433 ilim = ilim0;
434 }
435
436 /* Do we have a "small" integer? */
437
438 if (be >= 0 && k <= Int_max) {
439 /* Yes. */
440 ds = tens[k];
441 if (ndigits < 0 && ilim <= 0) {
442 S = mhi = 0;
441 if (ilim < 0 || dval(d) <= 5*ds)
443 if (ilim < 0 || dval(&d) <= 5*ds)
442 goto no_digits;
443 goto one_digit;
444 }
444 goto no_digits;
445 goto one_digit;
446 }
445 for(i = 1;; i++, dval(d) *= 10.) {
446 L = (Long)(dval(d) / ds);
447 dval(d) -= L*ds;
447 for(i = 1;; i++, dval(&d) *= 10.) {
448 L = (Long)(dval(&d) / ds);
449 dval(&d) -= L*ds;
448#ifdef Check_FLT_ROUNDS
449 /* If FLT_ROUNDS == 2, L will usually be high by 1 */
450#ifdef Check_FLT_ROUNDS
451 /* If FLT_ROUNDS == 2, L will usually be high by 1 */
450 if (dval(d) < 0) {
452 if (dval(&d) < 0) {
451 L--;
453 L--;
452 dval(d) += ds;
454 dval(&d) += ds;
453 }
454#endif
455 *s++ = '0' + (int)L;
455 }
456#endif
457 *s++ = '0' + (int)L;
456 if (!dval(d)) {
458 if (!dval(&d)) {
457#ifdef SET_INEXACT
458 inexact = 0;
459#endif
460 break;
461 }
462 if (i == ilim) {
463#ifdef Honor_FLT_ROUNDS
464 if (mode > 1)
465 switch(Rounding) {
466 case 0: goto ret1;
467 case 2: goto bump_up;
468 }
469#endif
459#ifdef SET_INEXACT
460 inexact = 0;
461#endif
462 break;
463 }
464 if (i == ilim) {
465#ifdef Honor_FLT_ROUNDS
466 if (mode > 1)
467 switch(Rounding) {
468 case 0: goto ret1;
469 case 2: goto bump_up;
470 }
471#endif
470 dval(d) += dval(d);
471 if (dval(d) > ds || dval(d) == ds && L & 1) {
472 dval(&d) += dval(&d);
473#ifdef ROUND_BIASED
474 if (dval(&d) >= ds)
475#else
476 if (dval(&d) > ds || (dval(&d) == ds && L & 1))
477#endif
478 {
472 bump_up:
473 while(*--s == '9')
474 if (s == s0) {
475 k++;
476 *s = '0';
477 break;
478 }
479 ++*s++;

--- 48 unchanged lines hidden (view full) ---

528 /* Check for special case that d is a normalized power of 2. */
529
530 spec_case = 0;
531 if ((mode < 2 || leftright)
532#ifdef Honor_FLT_ROUNDS
533 && Rounding == 1
534#endif
535 ) {
479 bump_up:
480 while(*--s == '9')
481 if (s == s0) {
482 k++;
483 *s = '0';
484 break;
485 }
486 ++*s++;

--- 48 unchanged lines hidden (view full) ---

535 /* Check for special case that d is a normalized power of 2. */
536
537 spec_case = 0;
538 if ((mode < 2 || leftright)
539#ifdef Honor_FLT_ROUNDS
540 && Rounding == 1
541#endif
542 ) {
536 if (!word1(d) && !(word0(d) & Bndry_mask)
543 if (!word1(&d) && !(word0(&d) & Bndry_mask)
537#ifndef Sudden_Underflow
544#ifndef Sudden_Underflow
538 && word0(d) & (Exp_mask & ~Exp_msk1)
545 && word0(&d) & (Exp_mask & ~Exp_msk1)
539#endif
540 ) {
541 /* The special case */
542 b2 += Log2P;
543 s2 += Log2P;
544 spec_case = 1;
545 }
546 }

--- 69 unchanged lines hidden (view full) ---

616 /* Do we yet have the shortest decimal string
617 * that will round to d?
618 */
619 j = cmp(b, mlo);
620 delta = diff(S, mhi);
621 j1 = delta->sign ? 1 : cmp(b, delta);
622 Bfree(delta);
623#ifndef ROUND_BIASED
546#endif
547 ) {
548 /* The special case */
549 b2 += Log2P;
550 s2 += Log2P;
551 spec_case = 1;
552 }
553 }

--- 69 unchanged lines hidden (view full) ---

623 /* Do we yet have the shortest decimal string
624 * that will round to d?
625 */
626 j = cmp(b, mlo);
627 delta = diff(S, mhi);
628 j1 = delta->sign ? 1 : cmp(b, delta);
629 Bfree(delta);
630#ifndef ROUND_BIASED
624 if (j1 == 0 && mode != 1 && !(word1(d) & 1)
631 if (j1 == 0 && mode != 1 && !(word1(&d) & 1)
625#ifdef Honor_FLT_ROUNDS
626 && Rounding >= 1
627#endif
628 ) {
629 if (dig == '9')
630 goto round_9_up;
631 if (j > 0)
632 dig++;
633#ifdef SET_INEXACT
634 else if (!b->x[0] && b->wds <= 1)
635 inexact = 0;
636#endif
637 *s++ = dig;
638 goto ret;
639 }
640#endif
632#ifdef Honor_FLT_ROUNDS
633 && Rounding >= 1
634#endif
635 ) {
636 if (dig == '9')
637 goto round_9_up;
638 if (j > 0)
639 dig++;
640#ifdef SET_INEXACT
641 else if (!b->x[0] && b->wds <= 1)
642 inexact = 0;
643#endif
644 *s++ = dig;
645 goto ret;
646 }
647#endif
641 if (j < 0 || j == 0 && mode != 1
648 if (j < 0 || (j == 0 && mode != 1
642#ifndef ROUND_BIASED
649#ifndef ROUND_BIASED
643 && !(word1(d) & 1)
650 && !(word1(&d) & 1)
644#endif
651#endif
645 ) {
652 )) {
646 if (!b->x[0] && b->wds <= 1) {
647#ifdef SET_INEXACT
648 inexact = 0;
649#endif
650 goto accept_dig;
651 }
652#ifdef Honor_FLT_ROUNDS
653 if (mode > 1)
654 switch(Rounding) {
655 case 0: goto accept_dig;
656 case 2: goto keep_dig;
657 }
658#endif /*Honor_FLT_ROUNDS*/
659 if (j1 > 0) {
660 b = lshift(b, 1);
661 j1 = cmp(b, S);
653 if (!b->x[0] && b->wds <= 1) {
654#ifdef SET_INEXACT
655 inexact = 0;
656#endif
657 goto accept_dig;
658 }
659#ifdef Honor_FLT_ROUNDS
660 if (mode > 1)
661 switch(Rounding) {
662 case 0: goto accept_dig;
663 case 2: goto keep_dig;
664 }
665#endif /*Honor_FLT_ROUNDS*/
666 if (j1 > 0) {
667 b = lshift(b, 1);
668 j1 = cmp(b, S);
662 if ((j1 > 0 || j1 == 0 && dig & 1)
669#ifdef ROUND_BIASED
670 if (j1 >= 0 /*)*/
671#else
672 if ((j1 > 0 || (j1 == 0 && dig & 1))
673#endif
663 && dig++ == '9')
664 goto round_9_up;
665 }
666 accept_dig:
667 *s++ = dig;
668 goto ret;
669 }
670 if (j1 > 0) {

--- 43 unchanged lines hidden (view full) ---

714#ifdef Honor_FLT_ROUNDS
715 switch(Rounding) {
716 case 0: goto trimzeros;
717 case 2: goto roundoff;
718 }
719#endif
720 b = lshift(b, 1);
721 j = cmp(b, S);
674 && dig++ == '9')
675 goto round_9_up;
676 }
677 accept_dig:
678 *s++ = dig;
679 goto ret;
680 }
681 if (j1 > 0) {

--- 43 unchanged lines hidden (view full) ---

725#ifdef Honor_FLT_ROUNDS
726 switch(Rounding) {
727 case 0: goto trimzeros;
728 case 2: goto roundoff;
729 }
730#endif
731 b = lshift(b, 1);
732 j = cmp(b, S);
722 if (j > 0 || j == 0 && dig & 1) {
733#ifdef ROUND_BIASED
734 if (j >= 0)
735#else
736 if (j > 0 || (j == 0 && dig & 1))
737#endif
738 {
723 roundoff:
724 while(*--s == '9')
725 if (s == s0) {
726 k++;
727 *s++ = '1';
728 goto ret;
729 }
730 ++*s++;
731 }
732 else {
739 roundoff:
740 while(*--s == '9')
741 if (s == s0) {
742 k++;
743 *s++ = '1';
744 goto ret;
745 }
746 ++*s++;
747 }
748 else {
749#ifdef Honor_FLT_ROUNDS
733 trimzeros:
750 trimzeros:
751#endif
734 while(*--s == '0');
735 s++;
736 }
737 ret:
738 Bfree(S);
739 if (mhi) {
740 if (mlo && mlo != mhi)
741 Bfree(mlo);
742 Bfree(mhi);
743 }
744 ret1:
745#ifdef SET_INEXACT
746 if (inexact) {
747 if (!oldinexact) {
752 while(*--s == '0');
753 s++;
754 }
755 ret:
756 Bfree(S);
757 if (mhi) {
758 if (mlo && mlo != mhi)
759 Bfree(mlo);
760 Bfree(mhi);
761 }
762 ret1:
763#ifdef SET_INEXACT
764 if (inexact) {
765 if (!oldinexact) {
748 word0(d) = Exp_1 + (70 << Exp_shift);
749 word1(d) = 0;
750 dval(d) += 1.;
766 word0(&d) = Exp_1 + (70 << Exp_shift);
767 word1(&d) = 0;
768 dval(&d) += 1.;
751 }
752 }
753 else if (!oldinexact)
754 clear_inexact();
755#endif
756 Bfree(b);
757 *s = 0;
758 *decpt = k + 1;
759 if (rve)
760 *rve = s;
761 return s0;
762 }
769 }
770 }
771 else if (!oldinexact)
772 clear_inexact();
773#endif
774 Bfree(b);
775 *s = 0;
776 *decpt = k + 1;
777 if (rve)
778 *rve = s;
779 return s0;
780 }