/* Floating point output for `printf'.
- Copyright (C) 1995-2003, 2006, 2007 Free Software Foundation, Inc.
+ Copyright (C) 1995-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA. */
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
/* The gmp headers need some configuration frobs. */
#define HAVE_ALLOCA 1
#include <float.h>
#include <gmp-mparam.h>
#include <gmp.h>
+#include <ieee754.h>
#include <stdlib/gmp-impl.h>
#include <stdlib/longlong.h>
#include <stdlib/fpioconst.h>
#include <unistd.h>
#include <stdlib.h>
#include <wchar.h>
+#include <stdbool.h>
+#include <rounding-mode.h>
#ifdef COMPILE_WPRINTF
# define CHAR_T wchar_t
/* This defines make it possible to use the same code for GNU C library and
the GNU I/O library. */
#define PUT(f, s, n) _IO_sputn (f, s, n)
-#define PAD(f, c, n) (wide ? _IO_wpadn (f, c, n) : INTUSE(_IO_padn) (f, c, n))
+#define PAD(f, c, n) (wide ? _IO_wpadn (f, c, n) : _IO_padn (f, c, n))
/* We use this file GNU C library and GNU I/O library. So make
names equal. */
#undef putc
#define outchar(ch) \
do \
{ \
- register const int outc = (ch); \
+ const int outc = (ch); \
if (putc (outc, fp) == EOF) \
{ \
if (buffer_malloced) \
#define PRINT(ptr, wptr, len) \
do \
{ \
- register size_t outlen = (len); \
+ size_t outlen = (len); \
if (len > 20) \
{ \
if (PUT (fp, wide ? (const char *) wptr : ptr, outlen) != outlen) \
#define MPN_GE(u,v) \
(u##size > v##size || (u##size == v##size && __mpn_cmp (u, v, u##size) >= 0))
-extern int __isinfl_internal (long double) attribute_hidden;
-extern int __isnanl_internal (long double) attribute_hidden;
-
extern mp_size_t __mpn_extract_double (mp_ptr res_ptr, mp_size_t size,
int *expt, int *is_neg,
double value);
wchar_t thousands_sep, int ngroups)
internal_function;
+struct hack_digit_param
+{
+ /* Sign of the exponent. */
+ int expsign;
+ /* The type of output format that will be used: 'e'/'E' or 'f'. */
+ int type;
+ /* and the exponent. */
+ int exponent;
+ /* The fraction of the floting-point value in question */
+ MPN_VAR(frac);
+ /* Scaling factor. */
+ MPN_VAR(scale);
+ /* Temporary bignum value. */
+ MPN_VAR(tmp);
+};
+
+static wchar_t
+hack_digit (struct hack_digit_param *p)
+{
+ mp_limb_t hi;
+
+ if (p->expsign != 0 && p->type == 'f' && p->exponent-- > 0)
+ hi = 0;
+ else if (p->scalesize == 0)
+ {
+ hi = p->frac[p->fracsize - 1];
+ p->frac[p->fracsize - 1] = __mpn_mul_1 (p->frac, p->frac,
+ p->fracsize - 1, 10);
+ }
+ else
+ {
+ if (p->fracsize < p->scalesize)
+ hi = 0;
+ else
+ {
+ hi = mpn_divmod (p->tmp, p->frac, p->fracsize,
+ p->scale, p->scalesize);
+ p->tmp[p->fracsize - p->scalesize] = hi;
+ hi = p->tmp[0];
+
+ p->fracsize = p->scalesize;
+ while (p->fracsize != 0 && p->frac[p->fracsize - 1] == 0)
+ --p->fracsize;
+ if (p->fracsize == 0)
+ {
+ /* We're not prepared for an mpn variable with zero
+ limbs. */
+ p->fracsize = 1;
+ return L'0' + hi;
+ }
+ }
+
+ mp_limb_t _cy = __mpn_mul_1 (p->frac, p->frac, p->fracsize, 10);
+ if (_cy != 0)
+ p->frac[p->fracsize++] = _cy;
+ }
+
+ return L'0' + hi;
+}
int
___printf_fp (FILE *fp,
/* We need to shift the contents of fp_input by this amount of bits. */
int to_shift = 0;
- /* The fraction of the floting-point value in question */
- MPN_VAR(frac);
- /* and the exponent. */
- int exponent;
- /* Sign of the exponent. */
- int expsign = 0;
+ struct hack_digit_param p;
/* Sign of float number. */
int is_neg = 0;
- /* Scaling factor. */
- MPN_VAR(scale);
-
- /* Temporary bignum value. */
- MPN_VAR(tmp);
-
- /* Digit which is result of last hack_digit() call. */
- wchar_t digit;
-
- /* The type of output format that will be used: 'e'/'E' or 'f'. */
- int type;
-
/* Counter for number of written characters. */
int done = 0;
/* Flag whether wbuffer is malloc'ed or not. */
int buffer_malloced = 0;
- auto wchar_t hack_digit (void);
-
- wchar_t hack_digit (void)
- {
- mp_limb_t hi;
-
- if (expsign != 0 && type == 'f' && exponent-- > 0)
- hi = 0;
- else if (scalesize == 0)
- {
- hi = frac[fracsize - 1];
- frac[fracsize - 1] = __mpn_mul_1 (frac, frac, fracsize - 1, 10);
- }
- else
- {
- if (fracsize < scalesize)
- hi = 0;
- else
- {
- hi = mpn_divmod (tmp, frac, fracsize, scale, scalesize);
- tmp[fracsize - scalesize] = hi;
- hi = tmp[0];
-
- fracsize = scalesize;
- while (fracsize != 0 && frac[fracsize - 1] == 0)
- --fracsize;
- if (fracsize == 0)
- {
- /* We're not prepared for an mpn variable with zero
- limbs. */
- fracsize = 1;
- return L'0' + hi;
- }
- }
-
- mp_limb_t _cy = __mpn_mul_1 (frac, frac, fracsize, 10);
- if (_cy != 0)
- frac[fracsize++] = _cy;
- }
-
- return L'0' + hi;
- }
-
+ p.expsign = 0;
/* Figure out the decimal point character. */
if (info->extra == 0)
fpnum.ldbl = *(const long double *) args[0];
/* Check for special values: not a number or infinity. */
- if (__isnanl (fpnum.ldbl))
+ if (isnan (fpnum.ldbl))
{
+ is_neg = signbit (fpnum.ldbl);
if (isupper (info->spec))
{
special = "NAN";
special = "nan";
wspecial = L"nan";
}
- is_neg = 0;
}
- else if (__isinfl (fpnum.ldbl))
+ else if (isinf (fpnum.ldbl))
{
+ is_neg = signbit (fpnum.ldbl);
if (isupper (info->spec))
{
special = "INF";
special = "inf";
wspecial = L"inf";
}
- is_neg = fpnum.ldbl < 0;
}
else
{
- fracsize = __mpn_extract_long_double (fp_input,
+ p.fracsize = __mpn_extract_long_double (fp_input,
(sizeof (fp_input) /
sizeof (fp_input[0])),
- &exponent, &is_neg,
+ &p.exponent, &is_neg,
fpnum.ldbl);
- to_shift = 1 + fracsize * BITS_PER_MP_LIMB - LDBL_MANT_DIG;
+ to_shift = 1 + p.fracsize * BITS_PER_MP_LIMB - LDBL_MANT_DIG;
}
}
else
fpnum.dbl = *(const double *) args[0];
/* Check for special values: not a number or infinity. */
- if (__isnan (fpnum.dbl))
+ if (isnan (fpnum.dbl))
{
- is_neg = 0;
+ is_neg = signbit (fpnum.dbl);
if (isupper (info->spec))
{
special = "NAN";
wspecial = L"nan";
}
}
- else if (__isinf (fpnum.dbl))
+ else if (isinf (fpnum.dbl))
{
- is_neg = fpnum.dbl < 0;
+ is_neg = signbit (fpnum.dbl);
if (isupper (info->spec))
{
special = "INF";
}
else
{
- fracsize = __mpn_extract_double (fp_input,
+ p.fracsize = __mpn_extract_double (fp_input,
(sizeof (fp_input)
/ sizeof (fp_input[0])),
- &exponent, &is_neg, fpnum.dbl);
- to_shift = 1 + fracsize * BITS_PER_MP_LIMB - DBL_MANT_DIG;
+ &p.exponent, &is_neg, fpnum.dbl);
+ to_shift = 1 + p.fracsize * BITS_PER_MP_LIMB - DBL_MANT_DIG;
}
}
}
- /* We need three multiprecision variables. Now that we have the exponent
+ /* We need three multiprecision variables. Now that we have the p.exponent
of the number we can allocate the needed memory. It would be more
efficient to use variables of the fixed maximum size but because this
would be really big it could lead to memory problems. */
{
- mp_size_t bignum_size = ((ABS (exponent) + BITS_PER_MP_LIMB - 1)
+ mp_size_t bignum_size = ((abs (p.exponent) + BITS_PER_MP_LIMB - 1)
/ BITS_PER_MP_LIMB
+ (LDBL_MANT_DIG / BITS_PER_MP_LIMB > 2 ? 8 : 4))
* sizeof (mp_limb_t);
- frac = (mp_limb_t *) alloca (bignum_size);
- tmp = (mp_limb_t *) alloca (bignum_size);
- scale = (mp_limb_t *) alloca (bignum_size);
+ p.frac = (mp_limb_t *) alloca (bignum_size);
+ p.tmp = (mp_limb_t *) alloca (bignum_size);
+ p.scale = (mp_limb_t *) alloca (bignum_size);
}
/* We now have to distinguish between numbers with positive and negative
exponents because the method used for the one is not applicable/efficient
for the other. */
- scalesize = 0;
- if (exponent > 2)
+ p.scalesize = 0;
+ if (p.exponent > 2)
{
/* |FP| >= 8.0. */
int scaleexpo = 0;
const struct mp_power *powers = &_fpioconst_pow10[explog + 1];
int cnt_h, cnt_l, i;
- if ((exponent + to_shift) % BITS_PER_MP_LIMB == 0)
+ if ((p.exponent + to_shift) % BITS_PER_MP_LIMB == 0)
{
- MPN_COPY_DECR (frac + (exponent + to_shift) / BITS_PER_MP_LIMB,
- fp_input, fracsize);
- fracsize += (exponent + to_shift) / BITS_PER_MP_LIMB;
+ MPN_COPY_DECR (p.frac + (p.exponent + to_shift) / BITS_PER_MP_LIMB,
+ fp_input, p.fracsize);
+ p.fracsize += (p.exponent + to_shift) / BITS_PER_MP_LIMB;
}
else
{
- cy = __mpn_lshift (frac + (exponent + to_shift) / BITS_PER_MP_LIMB,
- fp_input, fracsize,
- (exponent + to_shift) % BITS_PER_MP_LIMB);
- fracsize += (exponent + to_shift) / BITS_PER_MP_LIMB;
+ cy = __mpn_lshift (p.frac +
+ (p.exponent + to_shift) / BITS_PER_MP_LIMB,
+ fp_input, p.fracsize,
+ (p.exponent + to_shift) % BITS_PER_MP_LIMB);
+ p.fracsize += (p.exponent + to_shift) / BITS_PER_MP_LIMB;
if (cy)
- frac[fracsize++] = cy;
+ p.frac[p.fracsize++] = cy;
}
- MPN_ZERO (frac, (exponent + to_shift) / BITS_PER_MP_LIMB);
+ MPN_ZERO (p.frac, (p.exponent + to_shift) / BITS_PER_MP_LIMB);
assert (powers > &_fpioconst_pow10[0]);
do
/* The number of the product of two binary numbers with n and m
bits respectively has m+n or m+n-1 bits. */
- if (exponent >= scaleexpo + powers->p_expo - 1)
+ if (p.exponent >= scaleexpo + powers->p_expo - 1)
{
- if (scalesize == 0)
+ if (p.scalesize == 0)
{
#ifndef __NO_LONG_DOUBLE_MATH
if (LDBL_MANT_DIG > _FPIO_CONST_OFFSET * BITS_PER_MP_LIMB
- _FPIO_CONST_OFFSET)
/* 64bit const offset is not enough for
IEEE quad long double. */
- tmpsize = powers->arraysize + _FPIO_CONST_SHIFT;
- memcpy (tmp + _FPIO_CONST_SHIFT,
+ p.tmpsize = powers->arraysize + _FPIO_CONST_SHIFT;
+ memcpy (p.tmp + _FPIO_CONST_SHIFT,
&__tens[powers->arrayoff],
- tmpsize * sizeof (mp_limb_t));
- MPN_ZERO (tmp, _FPIO_CONST_SHIFT);
- /* Adjust exponent, as scaleexpo will be this much
+ p.tmpsize * sizeof (mp_limb_t));
+ MPN_ZERO (p.tmp, _FPIO_CONST_SHIFT);
+ /* Adjust p.exponent, as scaleexpo will be this much
bigger too. */
- exponent += _FPIO_CONST_SHIFT * BITS_PER_MP_LIMB;
+ p.exponent += _FPIO_CONST_SHIFT * BITS_PER_MP_LIMB;
}
else
#endif
{
- tmpsize = powers->arraysize;
- memcpy (tmp, &__tens[powers->arrayoff],
- tmpsize * sizeof (mp_limb_t));
+ p.tmpsize = powers->arraysize;
+ memcpy (p.tmp, &__tens[powers->arrayoff],
+ p.tmpsize * sizeof (mp_limb_t));
}
}
else
{
- cy = __mpn_mul (tmp, scale, scalesize,
+ cy = __mpn_mul (p.tmp, p.scale, p.scalesize,
&__tens[powers->arrayoff
+ _FPIO_CONST_OFFSET],
powers->arraysize - _FPIO_CONST_OFFSET);
- tmpsize = scalesize + powers->arraysize - _FPIO_CONST_OFFSET;
+ p.tmpsize = p.scalesize +
+ powers->arraysize - _FPIO_CONST_OFFSET;
if (cy == 0)
- --tmpsize;
+ --p.tmpsize;
}
- if (MPN_GE (frac, tmp))
+ if (MPN_GE (p.frac, p.tmp))
{
int cnt;
- MPN_ASSIGN (scale, tmp);
- count_leading_zeros (cnt, scale[scalesize - 1]);
- scaleexpo = (scalesize - 2) * BITS_PER_MP_LIMB - cnt - 1;
+ MPN_ASSIGN (p.scale, p.tmp);
+ count_leading_zeros (cnt, p.scale[p.scalesize - 1]);
+ scaleexpo = (p.scalesize - 2) * BITS_PER_MP_LIMB - cnt - 1;
exp10 |= 1 << explog;
}
}
--explog;
}
while (powers > &_fpioconst_pow10[0]);
- exponent = exp10;
+ p.exponent = exp10;
/* Optimize number representations. We want to represent the numbers
with the lowest number of bytes possible without losing any
bytes. Also the highest bit in the scaling factor has to be set
(this is a requirement of the MPN division routines). */
- if (scalesize > 0)
+ if (p.scalesize > 0)
{
/* Determine minimum number of zero bits at the end of
both numbers. */
- for (i = 0; scale[i] == 0 && frac[i] == 0; i++)
+ for (i = 0; p.scale[i] == 0 && p.frac[i] == 0; i++)
;
/* Determine number of bits the scaling factor is misplaced. */
- count_leading_zeros (cnt_h, scale[scalesize - 1]);
+ count_leading_zeros (cnt_h, p.scale[p.scalesize - 1]);
if (cnt_h == 0)
{
we only have to remove the trailing empty limbs. */
if (i > 0)
{
- MPN_COPY_INCR (scale, scale + i, scalesize - i);
- scalesize -= i;
- MPN_COPY_INCR (frac, frac + i, fracsize - i);
- fracsize -= i;
+ MPN_COPY_INCR (p.scale, p.scale + i, p.scalesize - i);
+ p.scalesize -= i;
+ MPN_COPY_INCR (p.frac, p.frac + i, p.fracsize - i);
+ p.fracsize -= i;
}
}
else
{
- if (scale[i] != 0)
+ if (p.scale[i] != 0)
{
- count_trailing_zeros (cnt_l, scale[i]);
- if (frac[i] != 0)
+ count_trailing_zeros (cnt_l, p.scale[i]);
+ if (p.frac[i] != 0)
{
int cnt_l2;
- count_trailing_zeros (cnt_l2, frac[i]);
+ count_trailing_zeros (cnt_l2, p.frac[i]);
if (cnt_l2 < cnt_l)
cnt_l = cnt_l2;
}
}
else
- count_trailing_zeros (cnt_l, frac[i]);
+ count_trailing_zeros (cnt_l, p.frac[i]);
/* Now shift the numbers to their optimal position. */
if (i == 0 && BITS_PER_MP_LIMB - cnt_h > cnt_l)
/* We cannot save any memory. So just roll both numbers
so that the scaling factor has its highest bit set. */
- (void) __mpn_lshift (scale, scale, scalesize, cnt_h);
- cy = __mpn_lshift (frac, frac, fracsize, cnt_h);
+ (void) __mpn_lshift (p.scale, p.scale, p.scalesize, cnt_h);
+ cy = __mpn_lshift (p.frac, p.frac, p.fracsize, cnt_h);
if (cy != 0)
- frac[fracsize++] = cy;
+ p.frac[p.fracsize++] = cy;
}
else if (BITS_PER_MP_LIMB - cnt_h <= cnt_l)
{
and by packing the non-zero limbs which gain another
free one. */
- (void) __mpn_rshift (scale, scale + i, scalesize - i,
+ (void) __mpn_rshift (p.scale, p.scale + i, p.scalesize - i,
BITS_PER_MP_LIMB - cnt_h);
- scalesize -= i + 1;
- (void) __mpn_rshift (frac, frac + i, fracsize - i,
+ p.scalesize -= i + 1;
+ (void) __mpn_rshift (p.frac, p.frac + i, p.fracsize - i,
BITS_PER_MP_LIMB - cnt_h);
- fracsize -= frac[fracsize - i - 1] == 0 ? i + 1 : i;
+ p.fracsize -= p.frac[p.fracsize - i - 1] == 0 ? i + 1 : i;
}
else
{
/* We can only save the memory of the limbs which are zero.
The non-zero parts occupy the same number of limbs. */
- (void) __mpn_rshift (scale, scale + (i - 1),
- scalesize - (i - 1),
+ (void) __mpn_rshift (p.scale, p.scale + (i - 1),
+ p.scalesize - (i - 1),
BITS_PER_MP_LIMB - cnt_h);
- scalesize -= i;
- (void) __mpn_rshift (frac, frac + (i - 1),
- fracsize - (i - 1),
+ p.scalesize -= i;
+ (void) __mpn_rshift (p.frac, p.frac + (i - 1),
+ p.fracsize - (i - 1),
BITS_PER_MP_LIMB - cnt_h);
- fracsize -= frac[fracsize - (i - 1) - 1] == 0 ? i : i - 1;
+ p.fracsize -=
+ p.frac[p.fracsize - (i - 1) - 1] == 0 ? i : i - 1;
}
}
}
}
- else if (exponent < 0)
+ else if (p.exponent < 0)
{
/* |FP| < 1.0. */
int exp10 = 0;
int explog = LDBL_MAX_10_EXP_LOG;
const struct mp_power *powers = &_fpioconst_pow10[explog + 1];
- mp_size_t used_limbs = fracsize - 1;
/* Now shift the input value to its right place. */
- cy = __mpn_lshift (frac, fp_input, fracsize, to_shift);
- frac[fracsize++] = cy;
- assert (cy == 1 || (frac[fracsize - 2] == 0 && frac[0] == 0));
+ cy = __mpn_lshift (p.frac, fp_input, p.fracsize, to_shift);
+ p.frac[p.fracsize++] = cy;
+ assert (cy == 1 || (p.frac[p.fracsize - 2] == 0 && p.frac[0] == 0));
- expsign = 1;
- exponent = -exponent;
+ p.expsign = 1;
+ p.exponent = -p.exponent;
assert (powers != &_fpioconst_pow10[0]);
do
{
--powers;
- if (exponent >= powers->m_expo)
+ if (p.exponent >= powers->m_expo)
{
int i, incr, cnt_h, cnt_l;
mp_limb_t topval[2];
/* The __mpn_mul function expects the first argument to be
bigger than the second. */
- if (fracsize < powers->arraysize - _FPIO_CONST_OFFSET)
- cy = __mpn_mul (tmp, &__tens[powers->arrayoff
+ if (p.fracsize < powers->arraysize - _FPIO_CONST_OFFSET)
+ cy = __mpn_mul (p.tmp, &__tens[powers->arrayoff
+ _FPIO_CONST_OFFSET],
powers->arraysize - _FPIO_CONST_OFFSET,
- frac, fracsize);
+ p.frac, p.fracsize);
else
- cy = __mpn_mul (tmp, frac, fracsize,
+ cy = __mpn_mul (p.tmp, p.frac, p.fracsize,
&__tens[powers->arrayoff + _FPIO_CONST_OFFSET],
powers->arraysize - _FPIO_CONST_OFFSET);
- tmpsize = fracsize + powers->arraysize - _FPIO_CONST_OFFSET;
+ p.tmpsize = p.fracsize + powers->arraysize - _FPIO_CONST_OFFSET;
if (cy == 0)
- --tmpsize;
+ --p.tmpsize;
- count_leading_zeros (cnt_h, tmp[tmpsize - 1]);
- incr = (tmpsize - fracsize) * BITS_PER_MP_LIMB
+ count_leading_zeros (cnt_h, p.tmp[p.tmpsize - 1]);
+ incr = (p.tmpsize - p.fracsize) * BITS_PER_MP_LIMB
+ BITS_PER_MP_LIMB - 1 - cnt_h;
assert (incr <= powers->p_expo);
- /* If we increased the exponent by exactly 3 we have to test
+ /* If we increased the p.exponent by exactly 3 we have to test
for overflow. This is done by comparing with 10 shifted
to the right position. */
- if (incr == exponent + 3)
+ if (incr == p.exponent + 3)
{
if (cnt_h <= BITS_PER_MP_LIMB - 4)
{
against 10.0. If it is greater or equal to 10.0 the
multiplication was not valid. This is because we cannot
determine the number of bits in the result in advance. */
- if (incr < exponent + 3
- || (incr == exponent + 3 &&
- (tmp[tmpsize - 1] < topval[1]
- || (tmp[tmpsize - 1] == topval[1]
- && tmp[tmpsize - 2] < topval[0]))))
+ if (incr < p.exponent + 3
+ || (incr == p.exponent + 3 &&
+ (p.tmp[p.tmpsize - 1] < topval[1]
+ || (p.tmp[p.tmpsize - 1] == topval[1]
+ && p.tmp[p.tmpsize - 2] < topval[0]))))
{
/* The factor is right. Adapt binary and decimal
exponents. */
- exponent -= incr;
+ p.exponent -= incr;
exp10 |= 1 << explog;
/* If this factor yields a number greater or equal to
1.0, we must not shift the non-fractional digits down. */
- if (exponent < 0)
- cnt_h += -exponent;
+ if (p.exponent < 0)
+ cnt_h += -p.exponent;
/* Now we optimize the number representation. */
- for (i = 0; tmp[i] == 0; ++i);
+ for (i = 0; p.tmp[i] == 0; ++i);
if (cnt_h == BITS_PER_MP_LIMB - 1)
{
- MPN_COPY (frac, tmp + i, tmpsize - i);
- fracsize = tmpsize - i;
+ MPN_COPY (p.frac, p.tmp + i, p.tmpsize - i);
+ p.fracsize = p.tmpsize - i;
}
else
{
- count_trailing_zeros (cnt_l, tmp[i]);
+ count_trailing_zeros (cnt_l, p.tmp[i]);
/* Now shift the numbers to their optimal position. */
if (i == 0 && BITS_PER_MP_LIMB - 1 - cnt_h > cnt_l)
number so that the leading digit is in a
separate limb. */
- cy = __mpn_lshift (frac, tmp, tmpsize, cnt_h + 1);
- fracsize = tmpsize + 1;
- frac[fracsize - 1] = cy;
+ cy = __mpn_lshift (p.frac, p.tmp, p.tmpsize,
+ cnt_h + 1);
+ p.fracsize = p.tmpsize + 1;
+ p.frac[p.fracsize - 1] = cy;
}
else if (BITS_PER_MP_LIMB - 1 - cnt_h <= cnt_l)
{
- (void) __mpn_rshift (frac, tmp + i, tmpsize - i,
+ (void) __mpn_rshift (p.frac, p.tmp + i, p.tmpsize - i,
BITS_PER_MP_LIMB - 1 - cnt_h);
- fracsize = tmpsize - i;
+ p.fracsize = p.tmpsize - i;
}
else
{
are zero. The non-zero parts occupy the same
number of limbs. */
- (void) __mpn_rshift (frac, tmp + (i - 1),
- tmpsize - (i - 1),
+ (void) __mpn_rshift (p.frac, p.tmp + (i - 1),
+ p.tmpsize - (i - 1),
BITS_PER_MP_LIMB - 1 - cnt_h);
- fracsize = tmpsize - (i - 1);
+ p.fracsize = p.tmpsize - (i - 1);
}
}
- used_limbs = fracsize - 1;
}
}
--explog;
}
- while (powers != &_fpioconst_pow10[1] && exponent > 0);
+ while (powers != &_fpioconst_pow10[1] && p.exponent > 0);
/* All factors but 10^-1 are tested now. */
- if (exponent > 0)
+ if (p.exponent > 0)
{
int cnt_l;
- cy = __mpn_mul_1 (tmp, frac, fracsize, 10);
- tmpsize = fracsize;
- assert (cy == 0 || tmp[tmpsize - 1] < 20);
+ cy = __mpn_mul_1 (p.tmp, p.frac, p.fracsize, 10);
+ p.tmpsize = p.fracsize;
+ assert (cy == 0 || p.tmp[p.tmpsize - 1] < 20);
- count_trailing_zeros (cnt_l, tmp[0]);
- if (cnt_l < MIN (4, exponent))
+ count_trailing_zeros (cnt_l, p.tmp[0]);
+ if (cnt_l < MIN (4, p.exponent))
{
- cy = __mpn_lshift (frac, tmp, tmpsize,
- BITS_PER_MP_LIMB - MIN (4, exponent));
+ cy = __mpn_lshift (p.frac, p.tmp, p.tmpsize,
+ BITS_PER_MP_LIMB - MIN (4, p.exponent));
if (cy != 0)
- frac[tmpsize++] = cy;
+ p.frac[p.tmpsize++] = cy;
}
else
- (void) __mpn_rshift (frac, tmp, tmpsize, MIN (4, exponent));
- fracsize = tmpsize;
+ (void) __mpn_rshift (p.frac, p.tmp, p.tmpsize, MIN (4, p.exponent));
+ p.fracsize = p.tmpsize;
exp10 |= 1;
- assert (frac[fracsize - 1] < 10);
+ assert (p.frac[p.fracsize - 1] < 10);
}
- exponent = exp10;
+ p.exponent = exp10;
}
else
{
numbers are in the range of 1.0 <= |fp| < 8.0. We simply
shift it to the right place and divide it by 1.0 to get the
leading digit. (Of course this division is not really made.) */
- assert (0 <= exponent && exponent < 3 &&
- exponent + to_shift < BITS_PER_MP_LIMB);
+ assert (0 <= p.exponent && p.exponent < 3 &&
+ p.exponent + to_shift < BITS_PER_MP_LIMB);
/* Now shift the input value to its right place. */
- cy = __mpn_lshift (frac, fp_input, fracsize, (exponent + to_shift));
- frac[fracsize++] = cy;
- exponent = 0;
+ cy = __mpn_lshift (p.frac, fp_input, p.fracsize, (p.exponent + to_shift));
+ p.frac[p.fracsize++] = cy;
+ p.exponent = 0;
}
{
if (spec == 'e')
{
- type = info->spec;
+ p.type = info->spec;
intdig_max = 1;
fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec;
chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4;
}
else if (spec == 'f')
{
- type = 'f';
+ p.type = 'f';
fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec;
dig_max = INT_MAX; /* Unlimited. */
significant = 1; /* Does not matter here. */
- if (expsign == 0)
+ if (p.expsign == 0)
{
- intdig_max = exponent + 1;
+ intdig_max = p.exponent + 1;
/* This can be really big! */ /* XXX Maybe malloc if too big? */
- chars_needed = (size_t) exponent + 1 + 1 + (size_t) fracdig_max;
+ chars_needed = (size_t) p.exponent + 1 + 1 + (size_t) fracdig_max;
}
else
{
else
{
dig_max = info->prec < 0 ? 6 : (info->prec == 0 ? 1 : info->prec);
- if ((expsign == 0 && exponent >= dig_max)
- || (expsign != 0 && exponent > 4))
+ if ((p.expsign == 0 && p.exponent >= dig_max)
+ || (p.expsign != 0 && p.exponent > 4))
{
if ('g' - 'G' == 'e' - 'E')
- type = 'E' + (info->spec - 'G');
+ p.type = 'E' + (info->spec - 'G');
else
- type = isupper (info->spec) ? 'E' : 'e';
+ p.type = isupper (info->spec) ? 'E' : 'e';
fracdig_max = dig_max - 1;
intdig_max = 1;
chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4;
}
else
{
- type = 'f';
- intdig_max = expsign == 0 ? exponent + 1 : 0;
+ p.type = 'f';
+ intdig_max = p.expsign == 0 ? p.exponent + 1 : 0;
fracdig_max = dig_max - intdig_max;
/* We need space for the significant digits and perhaps
for leading zeros when < 1.0. The number of leading
zeros can be as many as would be required for
exponential notation with a negative two-digit
- exponent, which is 4. */
+ p.exponent, which is 4. */
chars_needed = (size_t) dig_max + 1 + 4;
}
fracdig_min = info->alt ? fracdig_max : 0;
/* Guess the number of groups we will make, and thus how
many spaces we need for separator characters. */
ngroups = __guess_grouping (intdig_max, grouping);
- chars_needed += ngroups;
+ /* Allocate one more character in case rounding increases the
+ number of groups. */
+ chars_needed += ngroups + 1;
}
/* Allocate buffer for output. We need two more because while rounding
it is possible that we need two more characters in front of all the
other output. If the amount of memory we have to allocate is too
large use `malloc' instead of `alloca'. */
- size_t wbuffer_to_alloc = (2 + (size_t) chars_needed) * sizeof (wchar_t);
- buffer_malloced = ! __libc_use_alloca (chars_needed * 2 * sizeof (wchar_t));
+ if (__builtin_expect (chars_needed >= (size_t) -1 / sizeof (wchar_t) - 2
+ || chars_needed < fracdig_max, 0))
+ {
+ /* Some overflow occurred. */
+ __set_errno (ERANGE);
+ return -1;
+ }
+ size_t wbuffer_to_alloc = (2 + chars_needed) * sizeof (wchar_t);
+ buffer_malloced = ! __libc_use_alloca (wbuffer_to_alloc);
if (__builtin_expect (buffer_malloced, 0))
{
wbuffer = (wchar_t *) malloc (wbuffer_to_alloc);
wcp = wstartp = wbuffer + 2; /* Let room for rounding. */
/* Do the real work: put digits in allocated buffer. */
- if (expsign == 0 || type != 'f')
+ if (p.expsign == 0 || p.type != 'f')
{
- assert (expsign == 0 || intdig_max == 1);
+ assert (p.expsign == 0 || intdig_max == 1);
while (intdig_no < intdig_max)
{
++intdig_no;
- *wcp++ = hack_digit ();
+ *wcp++ = hack_digit (&p);
}
significant = 1;
if (info->alt
|| fracdig_min > 0
- || (fracdig_max > 0 && (fracsize > 1 || frac[0] != 0)))
+ || (fracdig_max > 0 && (p.fracsize > 1 || p.frac[0] != 0)))
*wcp++ = decimalwc;
}
else
{
- /* |fp| < 1.0 and the selected type is 'f', so put "0."
+ /* |fp| < 1.0 and the selected p.type is 'f', so put "0."
in the buffer. */
*wcp++ = L'0';
- --exponent;
+ --p.exponent;
*wcp++ = decimalwc;
}
int fracdig_no = 0;
int added_zeros = 0;
while (fracdig_no < fracdig_min + added_zeros
- || (fracdig_no < fracdig_max && (fracsize > 1 || frac[0] != 0)))
+ || (fracdig_no < fracdig_max && (p.fracsize > 1 || p.frac[0] != 0)))
{
++fracdig_no;
- *wcp = hack_digit ();
+ *wcp = hack_digit (&p);
if (*wcp++ != L'0')
significant = 1;
else if (significant == 0)
}
/* Do rounding. */
- digit = hack_digit ();
- if (digit > L'4')
+ wchar_t last_digit = wcp[-1] != decimalwc ? wcp[-1] : wcp[-2];
+ wchar_t next_digit = hack_digit (&p);
+ bool more_bits;
+ if (next_digit != L'0' && next_digit != L'5')
+ more_bits = true;
+ else if (p.fracsize == 1 && p.frac[0] == 0)
+ /* Rest of the number is zero. */
+ more_bits = false;
+ else if (p.scalesize == 0)
+ {
+ /* Here we have to see whether all limbs are zero since no
+ normalization happened. */
+ size_t lcnt = p.fracsize;
+ while (lcnt >= 1 && p.frac[lcnt - 1] == 0)
+ --lcnt;
+ more_bits = lcnt > 0;
+ }
+ else
+ more_bits = true;
+ int rounding_mode = get_rounding_mode ();
+ if (round_away (is_neg, (last_digit - L'0') & 1, next_digit >= L'5',
+ more_bits, rounding_mode))
{
wchar_t *wtp = wcp;
- if (digit == L'5'
- && ((*(wcp - 1) != decimalwc && (*(wcp - 1) & 1) == 0)
- || ((*(wcp - 1) == decimalwc && (*(wcp - 2) & 1) == 0))))
- {
- /* This is the critical case. */
- if (fracsize == 1 && frac[0] == 0)
- /* Rest of the number is zero -> round to even.
- (IEEE 754-1985 4.1 says this is the default rounding.) */
- goto do_expo;
- else if (scalesize == 0)
- {
- /* Here we have to see whether all limbs are zero since no
- normalization happened. */
- size_t lcnt = fracsize;
- while (lcnt >= 1 && frac[lcnt - 1] == 0)
- --lcnt;
- if (lcnt == 0)
- /* Rest of the number is zero -> round to even.
- (IEEE 754-1985 4.1 says this is the default rounding.) */
- goto do_expo;
- }
- }
-
if (fracdig_no > 0)
{
/* Process fractional digits. Terminate if not rounded or
if (*wtp != decimalwc)
/* Round up. */
(*wtp)++;
- else if (__builtin_expect (spec == 'g' && type == 'f' && info->alt
+ else if (__builtin_expect (spec == 'g' && p.type == 'f' && info->alt
&& wtp == wstartp + 1
&& wstartp[0] == L'0',
0))
else
/* It is more critical. All digits were 9's. */
{
- if (type != 'f')
+ if (p.type != 'f')
{
*wstartp = '1';
- exponent += expsign == 0 ? 1 : -1;
+ p.exponent += p.expsign == 0 ? 1 : -1;
- /* The above exponent adjustment could lead to 1.0e-00,
- e.g. for 0.999999999. Make sure exponent 0 always
+ /* The above p.exponent adjustment could lead to 1.0e-00,
+ e.g. for 0.999999999. Make sure p.exponent 0 always
uses + sign. */
- if (exponent == 0)
- expsign = 0;
+ if (p.exponent == 0)
+ p.expsign = 0;
}
else if (intdig_no == dig_max)
{
- /* This is the case where for type %g the number fits
+ /* This is the case where for p.type %g the number fits
really in the range for %f output but after rounding
the number of digits is too big. */
*--wstartp = decimalwc;
fracdig_no += intdig_no;
intdig_no = 1;
fracdig_max = intdig_max - intdig_no;
- ++exponent;
- /* Now we must print the exponent. */
- type = isupper (info->spec) ? 'E' : 'e';
+ ++p.exponent;
+ /* Now we must print the p.exponent. */
+ p.type = isupper (info->spec) ? 'E' : 'e';
}
else
{
}
}
- do_expo:
/* Now remove unnecessary '0' at the end of the string. */
while (fracdig_no > fracdig_min + added_zeros && *(wcp - 1) == L'0')
{
--wcp;
if (grouping)
- /* Add in separator characters, overwriting the same buffer. */
- wcp = group_number (wstartp, wcp, intdig_no, grouping, thousands_sepwc,
- ngroups);
+ {
+ /* Rounding might have changed the number of groups. We allocated
+ enough memory but we need here the correct number of groups. */
+ if (intdig_no != intdig_max)
+ ngroups = __guess_grouping (intdig_no, grouping);
+
+ /* Add in separator characters, overwriting the same buffer. */
+ wcp = group_number (wstartp, wcp, intdig_no, grouping, thousands_sepwc,
+ ngroups);
+ }
- /* Write the exponent if it is needed. */
- if (type != 'f')
+ /* Write the p.exponent if it is needed. */
+ if (p.type != 'f')
{
- if (__builtin_expect (expsign != 0 && exponent == 4 && spec == 'g', 0))
+ if (__glibc_unlikely (p.expsign != 0 && p.exponent == 4 && spec == 'g'))
{
- /* This is another special case. The exponent of the number is
+ /* This is another special case. The p.exponent of the number is
really smaller than -4, which requires the 'e'/'E' format.
- But after rounding the number has an exponent of -4. */
+ But after rounding the number has an p.exponent of -4. */
assert (wcp >= wstartp + 1);
assert (wstartp[0] == L'1');
__wmemcpy (wstartp, L"0.0001", 6);
wstartp[1] = decimalwc;
if (wcp >= wstartp + 2)
{
- wmemset (wstartp + 6, L'0', wcp - (wstartp + 2));
+ __wmemset (wstartp + 6, L'0', wcp - (wstartp + 2));
wcp += 4;
}
else
}
else
{
- *wcp++ = (wchar_t) type;
- *wcp++ = expsign ? L'-' : L'+';
+ *wcp++ = (wchar_t) p.type;
+ *wcp++ = p.expsign ? L'-' : L'+';
- /* Find the magnitude of the exponent. */
+ /* Find the magnitude of the p.exponent. */
expscale = 10;
- while (expscale <= exponent)
+ while (expscale <= p.exponent)
expscale *= 10;
- if (exponent < 10)
+ if (p.exponent < 10)
/* Exponent always has at least two digits. */
*wcp++ = L'0';
else
do
{
expscale /= 10;
- *wcp++ = L'0' + (exponent / expscale);
- exponent %= expscale;
+ *wcp++ = L'0' + (p.exponent / expscale);
+ p.exponent %= expscale;
}
while (expscale > 10);
- *wcp++ = L'0' + exponent;
+ *wcp++ = L'0' + p.exponent;
}
}
{
char *buffer = NULL;
+ char *buffer_end = NULL;
char *cp = NULL;
char *tmpptr;
size_t decimal_len;
size_t thousands_sep_len;
wchar_t *copywc;
+ size_t factor = (info->i18n
+ ? _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MB_CUR_MAX)
+ : 1);
decimal_len = strlen (decimal);
else
thousands_sep_len = strlen (thousands_sep);
- if (__builtin_expect (buffer_malloced, 0))
+ size_t nbuffer = (2 + chars_needed * factor + decimal_len
+ + ngroups * thousands_sep_len);
+ if (__glibc_unlikely (buffer_malloced))
{
- buffer = (char *) malloc (2 + chars_needed + decimal_len
- + ngroups * thousands_sep_len);
+ buffer = (char *) malloc (nbuffer);
if (buffer == NULL)
{
/* Signal an error to the caller. */
}
}
else
- buffer = (char *) alloca (2 + chars_needed + decimal_len
- + ngroups * thousands_sep_len);
+ buffer = (char *) alloca (nbuffer);
+ buffer_end = buffer + nbuffer;
/* Now copy the wide character string. Since the character
(except for the decimal point and thousands separator) must
}
tmpptr = buffer;
- if (__builtin_expect (info->i18n, 0))
- {
+ if (__glibc_unlikely (info->i18n))
+ {
#ifdef COMPILE_WPRINTF
- wstartp = _i18n_number_rewrite (wstartp, wcp);
+ wstartp = _i18n_number_rewrite (wstartp, wcp,
+ wbuffer + wbuffer_to_alloc);
+ wcp = wbuffer + wbuffer_to_alloc;
+ assert ((uintptr_t) wbuffer <= (uintptr_t) wstartp);
+ assert ((uintptr_t) wstartp
+ < (uintptr_t) wbuffer + wbuffer_to_alloc);
#else
- tmpptr = _i18n_number_rewrite (tmpptr, cp);
+ tmpptr = _i18n_number_rewrite (tmpptr, cp, buffer_end);
+ cp = buffer_end;
+ assert ((uintptr_t) buffer <= (uintptr_t) tmpptr);
+ assert ((uintptr_t) tmpptr < (uintptr_t) buffer_end);
#endif
- }
+ }
PRINT (tmpptr, wstartp, wide ? wcp - wstartp : cp - tmpptr);
/* Free the memory if necessary. */
- if (__builtin_expect (buffer_malloced, 0))
+ if (__glibc_unlikely (buffer_malloced))
{
free (buffer);
free (wbuffer);
projects / thirdparty / glibc.git / blobdiff