#include <errno.h> /* errno */
#include <limits.h> /* CHAR_BIT */
#include <float.h> /* DBL_MAX_EXP, LDBL_MAX_EXP */
+#if HAVE_NL_LANGINFO
+# include <langinfo.h>
+#endif
#if WIDE_CHAR_VERSION
# include "wprintf-parse.h"
#else
#include "xsize.h"
#if NEED_PRINTF_DIRECTIVE_A && !defined IN_LIBINTL
+# include "float+.h"
# include "isnan.h"
-# include "isnanl.h"
-# if HAVE_LONG_DOUBLE
-# include "printf-frexp.h"
-# include "printf-frexpl.h"
-# endif
+# include "printf-frexp.h"
+# include "isnanl-nolibm.h"
+# include "printf-frexpl.h"
+# include "fpucw.h"
+#endif
+
+/* Some systems, like OSF/1 4.0 and Woe32, don't have EOVERFLOW. */
+#ifndef EOVERFLOW
+# define EOVERFLOW E2BIG
#endif
#if HAVE_WCHAR_T
/* Here we need to call the native sprintf, not rpl_sprintf. */
#undef sprintf
+#if NEED_PRINTF_DIRECTIVE_A && !defined IN_LIBINTL
+/* Determine the decimal-point character according to the current locale. */
+# ifndef decimal_point_char_defined
+# define decimal_point_char_defined 1
+static char
+decimal_point_char ()
+{
+ const char *point;
+ /* Determine it in a multithread-safe way. We know nl_langinfo is
+ multithread-safe on glibc systems, but is not required to be multithread-
+ safe by POSIX. sprintf(), however, is multithread-safe. localeconv()
+ is rarely multithread-safe. */
+# if HAVE_NL_LANGINFO && __GLIBC__
+ point = nl_langinfo (RADIXCHAR);
+# elif 1
+ char pointbuf[5];
+ sprintf (pointbuf, "%#.0f", 1.0);
+ point = &pointbuf[1];
+# else
+ point = localeconv () -> decimal_point;
+# endif
+ /* The decimal point is always a single byte: either '.' or ','. */
+ return (point[0] != '\0' ? point[0] : '.');
+}
+# endif
+#endif
+
CHAR_T *
VASNPRINTF (CHAR_T *resultbuf, size_t *lengthp, const CHAR_T *format, va_list args)
{
}
/* Allocate a temporary buffer of sufficient size. */
-# if HAVE_LONG_DOUBLE
if (type == TYPE_LONGDOUBLE)
tmp_length =
(unsigned int) ((LDBL_DIG + 1)
)
+ 1; /* turn floor into ceil */
else
-# endif
tmp_length =
(unsigned int) ((DBL_DIG + 1)
* 0.831 /* decimal -> hexadecimal */
pad_ptr = NULL;
p = tmp;
-# if HAVE_LONG_DOUBLE
if (type == TYPE_LONGDOUBLE)
{
long double arg = a.arg[dp->arg_index].a.a_longdouble;
else
{
int sign = 0;
+ DECL_LONG_DOUBLE_ROUNDING
+
+ BEGIN_LONG_DOUBLE_ROUNDING ();
if (arg < 0.0L)
{
{
/* Distinguish 0.0L and -0.0L. */
static long double plus_zero = 0.0L;
- long double arg_mem;
- memset (&arg_mem, 0, sizeof (long double));
- arg_mem = arg;
- if (memcmp (&plus_zero, &arg_mem, sizeof (long double)) != 0)
+ long double arg_mem = arg;
+ if (memcmp (&plus_zero, &arg_mem, SIZEOF_LDBL) != 0)
{
sign = -1;
arg = -arg;
if ((flags & FLAG_ALT)
|| mantissa > 0.0L || precision > 0)
{
- const char *point =
- localeconv () -> decimal_point;
- /* The decimal point is always a single byte:
- either '.' or ','. */
- *p++ = (point[0] != '\0' ? point[0] : '.');
+ *p++ = decimal_point_char ();
/* This loop terminates because we assume
that FLT_RADIX is a power of 2. */
while (mantissa > 0.0L)
}
}
*p++ = dp->conversion - 'A' + 'P';
-# if WIDE_CHAR_VERSION
+# if WIDE_CHAR_VERSION
{
static const wchar_t decimal_format[] =
{ '%', '+', 'd', '\0' };
SNPRINTF (p, 6 + 1, decimal_format, exponent);
}
-# else
+# else
sprintf (p, "%+d", exponent);
-# endif
+# endif
while (*p != '\0')
p++;
}
+
+ END_LONG_DOUBLE_ROUNDING ();
}
}
else
-# endif
{
double arg = a.arg[dp->arg_index].a.a_double;
{
/* Distinguish 0.0 and -0.0. */
static double plus_zero = 0.0;
- double arg_mem;
- memset (&arg_mem, 0, sizeof (double));
- arg_mem = arg;
- if (memcmp (&plus_zero, &arg_mem, sizeof (double)) != 0)
+ double arg_mem = arg;
+ if (memcmp (&plus_zero, &arg_mem, SIZEOF_DBL) != 0)
{
sign = -1;
arg = -arg;
if ((flags & FLAG_ALT)
|| mantissa > 0.0 || precision > 0)
{
- const char *point =
- localeconv () -> decimal_point;
- /* The decimal point is always a single byte:
- either '.' or ','. */
- *p++ = (point[0] != '\0' ? point[0] : '.');
+ *p++ = decimal_point_char ();
/* This loop terminates because we assume
that FLT_RADIX is a power of 2. */
while (mantissa > 0.0)
break;
case 'f': case 'F':
-# if HAVE_LONG_DOUBLE
if (type == TYPE_LONGDOUBLE)
tmp_length =
(unsigned int) (LDBL_MAX_EXP
+ 1 /* turn floor into ceil */
+ 10; /* sign, decimal point etc. */
else
-# endif
tmp_length =
(unsigned int) (DBL_MAX_EXP
* 0.30103 /* binary -> decimal */
break;
case 'a': case 'A':
-# if HAVE_LONG_DOUBLE
if (type == TYPE_LONGDOUBLE)
tmp_length =
(unsigned int) (LDBL_DIG
)
+ 1; /* turn floor into ceil */
else
-# endif
tmp_length =
(unsigned int) (DBL_DIG
* 0.831 /* decimal -> hexadecimal */
#endif
*p++ = 'l';
break;
-#if HAVE_LONG_DOUBLE
case TYPE_LONGDOUBLE:
*p++ = 'L';
break;
-#endif
default:
break;
}
retcount = 0;
#if USE_SNPRINTF
+ /* SNPRINTF can fail if maxlen > INT_MAX. */
+ if (maxlen > INT_MAX)
+ goto overflow;
# define SNPRINTF_BUF(arg) \
switch (prefix_count) \
{ \
SNPRINTF_BUF (arg);
}
break;
-#if HAVE_LONG_DOUBLE
case TYPE_LONGDOUBLE:
{
long double arg = a.arg[dp->arg_index].a.a_longdouble;
SNPRINTF_BUF (arg);
}
break;
-#endif
case TYPE_CHAR:
{
int arg = a.arg[dp->arg_index].a.a_char;
not have this limitation. */
return result;
+ overflow:
+ if (!(result == resultbuf || result == NULL))
+ free (result);
+ if (buf_malloced != NULL)
+ free (buf_malloced);
+ CLEANUP ();
+ errno = EOVERFLOW;
+ return NULL;
+
out_of_memory:
if (!(result == resultbuf || result == NULL))
free (result);
projects / gnulib.git / blobdiff