OSDN Git Service

2005-03-05 Andreas Tobler <a.tobler@schweiz.ch>
[pf3gnuchains/gcc-fork.git] / libjava / java / lang / dtoa.c
1 /****************************************************************
2  *
3  * The author of this software is David M. Gay.
4  *
5  * Copyright (c) 1991 by AT&T.
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose without fee is hereby granted, provided that this entire notice
9  * is included in all copies of any software which is or includes a copy
10  * or modification of this software and in all copies of the supporting
11  * documentation for such software.
12  *
13  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
14  * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
15  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
16  * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
17  *
18  ***************************************************************/
19
20 /* Please send bug reports to
21         David M. Gay
22         AT&T Bell Laboratories, Room 2C-463
23         600 Mountain Avenue
24         Murray Hill, NJ 07974-2070
25         U.S.A.
26         dmg@research.att.com or research!dmg
27  */
28
29 #include "mprec.h"
30 #include <string.h>
31
32 static int
33 _DEFUN (quorem,
34         (b, S),
35         _Jv_Bigint * b _AND _Jv_Bigint * S)
36 {
37   int n;
38   long borrow, y;
39   unsigned long carry, q, ys;
40   unsigned long *bx, *bxe, *sx, *sxe;
41 #ifdef Pack_32
42   long z;
43   unsigned long si, zs;
44 #endif
45
46   n = S->_wds;
47 #ifdef DEBUG
48   /*debug*/ if (b->_wds > n)
49     /*debug*/ Bug ("oversize b in quorem");
50 #endif
51   if (b->_wds < n)
52     return 0;
53   sx = S->_x;
54   sxe = sx + --n;
55   bx = b->_x;
56   bxe = bx + n;
57   q = *bxe / (*sxe + 1);        /* ensure q <= true quotient */
58 #ifdef DEBUG
59   /*debug*/ if (q > 9)
60     /*debug*/ Bug ("oversized quotient in quorem");
61 #endif
62   if (q)
63     {
64       borrow = 0;
65       carry = 0;
66       do
67         {
68 #ifdef Pack_32
69           si = *sx++;
70           ys = (si & 0xffff) * q + carry;
71           zs = (si >> 16) * q + (ys >> 16);
72           carry = zs >> 16;
73           y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
74           borrow = y >> 16;
75           Sign_Extend (borrow, y);
76           z = (*bx >> 16) - (zs & 0xffff) + borrow;
77           borrow = z >> 16;
78           Sign_Extend (borrow, z);
79           Storeinc (bx, z, y);
80 #else
81           ys = *sx++ * q + carry;
82           carry = ys >> 16;
83           y = *bx - (ys & 0xffff) + borrow;
84           borrow = y >> 16;
85           Sign_Extend (borrow, y);
86           *bx++ = y & 0xffff;
87 #endif
88         }
89       while (sx <= sxe);
90       if (!*bxe)
91         {
92           bx = b->_x;
93           while (--bxe > bx && !*bxe)
94             --n;
95           b->_wds = n;
96         }
97     }
98   if (cmp (b, S) >= 0)
99     {
100       q++;
101       borrow = 0;
102       carry = 0;
103       bx = b->_x;
104       sx = S->_x;
105       do
106         {
107 #ifdef Pack_32
108           si = *sx++;
109           ys = (si & 0xffff) + carry;
110           zs = (si >> 16) + (ys >> 16);
111           carry = zs >> 16;
112           y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
113           borrow = y >> 16;
114           Sign_Extend (borrow, y);
115           z = (*bx >> 16) - (zs & 0xffff) + borrow;
116           borrow = z >> 16;
117           Sign_Extend (borrow, z);
118           Storeinc (bx, z, y);
119 #else
120           ys = *sx++ + carry;
121           carry = ys >> 16;
122           y = *bx - (ys & 0xffff) + borrow;
123           borrow = y >> 16;
124           Sign_Extend (borrow, y);
125           *bx++ = y & 0xffff;
126 #endif
127         }
128       while (sx <= sxe);
129       bx = b->_x;
130       bxe = bx + n;
131       if (!*bxe)
132         {
133           while (--bxe > bx && !*bxe)
134             --n;
135           b->_wds = n;
136         }
137     }
138   return q;
139 }
140
141 #ifdef DEBUG
142 #include <stdio.h>
143
144 void
145 print (_Jv_Bigint * b)
146 {
147   int i, wds;
148   unsigned long *x, y;
149   wds = b->_wds;
150   x = b->_x+wds;
151   i = 0;
152   do
153     {
154       x--;
155       fprintf (stderr, "%08x", *x);
156     }
157   while (++i < wds);
158   fprintf (stderr, "\n");
159 }
160 #endif
161
162 /* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
163  *
164  * Inspired by "How to Print Floating-Point Numbers Accurately" by
165  * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101].
166  *
167  * Modifications:
168  *      1. Rather than iterating, we use a simple numeric overestimate
169  *         to determine k = floor(log10(d)).  We scale relevant
170  *         quantities using O(log2(k)) rather than O(k) multiplications.
171  *      2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
172  *         try to generate digits strictly left to right.  Instead, we
173  *         compute with fewer bits and propagate the carry if necessary
174  *         when rounding the final digit up.  This is often faster.
175  *      3. Under the assumption that input will be rounded nearest,
176  *         mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
177  *         That is, we allow equality in stopping tests when the
178  *         round-nearest rule will give the same floating-point value
179  *         as would satisfaction of the stopping test with strict
180  *         inequality.
181  *      4. We remove common factors of powers of 2 from relevant
182  *         quantities.
183  *      5. When converting floating-point integers less than 1e16,
184  *         we use floating-point arithmetic rather than resorting
185  *         to multiple-precision integers.
186  *      6. When asked to produce fewer than 15 digits, we first try
187  *         to get by with floating-point arithmetic; we resort to
188  *         multiple-precision integer arithmetic only if we cannot
189  *         guarantee that the floating-point calculation has given
190  *         the correctly rounded result.  For k requested digits and
191  *         "uniformly" distributed input, the probability is
192  *         something like 10^(k-15) that we must resort to the long
193  *         calculation.
194  */
195
196
197 char *
198 _DEFUN (_dtoa_r,
199         (ptr, _d, mode, ndigits, decpt, sign, rve, float_type),
200         struct _Jv_reent *ptr _AND
201         double _d _AND
202         int mode _AND
203         int ndigits _AND
204         int *decpt _AND
205         int *sign _AND
206         char **rve _AND
207         int float_type)
208 {
209   /*
210         float_type == 0 for double precision, 1 for float.
211
212         Arguments ndigits, decpt, sign are similar to those
213         of ecvt and fcvt; trailing zeros are suppressed from
214         the returned string.  If not null, *rve is set to point
215         to the end of the return value.  If d is +-Infinity or NaN,
216         then *decpt is set to 9999.
217
218         mode:
219                 0 ==> shortest string that yields d when read in
220                         and rounded to nearest.
221                 1 ==> like 0, but with Steele & White stopping rule;
222                         e.g. with IEEE P754 arithmetic , mode 0 gives
223                         1e23 whereas mode 1 gives 9.999999999999999e22.
224                 2 ==> max(1,ndigits) significant digits.  This gives a
225                         return value similar to that of ecvt, except
226                         that trailing zeros are suppressed.
227                 3 ==> through ndigits past the decimal point.  This
228                         gives a return value similar to that from fcvt,
229                         except that trailing zeros are suppressed, and
230                         ndigits can be negative.
231                 4-9 should give the same return values as 2-3, i.e.,
232                         4 <= mode <= 9 ==> same return as mode
233                         2 + (mode & 1).  These modes are mainly for
234                         debugging; often they run slower but sometimes
235                         faster than modes 2-3.
236                 4,5,8,9 ==> left-to-right digit generation.
237                 6-9 ==> don't try fast floating-point estimate
238                         (if applicable).
239
240                 > 16 ==> Floating-point arg is treated as single precision.
241
242                 Values of mode other than 0-9 are treated as mode 0.
243
244                 Sufficient space is allocated to the return value
245                 to hold the suppressed trailing zeros.
246         */
247
248   int bbits, b2, b5, be, dig, i, ieps, ilim0, j, j1, k, k0,
249     k_check, leftright, m2, m5, s2, s5, try_quick;
250   int ilim = 0, ilim1 = 0, spec_case = 0;
251   union double_union d, d2, eps;
252   long L;
253 #ifndef Sudden_Underflow
254   int denorm;
255   unsigned long x;
256 #endif
257   _Jv_Bigint *b, *b1, *delta, *mlo = NULL, *mhi, *S;
258   double ds;
259   char *s, *s0;
260
261   d.d = _d;
262
263   if (ptr->_result)
264     {
265       ptr->_result->_k = ptr->_result_k;
266       ptr->_result->_maxwds = 1 << ptr->_result_k;
267       Bfree (ptr, ptr->_result);
268       ptr->_result = 0;
269     }
270
271   if (word0 (d) & Sign_bit)
272     {
273       /* set sign for everything, including 0's and NaNs */
274       *sign = 1;
275       word0 (d) &= ~Sign_bit;   /* clear sign bit */
276     }
277   else
278     *sign = 0;
279
280 #if defined(IEEE_Arith) + defined(VAX)
281 #ifdef IEEE_Arith
282   if ((word0 (d) & Exp_mask) == Exp_mask)
283 #else
284   if (word0 (d) == 0x8000)
285 #endif
286     {
287       /* Infinity or NaN */
288       *decpt = 9999;
289       s =
290 #ifdef IEEE_Arith
291         !word1 (d) && !(word0 (d) & 0xfffff) ? "Infinity" :
292 #endif
293         "NaN";
294       if (rve)
295         *rve =
296 #ifdef IEEE_Arith
297           s[3] ? s + 8 :
298 #endif
299           s + 3;
300       return s;
301     }
302 #endif
303 #ifdef IBM
304   d.d += 0;                     /* normalize */
305 #endif
306   if (!d.d)
307     {
308       *decpt = 1;
309       s = "0";
310       if (rve)
311         *rve = s + 1;
312       return s;
313     }
314
315   b = d2b (ptr, d.d, &be, &bbits);
316 #ifdef Sudden_Underflow
317   i = (int) (word0 (d) >> Exp_shift1 & (Exp_mask >> Exp_shift1));
318 #else
319   if ((i = (int) (word0 (d) >> Exp_shift1 & (Exp_mask >> Exp_shift1))))
320     {
321 #endif
322       d2.d = d.d;
323       word0 (d2) &= Frac_mask1;
324       word0 (d2) |= Exp_11;
325 #ifdef IBM
326       if (j = 11 - hi0bits (word0 (d2) & Frac_mask))
327         d2.d /= 1 << j;
328 #endif
329
330       /* log(x) ~=~ log(1.5) + (x-1.5)/1.5
331                  * log10(x)      =  log(x) / log(10)
332                  *              ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
333                  * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
334                  *
335                  * This suggests computing an approximation k to log10(d) by
336                  *
337                  * k = (i - Bias)*0.301029995663981
338                  *      + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
339                  *
340                  * We want k to be too large rather than too small.
341                  * The error in the first-order Taylor series approximation
342                  * is in our favor, so we just round up the constant enough
343                  * to compensate for any error in the multiplication of
344                  * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
345                  * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
346                  * adding 1e-13 to the constant term more than suffices.
347                  * Hence we adjust the constant term to 0.1760912590558.
348                  * (We could get a more accurate k by invoking log10,
349                  *  but this is probably not worthwhile.)
350                  */
351
352       i -= Bias;
353 #ifdef IBM
354       i <<= 2;
355       i += j;
356 #endif
357 #ifndef Sudden_Underflow
358       denorm = 0;
359     }
360   else
361     {
362       /* d is denormalized */
363
364       i = bbits + be + (Bias + (P - 1) - 1);
365       x = i > 32 ? word0 (d) << (64 - i) | word1 (d) >> (i - 32)
366         : word1 (d) << (32 - i);
367       d2.d = x;
368       word0 (d2) -= 31 * Exp_msk1;      /* adjust exponent */
369       i -= (Bias + (P - 1) - 1) + 1;
370       denorm = 1;
371     }
372 #endif
373   ds = (d2.d - 1.5) * 0.289529654602168 + 0.1760912590558 + i * 0.301029995663981;
374   k = (int) ds;
375   if (ds < 0. && ds != k)
376     k--;                        /* want k = floor(ds) */
377   k_check = 1;
378   if (k >= 0 && k <= Ten_pmax)
379     {
380       if (d.d < tens[k])
381         k--;
382       k_check = 0;
383     }
384   j = bbits - i - 1;
385   if (j >= 0)
386     {
387       b2 = 0;
388       s2 = j;
389     }
390   else
391     {
392       b2 = -j;
393       s2 = 0;
394     }
395   if (k >= 0)
396     {
397       b5 = 0;
398       s5 = k;
399       s2 += k;
400     }
401   else
402     {
403       b2 -= k;
404       b5 = -k;
405       s5 = 0;
406     }
407   if (mode < 0 || mode > 9)
408     mode = 0;
409   try_quick = 1;
410   if (mode > 5)
411     {
412       mode -= 4;
413       try_quick = 0;
414     }
415   leftright = 1;
416   switch (mode)
417     {
418     case 0:
419     case 1:
420       ilim = ilim1 = -1;
421       i = 18;
422       ndigits = 0;
423       break;
424     case 2:
425       leftright = 0;
426       /* no break */
427     case 4:
428       if (ndigits <= 0)
429         ndigits = 1;
430       ilim = ilim1 = i = ndigits;
431       break;
432     case 3:
433       leftright = 0;
434       /* no break */
435     case 5:
436       i = ndigits + k + 1;
437       ilim = i;
438       ilim1 = i - 1;
439       if (i <= 0)
440         i = 1;
441     }
442   j = sizeof (unsigned long);
443   for (ptr->_result_k = 0; (int) (sizeof (_Jv_Bigint) - sizeof (unsigned long)) + j <= i;
444        j <<= 1)
445     ptr->_result_k++;
446   ptr->_result = Balloc (ptr, ptr->_result_k);
447   s = s0 = (char *) ptr->_result;
448
449   if (ilim >= 0 && ilim <= Quick_max && try_quick)
450     {
451       /* Try to get by with floating-point arithmetic. */
452
453       i = 0;
454       d2.d = d.d;
455       k0 = k;
456       ilim0 = ilim;
457       ieps = 2;                 /* conservative */
458       if (k > 0)
459         {
460           ds = tens[k & 0xf];
461           j = k >> 4;
462           if (j & Bletch)
463             {
464               /* prevent overflows */
465               j &= Bletch - 1;
466               d.d /= bigtens[n_bigtens - 1];
467               ieps++;
468             }
469           for (; j; j >>= 1, i++)
470             if (j & 1)
471               {
472                 ieps++;
473                 ds *= bigtens[i];
474               }
475           d.d /= ds;
476         }
477       else if ((j1 = -k))
478         {
479           d.d *= tens[j1 & 0xf];
480           for (j = j1 >> 4; j; j >>= 1, i++)
481             if (j & 1)
482               {
483                 ieps++;
484                 d.d *= bigtens[i];
485               }
486         }
487       if (k_check && d.d < 1. && ilim > 0)
488         {
489           if (ilim1 <= 0)
490             goto fast_failed;
491           ilim = ilim1;
492           k--;
493           d.d *= 10.;
494           ieps++;
495         }
496       eps.d = ieps * d.d + 7.;
497       word0 (eps) -= (P - 1) * Exp_msk1;
498       if (ilim == 0)
499         {
500           S = mhi = 0;
501           d.d -= 5.;
502           if (d.d > eps.d)
503             goto one_digit;
504           if (d.d < -eps.d)
505             goto no_digits;
506           goto fast_failed;
507         }
508 #ifndef No_leftright
509       if (leftright)
510         {
511           /* Use Steele & White method of only
512            * generating digits needed.
513            */
514           eps.d = 0.5 / tens[ilim - 1] - eps.d;
515           for (i = 0;;)
516             {
517               L = d.d;
518               d.d -= L;
519               *s++ = '0' + (int) L;
520               if (d.d < eps.d)
521                 goto ret1;
522               if (1. - d.d < eps.d)
523                 goto bump_up;
524               if (++i >= ilim)
525                 break;
526               eps.d *= 10.;
527               d.d *= 10.;
528             }
529         }
530       else
531         {
532 #endif
533           /* Generate ilim digits, then fix them up. */
534           eps.d *= tens[ilim - 1];
535           for (i = 1;; i++, d.d *= 10.)
536             {
537               L = d.d;
538               d.d -= L;
539               *s++ = '0' + (int) L;
540               if (i == ilim)
541                 {
542                   if (d.d > 0.5 + eps.d)
543                     goto bump_up;
544                   else if (d.d < 0.5 - eps.d)
545                     {
546                       while (*--s == '0');
547                       s++;
548                       goto ret1;
549                     }
550                   break;
551                 }
552             }
553 #ifndef No_leftright
554         }
555 #endif
556     fast_failed:
557       s = s0;
558       d.d = d2.d;
559       k = k0;
560       ilim = ilim0;
561     }
562
563   /* Do we have a "small" integer? */
564
565   if (be >= 0 && k <= Int_max)
566     {
567       /* Yes. */
568       ds = tens[k];
569       if (ndigits < 0 && ilim <= 0)
570         {
571           S = mhi = 0;
572           if (ilim < 0 || d.d <= 5 * ds)
573             goto no_digits;
574           goto one_digit;
575         }
576       for (i = 1;; i++)
577         {
578           L = d.d / ds;
579           d.d -= L * ds;
580 #ifdef Check_FLT_ROUNDS
581           /* If FLT_ROUNDS == 2, L will usually be high by 1 */
582           if (d.d < 0)
583             {
584               L--;
585               d.d += ds;
586             }
587 #endif
588           *s++ = '0' + (int) L;
589           if (i == ilim)
590             {
591               d.d += d.d;
592               if (d.d > ds || (d.d == ds && L & 1))
593                 {
594                 bump_up:
595                   while (*--s == '9')
596                     if (s == s0)
597                       {
598                         k++;
599                         *s = '0';
600                         break;
601                       }
602                   ++*s++;
603                 }
604               break;
605             }
606           if (!(d.d *= 10.))
607             break;
608         }
609       goto ret1;
610     }
611
612   m2 = b2;
613   m5 = b5;
614   mhi = mlo = 0;
615   if (leftright)
616     {
617       if (mode < 2)
618         {
619           i =
620 #ifndef Sudden_Underflow
621             denorm ? be + (Bias + (P - 1) - 1 + 1) :
622 #endif
623 #ifdef IBM
624             1 + 4 * P - 3 - bbits + ((bbits + be - 1) & 3);
625 #else
626             1 + P - bbits;
627 #endif
628         }
629       else
630         {
631           j = ilim - 1;
632           if (m5 >= j)
633             m5 -= j;
634           else
635             {
636               s5 += j -= m5;
637               b5 += j;
638               m5 = 0;
639             }
640           if ((i = ilim) < 0)
641             {
642               m2 -= i;
643               i = 0;
644             }
645         }
646       b2 += i;
647       s2 += i;
648       mhi = i2b (ptr, 1);
649     }
650   if (m2 > 0 && s2 > 0)
651     {
652       i = m2 < s2 ? m2 : s2;
653       b2 -= i;
654       m2 -= i;
655       s2 -= i;
656     }
657   if (b5 > 0)
658     {
659       if (leftright)
660         {
661           if (m5 > 0)
662             {
663               mhi = pow5mult (ptr, mhi, m5);
664               b1 = mult (ptr, mhi, b);
665               Bfree (ptr, b);
666               b = b1;
667             }
668           if ((j = b5 - m5))
669             b = pow5mult (ptr, b, j);
670         }
671       else
672         b = pow5mult (ptr, b, b5);
673     }
674   S = i2b (ptr, 1);
675   if (s5 > 0)
676     S = pow5mult (ptr, S, s5);
677
678   /* Check for special case that d is a normalized power of 2. */
679
680   if (mode < 2)
681     {
682       if (!word1 (d) && !(word0 (d) & Bndry_mask)
683 #ifndef Sudden_Underflow
684           && word0(d) & Exp_mask
685 #endif
686         )
687         {
688           /* The special case */
689           b2 += Log2P;
690           s2 += Log2P;
691           spec_case = 1;
692         }
693       else
694         spec_case = 0;
695     }
696
697   /* Arrange for convenient computation of quotients:
698    * shift left if necessary so divisor has 4 leading 0 bits.
699    *
700    * Perhaps we should just compute leading 28 bits of S once
701    * and for all and pass them and a shift to quorem, so it
702    * can do shifts and ors to compute the numerator for q.
703    */
704
705 #ifdef Pack_32
706   if ((i = ((s5 ? 32 - hi0bits (S->_x[S->_wds - 1]) : 1) + s2) & 0x1f))
707     i = 32 - i;
708 #else
709   if ((i = ((s5 ? 32 - hi0bits (S->_x[S->_wds - 1]) : 1) + s2) & 0xf))
710     i = 16 - i;
711 #endif
712   if (i > 4)
713     {
714       i -= 4;
715       b2 += i;
716       m2 += i;
717       s2 += i;
718     }
719   else if (i < 4)
720     {
721       i += 28;
722       b2 += i;
723       m2 += i;
724       s2 += i;
725     }
726   if (b2 > 0)
727     b = lshift (ptr, b, b2);
728   if (s2 > 0)
729     S = lshift (ptr, S, s2);
730   if (k_check)
731     {
732       if (cmp (b, S) < 0)
733         {
734           k--;
735           b = multadd (ptr, b, 10, 0);  /* we botched the k estimate */
736           if (leftright)
737             mhi = multadd (ptr, mhi, 10, 0);
738           ilim = ilim1;
739         }
740     }
741   if (ilim <= 0 && mode > 2)
742     {
743       if (ilim < 0 || cmp (b, S = multadd (ptr, S, 5, 0)) <= 0)
744         {
745           /* no digits, fcvt style */
746         no_digits:
747           k = -1 - ndigits;
748           goto ret;
749         }
750     one_digit:
751       *s++ = '1';
752       k++;
753       goto ret;
754     }
755   if (leftright)
756     {
757       if (m2 > 0)
758         mhi = lshift (ptr, mhi, m2);
759
760       /* Single precision case, */
761       if (float_type)
762         mhi = lshift (ptr, mhi, 29);
763
764       /* Compute mlo -- check for special case
765        * that d is a normalized power of 2.
766        */
767
768       mlo = mhi;
769       if (spec_case)
770         {
771           mhi = Balloc (ptr, mhi->_k);
772           Bcopy (mhi, mlo);
773           mhi = lshift (ptr, mhi, Log2P);
774         }
775
776       for (i = 1;; i++)
777         {
778           dig = quorem (b, S) + '0';
779           /* Do we yet have the shortest decimal string
780            * that will round to d?
781            */
782           j = cmp (b, mlo);
783           delta = diff (ptr, S, mhi);
784           j1 = delta->_sign ? 1 : cmp (b, delta);
785           Bfree (ptr, delta);
786 #ifndef ROUND_BIASED
787           if (j1 == 0 && !mode && !(word1 (d) & 1))
788             {
789               if (dig == '9')
790                 goto round_9_up;
791               if (j > 0)
792                 dig++;
793               *s++ = dig;
794               goto ret;
795             }
796 #endif
797           if (j < 0 || (j == 0 && !mode
798 #ifndef ROUND_BIASED
799               && !(word1 (d) & 1)
800 #endif
801             ))
802             {
803               if (j1 > 0)
804                 {
805                   b = lshift (ptr, b, 1);
806                   j1 = cmp (b, S);
807                   if ((j1 > 0 || (j1 == 0 && dig & 1))
808                       && dig++ == '9')
809                     goto round_9_up;
810                 }
811               *s++ = dig;
812               goto ret;
813             }
814           if (j1 > 0)
815             {
816               if (dig == '9')
817                 {               /* possible if i == 1 */
818                 round_9_up:
819                   *s++ = '9';
820                   goto roundoff;
821                 }
822               *s++ = dig + 1;
823               goto ret;
824             }
825           *s++ = dig;
826           if (i == ilim)
827             break;
828           b = multadd (ptr, b, 10, 0);
829           if (mlo == mhi)
830             mlo = mhi = multadd (ptr, mhi, 10, 0);
831           else
832             {
833               mlo = multadd (ptr, mlo, 10, 0);
834               mhi = multadd (ptr, mhi, 10, 0);
835             }
836         }
837     }
838   else
839     for (i = 1;; i++)
840       {
841         *s++ = dig = quorem (b, S) + '0';
842         if (i >= ilim)
843           break;
844         b = multadd (ptr, b, 10, 0);
845       }
846
847   /* Round off last digit */
848
849   b = lshift (ptr, b, 1);
850   j = cmp (b, S);
851   if (j > 0 || (j == 0 && dig & 1))
852     {
853     roundoff:
854       while (*--s == '9')
855         if (s == s0)
856           {
857             k++;
858             *s++ = '1';
859             goto ret;
860           }
861       ++*s++;
862     }
863   else
864     {
865       while (*--s == '0');
866       s++;
867     }
868 ret:
869   Bfree (ptr, S);
870   if (mhi)
871     {
872       if (mlo && mlo != mhi)
873         Bfree (ptr, mlo);
874       Bfree (ptr, mhi);
875     }
876 ret1:
877   Bfree (ptr, b);
878   *s = 0;
879   *decpt = k + 1;
880   if (rve)
881     *rve = s;
882   return s0;
883 }
884
885
886 _VOID
887 _DEFUN (_dtoa,
888         (_d, mode, ndigits, decpt, sign, rve, buf, float_type),
889         double _d _AND
890         int mode _AND
891         int ndigits _AND
892         int *decpt _AND
893         int *sign _AND
894         char **rve _AND
895         char *buf _AND
896         int float_type)
897 {
898   struct _Jv_reent reent;
899   char *p;
900   memset (&reent, 0, sizeof reent);
901
902   p = _dtoa_r (&reent, _d, mode, ndigits, decpt, sign, rve, float_type);
903   strcpy (buf, p);
904
905   return;
906 }