?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/i915: Update to Linux 4.6
[dragonfly.git] / contrib / gdtoa / gdtoa.c
blobe15bb2ad862ed0435961dd4f52cc4562e59f26b2
1 /****************************************************************
2
3 The author of this software is David M. Gay.
4
5 Copyright (C) 1998, 1999 by Lucent Technologies
6 All Rights Reserved
7
8 Permission to use, copy, modify, and distribute this software and
9 its documentation for any purpose and without fee is hereby
10 granted, provided that the above copyright notice appear in all
11 copies and that both that the copyright notice and this
12 permission notice and warranty disclaimer appear in supporting
13 documentation, and that the name of Lucent or any of its entities
14 not be used in advertising or publicity pertaining to
15 distribution of the software without specific, written prior
16 permission.
17
18 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
19 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
20 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
21 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
22 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
23 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
25 THIS SOFTWARE.
26
27 ****************************************************************/
28
29 /* Please send bug reports to David M. Gay (dmg at acm dot org,
30 * with " at " changed at "@" and " dot " changed to "."). */
31
32 #include "gdtoaimp.h"
33
34 static Bigint *
35 #ifdef KR_headers
36 bitstob(bits, nbits, bbits) ULong *bits; int nbits; int *bbits;
37 #else
38 bitstob(ULong *bits, int nbits, int *bbits)
39 #endif
40 {
41 int i, k;
42 Bigint *b;
43 ULong *be, *x, *x0;
44
45 i = ULbits;
46 k = 0;
47 while(i < nbits) {
48 i <<= 1;
49 k++;
50 }
51 #ifndef Pack_32
52 if (!k)
53 k = 1;
54 #endif
55 b = Balloc(k);
56 be = bits + ((nbits - 1) >> kshift);
57 x = x0 = b->x;
58 do {
59 *x++ = *bits & ALL_ON;
60 #ifdef Pack_16
61 *x++ = (*bits >> 16) & ALL_ON;
62 #endif
63 } while(++bits <= be);
64 i = x - x0;
65 while(!x0[--i])
66 if (!i) {
67 b->wds = 0;
68 *bbits = 0;
69 goto ret;
70 }
71 b->wds = i + 1;
72 *bbits = i*ULbits + 32 - hi0bits(b->x[i]);
73 ret:
74 return b;
75 }
76
77 /* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
78 *
79 * Inspired by "How to Print Floating-Point Numbers Accurately" by
80 * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 112-126].
81 *
82 * Modifications:
83 * 1. Rather than iterating, we use a simple numeric overestimate
84 * to determine k = floor(log10(d)). We scale relevant
85 * quantities using O(log2(k)) rather than O(k) multiplications.
86 * 2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
87 * try to generate digits strictly left to right. Instead, we
88 * compute with fewer bits and propagate the carry if necessary
89 * when rounding the final digit up. This is often faster.
90 * 3. Under the assumption that input will be rounded nearest,
91 * mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
92 * That is, we allow equality in stopping tests when the
93 * round-nearest rule will give the same floating-point value
94 * as would satisfaction of the stopping test with strict
95 * inequality.
96 * 4. We remove common factors of powers of 2 from relevant
97 * quantities.
98 * 5. When converting floating-point integers less than 1e16,
99 * we use floating-point arithmetic rather than resorting
100 * to multiple-precision integers.
101 * 6. When asked to produce fewer than 15 digits, we first try
102 * to get by with floating-point arithmetic; we resort to
103 * multiple-precision integer arithmetic only if we cannot
104 * guarantee that the floating-point calculation has given
105 * the correctly rounded result. For k requested digits and
106 * "uniformly" distributed input, the probability is
107 * something like 10^(k-15) that we must resort to the Long
108 * calculation.
109 */
110
111 char *
112 gdtoa
113 #ifdef KR_headers
114 (fpi, be, bits, kindp, mode, ndigits, decpt, rve)
115 FPI *fpi; int be; ULong *bits;
116 int *kindp, mode, ndigits, *decpt; char **rve;
117 #else
118 (FPI *fpi, int be, ULong *bits, int *kindp, int mode, int ndigits, int *decpt, char **rve)
119 #endif
120 {
121 /* Arguments ndigits and decpt are similar to the second and third
122 arguments of ecvt and fcvt; trailing zeros are suppressed from
123 the returned string. If not null, *rve is set to point
124 to the end of the return value. If d is +-Infinity or NaN,
125 then *decpt is set to 9999.
126 be = exponent: value = (integer represented by bits) * (2 to the power of be).
127
128 mode:
129 0 ==> shortest string that yields d when read in
130 and rounded to nearest.
131 1 ==> like 0, but with Steele & White stopping rule;
132 e.g. with IEEE P754 arithmetic , mode 0 gives
133 1e23 whereas mode 1 gives 9.999999999999999e22.
134 2 ==> max(1,ndigits) significant digits. This gives a
135 return value similar to that of ecvt, except
136 that trailing zeros are suppressed.
137 3 ==> through ndigits past the decimal point. This
138 gives a return value similar to that from fcvt,
139 except that trailing zeros are suppressed, and
140 ndigits can be negative.
141 4-9 should give the same return values as 2-3, i.e.,
142 4 <= mode <= 9 ==> same return as mode
143 2 + (mode & 1). These modes are mainly for
144 debugging; often they run slower but sometimes
145 faster than modes 2-3.
146 4,5,8,9 ==> left-to-right digit generation.
147 6-9 ==> don't try fast floating-point estimate
148 (if applicable).
149
150 Values of mode other than 0-9 are treated as mode 0.
151
152 Sufficient space is allocated to the return value
153 to hold the suppressed trailing zeros.
154 */
155
156 int bbits, b2, b5, be0, dig, i, ieps, ilim, ilim0, ilim1, inex;
157 int j, j1, k, k0, k_check, kind, leftright, m2, m5, nbits;
158 int rdir, s2, s5, spec_case, try_quick;
159 Long L;
160 Bigint *b, *b1, *delta, *mlo, *mhi, *mhi1, *S;
161 double d2, ds;
162 char *s, *s0;
163 U d, eps;
164
165 #ifndef MULTIPLE_THREADS
166 if (dtoa_result) {
167 freedtoa(dtoa_result);
168 dtoa_result = 0;
169 }
170 #endif
171 inex = 0;
172 kind = *kindp &= ~STRTOG_Inexact;
173 switch(kind & STRTOG_Retmask) {
174 case STRTOG_Zero:
175 goto ret_zero;
176 case STRTOG_Normal:
177 case STRTOG_Denormal:
178 break;
179 case STRTOG_Infinite:
180 *decpt = -32768;
181 return nrv_alloc("Infinity", rve, 8);
182 case STRTOG_NaN:
183 *decpt = -32768;
184 return nrv_alloc("NaN", rve, 3);
185 default:
186 return 0;
187 }
188 b = bitstob(bits, nbits = fpi->nbits, &bbits);
189 be0 = be;
190 if ( (i = trailz(b)) !=0) {
191 rshift(b, i);
192 be += i;
193 bbits -= i;
194 }
195 if (!b->wds) {
196 Bfree(b);
197 ret_zero:
198 *decpt = 1;
199 return nrv_alloc("0", rve, 1);
200 }
201
202 dval(&d) = b2d(b, &i);
203 i = be + bbits - 1;
204 word0(&d) &= Frac_mask1;
205 word0(&d) |= Exp_11;
206 #ifdef IBM
207 if ( (j = 11 - hi0bits(word0(&d) & Frac_mask)) !=0)
208 dval(&d) /= 1 << j;
209 #endif
210
211 /* log(x) ~=~ log(1.5) + (x-1.5)/1.5
212 * log10(x) = log(x) / log(10)
213 * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
214 * log10(&d) = (i-Bias)*log(2)/log(10) + log10(d2)
215 *
216 * This suggests computing an approximation k to log10(&d) by
217 *
218 * k = (i - Bias)*0.301029995663981
219 * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
220 *
221 * We want k to be too large rather than too small.
222 * The error in the first-order Taylor series approximation
223 * is in our favor, so we just round up the constant enough
224 * to compensate for any error in the multiplication of
225 * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
226 * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
227 * adding 1e-13 to the constant term more than suffices.
228 * Hence we adjust the constant term to 0.1760912590558.
229 * (We could get a more accurate k by invoking log10,
230 * but this is probably not worthwhile.)
231 */
232 #ifdef IBM
233 i <<= 2;
234 i += j;
235 #endif
236 ds = (dval(&d)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
237
238 /* correct assumption about exponent range */
239 if ((j = i) < 0)
240 j = -j;
241 if ((j -= 1077) > 0)
242 ds += j * 7e-17;
243
244 k = (int)ds;
245 if (ds < 0. && ds != k)
246 k--; /* want k = floor(ds) */
247 k_check = 1;
248 #ifdef IBM
249 j = be + bbits - 1;
250 if ( (j1 = j & 3) !=0)
251 dval(&d) *= 1 << j1;
252 word0(&d) += j << Exp_shift - 2 & Exp_mask;
253 #else
254 word0(&d) += (be + bbits - 1) << Exp_shift;
255 #endif
256 if (k >= 0 && k <= Ten_pmax) {
257 if (dval(&d) < tens[k])
258 k--;
259 k_check = 0;
260 }
261 j = bbits - i - 1;
262 if (j >= 0) {
263 b2 = 0;
264 s2 = j;
265 }
266 else {
267 b2 = -j;
268 s2 = 0;
269 }
270 if (k >= 0) {
271 b5 = 0;
272 s5 = k;
273 s2 += k;
274 }
275 else {
276 b2 -= k;
277 b5 = -k;
278 s5 = 0;
279 }
280 if (mode < 0 || mode > 9)
281 mode = 0;
282 try_quick = 1;
283 if (mode > 5) {
284 mode -= 4;
285 try_quick = 0;
286 }
287 else if (i >= -4 - Emin || i < Emin)
288 try_quick = 0;
289 leftright = 1;
290 ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */
291 /* silence erroneous "gcc -Wall" warning. */
292 switch(mode) {
293 case 0:
294 case 1:
295 i = (int)(nbits * .30103) + 3;
296 ndigits = 0;
297 break;
298 case 2:
299 leftright = 0;
300 /* no break */
301 case 4:
302 if (ndigits <= 0)
303 ndigits = 1;
304 ilim = ilim1 = i = ndigits;
305 break;
306 case 3:
307 leftright = 0;
308 /* no break */
309 case 5:
310 i = ndigits + k + 1;
311 ilim = i;
312 ilim1 = i - 1;
313 if (i <= 0)
314 i = 1;
315 }
316 s = s0 = rv_alloc(i);
317
318 if ( (rdir = fpi->rounding - 1) !=0) {
319 if (rdir < 0)
320 rdir = 2;
321 if (kind & STRTOG_Neg)
322 rdir = 3 - rdir;
323 }
324
325 /* Now rdir = 0 ==> round near, 1 ==> round up, 2 ==> round down. */
326
327 if (ilim >= 0 && ilim <= Quick_max && try_quick && !rdir
328 #ifndef IMPRECISE_INEXACT
329 && k == 0
330 #endif
331 ) {
332
333 /* Try to get by with floating-point arithmetic. */
334
335 i = 0;
336 d2 = dval(&d);
337 #ifdef IBM
338 if ( (j = 11 - hi0bits(word0(&d) & Frac_mask)) !=0)
339 dval(&d) /= 1 << j;
340 #endif
341 k0 = k;
342 ilim0 = ilim;
343 ieps = 2; /* conservative */
344 if (k > 0) {
345 ds = tens[k&0xf];
346 j = k >> 4;
347 if (j & Bletch) {
348 /* prevent overflows */
349 j &= Bletch - 1;
350 dval(&d) /= bigtens[n_bigtens-1];
351 ieps++;
352 }
353 for(; j; j >>= 1, i++)
354 if (j & 1) {
355 ieps++;
356 ds *= bigtens[i];
357 }
358 }
359 else {
360 ds = 1.;
361 if ( (j1 = -k) !=0) {
362 dval(&d) *= tens[j1 & 0xf];
363 for(j = j1 >> 4; j; j >>= 1, i++)
364 if (j & 1) {
365 ieps++;
366 dval(&d) *= bigtens[i];
367 }
368 }
369 }
370 if (k_check && dval(&d) < 1. && ilim > 0) {
371 if (ilim1 <= 0)
372 goto fast_failed;
373 ilim = ilim1;
374 k--;
375 dval(&d) *= 10.;
376 ieps++;
377 }
378 dval(&eps) = ieps*dval(&d) + 7.;
379 word0(&eps) -= (P-1)*Exp_msk1;
380 if (ilim == 0) {
381 S = mhi = 0;
382 dval(&d) -= 5.;
383 if (dval(&d) > dval(&eps))
384 goto one_digit;
385 if (dval(&d) < -dval(&eps))
386 goto no_digits;
387 goto fast_failed;
388 }
389 #ifndef No_leftright
390 if (leftright) {
391 /* Use Steele & White method of only
392 * generating digits needed.
393 */
394 dval(&eps) = ds*0.5/tens[ilim-1] - dval(&eps);
395 for(i = 0;;) {
396 L = (Long)(dval(&d)/ds);
397 dval(&d) -= L*ds;
398 *s++ = '0' + (int)L;
399 if (dval(&d) < dval(&eps)) {
400 if (dval(&d))
401 inex = STRTOG_Inexlo;
402 goto ret1;
403 }
404 if (ds - dval(&d) < dval(&eps))
405 goto bump_up;
406 if (++i >= ilim)
407 break;
408 dval(&eps) *= 10.;
409 dval(&d) *= 10.;
410 }
411 }
412 else {
413 #endif
414 /* Generate ilim digits, then fix them up. */
415 dval(&eps) *= tens[ilim-1];
416 for(i = 1;; i++, dval(&d) *= 10.) {
417 if ( (L = (Long)(dval(&d)/ds)) !=0)
418 dval(&d) -= L*ds;
419 *s++ = '0' + (int)L;
420 if (i == ilim) {
421 ds *= 0.5;
422 if (dval(&d) > ds + dval(&eps))
423 goto bump_up;
424 else if (dval(&d) < ds - dval(&eps)) {
425 if (dval(&d))
426 inex = STRTOG_Inexlo;
427 goto clear_trailing0;
428 }
429 break;
430 }
431 }
432 #ifndef No_leftright
433 }
434 #endif
435 fast_failed:
436 s = s0;
437 dval(&d) = d2;
438 k = k0;
439 ilim = ilim0;
440 }
441
442 /* Do we have a "small" integer? */
443
444 if (be >= 0 && k <= Int_max) {
445 /* Yes. */
446 ds = tens[k];
447 if (ndigits < 0 && ilim <= 0) {
448 S = mhi = 0;
449 if (ilim < 0 || dval(&d) <= 5*ds)
450 goto no_digits;
451 goto one_digit;
452 }
453 for(i = 1;; i++, dval(&d) *= 10.) {
454 L = dval(&d) / ds;
455 dval(&d) -= L*ds;
456 #ifdef Check_FLT_ROUNDS
457 /* If FLT_ROUNDS == 2, L will usually be high by 1 */
458 if (dval(&d) < 0) {
459 L--;
460 dval(&d) += ds;
461 }
462 #endif
463 *s++ = '0' + (int)L;
464 if (dval(&d) == 0.)
465 break;
466 if (i == ilim) {
467 if (rdir) {
468 if (rdir == 1)
469 goto bump_up;
470 inex = STRTOG_Inexlo;
471 goto ret1;
472 }
473 dval(&d) += dval(&d);
474 #ifdef ROUND_BIASED
475 if (dval(&d) >= ds)
476 #else
477 if (dval(&d) > ds || (dval(&d) == ds && L & 1))
478 #endif
479 {
480 bump_up:
481 inex = STRTOG_Inexhi;
482 while(*--s == '9')
483 if (s == s0) {
484 k++;
485 *s = '0';
486 break;
487 }
488 ++*s++;
489 }
490 else {
491 inex = STRTOG_Inexlo;
492 clear_trailing0:
493 while(*--s == '0'){}
494 ++s;
495 }
496 break;
497 }
498 }
499 goto ret1;
500 }
501
502 m2 = b2;
503 m5 = b5;
504 mhi = mlo = 0;
505 if (leftright) {
506 i = nbits - bbits;
507 if (be - i++ < fpi->emin && mode != 3 && mode != 5) {
508 /* denormal */
509 i = be - fpi->emin + 1;
510 if (mode >= 2 && ilim > 0 && ilim < i)
511 goto small_ilim;
512 }
513 else if (mode >= 2) {
514 small_ilim:
515 j = ilim - 1;
516 if (m5 >= j)
517 m5 -= j;
518 else {
519 s5 += j -= m5;
520 b5 += j;
521 m5 = 0;
522 }
523 if ((i = ilim) < 0) {
524 m2 -= i;
525 i = 0;
526 }
527 }
528 b2 += i;
529 s2 += i;
530 mhi = i2b(1);
531 }
532 if (m2 > 0 && s2 > 0) {
533 i = m2 < s2 ? m2 : s2;
534 b2 -= i;
535 m2 -= i;
536 s2 -= i;
537 }
538 if (b5 > 0) {
539 if (leftright) {
540 if (m5 > 0) {
541 mhi = pow5mult(mhi, m5);
542 b1 = mult(mhi, b);
543 Bfree(b);
544 b = b1;
545 }
546 if ( (j = b5 - m5) !=0)
547 b = pow5mult(b, j);
548 }
549 else
550 b = pow5mult(b, b5);
551 }
552 S = i2b(1);
553 if (s5 > 0)
554 S = pow5mult(S, s5);
555
556 /* Check for special case that d is a normalized power of 2. */
557
558 spec_case = 0;
559 if (mode < 2) {
560 if (bbits == 1 && be0 > fpi->emin + 1) {
561 /* The special case */
562 b2++;
563 s2++;
564 spec_case = 1;
565 }
566 }
567
568 /* Arrange for convenient computation of quotients:
569 * shift left if necessary so divisor has 4 leading 0 bits.
570 *
571 * Perhaps we should just compute leading 28 bits of S once
572 * and for all and pass them and a shift to quorem, so it
573 * can do shifts and ors to compute the numerator for q.
574 */
575 i = ((s5 ? hi0bits(S->x[S->wds-1]) : ULbits - 1) - s2 - 4) & kmask;
576 m2 += i;
577 if ((b2 += i) > 0)
578 b = lshift(b, b2);
579 if ((s2 += i) > 0)
580 S = lshift(S, s2);
581 if (k_check) {
582 if (cmp(b,S) < 0) {
583 k--;
584 b = multadd(b, 10, 0); /* we botched the k estimate */
585 if (leftright)
586 mhi = multadd(mhi, 10, 0);
587 ilim = ilim1;
588 }
589 }
590 if (ilim <= 0 && mode > 2) {
591 if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) {
592 /* no digits, fcvt style */
593 no_digits:
594 k = -1 - ndigits;
595 inex = STRTOG_Inexlo;
596 goto ret;
597 }
598 one_digit:
599 inex = STRTOG_Inexhi;
600 *s++ = '1';
601 k++;
602 goto ret;
603 }
604 if (leftright) {
605 if (m2 > 0)
606 mhi = lshift(mhi, m2);
607
608 /* Compute mlo -- check for special case
609 * that d is a normalized power of 2.
610 */
611
612 mlo = mhi;
613 if (spec_case) {
614 mhi = Balloc(mhi->k);
615 Bcopy(mhi, mlo);
616 mhi = lshift(mhi, 1);
617 }
618
619 for(i = 1;;i++) {
620 dig = quorem(b,S) + '0';
621 /* Do we yet have the shortest decimal string
622 * that will round to d?
623 */
624 j = cmp(b, mlo);
625 delta = diff(S, mhi);
626 j1 = delta->sign ? 1 : cmp(b, delta);
627 Bfree(delta);
628 #ifndef ROUND_BIASED
629 if (j1 == 0 && !mode && !(bits[0] & 1) && !rdir) {
630 if (dig == '9')
631 goto round_9_up;
632 if (j <= 0) {
633 if (b->wds > 1 || b->x[0])
634 inex = STRTOG_Inexlo;
635 }
636 else {
637 dig++;
638 inex = STRTOG_Inexhi;
639 }
640 *s++ = dig;
641 goto ret;
642 }
643 #endif
644 if (j < 0 || (j == 0 && !mode
645 #ifndef ROUND_BIASED
646 && !(bits[0] & 1)
647 #endif
648 )) {
649 if (rdir && (b->wds > 1 || b->x[0])) {
650 if (rdir == 2) {
651 inex = STRTOG_Inexlo;
652 goto accept;
653 }
654 while (cmp(S,mhi) > 0) {
655 *s++ = dig;
656 mhi1 = multadd(mhi, 10, 0);
657 if (mlo == mhi)
658 mlo = mhi1;
659 mhi = mhi1;
660 b = multadd(b, 10, 0);
661 dig = quorem(b,S) + '0';
662 }
663 if (dig++ == '9')
664 goto round_9_up;
665 inex = STRTOG_Inexhi;
666 goto accept;
667 }
668 if (j1 > 0) {
669 b = lshift(b, 1);
670 j1 = cmp(b, S);
671 #ifdef ROUND_BIASED
672 if (j1 >= 0 /*)*/
673 #else
674 if ((j1 > 0 || (j1 == 0 && dig & 1))
675 #endif
676 && dig++ == '9')
677 goto round_9_up;
678 inex = STRTOG_Inexhi;
679 }
680 if (b->wds > 1 || b->x[0])
681 inex = STRTOG_Inexlo;
682 accept:
683 *s++ = dig;
684 goto ret;
685 }
686 if (j1 > 0 && rdir != 2) {
687 if (dig == '9') { /* possible if i == 1 */
688 round_9_up:
689 *s++ = '9';
690 inex = STRTOG_Inexhi;
691 goto roundoff;
692 }
693 inex = STRTOG_Inexhi;
694 *s++ = dig + 1;
695 goto ret;
696 }
697 *s++ = dig;
698 if (i == ilim)
699 break;
700 b = multadd(b, 10, 0);
701 if (mlo == mhi)
702 mlo = mhi = multadd(mhi, 10, 0);
703 else {
704 mlo = multadd(mlo, 10, 0);
705 mhi = multadd(mhi, 10, 0);
706 }
707 }
708 }
709 else
710 for(i = 1;; i++) {
711 *s++ = dig = quorem(b,S) + '0';
712 if (i >= ilim)
713 break;
714 b = multadd(b, 10, 0);
715 }
716
717 /* Round off last digit */
718
719 if (rdir) {
720 if (rdir == 2 || (b->wds <= 1 && !b->x[0]))
721 goto chopzeros;
722 goto roundoff;
723 }
724 b = lshift(b, 1);
725 j = cmp(b, S);
726 #ifdef ROUND_BIASED
727 if (j >= 0)
728 #else
729 if (j > 0 || (j == 0 && dig & 1))
730 #endif
731 {
732 roundoff:
733 inex = STRTOG_Inexhi;
734 while(*--s == '9')
735 if (s == s0) {
736 k++;
737 *s++ = '1';
738 goto ret;
739 }
740 ++*s++;
741 }
742 else {
743 chopzeros:
744 if (b->wds > 1 || b->x[0])
745 inex = STRTOG_Inexlo;
746 while(*--s == '0'){}
747 ++s;
748 }
749 ret:
750 Bfree(S);
751 if (mhi) {
752 if (mlo && mlo != mhi)
753 Bfree(mlo);
754 Bfree(mhi);
755 }
756 ret1:
757 Bfree(b);
758 *s = 0;
759 *decpt = k + 1;
760 if (rve)
761 *rve = s;
762 *kindp |= inex;
763 return s0;
764 }
DragonFly BSD