File: | src/lib/libc/gdtoa/gdtoa.c |
Warning: | line 742, column 6 Value stored to 'inex' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
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 = ULbits32; |
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__Balloc_D2A(k); |
56 | if (b == NULL((void*)0)) |
57 | return (NULL((void*)0)); |
58 | be = bits + ((nbits - 1) >> kshift5); |
59 | x = x0 = b->x; |
60 | do { |
61 | *x++ = *bits & ALL_ON0xffffffff; |
62 | #ifdef Pack_16 |
63 | *x++ = (*bits >> 16) & ALL_ON0xffffffff; |
64 | #endif |
65 | } while(++bits <= be); |
66 | i = x - x0; |
67 | while(!x0[--i]) |
68 | if (!i) { |
69 | b->wds = 0; |
70 | *bbits = 0; |
71 | goto ret; |
72 | } |
73 | b->wds = i + 1; |
74 | *bbits = i*ULbits32 + 32 - hi0bits(b->x[i])__hi0bits_D2A((ULong)(b->x[i])); |
75 | ret: |
76 | return b; |
77 | } |
78 | |
79 | /* dtoa for IEEE arithmetic (dmg): convert double to ASCII string. |
80 | * |
81 | * Inspired by "How to Print Floating-Point Numbers Accurately" by |
82 | * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 112-126]. |
83 | * |
84 | * Modifications: |
85 | * 1. Rather than iterating, we use a simple numeric overestimate |
86 | * to determine k = floor(log10(d)). We scale relevant |
87 | * quantities using O(log2(k)) rather than O(k) multiplications. |
88 | * 2. For some modes > 2 (corresponding to ecvt and fcvt), we don't |
89 | * try to generate digits strictly left to right. Instead, we |
90 | * compute with fewer bits and propagate the carry if necessary |
91 | * when rounding the final digit up. This is often faster. |
92 | * 3. Under the assumption that input will be rounded nearest, |
93 | * mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22. |
94 | * That is, we allow equality in stopping tests when the |
95 | * round-nearest rule will give the same floating-point value |
96 | * as would satisfaction of the stopping test with strict |
97 | * inequality. |
98 | * 4. We remove common factors of powers of 2 from relevant |
99 | * quantities. |
100 | * 5. When converting floating-point integers less than 1e16, |
101 | * we use floating-point arithmetic rather than resorting |
102 | * to multiple-precision integers. |
103 | * 6. When asked to produce fewer than 15 digits, we first try |
104 | * to get by with floating-point arithmetic; we resort to |
105 | * multiple-precision integer arithmetic only if we cannot |
106 | * guarantee that the floating-point calculation has given |
107 | * the correctly rounded result. For k requested digits and |
108 | * "uniformly" distributed input, the probability is |
109 | * something like 10^(k-15) that we must resort to the Long |
110 | * calculation. |
111 | */ |
112 | |
113 | char * |
114 | gdtoa__gdtoa |
115 | #ifdef KR_headers |
116 | (fpi, be, bits, kindp, mode, ndigits, decpt, rve) |
117 | FPI *fpi; int be; ULong *bits; |
118 | int *kindp, mode, ndigits, *decpt; char **rve; |
119 | #else |
120 | (FPI *fpi, int be, ULong *bits, int *kindp, int mode, int ndigits, int *decpt, char **rve) |
121 | #endif |
122 | { |
123 | /* Arguments ndigits and decpt are similar to the second and third |
124 | arguments of ecvt and fcvt; trailing zeros are suppressed from |
125 | the returned string. If not null, *rve is set to point |
126 | to the end of the return value. If d is +-Infinity or NaN, |
127 | then *decpt is set to 9999. |
128 | be = exponent: value = (integer represented by bits) * (2 to the power of be). |
129 | |
130 | mode: |
131 | 0 ==> shortest string that yields d when read in |
132 | and rounded to nearest. |
133 | 1 ==> like 0, but with Steele & White stopping rule; |
134 | e.g. with IEEE P754 arithmetic , mode 0 gives |
135 | 1e23 whereas mode 1 gives 9.999999999999999e22. |
136 | 2 ==> max(1,ndigits) significant digits. This gives a |
137 | return value similar to that of ecvt, except |
138 | that trailing zeros are suppressed. |
139 | 3 ==> through ndigits past the decimal point. This |
140 | gives a return value similar to that from fcvt, |
141 | except that trailing zeros are suppressed, and |
142 | ndigits can be negative. |
143 | 4-9 should give the same return values as 2-3, i.e., |
144 | 4 <= mode <= 9 ==> same return as mode |
145 | 2 + (mode & 1). These modes are mainly for |
146 | debugging; often they run slower but sometimes |
147 | faster than modes 2-3. |
148 | 4,5,8,9 ==> left-to-right digit generation. |
149 | 6-9 ==> don't try fast floating-point estimate |
150 | (if applicable). |
151 | |
152 | Values of mode other than 0-9 are treated as mode 0. |
153 | |
154 | Sufficient space is allocated to the return value |
155 | to hold the suppressed trailing zeros. |
156 | */ |
157 | |
158 | int bbits, b2, b5, be0, dig, i, ieps, ilim, ilim0, ilim1, inex; |
159 | int j, j1, k, k0, k_check, kind, leftright, m2, m5, nbits; |
160 | int rdir, s2, s5, spec_case, try_quick; |
161 | Longint L; |
162 | Bigint *b, *b1, *delta, *mlo, *mhi, *mhi1, *S; |
163 | double d2, ds; |
164 | char *s, *s0; |
165 | U d, eps; |
166 | |
167 | #ifndef MULTIPLE_THREADS1 |
168 | if (dtoa_result__dtoa_result_D2A) { |
169 | freedtoa__freedtoa(dtoa_result__dtoa_result_D2A); |
170 | dtoa_result__dtoa_result_D2A = 0; |
171 | } |
172 | #endif |
173 | inex = 0; |
174 | kind = *kindp &= ~STRTOG_Inexact; |
175 | switch(kind & STRTOG_Retmask) { |
176 | case STRTOG_Zero: |
177 | goto ret_zero; |
178 | case STRTOG_Normal: |
179 | case STRTOG_Denormal: |
180 | break; |
181 | case STRTOG_Infinite: |
182 | *decpt = -32768; |
183 | return nrv_alloc__nrv_alloc_D2A("Infinity", rve, 8); |
184 | case STRTOG_NaN: |
185 | *decpt = -32768; |
186 | return nrv_alloc__nrv_alloc_D2A("NaN", rve, 3); |
187 | default: |
188 | return 0; |
189 | } |
190 | b = bitstob(bits, nbits = fpi->nbits, &bbits); |
191 | if (b == NULL((void*)0)) |
192 | return (NULL((void*)0)); |
193 | be0 = be; |
194 | if ( (i = trailz__trailz_D2A(b)) !=0) { |
195 | rshift__rshift_D2A(b, i); |
196 | be += i; |
197 | bbits -= i; |
198 | } |
199 | if (!b->wds) { |
200 | Bfree__Bfree_D2A(b); |
201 | ret_zero: |
202 | *decpt = 1; |
203 | return nrv_alloc__nrv_alloc_D2A("0", rve, 1); |
204 | } |
205 | |
206 | dval(&d)(&d)->d = b2d__b2d_D2A(b, &i); |
207 | i = be + bbits - 1; |
208 | word0(&d)(&d)->L[1] &= Frac_mask10xfffff; |
209 | word0(&d)(&d)->L[1] |= Exp_110x3ff00000; |
210 | #ifdef IBM |
211 | if ( (j = 11 - hi0bits(word0(&d) & Frac_mask)__hi0bits_D2A((ULong)((&d)->L[1] & 0xfffff))) !=0) |
212 | dval(&d)(&d)->d /= 1 << j; |
213 | #endif |
214 | |
215 | /* log(x) ~=~ log(1.5) + (x-1.5)/1.5 |
216 | * log10(x) = log(x) / log(10) |
217 | * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10)) |
218 | * log10(&d) = (i-Bias)*log(2)/log(10) + log10(d2) |
219 | * |
220 | * This suggests computing an approximation k to log10(&d) by |
221 | * |
222 | * k = (i - Bias)*0.301029995663981 |
223 | * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 ); |
224 | * |
225 | * We want k to be too large rather than too small. |
226 | * The error in the first-order Taylor series approximation |
227 | * is in our favor, so we just round up the constant enough |
228 | * to compensate for any error in the multiplication of |
229 | * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077, |
230 | * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14, |
231 | * adding 1e-13 to the constant term more than suffices. |
232 | * Hence we adjust the constant term to 0.1760912590558. |
233 | * (We could get a more accurate k by invoking log10, |
234 | * but this is probably not worthwhile.) |
235 | */ |
236 | #ifdef IBM |
237 | i <<= 2; |
238 | i += j; |
239 | #endif |
240 | ds = (dval(&d)(&d)->d-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981; |
241 | |
242 | /* correct assumption about exponent range */ |
243 | if ((j = i) < 0) |
244 | j = -j; |
245 | if ((j -= 1077) > 0) |
246 | ds += j * 7e-17; |
247 | |
248 | k = (int)ds; |
249 | if (ds < 0. && ds != k) |
250 | k--; /* want k = floor(ds) */ |
251 | k_check = 1; |
252 | #ifdef IBM |
253 | j = be + bbits - 1; |
254 | if ( (j1 = j & 3) !=0) |
255 | dval(&d)(&d)->d *= 1 << j1; |
256 | word0(&d)(&d)->L[1] += j << Exp_shift20 - 2 & Exp_mask0x7ff00000; |
257 | #else |
258 | word0(&d)(&d)->L[1] += (be + bbits - 1) << Exp_shift20; |
259 | #endif |
260 | if (k >= 0 && k <= Ten_pmax22) { |
261 | if (dval(&d)(&d)->d < tens__tens_D2A[k]) |
262 | k--; |
263 | k_check = 0; |
264 | } |
265 | j = bbits - i - 1; |
266 | if (j >= 0) { |
267 | b2 = 0; |
268 | s2 = j; |
269 | } |
270 | else { |
271 | b2 = -j; |
272 | s2 = 0; |
273 | } |
274 | if (k >= 0) { |
275 | b5 = 0; |
276 | s5 = k; |
277 | s2 += k; |
278 | } |
279 | else { |
280 | b2 -= k; |
281 | b5 = -k; |
282 | s5 = 0; |
283 | } |
284 | if (mode < 0 || mode > 9) |
285 | mode = 0; |
286 | try_quick = 1; |
287 | if (mode > 5) { |
288 | mode -= 4; |
289 | try_quick = 0; |
290 | } |
291 | else if (i >= -4 - Emin(-1022) || i < Emin(-1022)) |
292 | try_quick = 0; |
293 | leftright = 1; |
294 | ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */ |
295 | /* silence erroneous "gcc -Wall" warning. */ |
296 | switch(mode) { |
297 | case 0: |
298 | case 1: |
299 | i = (int)(nbits * .30103) + 3; |
300 | ndigits = 0; |
301 | break; |
302 | case 2: |
303 | leftright = 0; |
304 | /* no break */ |
305 | case 4: |
306 | if (ndigits <= 0) |
307 | ndigits = 1; |
308 | ilim = ilim1 = i = ndigits; |
309 | break; |
310 | case 3: |
311 | leftright = 0; |
312 | /* no break */ |
313 | case 5: |
314 | i = ndigits + k + 1; |
315 | ilim = i; |
316 | ilim1 = i - 1; |
317 | if (i <= 0) |
318 | i = 1; |
319 | } |
320 | s = s0 = rv_alloc__rv_alloc_D2A(i); |
321 | if (s == NULL((void*)0)) |
322 | return (NULL((void*)0)); |
323 | |
324 | if ( (rdir = fpi->rounding - 1) !=0) { |
325 | if (rdir < 0) |
326 | rdir = 2; |
327 | if (kind & STRTOG_Neg) |
328 | rdir = 3 - rdir; |
329 | } |
330 | |
331 | /* Now rdir = 0 ==> round near, 1 ==> round up, 2 ==> round down. */ |
332 | |
333 | if (ilim >= 0 && ilim <= Quick_max14 && try_quick && !rdir |
334 | #ifndef IMPRECISE_INEXACT |
335 | && k == 0 |
336 | #endif |
337 | ) { |
338 | |
339 | /* Try to get by with floating-point arithmetic. */ |
340 | |
341 | i = 0; |
342 | d2 = dval(&d)(&d)->d; |
343 | #ifdef IBM |
344 | if ( (j = 11 - hi0bits(word0(&d) & Frac_mask)__hi0bits_D2A((ULong)((&d)->L[1] & 0xfffff))) !=0) |
345 | dval(&d)(&d)->d /= 1 << j; |
346 | #endif |
347 | k0 = k; |
348 | ilim0 = ilim; |
349 | ieps = 2; /* conservative */ |
350 | if (k > 0) { |
351 | ds = tens__tens_D2A[k&0xf]; |
352 | j = k >> 4; |
353 | if (j & Bletch0x10) { |
354 | /* prevent overflows */ |
355 | j &= Bletch0x10 - 1; |
356 | dval(&d)(&d)->d /= bigtens__bigtens_D2A[n_bigtens5-1]; |
357 | ieps++; |
358 | } |
359 | for(; j; j >>= 1, i++) |
360 | if (j & 1) { |
361 | ieps++; |
362 | ds *= bigtens__bigtens_D2A[i]; |
363 | } |
364 | } |
365 | else { |
366 | ds = 1.; |
367 | if ( (j1 = -k) !=0) { |
368 | dval(&d)(&d)->d *= tens__tens_D2A[j1 & 0xf]; |
369 | for(j = j1 >> 4; j; j >>= 1, i++) |
370 | if (j & 1) { |
371 | ieps++; |
372 | dval(&d)(&d)->d *= bigtens__bigtens_D2A[i]; |
373 | } |
374 | } |
375 | } |
376 | if (k_check && dval(&d)(&d)->d < 1. && ilim > 0) { |
377 | if (ilim1 <= 0) |
378 | goto fast_failed; |
379 | ilim = ilim1; |
380 | k--; |
381 | dval(&d)(&d)->d *= 10.; |
382 | ieps++; |
383 | } |
384 | dval(&eps)(&eps)->d = ieps*dval(&d)(&d)->d + 7.; |
385 | word0(&eps)(&eps)->L[1] -= (P53-1)*Exp_msk10x100000; |
386 | if (ilim == 0) { |
387 | S = mhi = 0; |
388 | dval(&d)(&d)->d -= 5.; |
389 | if (dval(&d)(&d)->d > dval(&eps)(&eps)->d) |
390 | goto one_digit; |
391 | if (dval(&d)(&d)->d < -dval(&eps)(&eps)->d) |
392 | goto no_digits; |
393 | goto fast_failed; |
394 | } |
395 | #ifndef No_leftright |
396 | if (leftright) { |
397 | /* Use Steele & White method of only |
398 | * generating digits needed. |
399 | */ |
400 | dval(&eps)(&eps)->d = ds*0.5/tens__tens_D2A[ilim-1] - dval(&eps)(&eps)->d; |
401 | for(i = 0;;) { |
402 | L = (Longint)(dval(&d)(&d)->d/ds); |
403 | dval(&d)(&d)->d -= L*ds; |
404 | *s++ = '0' + (int)L; |
405 | if (dval(&d)(&d)->d < dval(&eps)(&eps)->d) { |
406 | if (dval(&d)(&d)->d) |
407 | inex = STRTOG_Inexlo; |
408 | goto ret1; |
409 | } |
410 | if (ds - dval(&d)(&d)->d < dval(&eps)(&eps)->d) |
411 | goto bump_up; |
412 | if (++i >= ilim) |
413 | break; |
414 | dval(&eps)(&eps)->d *= 10.; |
415 | dval(&d)(&d)->d *= 10.; |
416 | } |
417 | } |
418 | else { |
419 | #endif |
420 | /* Generate ilim digits, then fix them up. */ |
421 | dval(&eps)(&eps)->d *= tens__tens_D2A[ilim-1]; |
422 | for(i = 1;; i++, dval(&d)(&d)->d *= 10.) { |
423 | if ( (L = (Longint)(dval(&d)(&d)->d/ds)) !=0) |
424 | dval(&d)(&d)->d -= L*ds; |
425 | *s++ = '0' + (int)L; |
426 | if (i == ilim) { |
427 | ds *= 0.5; |
428 | if (dval(&d)(&d)->d > ds + dval(&eps)(&eps)->d) |
429 | goto bump_up; |
430 | else if (dval(&d)(&d)->d < ds - dval(&eps)(&eps)->d) { |
431 | if (dval(&d)(&d)->d) |
432 | inex = STRTOG_Inexlo; |
433 | goto clear_trailing0; |
434 | } |
435 | break; |
436 | } |
437 | } |
438 | #ifndef No_leftright |
439 | } |
440 | #endif |
441 | fast_failed: |
442 | s = s0; |
443 | dval(&d)(&d)->d = d2; |
444 | k = k0; |
445 | ilim = ilim0; |
446 | } |
447 | |
448 | /* Do we have a "small" integer? */ |
449 | |
450 | if (be >= 0 && k <= Int_max14) { |
451 | /* Yes. */ |
452 | ds = tens__tens_D2A[k]; |
453 | if (ndigits < 0 && ilim <= 0) { |
454 | S = mhi = 0; |
455 | if (ilim < 0 || dval(&d)(&d)->d <= 5*ds) |
456 | goto no_digits; |
457 | goto one_digit; |
458 | } |
459 | for(i = 1;; i++, dval(&d)(&d)->d *= 10.) { |
460 | L = dval(&d)(&d)->d / ds; |
461 | dval(&d)(&d)->d -= L*ds; |
462 | #ifdef Check_FLT_ROUNDS |
463 | /* If FLT_ROUNDS == 2, L will usually be high by 1 */ |
464 | if (dval(&d)(&d)->d < 0) { |
465 | L--; |
466 | dval(&d)(&d)->d += ds; |
467 | } |
468 | #endif |
469 | *s++ = '0' + (int)L; |
470 | if (dval(&d)(&d)->d == 0.) |
471 | break; |
472 | if (i == ilim) { |
473 | if (rdir) { |
474 | if (rdir == 1) |
475 | goto bump_up; |
476 | inex = STRTOG_Inexlo; |
477 | goto ret1; |
478 | } |
479 | dval(&d)(&d)->d += dval(&d)(&d)->d; |
480 | #ifdef ROUND_BIASED |
481 | if (dval(&d)(&d)->d >= ds) |
482 | #else |
483 | if (dval(&d)(&d)->d > ds || (dval(&d)(&d)->d == ds && L & 1)) |
484 | #endif |
485 | { |
486 | bump_up: |
487 | inex = STRTOG_Inexhi; |
488 | while(*--s == '9') |
489 | if (s == s0) { |
490 | k++; |
491 | *s = '0'; |
492 | break; |
493 | } |
494 | ++*s++; |
495 | } |
496 | else { |
497 | inex = STRTOG_Inexlo; |
498 | clear_trailing0: |
499 | while(*--s == '0'){} |
500 | ++s; |
501 | } |
502 | break; |
503 | } |
504 | } |
505 | goto ret1; |
506 | } |
507 | |
508 | m2 = b2; |
509 | m5 = b5; |
510 | mhi = mlo = 0; |
511 | if (leftright) { |
512 | i = nbits - bbits; |
513 | if (be - i++ < fpi->emin && mode != 3 && mode != 5) { |
514 | /* denormal */ |
515 | i = be - fpi->emin + 1; |
516 | if (mode >= 2 && ilim > 0 && ilim < i) |
517 | goto small_ilim; |
518 | } |
519 | else if (mode >= 2) { |
520 | small_ilim: |
521 | j = ilim - 1; |
522 | if (m5 >= j) |
523 | m5 -= j; |
524 | else { |
525 | s5 += j -= m5; |
526 | b5 += j; |
527 | m5 = 0; |
528 | } |
529 | if ((i = ilim) < 0) { |
530 | m2 -= i; |
531 | i = 0; |
532 | } |
533 | } |
534 | b2 += i; |
535 | s2 += i; |
536 | mhi = i2b__i2b_D2A(1); |
537 | if (mhi == NULL((void*)0)) |
538 | return (NULL((void*)0)); |
539 | } |
540 | if (m2 > 0 && s2 > 0) { |
541 | i = m2 < s2 ? m2 : s2; |
542 | b2 -= i; |
543 | m2 -= i; |
544 | s2 -= i; |
545 | } |
546 | if (b5 > 0) { |
547 | if (leftright) { |
548 | if (m5 > 0) { |
549 | mhi = pow5mult__pow5mult_D2A(mhi, m5); |
550 | if (mhi == NULL((void*)0)) |
551 | return (NULL((void*)0)); |
552 | b1 = mult__mult_D2A(mhi, b); |
553 | if (b1 == NULL((void*)0)) |
554 | return (NULL((void*)0)); |
555 | Bfree__Bfree_D2A(b); |
556 | b = b1; |
557 | } |
558 | if ( (j = b5 - m5) !=0) { |
559 | b = pow5mult__pow5mult_D2A(b, j); |
560 | if (b == NULL((void*)0)) |
561 | return (NULL((void*)0)); |
562 | } |
563 | } |
564 | else { |
565 | b = pow5mult__pow5mult_D2A(b, b5); |
566 | if (b == NULL((void*)0)) |
567 | return (NULL((void*)0)); |
568 | } |
569 | } |
570 | S = i2b__i2b_D2A(1); |
571 | if (S == NULL((void*)0)) |
572 | return (NULL((void*)0)); |
573 | if (s5 > 0) { |
574 | S = pow5mult__pow5mult_D2A(S, s5); |
575 | if (S == NULL((void*)0)) |
576 | return (NULL((void*)0)); |
577 | } |
578 | |
579 | /* Check for special case that d is a normalized power of 2. */ |
580 | |
581 | spec_case = 0; |
582 | if (mode < 2) { |
583 | if (bbits == 1 && be0 > fpi->emin + 1) { |
584 | /* The special case */ |
585 | b2++; |
586 | s2++; |
587 | spec_case = 1; |
588 | } |
589 | } |
590 | |
591 | /* Arrange for convenient computation of quotients: |
592 | * shift left if necessary so divisor has 4 leading 0 bits. |
593 | * |
594 | * Perhaps we should just compute leading 28 bits of S once |
595 | * and for all and pass them and a shift to quorem, so it |
596 | * can do shifts and ors to compute the numerator for q. |
597 | */ |
598 | i = ((s5 ? hi0bits(S->x[S->wds-1])__hi0bits_D2A((ULong)(S->x[S->wds-1])) : ULbits32 - 1) - s2 - 4) & kmask31; |
599 | m2 += i; |
600 | if ((b2 += i) > 0) { |
601 | b = lshift__lshift_D2A(b, b2); |
602 | if (b == NULL((void*)0)) |
603 | return (NULL((void*)0)); |
604 | } |
605 | if ((s2 += i) > 0) { |
606 | S = lshift__lshift_D2A(S, s2); |
607 | if (S == NULL((void*)0)) |
608 | return (NULL((void*)0)); |
609 | } |
610 | if (k_check) { |
611 | if (cmp__cmp_D2A(b,S) < 0) { |
612 | k--; |
613 | b = multadd__multadd_D2A(b, 10, 0); /* we botched the k estimate */ |
614 | if (b == NULL((void*)0)) |
615 | return (NULL((void*)0)); |
616 | if (leftright) { |
617 | mhi = multadd__multadd_D2A(mhi, 10, 0); |
618 | if (mhi == NULL((void*)0)) |
619 | return (NULL((void*)0)); |
620 | } |
621 | ilim = ilim1; |
622 | } |
623 | } |
624 | if (ilim <= 0 && mode > 2) { |
625 | S = multadd__multadd_D2A(S,5,0); |
626 | if (S == NULL((void*)0)) |
627 | return (NULL((void*)0)); |
628 | if (ilim < 0 || cmp__cmp_D2A(b,S) <= 0) { |
629 | /* no digits, fcvt style */ |
630 | no_digits: |
631 | k = -1 - ndigits; |
632 | inex = STRTOG_Inexlo; |
633 | goto ret; |
634 | } |
635 | one_digit: |
636 | inex = STRTOG_Inexhi; |
637 | *s++ = '1'; |
638 | k++; |
639 | goto ret; |
640 | } |
641 | if (leftright) { |
642 | if (m2 > 0) { |
643 | mhi = lshift__lshift_D2A(mhi, m2); |
644 | if (mhi == NULL((void*)0)) |
645 | return (NULL((void*)0)); |
646 | } |
647 | |
648 | /* Compute mlo -- check for special case |
649 | * that d is a normalized power of 2. |
650 | */ |
651 | |
652 | mlo = mhi; |
653 | if (spec_case) { |
654 | mhi = Balloc__Balloc_D2A(mhi->k); |
655 | if (mhi == NULL((void*)0)) |
656 | return (NULL((void*)0)); |
657 | Bcopy(mhi, mlo)memcpy(&mhi->sign,&mlo->sign,mlo->wds*sizeof (ULong) + 2*sizeof(int)); |
658 | mhi = lshift__lshift_D2A(mhi, 1); |
659 | if (mhi == NULL((void*)0)) |
660 | return (NULL((void*)0)); |
661 | } |
662 | |
663 | for(i = 1;;i++) { |
664 | dig = quorem__quorem_D2A(b,S) + '0'; |
665 | /* Do we yet have the shortest decimal string |
666 | * that will round to d? |
667 | */ |
668 | j = cmp__cmp_D2A(b, mlo); |
669 | delta = diff__diff_D2A(S, mhi); |
670 | if (delta == NULL((void*)0)) |
671 | return (NULL((void*)0)); |
672 | j1 = delta->sign ? 1 : cmp__cmp_D2A(b, delta); |
673 | Bfree__Bfree_D2A(delta); |
674 | #ifndef ROUND_BIASED |
675 | if (j1 == 0 && !mode && !(bits[0] & 1) && !rdir) { |
676 | if (dig == '9') |
677 | goto round_9_up; |
678 | if (j <= 0) { |
679 | if (b->wds > 1 || b->x[0]) |
680 | inex = STRTOG_Inexlo; |
681 | } |
682 | else { |
683 | dig++; |
684 | inex = STRTOG_Inexhi; |
685 | } |
686 | *s++ = dig; |
687 | goto ret; |
688 | } |
689 | #endif |
690 | if (j < 0 || (j == 0 && !mode |
691 | #ifndef ROUND_BIASED |
692 | && !(bits[0] & 1) |
693 | #endif |
694 | )) { |
695 | if (rdir && (b->wds > 1 || b->x[0])) { |
696 | if (rdir == 2) { |
697 | inex = STRTOG_Inexlo; |
698 | goto accept; |
699 | } |
700 | while (cmp__cmp_D2A(S,mhi) > 0) { |
701 | *s++ = dig; |
702 | mhi1 = multadd__multadd_D2A(mhi, 10, 0); |
703 | if (mhi1 == NULL((void*)0)) |
704 | return (NULL((void*)0)); |
705 | if (mlo == mhi) |
706 | mlo = mhi1; |
707 | mhi = mhi1; |
708 | b = multadd__multadd_D2A(b, 10, 0); |
709 | if (b == NULL((void*)0)) |
710 | return (NULL((void*)0)); |
711 | dig = quorem__quorem_D2A(b,S) + '0'; |
712 | } |
713 | if (dig++ == '9') |
714 | goto round_9_up; |
715 | inex = STRTOG_Inexhi; |
716 | goto accept; |
717 | } |
718 | if (j1 > 0) { |
719 | b = lshift__lshift_D2A(b, 1); |
720 | if (b == NULL((void*)0)) |
721 | return (NULL((void*)0)); |
722 | j1 = cmp__cmp_D2A(b, S); |
723 | #ifdef ROUND_BIASED |
724 | if (j1 >= 0 /*)*/ |
725 | #else |
726 | if ((j1 > 0 || (j1 == 0 && dig & 1)) |
727 | #endif |
728 | && dig++ == '9') |
729 | goto round_9_up; |
730 | inex = STRTOG_Inexhi; |
731 | } |
732 | if (b->wds > 1 || b->x[0]) |
733 | inex = STRTOG_Inexlo; |
734 | accept: |
735 | *s++ = dig; |
736 | goto ret; |
737 | } |
738 | if (j1 > 0 && rdir != 2) { |
739 | if (dig == '9') { /* possible if i == 1 */ |
740 | round_9_up: |
741 | *s++ = '9'; |
742 | inex = STRTOG_Inexhi; |
Value stored to 'inex' is never read | |
743 | goto roundoff; |
744 | } |
745 | inex = STRTOG_Inexhi; |
746 | *s++ = dig + 1; |
747 | goto ret; |
748 | } |
749 | *s++ = dig; |
750 | if (i == ilim) |
751 | break; |
752 | b = multadd__multadd_D2A(b, 10, 0); |
753 | if (b == NULL((void*)0)) |
754 | return (NULL((void*)0)); |
755 | if (mlo == mhi) { |
756 | mlo = mhi = multadd__multadd_D2A(mhi, 10, 0); |
757 | if (mlo == NULL((void*)0)) |
758 | return (NULL((void*)0)); |
759 | } |
760 | else { |
761 | mlo = multadd__multadd_D2A(mlo, 10, 0); |
762 | if (mlo == NULL((void*)0)) |
763 | return (NULL((void*)0)); |
764 | mhi = multadd__multadd_D2A(mhi, 10, 0); |
765 | if (mhi == NULL((void*)0)) |
766 | return (NULL((void*)0)); |
767 | } |
768 | } |
769 | } |
770 | else |
771 | for(i = 1;; i++) { |
772 | *s++ = dig = quorem__quorem_D2A(b,S) + '0'; |
773 | if (i >= ilim) |
774 | break; |
775 | b = multadd__multadd_D2A(b, 10, 0); |
776 | if (b == NULL((void*)0)) |
777 | return (NULL((void*)0)); |
778 | } |
779 | |
780 | /* Round off last digit */ |
781 | |
782 | if (rdir) { |
783 | if (rdir == 2 || (b->wds <= 1 && !b->x[0])) |
784 | goto chopzeros; |
785 | goto roundoff; |
786 | } |
787 | b = lshift__lshift_D2A(b, 1); |
788 | if (b == NULL((void*)0)) |
789 | return (NULL((void*)0)); |
790 | j = cmp__cmp_D2A(b, S); |
791 | #ifdef ROUND_BIASED |
792 | if (j >= 0) |
793 | #else |
794 | if (j > 0 || (j == 0 && dig & 1)) |
795 | #endif |
796 | { |
797 | roundoff: |
798 | inex = STRTOG_Inexhi; |
799 | while(*--s == '9') |
800 | if (s == s0) { |
801 | k++; |
802 | *s++ = '1'; |
803 | goto ret; |
804 | } |
805 | ++*s++; |
806 | } |
807 | else { |
808 | chopzeros: |
809 | if (b->wds > 1 || b->x[0]) |
810 | inex = STRTOG_Inexlo; |
811 | while(*--s == '0'){} |
812 | ++s; |
813 | } |
814 | ret: |
815 | Bfree__Bfree_D2A(S); |
816 | if (mhi) { |
817 | if (mlo && mlo != mhi) |
818 | Bfree__Bfree_D2A(mlo); |
819 | Bfree__Bfree_D2A(mhi); |
820 | } |
821 | ret1: |
822 | Bfree__Bfree_D2A(b); |
823 | *s = 0; |
824 | *decpt = k + 1; |
825 | if (rve) |
826 | *rve = s; |
827 | *kindp |= inex; |
828 | return s0; |
829 | } |
830 | DEF_STRONG(gdtoa)__asm__(".global " "__gdtoa" " ; " "__gdtoa" " = " "_libc___gdtoa" ); |