1 /* Floating point output for `printf'.
2 Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Library General Public License for more details.
16 You should have received a copy of the GNU Library General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If not,
18 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* The gmp headers need some configuration frobs. */
32 #include <gmp-mparam.h>
34 #include <stdlib/gmp-impl.h>
35 #include <stdlib/longlong.h>
36 #include <stdlib/fpioconst.h>
37 #include <locale/localeinfo.h>
47 # define NDEBUG /* Undefine this for debugging assertions. */
51 /* This defines make it possible to use the same code for GNU C library and
52 the GNU I/O library. */
54 # define PUT(f, s, n) _IO_sputn (f, s, n)
55 # define PAD(f, c, n) (wide ? _IO_wpadn (f, c, n) : _IO_padn (f, c, n))
56 /* We use this file GNU C library and GNU I/O library. So make
59 # define putc(c, f) (wide \
60 ? (int)_IO_putwc_unlocked (c, f) : _IO_putc_unlocked (c, f))
61 # define size_t _IO_size_t
62 # define FILE _IO_FILE
63 #else /* ! USE_IN_LIBIO */
64 # define PUT(f, s, n) fwrite (s, 1, n, f)
65 # define PAD(f, c, n) __printf_pad (f, c, n)
66 ssize_t __printf_pad
__P ((FILE *, char pad
, int n
)); /* In vfprintf.c. */
67 #endif /* USE_IN_LIBIO */
69 /* Macros for doing the actual output. */
74 register const int outc = (ch); \
75 if (putc (outc, fp) == EOF) \
80 #define PRINT(ptr, wptr, len) \
83 register size_t outlen = (len); \
86 if (PUT (fp, wide ? (const char *) wptr : ptr, outlen) != outlen) \
94 while (outlen-- > 0) \
97 while (outlen-- > 0) \
102 #define PADN(ch, len) \
105 if (PAD (fp, ch, len) != len) \
111 /* We use the GNU MP library to handle large numbers.
113 An MP variable occupies a varying number of entries in its array. We keep
114 track of this number for efficiency reasons. Otherwise we would always
115 have to process the whole array. */
116 #define MPN_VAR(name) mp_limb_t *name; mp_size_t name##size
118 #define MPN_ASSIGN(dst,src) \
119 memcpy (dst, src, (dst##size = src##size) * sizeof (mp_limb_t))
120 #define MPN_GE(u,v) \
121 (u##size > v##size || (u##size == v##size && __mpn_cmp (u, v, u##size) >= 0))
123 extern int __isinfl (long double), __isnanl (long double);
125 extern mp_size_t
__mpn_extract_double (mp_ptr res_ptr
, mp_size_t size
,
126 int *expt
, int *is_neg
,
128 extern mp_size_t
__mpn_extract_long_double (mp_ptr res_ptr
, mp_size_t size
,
129 int *expt
, int *is_neg
,
131 extern unsigned int __guess_grouping (unsigned int intdig_max
,
132 const char *grouping
);
135 static wchar_t *group_number (wchar_t *buf
, wchar_t *bufend
,
136 unsigned int intdig_no
, const char *grouping
,
137 wchar_t thousands_sep
, int ngroups
)
142 __printf_fp (FILE *fp
,
143 const struct printf_info
*info
,
144 const void *const *args
)
146 /* The floating-point value to output. */
150 __long_double_t ldbl
;
154 /* Locale-dependent representation of decimal point. */
158 /* Locale-dependent thousands separator and grouping specification. */
159 const char *thousands_sep
= NULL
;
160 wchar_t thousands_sepwc
= 0;
161 const char *grouping
;
163 /* "NaN" or "Inf" for the special cases. */
164 const char *special
= NULL
;
165 const wchar_t *wspecial
= NULL
;
167 /* We need just a few limbs for the input before shifting to the right
169 mp_limb_t fp_input
[(LDBL_MANT_DIG
+ BITS_PER_MP_LIMB
- 1) / BITS_PER_MP_LIMB
];
170 /* We need to shift the contents of fp_input by this amount of bits. */
173 /* The fraction of the floting-point value in question */
175 /* and the exponent. */
177 /* Sign of the exponent. */
179 /* Sign of float number. */
182 /* Scaling factor. */
185 /* Temporary bignum value. */
188 /* Digit which is result of last hack_digit() call. */
191 /* The type of output format that will be used: 'e'/'E' or 'f'. */
194 /* Counter for number of written characters. */
197 /* General helper (carry limb). */
200 /* Nonzero if this is output on a wide character stream. */
201 int wide
= info
->wide
;
203 auto wchar_t hack_digit (void);
205 wchar_t hack_digit (void)
209 if (expsign
!= 0 && type
== 'f' && exponent
-- > 0)
211 else if (scalesize
== 0)
213 hi
= frac
[fracsize
- 1];
214 cy
= __mpn_mul_1 (frac
, frac
, fracsize
- 1, 10);
215 frac
[fracsize
- 1] = cy
;
219 if (fracsize
< scalesize
)
223 hi
= mpn_divmod (tmp
, frac
, fracsize
, scale
, scalesize
);
224 tmp
[fracsize
- scalesize
] = hi
;
227 fracsize
= scalesize
;
228 while (fracsize
!= 0 && frac
[fracsize
- 1] == 0)
232 /* We're not prepared for an mpn variable with zero
239 cy
= __mpn_mul_1 (frac
, frac
, fracsize
, 10);
241 frac
[fracsize
++] = cy
;
248 /* Figure out the decimal point character. */
249 if (info
->extra
== 0)
251 decimal
= _NL_CURRENT (LC_NUMERIC
, DECIMAL_POINT
);
252 decimalwc
= _NL_CURRENT_WORD (LC_NUMERIC
, _NL_NUMERIC_DECIMAL_POINT_WC
);
256 decimal
= _NL_CURRENT (LC_MONETARY
, MON_DECIMAL_POINT
);
257 if (*decimal
== '\0')
258 decimal
= _NL_CURRENT (LC_NUMERIC
, DECIMAL_POINT
);
259 decimalwc
= _NL_CURRENT_WORD (LC_MONETARY
,
260 _NL_MONETARY_DECIMAL_POINT_WC
);
261 if (decimalwc
== L
'\0')
262 decimalwc
= _NL_CURRENT_WORD (LC_NUMERIC
,
263 _NL_NUMERIC_DECIMAL_POINT_WC
);
265 /* The decimal point character must not be zero. */
266 assert (*decimal
!= '\0');
267 assert (decimalwc
!= L
'\0');
271 if (info
->extra
== 0)
272 grouping
= _NL_CURRENT (LC_NUMERIC
, GROUPING
);
274 grouping
= _NL_CURRENT (LC_MONETARY
, MON_GROUPING
);
276 if (*grouping
<= 0 || *grouping
== CHAR_MAX
)
280 /* Figure out the thousands separator character. */
283 if (info
->extra
== 0)
285 _NL_CURRENT_WORD (LC_NUMERIC
, _NL_NUMERIC_THOUSANDS_SEP_WC
);
288 _NL_CURRENT_WORD (LC_MONETARY
,
289 _NL_MONETARY_THOUSANDS_SEP_WC
);
293 if (info
->extra
== 0)
294 thousands_sep
= _NL_CURRENT (LC_NUMERIC
, THOUSANDS_SEP
);
296 thousands_sep
= _NL_CURRENT (LC_MONETARY
, MON_THOUSANDS_SEP
);
299 if ((wide
&& thousands_sepwc
== L
'\0')
300 || (! wide
&& *thousands_sep
== '\0'))
302 else if (thousands_sepwc
== L
'\0')
303 /* If we are printing multibyte characters and there is a
304 multibyte representation for the thousands separator,
305 we must ensure the wide character thousands separator
306 is available, even if it is fake. */
307 thousands_sepwc
= 0xfffffffe;
313 /* Fetch the argument value. */
314 #ifndef __NO_LONG_DOUBLE_MATH
315 if (info
->is_long_double
&& sizeof (long double) > sizeof (double))
317 fpnum
.ldbl
= *(const long double *) args
[0];
319 /* Check for special values: not a number or infinity. */
320 if (__isnanl (fpnum
.ldbl
))
322 if (isupper (info
->spec
))
334 else if (__isinfl (fpnum
.ldbl
))
336 if (isupper (info
->spec
))
346 is_neg
= fpnum
.ldbl
< 0;
350 fracsize
= __mpn_extract_long_double (fp_input
,
352 sizeof (fp_input
[0])),
355 to_shift
= 1 + fracsize
* BITS_PER_MP_LIMB
- LDBL_MANT_DIG
;
359 #endif /* no long double */
361 fpnum
.dbl
= *(const double *) args
[0];
363 /* Check for special values: not a number or infinity. */
364 if (__isnan (fpnum
.dbl
))
366 if (isupper (info
->spec
))
378 else if (__isinf (fpnum
.dbl
))
380 if (isupper (info
->spec
))
390 is_neg
= fpnum
.dbl
< 0;
394 fracsize
= __mpn_extract_double (fp_input
,
396 / sizeof (fp_input
[0])),
397 &exponent
, &is_neg
, fpnum
.dbl
);
398 to_shift
= 1 + fracsize
* BITS_PER_MP_LIMB
- DBL_MANT_DIG
;
404 int width
= info
->width
;
406 if (is_neg
|| info
->showsign
|| info
->space
)
410 if (!info
->left
&& width
> 0)
415 else if (info
->showsign
)
417 else if (info
->space
)
420 PRINT (special
, wspecial
, 3);
422 if (info
->left
&& width
> 0)
429 /* We need three multiprecision variables. Now that we have the exponent
430 of the number we can allocate the needed memory. It would be more
431 efficient to use variables of the fixed maximum size but because this
432 would be really big it could lead to memory problems. */
434 mp_size_t bignum_size
= ((ABS (exponent
) + BITS_PER_MP_LIMB
- 1)
435 / BITS_PER_MP_LIMB
+ 4) * sizeof (mp_limb_t
);
436 frac
= (mp_limb_t
*) alloca (bignum_size
);
437 tmp
= (mp_limb_t
*) alloca (bignum_size
);
438 scale
= (mp_limb_t
*) alloca (bignum_size
);
441 /* We now have to distinguish between numbers with positive and negative
442 exponents because the method used for the one is not applicable/efficient
449 int explog
= LDBL_MAX_10_EXP_LOG
;
451 const struct mp_power
*powers
= &_fpioconst_pow10
[explog
+ 1];
454 if ((exponent
+ to_shift
) % BITS_PER_MP_LIMB
== 0)
456 MPN_COPY_DECR (frac
+ (exponent
+ to_shift
) / BITS_PER_MP_LIMB
,
458 fracsize
+= (exponent
+ to_shift
) / BITS_PER_MP_LIMB
;
462 cy
= __mpn_lshift (frac
+ (exponent
+ to_shift
) / BITS_PER_MP_LIMB
,
464 (exponent
+ to_shift
) % BITS_PER_MP_LIMB
);
465 fracsize
+= (exponent
+ to_shift
) / BITS_PER_MP_LIMB
;
467 frac
[fracsize
++] = cy
;
469 MPN_ZERO (frac
, (exponent
+ to_shift
) / BITS_PER_MP_LIMB
);
471 assert (powers
> &_fpioconst_pow10
[0]);
476 /* The number of the product of two binary numbers with n and m
477 bits respectively has m+n or m+n-1 bits. */
478 if (exponent
>= scaleexpo
+ powers
->p_expo
- 1)
482 #ifndef __NO_LONG_DOUBLE_MATH
483 if (LDBL_MANT_DIG
> _FPIO_CONST_OFFSET
* BITS_PER_MP_LIMB
484 && info
->is_long_double
)
486 #define _FPIO_CONST_SHIFT \
487 (((LDBL_MANT_DIG + BITS_PER_MP_LIMB - 1) / BITS_PER_MP_LIMB) \
488 - _FPIO_CONST_OFFSET)
489 /* 64bit const offset is not enough for
490 IEEE quad long double. */
491 tmpsize
= powers
->arraysize
+ _FPIO_CONST_SHIFT
;
492 memcpy (tmp
+ _FPIO_CONST_SHIFT
,
493 &__tens
[powers
->arrayoff
],
494 tmpsize
* sizeof (mp_limb_t
));
495 MPN_ZERO (tmp
, _FPIO_CONST_SHIFT
);
500 tmpsize
= powers
->arraysize
;
501 memcpy (tmp
, &__tens
[powers
->arrayoff
],
502 tmpsize
* sizeof (mp_limb_t
));
507 cy
= __mpn_mul (tmp
, scale
, scalesize
,
508 &__tens
[powers
->arrayoff
509 + _FPIO_CONST_OFFSET
],
510 powers
->arraysize
- _FPIO_CONST_OFFSET
);
511 tmpsize
= scalesize
+ powers
->arraysize
- _FPIO_CONST_OFFSET
;
516 if (MPN_GE (frac
, tmp
))
519 MPN_ASSIGN (scale
, tmp
);
520 count_leading_zeros (cnt
, scale
[scalesize
- 1]);
521 scaleexpo
= (scalesize
- 2) * BITS_PER_MP_LIMB
- cnt
- 1;
522 exp10
|= 1 << explog
;
527 while (powers
> &_fpioconst_pow10
[0]);
530 /* Optimize number representations. We want to represent the numbers
531 with the lowest number of bytes possible without losing any
532 bytes. Also the highest bit in the scaling factor has to be set
533 (this is a requirement of the MPN division routines). */
536 /* Determine minimum number of zero bits at the end of
538 for (i
= 0; scale
[i
] == 0 && frac
[i
] == 0; i
++)
541 /* Determine number of bits the scaling factor is misplaced. */
542 count_leading_zeros (cnt_h
, scale
[scalesize
- 1]);
546 /* The highest bit of the scaling factor is already set. So
547 we only have to remove the trailing empty limbs. */
550 MPN_COPY_INCR (scale
, scale
+ i
, scalesize
- i
);
552 MPN_COPY_INCR (frac
, frac
+ i
, fracsize
- i
);
560 count_trailing_zeros (cnt_l
, scale
[i
]);
564 count_trailing_zeros (cnt_l2
, frac
[i
]);
570 count_trailing_zeros (cnt_l
, frac
[i
]);
572 /* Now shift the numbers to their optimal position. */
573 if (i
== 0 && BITS_PER_MP_LIMB
- cnt_h
> cnt_l
)
575 /* We cannot save any memory. So just roll both numbers
576 so that the scaling factor has its highest bit set. */
578 (void) __mpn_lshift (scale
, scale
, scalesize
, cnt_h
);
579 cy
= __mpn_lshift (frac
, frac
, fracsize
, cnt_h
);
581 frac
[fracsize
++] = cy
;
583 else if (BITS_PER_MP_LIMB
- cnt_h
<= cnt_l
)
585 /* We can save memory by removing the trailing zero limbs
586 and by packing the non-zero limbs which gain another
589 (void) __mpn_rshift (scale
, scale
+ i
, scalesize
- i
,
590 BITS_PER_MP_LIMB
- cnt_h
);
592 (void) __mpn_rshift (frac
, frac
+ i
, fracsize
- i
,
593 BITS_PER_MP_LIMB
- cnt_h
);
594 fracsize
-= frac
[fracsize
- i
- 1] == 0 ? i
+ 1 : i
;
598 /* We can only save the memory of the limbs which are zero.
599 The non-zero parts occupy the same number of limbs. */
601 (void) __mpn_rshift (scale
, scale
+ (i
- 1),
603 BITS_PER_MP_LIMB
- cnt_h
);
605 (void) __mpn_rshift (frac
, frac
+ (i
- 1),
607 BITS_PER_MP_LIMB
- cnt_h
);
608 fracsize
-= frac
[fracsize
- (i
- 1) - 1] == 0 ? i
: i
- 1;
613 else if (exponent
< 0)
617 int explog
= LDBL_MAX_10_EXP_LOG
;
618 const struct mp_power
*powers
= &_fpioconst_pow10
[explog
+ 1];
619 mp_size_t used_limbs
= fracsize
- 1;
621 /* Now shift the input value to its right place. */
622 cy
= __mpn_lshift (frac
, fp_input
, fracsize
, to_shift
);
623 frac
[fracsize
++] = cy
;
624 assert (cy
== 1 || (frac
[fracsize
- 2] == 0 && frac
[0] == 0));
627 exponent
= -exponent
;
629 assert (powers
!= &_fpioconst_pow10
[0]);
634 if (exponent
>= powers
->m_expo
)
636 int i
, incr
, cnt_h
, cnt_l
;
639 /* The __mpn_mul function expects the first argument to be
640 bigger than the second. */
641 if (fracsize
< powers
->arraysize
- _FPIO_CONST_OFFSET
)
642 cy
= __mpn_mul (tmp
, &__tens
[powers
->arrayoff
643 + _FPIO_CONST_OFFSET
],
644 powers
->arraysize
- _FPIO_CONST_OFFSET
,
647 cy
= __mpn_mul (tmp
, frac
, fracsize
,
648 &__tens
[powers
->arrayoff
+ _FPIO_CONST_OFFSET
],
649 powers
->arraysize
- _FPIO_CONST_OFFSET
);
650 tmpsize
= fracsize
+ powers
->arraysize
- _FPIO_CONST_OFFSET
;
654 count_leading_zeros (cnt_h
, tmp
[tmpsize
- 1]);
655 incr
= (tmpsize
- fracsize
) * BITS_PER_MP_LIMB
656 + BITS_PER_MP_LIMB
- 1 - cnt_h
;
658 assert (incr
<= powers
->p_expo
);
660 /* If we increased the exponent by exactly 3 we have to test
661 for overflow. This is done by comparing with 10 shifted
662 to the right position. */
663 if (incr
== exponent
+ 3)
665 if (cnt_h
<= BITS_PER_MP_LIMB
- 4)
669 = ((mp_limb_t
) 10) << (BITS_PER_MP_LIMB
- 4 - cnt_h
);
673 topval
[0] = ((mp_limb_t
) 10) << (BITS_PER_MP_LIMB
- 4);
675 (void) __mpn_lshift (topval
, topval
, 2,
676 BITS_PER_MP_LIMB
- cnt_h
);
680 /* We have to be careful when multiplying the last factor.
681 If the result is greater than 1.0 be have to test it
682 against 10.0. If it is greater or equal to 10.0 the
683 multiplication was not valid. This is because we cannot
684 determine the number of bits in the result in advance. */
685 if (incr
< exponent
+ 3
686 || (incr
== exponent
+ 3 &&
687 (tmp
[tmpsize
- 1] < topval
[1]
688 || (tmp
[tmpsize
- 1] == topval
[1]
689 && tmp
[tmpsize
- 2] < topval
[0]))))
691 /* The factor is right. Adapt binary and decimal
694 exp10
|= 1 << explog
;
696 /* If this factor yields a number greater or equal to
697 1.0, we must not shift the non-fractional digits down. */
701 /* Now we optimize the number representation. */
702 for (i
= 0; tmp
[i
] == 0; ++i
);
703 if (cnt_h
== BITS_PER_MP_LIMB
- 1)
705 MPN_COPY (frac
, tmp
+ i
, tmpsize
- i
);
706 fracsize
= tmpsize
- i
;
710 count_trailing_zeros (cnt_l
, tmp
[i
]);
712 /* Now shift the numbers to their optimal position. */
713 if (i
== 0 && BITS_PER_MP_LIMB
- 1 - cnt_h
> cnt_l
)
715 /* We cannot save any memory. Just roll the
716 number so that the leading digit is in a
719 cy
= __mpn_lshift (frac
, tmp
, tmpsize
, cnt_h
+ 1);
720 fracsize
= tmpsize
+ 1;
721 frac
[fracsize
- 1] = cy
;
723 else if (BITS_PER_MP_LIMB
- 1 - cnt_h
<= cnt_l
)
725 (void) __mpn_rshift (frac
, tmp
+ i
, tmpsize
- i
,
726 BITS_PER_MP_LIMB
- 1 - cnt_h
);
727 fracsize
= tmpsize
- i
;
731 /* We can only save the memory of the limbs which
732 are zero. The non-zero parts occupy the same
735 (void) __mpn_rshift (frac
, tmp
+ (i
- 1),
737 BITS_PER_MP_LIMB
- 1 - cnt_h
);
738 fracsize
= tmpsize
- (i
- 1);
741 used_limbs
= fracsize
- 1;
746 while (powers
!= &_fpioconst_pow10
[1] && exponent
> 0);
747 /* All factors but 10^-1 are tested now. */
752 cy
= __mpn_mul_1 (tmp
, frac
, fracsize
, 10);
754 assert (cy
== 0 || tmp
[tmpsize
- 1] < 20);
756 count_trailing_zeros (cnt_l
, tmp
[0]);
757 if (cnt_l
< MIN (4, exponent
))
759 cy
= __mpn_lshift (frac
, tmp
, tmpsize
,
760 BITS_PER_MP_LIMB
- MIN (4, exponent
));
762 frac
[tmpsize
++] = cy
;
765 (void) __mpn_rshift (frac
, tmp
, tmpsize
, MIN (4, exponent
));
768 assert (frac
[fracsize
- 1] < 10);
774 /* This is a special case. We don't need a factor because the
775 numbers are in the range of 0.0 <= fp < 8.0. We simply
776 shift it to the right place and divide it by 1.0 to get the
777 leading digit. (Of course this division is not really made.) */
778 assert (0 <= exponent
&& exponent
< 3 &&
779 exponent
+ to_shift
< BITS_PER_MP_LIMB
);
781 /* Now shift the input value to its right place. */
782 cy
= __mpn_lshift (frac
, fp_input
, fracsize
, (exponent
+ to_shift
));
783 frac
[fracsize
++] = cy
;
788 int width
= info
->width
;
789 wchar_t *wbuffer
, *wstartp
, *wcp
;
793 int intdig_max
, intdig_no
= 0;
794 int fracdig_min
, fracdig_max
, fracdig_no
= 0;
799 if (_tolower (info
->spec
) == 'e')
803 fracdig_min
= fracdig_max
= info
->prec
< 0 ? 6 : info
->prec
;
804 chars_needed
= 1 + 1 + fracdig_max
+ 1 + 1 + 4;
805 /* d . ddd e +- ddd */
806 dig_max
= INT_MAX
; /* Unlimited. */
807 significant
= 1; /* Does not matter here. */
809 else if (info
->spec
== 'f')
812 fracdig_min
= fracdig_max
= info
->prec
< 0 ? 6 : info
->prec
;
815 intdig_max
= exponent
+ 1;
816 /* This can be really big! */ /* XXX Maybe malloc if too big? */
817 chars_needed
= exponent
+ 1 + 1 + fracdig_max
;
822 chars_needed
= 1 + 1 + fracdig_max
;
824 dig_max
= INT_MAX
; /* Unlimited. */
825 significant
= 1; /* Does not matter here. */
829 dig_max
= info
->prec
< 0 ? 6 : (info
->prec
== 0 ? 1 : info
->prec
);
830 if ((expsign
== 0 && exponent
>= dig_max
)
831 || (expsign
!= 0 && exponent
> 4))
833 if ('g' - 'G' == 'e' - 'E')
834 type
= 'E' + (info
->spec
- 'G');
836 type
= isupper (info
->spec
) ? 'E' : 'e';
837 fracdig_max
= dig_max
- 1;
839 chars_needed
= 1 + 1 + fracdig_max
+ 1 + 1 + 4;
844 intdig_max
= expsign
== 0 ? exponent
+ 1 : 0;
845 fracdig_max
= dig_max
- intdig_max
;
846 /* We need space for the significant digits and perhaps
847 for leading zeros when < 1.0. The number of leading
848 zeros can be as many as would be required for
849 exponential notation with a negative two-digit
850 exponent, which is 4. */
851 chars_needed
= dig_max
+ 1 + 4;
853 fracdig_min
= info
->alt
? fracdig_max
: 0;
854 significant
= 0; /* We count significant digits. */
859 /* Guess the number of groups we will make, and thus how
860 many spaces we need for separator characters. */
861 ngroups
= __guess_grouping (intdig_max
, grouping
);
862 chars_needed
+= ngroups
;
865 /* Allocate buffer for output. We need two more because while rounding
866 it is possible that we need two more characters in front of all the
867 other output. If the amount of memory we have to allocate is too
868 large use `malloc' instead of `alloca'. */
869 buffer_malloced
= chars_needed
> 5000;
872 wbuffer
= (wchar_t *) malloc ((2 + chars_needed
) * sizeof (wchar_t));
874 /* Signal an error to the caller. */
878 wbuffer
= (wchar_t *) alloca ((2 + chars_needed
) * sizeof (wchar_t));
879 wcp
= wstartp
= wbuffer
+ 2; /* Let room for rounding. */
881 /* Do the real work: put digits in allocated buffer. */
882 if (expsign
== 0 || type
!= 'f')
884 assert (expsign
== 0 || intdig_max
== 1);
885 while (intdig_no
< intdig_max
)
888 *wcp
++ = hack_digit ();
893 || (fracdig_max
> 0 && (fracsize
> 1 || frac
[0] != 0)))
898 /* |fp| < 1.0 and the selected type is 'f', so put "0."
905 /* Generate the needed number of fractional digits. */
906 while (fracdig_no
< fracdig_min
907 || (fracdig_no
< fracdig_max
&& (fracsize
> 1 || frac
[0] != 0)))
910 *wcp
= hack_digit ();
913 else if (significant
== 0)
923 digit
= hack_digit ();
929 && ((*(wcp
- 1) != decimalwc
&& (*(wcp
- 1) & 1) == 0)
930 || ((*(wcp
- 1) == decimalwc
&& (*(wcp
- 2) & 1) == 0))))
932 /* This is the critical case. */
933 if (fracsize
== 1 && frac
[0] == 0)
934 /* Rest of the number is zero -> round to even.
935 (IEEE 754-1985 4.1 says this is the default rounding.) */
937 else if (scalesize
== 0)
939 /* Here we have to see whether all limbs are zero since no
940 normalization happened. */
941 size_t lcnt
= fracsize
;
942 while (lcnt
>= 1 && frac
[lcnt
- 1] == 0)
945 /* Rest of the number is zero -> round to even.
946 (IEEE 754-1985 4.1 says this is the default rounding.) */
953 /* Process fractional digits. Terminate if not rounded or
954 radix character is reached. */
955 while (*--wtp
!= decimalwc
&& *wtp
== L
'9')
957 if (*wtp
!= decimalwc
)
962 if (fracdig_no
== 0 || *wtp
== decimalwc
)
964 /* Round the integer digits. */
965 if (*(wtp
- 1) == decimalwc
)
968 while (--wtp
>= wstartp
&& *wtp
== L
'9')
975 /* It is more critical. All digits were 9's. */
980 exponent
+= expsign
== 0 ? 1 : -1;
982 else if (intdig_no
== dig_max
)
984 /* This is the case where for type %g the number fits
985 really in the range for %f output but after rounding
986 the number of digits is too big. */
987 *--wstartp
= decimalwc
;
990 if (info
->alt
|| fracdig_no
> 0)
992 /* Overwrite the old radix character. */
993 wstartp
[intdig_no
+ 2] = L
'0';
997 fracdig_no
+= intdig_no
;
999 fracdig_max
= intdig_max
- intdig_no
;
1001 /* Now we must print the exponent. */
1002 type
= isupper (info
->spec
) ? 'E' : 'e';
1006 /* We can simply add another another digit before the
1012 /* While rounding the number of digits can change.
1013 If the number now exceeds the limits remove some
1014 fractional digits. */
1015 if (intdig_no
+ fracdig_no
> dig_max
)
1017 wcp
-= intdig_no
+ fracdig_no
- dig_max
;
1018 fracdig_no
-= intdig_no
+ fracdig_no
- dig_max
;
1025 /* Now remove unnecessary '0' at the end of the string. */
1026 while (fracdig_no
> fracdig_min
&& *(wcp
- 1) == L
'0')
1031 /* If we eliminate all fractional digits we perhaps also can remove
1032 the radix character. */
1033 if (fracdig_no
== 0 && !info
->alt
&& *(wcp
- 1) == decimalwc
)
1037 /* Add in separator characters, overwriting the same buffer. */
1038 wcp
= group_number (wstartp
, wcp
, intdig_no
, grouping
, thousands_sepwc
,
1041 /* Write the exponent if it is needed. */
1044 *wcp
++ = (wchar_t) type
;
1045 *wcp
++ = expsign
? L
'-' : L
'+';
1047 /* Find the magnitude of the exponent. */
1049 while (expscale
<= exponent
)
1053 /* Exponent always has at least two digits. */
1059 *wcp
++ = L
'0' + (exponent
/ expscale
);
1060 exponent
%= expscale
;
1062 while (expscale
> 10);
1063 *wcp
++ = L
'0' + exponent
;
1066 /* Compute number of characters which must be filled with the padding
1068 if (is_neg
|| info
->showsign
|| info
->space
)
1070 width
-= wcp
- wstartp
;
1072 if (!info
->left
&& info
->pad
!= '0' && width
> 0)
1073 PADN (info
->pad
, width
);
1077 else if (info
->showsign
)
1079 else if (info
->space
)
1082 if (!info
->left
&& info
->pad
== '0' && width
> 0)
1086 char *buffer
= NULL
;
1092 /* Create the single byte string. */
1094 size_t thousands_sep_len
;
1097 decimal_len
= strlen (decimal
);
1099 if (thousands_sep
== NULL
)
1100 thousands_sep_len
= 0;
1102 thousands_sep_len
= strlen (thousands_sep
);
1104 if (buffer_malloced
)
1106 buffer
= (char *) malloc (2 + chars_needed
+ decimal_len
1107 + ngroups
* thousands_sep_len
);
1109 /* Signal an error to the caller. */
1113 buffer
= (char *) alloca (2 + chars_needed
+ decimal_len
1114 + ngroups
* thousands_sep_len
);
1116 /* Now copy the wide character string. Since the character
1117 (except for the decimal point and thousands separator) must
1118 be coming from the ASCII range we can esily convert the
1119 string without mapping tables. */
1120 for (cp
= buffer
, copywc
= wstartp
; copywc
< wcp
; ++copywc
)
1121 if (*copywc
== decimalwc
)
1122 cp
= (char *) __mempcpy (cp
, decimal
, decimal_len
);
1123 else if (*copywc
== thousands_sepwc
)
1124 cp
= (char *) __mempcpy (cp
, thousands_sep
, thousands_sep_len
);
1126 *cp
++ = (char) *copywc
;
1130 PRINT (tmpptr
, wstartp
, wide
? wcp
- wstartp
: cp
- tmpptr
);
1132 /* Free the memory if necessary. */
1133 if (buffer_malloced
)
1140 if (info
->left
&& width
> 0)
1141 PADN (info
->pad
, width
);
1146 /* Return the number of extra grouping characters that will be inserted
1147 into a number with INTDIG_MAX integer digits. */
1150 __guess_grouping (unsigned int intdig_max
, const char *grouping
)
1152 unsigned int groups
;
1154 /* We treat all negative values like CHAR_MAX. */
1156 if (*grouping
== CHAR_MAX
|| *grouping
<= 0)
1157 /* No grouping should be done. */
1161 while (intdig_max
> (unsigned int) *grouping
)
1164 intdig_max
-= *grouping
++;
1166 if (*grouping
== CHAR_MAX
1171 /* No more grouping should be done. */
1173 else if (*grouping
== 0)
1175 /* Same grouping repeats. */
1176 groups
+= (intdig_max
- 1) / grouping
[-1];
1184 /* Group the INTDIG_NO integer digits of the number in [BUF,BUFEND).
1185 There is guaranteed enough space past BUFEND to extend it.
1186 Return the new end of buffer. */
1190 group_number (wchar_t *buf
, wchar_t *bufend
, unsigned int intdig_no
,
1191 const char *grouping
, wchar_t thousands_sep
, int ngroups
)
1198 /* Move the fractional part down. */
1199 __wmemmove (buf
+ intdig_no
+ ngroups
, buf
+ intdig_no
,
1200 bufend
- (buf
+ intdig_no
));
1202 p
= buf
+ intdig_no
+ ngroups
- 1;
1205 unsigned int len
= *grouping
++;
1207 *p
-- = buf
[--intdig_no
];
1209 *p
-- = thousands_sep
;
1211 if (*grouping
== CHAR_MAX
1216 /* No more grouping should be done. */
1218 else if (*grouping
== 0)
1219 /* Same grouping repeats. */
1221 } while (intdig_no
> (unsigned int) *grouping
);
1223 /* Copy the remaining ungrouped digits. */
1225 *p
-- = buf
[--intdig_no
];
1228 return bufend
+ ngroups
;