Update.

8 files changed, 533 insertions, 478 deletions

diff --git a/lgl/Makefile.am b/lgl/Makefile.am
index e4af9e1863..73dbeebd8f 100644
--- a/lgl/Makefile.am
+++ b/lgl/Makefile.am
@@ -646,6 +646,7 @@ wchar.h: wchar_.h
 	{ echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'; \
 	  sed -e 's|@''ABSOLUTE_WCHAR_H''@|$(ABSOLUTE_WCHAR_H)|g' \
 	      -e 's/@''HAVE_INCLUDE_NEXT''@/$(HAVE_INCLUDE_NEXT)/g' \
+	      -e 's/@''HAVE_WCHAR_H''@/$(HAVE_WCHAR_H)/g' \
 	    < $(srcdir)/wchar_.h; \
 	} > $@-t
 	mv $@-t $@
diff --git a/lgl/m4/intl.m4 b/lgl/m4/intl.m4
index e44fe21960..e0771d2a04 100644
--- a/lgl/m4/intl.m4
+++ b/lgl/m4/intl.m4
@@ -1,4 +1,4 @@
-# intl.m4 serial 4 (gettext-0.16.2)
+# intl.m4 serial 5 (gettext-0.16.2)
 dnl Copyright (C) 1995-2007 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -106,6 +106,19 @@ AC_DEFUN([AM_INTL_SUBDIR],
   WOE32DLL=$is_woe32dll
   AC_SUBST([WOE32DLL])
 
+  dnl On mingw and Cygwin, we can activate special Makefile rules which add
+  dnl version information to the shared libraries and executables.
+  case "$host_os" in
+    mingw* | cygwin*) is_woe32=yes ;;
+    *) is_woe32=no ;;
+  esac
+  WOE32=$is_woe32
+  AC_SUBST([WOE32])
+  if test $WOE32 = yes; then
+    dnl Check for a program that compiles Windows resource files.
+    AC_CHECK_TOOL([WINDRES], [windres])
+  fi
+
   dnl Rename some macros and functions used for locking.
   AH_BOTTOM([
 #define __libc_lock_t                   gl_lock_t
diff --git a/lgl/m4/lseek.m4 b/lgl/m4/lseek.m4
index 4877bfd2e9..69e9ea755c 100644
--- a/lgl/m4/lseek.m4
+++ b/lgl/m4/lseek.m4
@@ -1,4 +1,4 @@
-# lseek.m4 serial 2
+# lseek.m4 serial 3
 dnl Copyright (C) 2007 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -19,21 +19,21 @@ int main ()
   /* Exit with success only if stdin is seekable.  */
   return lseek (0, (off_t)0, SEEK_CUR) < 0;
 }],
-         [if test -s conftest$ac_exeext \
-             && ./conftest$ac_exeext < conftest.$ac_ext \
-             && { echo hi | ./conftest$ac_exeext; test $? = 1; }; then
-            gl_cv_func_lseek_pipe=yes
-          else
-            gl_cv_func_lseek_pipe=no
-          fi],
-         [gl_cv_func_lseek_pipe=no])
+	 [if test -s conftest$ac_exeext \
+	     && ./conftest$ac_exeext < conftest.$ac_ext \
+	     && { echo hi | ./conftest$ac_exeext; test $? = 1; }; then
+	    gl_cv_func_lseek_pipe=yes
+	  else
+	    gl_cv_func_lseek_pipe=no
+	  fi],
+	 [gl_cv_func_lseek_pipe=no])
      else
-       AC_LINK_IFELSE([
+       AC_COMPILE_IFELSE([
 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 /* mingw mistakenly returns 0 when trying to seek on pipes.  */
   Choke me.
 #endif],
-         [gl_cv_func_lseek_pipe=yes], [gl_cv_func_lseek_pipe=no])
+	 [gl_cv_func_lseek_pipe=yes], [gl_cv_func_lseek_pipe=no])
      fi])
   if test $gl_cv_func_lseek_pipe = no; then
     gl_REPLACE_LSEEK
diff --git a/lgl/m4/stdint.m4 b/lgl/m4/stdint.m4
index 659ca85273..c12311d274 100644
--- a/lgl/m4/stdint.m4
+++ b/lgl/m4/stdint.m4
@@ -1,5 +1,5 @@
-# stdint.m4 serial 23
-dnl Copyright (C) 2001-2002, 2004-2007 Free Software Foundation, Inc.
+# stdint.m4 serial 26
+dnl Copyright (C) 2001-2007 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
@@ -142,12 +142,32 @@ uintptr_t h = UINTPTR_MAX;
 #endif
 intmax_t i = INTMAX_MAX;
 uintmax_t j = UINTMAX_MAX;
+
+#include <limits.h> /* for CHAR_BIT */
+#define TYPE_MINIMUM(t) \
+  ((t) ((t) 0 < (t) -1 ? (t) 0 : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
+#define TYPE_MAXIMUM(t) \
+  ((t) ((t) 0 < (t) -1 ? (t) -1 : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
 struct s {
-  int check_PTRDIFF: PTRDIFF_MIN < (ptrdiff_t) 0 && (ptrdiff_t) 0 < PTRDIFF_MAX ? 1 : -1;
-  int check_SIG_ATOMIC: SIG_ATOMIC_MIN <= (sig_atomic_t) 0 && (sig_atomic_t) 0 < SIG_ATOMIC_MAX ? 1 : -1;
-  int check_SIZE: (size_t) 0 < SIZE_MAX ? 1 : -1;
-  int check_WCHAR: WCHAR_MIN <= (wchar_t) 0 && (wchar_t) 0 < WCHAR_MAX ? 1 : -1;
-  int check_WINT: WINT_MIN <= (wint_t) 0 && (wint_t) 0 < WINT_MAX ? 1 : -1;
+  int check_PTRDIFF:
+      PTRDIFF_MIN == TYPE_MINIMUM (ptrdiff_t)
+      && PTRDIFF_MAX == TYPE_MAXIMUM (ptrdiff_t)
+      ? 1 : -1;
+  /* Detect bug in FreeBSD 6.0 / ia64.  */
+  int check_SIG_ATOMIC:
+      SIG_ATOMIC_MIN == TYPE_MINIMUM (sig_atomic_t)
+      && SIG_ATOMIC_MAX == TYPE_MAXIMUM (sig_atomic_t)
+      ? 1 : -1;
+  int check_SIZE: SIZE_MAX == TYPE_MAXIMUM (size_t) ? 1 : -1;
+  int check_WCHAR:
+      WCHAR_MIN == TYPE_MINIMUM (wchar_t)
+      && WCHAR_MAX == TYPE_MAXIMUM (wchar_t)
+      ? 1 : -1;
+  /* Detect bug in mingw.  */
+  int check_WINT:
+      WINT_MIN == TYPE_MINIMUM (wint_t)
+      && WINT_MAX == TYPE_MAXIMUM (wint_t)
+      ? 1 : -1;
 
   /* Detect bugs in glibc 2.4 and Solaris 10 stdint.h, among others.  */
   int check_UINT8_C:
@@ -202,6 +222,10 @@ struct s {
     fi
     AC_SUBST([HAVE_SYS_BITYPES_H])
 
+    dnl Check for <wchar.h> (missing in Linux uClibc when built without wide
+    dnl character support).
+    AC_CHECK_HEADERS_ONCE([wchar.h])
+
     gl_STDINT_TYPE_PROPERTIES
     STDINT_H=stdint.h
   fi
@@ -337,9 +361,11 @@ AC_DEFUN([gl_STDINT_INCLUDES],
      included before <wchar.h>.  */
   #include <stddef.h>
   #include <signal.h>
-  #include <stdio.h>
-  #include <time.h>
-  #include <wchar.h>
+  #if HAVE_WCHAR_H
+  # include <stdio.h>
+  # include <time.h>
+  # include <wchar.h>
+  #endif
 ]])
 
 dnl gl_STDINT_TYPE_PROPERTIES
diff --git a/lgl/m4/vasnprintf.m4 b/lgl/m4/vasnprintf.m4
index fa953aaf26..7d676c25f2 100644
--- a/lgl/m4/vasnprintf.m4
+++ b/lgl/m4/vasnprintf.m4
@@ -1,4 +1,4 @@
-# vasnprintf.m4 serial 17
+# vasnprintf.m4 serial 18
 dnl Copyright (C) 2002-2004, 2006-2007 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -101,7 +101,7 @@ AC_DEFUN([gl_PREREQ_VASNPRINTF_INFINITE_LONG_DOUBLE],
   AC_REQUIRE([gl_PREREQ_VASNPRINTF_LONG_DOUBLE])
   case "$gl_cv_func_printf_long_double" in
     *yes)
-      case "$gl_cv_func_printf_infinite" in
+      case "$gl_cv_func_printf_infinite_long_double" in
         *yes)
           ;;
         *)
diff --git a/lgl/m4/wchar.m4 b/lgl/m4/wchar.m4
index 068f22d31b..30377ca12d 100644
--- a/lgl/m4/wchar.m4
+++ b/lgl/m4/wchar.m4
@@ -7,7 +7,7 @@ dnl with or without modifications, as long as this notice is preserved.
 
 dnl Written by Eric Blake.
 
-# wchar.m4 serial 1
+# wchar.m4 serial 2
 
 AC_DEFUN([gl_WCHAR_H],
 [
@@ -20,6 +20,15 @@ wchar_t w;]],
   if test $gl_cv_header_wchar_h_standalone = yes; then
     WCHAR_H=
   else
+    dnl Check for <wchar.h> (missing in Linux uClibc when built without wide
+    dnl character support).
+    AC_CHECK_HEADERS_ONCE([wchar.h])
+    if test $ac_cv_header_wchar_h = yes; then
+      HAVE_WCHAR_H=1
+    else
+      HAVE_WCHAR_H=0
+    fi
+    AC_SUBST([HAVE_WCHAR_H])
     gl_ABSOLUTE_HEADER([wchar.h])
     ABSOLUTE_WCHAR_H=\"$gl_cv_absolute_wchar_h\"
     WCHAR_H=wchar.h
diff --git a/lgl/vasnprintf.c b/lgl/vasnprintf.c
index 8080aa1c46..54ae10446b 100644
--- a/lgl/vasnprintf.c
+++ b/lgl/vasnprintf.c
@@ -56,6 +56,7 @@
 #if NEED_PRINTF_LONG_DOUBLE && !defined IN_LIBINTL
 # include <math.h>
 # include "float+.h"
+# include "fpucw.h"
 #endif
 
 #if NEED_PRINTF_INFINITE_DOUBLE && !defined IN_LIBINTL
@@ -66,6 +67,7 @@
 #if NEED_PRINTF_INFINITE_LONG_DOUBLE && !defined IN_LIBINTL
 # include <math.h>
 # include "isnanl-nolibm.h"
+# include "fpucw.h"
 #endif
 
 #if NEED_PRINTF_DIRECTIVE_A && !defined IN_LIBINTL
@@ -1289,10 +1291,458 @@ VASNPRINTF (CHAR_T *resultbuf, size_t *lengthp, const CHAR_T *format, va_list ar
 		    abort ();
 		  }
 	      }
+#if NEED_PRINTF_DIRECTIVE_A && !defined IN_LIBINTL
+	    else if (dp->conversion == 'a' || dp->conversion == 'A')
+	      {
+		arg_type type = a.arg[dp->arg_index].type;
+		int flags = dp->flags;
+		int has_width;
+		size_t width;
+		int has_precision;
+		size_t precision;
+		size_t tmp_length;
+		CHAR_T tmpbuf[700];
+		CHAR_T *tmp;
+		CHAR_T *pad_ptr;
+		CHAR_T *p;
+
+		has_width = 0;
+		width = 0;
+		if (dp->width_start != dp->width_end)
+		  {
+		    if (dp->width_arg_index != ARG_NONE)
+		      {
+			int arg;
+
+			if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
+			  abort ();
+			arg = a.arg[dp->width_arg_index].a.a_int;
+			if (arg < 0)
+			  {
+			    /* "A negative field width is taken as a '-' flag
+			        followed by a positive field width."  */
+			    flags |= FLAG_LEFT;
+			    width = (unsigned int) (-arg);
+			  }
+			else
+			  width = arg;
+		      }
+		    else
+		      {
+			const CHAR_T *digitp = dp->width_start;
+
+			do
+			  width = xsum (xtimes (width, 10), *digitp++ - '0');
+			while (digitp != dp->width_end);
+		      }
+		    has_width = 1;
+		  }
+
+		has_precision = 0;
+		precision = 0;
+		if (dp->precision_start != dp->precision_end)
+		  {
+		    if (dp->precision_arg_index != ARG_NONE)
+		      {
+			int arg;
+
+			if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
+			  abort ();
+			arg = a.arg[dp->precision_arg_index].a.a_int;
+			/* "A negative precision is taken as if the precision
+			    were omitted."  */
+			if (arg >= 0)
+			  {
+			    precision = arg;
+			    has_precision = 1;
+			  }
+		      }
+		    else
+		      {
+			const CHAR_T *digitp = dp->precision_start + 1;
+
+			precision = 0;
+			while (digitp != dp->precision_end)
+			  precision = xsum (xtimes (precision, 10), *digitp++ - '0');
+			has_precision = 1;
+		      }
+		  }
+
+		/* Allocate a temporary buffer of sufficient size.  */
+		if (type == TYPE_LONGDOUBLE)
+		  tmp_length =
+		    (unsigned int) ((LDBL_DIG + 1)
+				    * 0.831 /* decimal -> hexadecimal */
+				   )
+		    + 1; /* turn floor into ceil */
+		else
+		  tmp_length =
+		    (unsigned int) ((DBL_DIG + 1)
+				    * 0.831 /* decimal -> hexadecimal */
+				   )
+		    + 1; /* turn floor into ceil */
+		if (tmp_length < precision)
+		  tmp_length = precision;
+		/* Account for sign, decimal point etc. */
+		tmp_length = xsum (tmp_length, 12);
+
+		if (tmp_length < width)
+		  tmp_length = width;
+
+		tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
+
+		if (tmp_length <= sizeof (tmpbuf) / sizeof (CHAR_T))
+		  tmp = tmpbuf;
+		else
+		  {
+		    size_t tmp_memsize = xtimes (tmp_length, sizeof (CHAR_T));
+
+		    if (size_overflow_p (tmp_memsize))
+		      /* Overflow, would lead to out of memory.  */
+		      goto out_of_memory;
+		    tmp = (CHAR_T *) malloc (tmp_memsize);
+		    if (tmp == NULL)
+		      /* Out of memory.  */
+		      goto out_of_memory;
+		  }
+
+		pad_ptr = NULL;
+		p = tmp;
+		if (type == TYPE_LONGDOUBLE)
+		  {
+		    long double arg = a.arg[dp->arg_index].a.a_longdouble;
+
+		    if (isnanl (arg))
+		      {
+			if (dp->conversion == 'A')
+			  {
+			    *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
+			  }
+			else
+			  {
+			    *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
+			  }
+		      }
+		    else
+		      {
+			int sign = 0;
+			DECL_LONG_DOUBLE_ROUNDING
+
+			BEGIN_LONG_DOUBLE_ROUNDING ();
+
+			if (signbit (arg)) /* arg < 0.0L or negative zero */
+			  {
+			    sign = -1;
+			    arg = -arg;
+			  }
+
+			if (sign < 0)
+			  *p++ = '-';
+			else if (flags & FLAG_SHOWSIGN)
+			  *p++ = '+';
+			else if (flags & FLAG_SPACE)
+			  *p++ = ' ';
+
+			if (arg > 0.0L && arg + arg == arg)
+			  {
+			    if (dp->conversion == 'A')
+			      {
+				*p++ = 'I'; *p++ = 'N'; *p++ = 'F';
+			      }
+			    else
+			      {
+				*p++ = 'i'; *p++ = 'n'; *p++ = 'f';
+			      }
+			  }
+			else
+			  {
+			    int exponent;
+			    long double mantissa;
+
+			    if (arg > 0.0L)
+			      mantissa = printf_frexpl (arg, &exponent);
+			    else
+			      {
+				exponent = 0;
+				mantissa = 0.0L;
+			      }
+
+			    if (has_precision
+				&& precision < (unsigned int) ((LDBL_DIG + 1) * 0.831) + 1)
+			      {
+				/* Round the mantissa.  */
+				long double tail = mantissa;
+				size_t q;
+
+				for (q = precision; ; q--)
+				  {
+				    int digit = (int) tail;
+				    tail -= digit;
+				    if (q == 0)
+				      {
+					if (digit & 1 ? tail >= 0.5L : tail > 0.5L)
+					  tail = 1 - tail;
+					else
+					  tail = - tail;
+					break;
+				      }
+				    tail *= 16.0L;
+				  }
+				if (tail != 0.0L)
+				  for (q = precision; q > 0; q--)
+				    tail *= 0.0625L;
+				mantissa += tail;
+			      }
+
+			    *p++ = '0';
+			    *p++ = dp->conversion - 'A' + 'X';
+			    pad_ptr = p;
+			    {
+			      int digit;
+
+			      digit = (int) mantissa;
+			      mantissa -= digit;
+			      *p++ = '0' + digit;
+			      if ((flags & FLAG_ALT)
+				  || mantissa > 0.0L || precision > 0)
+				{
+				  *p++ = decimal_point_char ();
+				  /* This loop terminates because we assume
+				     that FLT_RADIX is a power of 2.  */
+				  while (mantissa > 0.0L)
+				    {
+				      mantissa *= 16.0L;
+				      digit = (int) mantissa;
+				      mantissa -= digit;
+				      *p++ = digit
+					     + (digit < 10
+						? '0'
+						: dp->conversion - 10);
+				      if (precision > 0)
+					precision--;
+				    }
+				  while (precision > 0)
+				    {
+				      *p++ = '0';
+				      precision--;
+				    }
+				}
+			      }
+			      *p++ = dp->conversion - 'A' + 'P';
+# if WIDE_CHAR_VERSION
+			      {
+				static const wchar_t decimal_format[] =
+				  { '%', '+', 'd', '\0' };
+				SNPRINTF (p, 6 + 1, decimal_format, exponent);
+			      }
+# else
+			      sprintf (p, "%+d", exponent);
+# endif
+			      while (*p != '\0')
+				p++;
+			  }
+
+			END_LONG_DOUBLE_ROUNDING ();
+		      }
+		  }
+		else
+		  {
+		    double arg = a.arg[dp->arg_index].a.a_double;
+
+		    if (isnan (arg))
+		      {
+			if (dp->conversion == 'A')
+			  {
+			    *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
+			  }
+			else
+			  {
+			    *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
+			  }
+		      }
+		    else
+		      {
+			int sign = 0;
+
+			if (signbit (arg)) /* arg < 0.0 or negative zero */
+			  {
+			    sign = -1;
+			    arg = -arg;
+			  }
+
+			if (sign < 0)
+			  *p++ = '-';
+			else if (flags & FLAG_SHOWSIGN)
+			  *p++ = '+';
+			else if (flags & FLAG_SPACE)
+			  *p++ = ' ';
+
+			if (arg > 0.0 && arg + arg == arg)
+			  {
+			    if (dp->conversion == 'A')
+			      {
+				*p++ = 'I'; *p++ = 'N'; *p++ = 'F';
+			      }
+			    else
+			      {
+				*p++ = 'i'; *p++ = 'n'; *p++ = 'f';
+			      }
+			  }
+			else
+			  {
+			    int exponent;
+			    double mantissa;
+
+			    if (arg > 0.0)
+			      mantissa = printf_frexp (arg, &exponent);
+			    else
+			      {
+				exponent = 0;
+				mantissa = 0.0;
+			      }
+
+			    if (has_precision
+				&& precision < (unsigned int) ((DBL_DIG + 1) * 0.831) + 1)
+			      {
+				/* Round the mantissa.  */
+				double tail = mantissa;
+				size_t q;
+
+				for (q = precision; ; q--)
+				  {
+				    int digit = (int) tail;
+				    tail -= digit;
+				    if (q == 0)
+				      {
+					if (digit & 1 ? tail >= 0.5 : tail > 0.5)
+					  tail = 1 - tail;
+					else
+					  tail = - tail;
+					break;
+				      }
+				    tail *= 16.0;
+				  }
+				if (tail != 0.0)
+				  for (q = precision; q > 0; q--)
+				    tail *= 0.0625;
+				mantissa += tail;
+			      }
+
+			    *p++ = '0';
+			    *p++ = dp->conversion - 'A' + 'X';
+			    pad_ptr = p;
+			    {
+			      int digit;
+
+			      digit = (int) mantissa;
+			      mantissa -= digit;
+			      *p++ = '0' + digit;
+			      if ((flags & FLAG_ALT)
+				  || mantissa > 0.0 || precision > 0)
+				{
+				  *p++ = decimal_point_char ();
+				  /* This loop terminates because we assume
+				     that FLT_RADIX is a power of 2.  */
+				  while (mantissa > 0.0)
+				    {
+				      mantissa *= 16.0;
+				      digit = (int) mantissa;
+				      mantissa -= digit;
+				      *p++ = digit
+					     + (digit < 10
+						? '0'
+						: dp->conversion - 10);
+				      if (precision > 0)
+					precision--;
+				    }
+				  while (precision > 0)
+				    {
+				      *p++ = '0';
+				      precision--;
+				    }
+				}
+			      }
+			      *p++ = dp->conversion - 'A' + 'P';
+# if WIDE_CHAR_VERSION
+			      {
+				static const wchar_t decimal_format[] =
+				  { '%', '+', 'd', '\0' };
+				SNPRINTF (p, 6 + 1, decimal_format, exponent);
+			      }
+# else
+			      sprintf (p, "%+d", exponent);
+# endif
+			      while (*p != '\0')
+				p++;
+			  }
+		      }
+		  }
+		/* The generated string now extends from tmp to p, with the
+		   zero padding insertion point being at pad_ptr.  */
+		if (has_width && p - tmp < width)
+		  {
+		    size_t pad = width - (p - tmp);
+		    CHAR_T *end = p + pad;
+
+		    if (flags & FLAG_LEFT)
+		      {
+			/* Pad with spaces on the right.  */
+			for (; pad > 0; pad--)
+			  *p++ = ' ';
+		      }
+		    else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
+		      {
+			/* Pad with zeroes.  */
+			CHAR_T *q = end;
+
+			while (p > pad_ptr)
+			  *--q = *--p;
+			for (; pad > 0; pad--)
+			  *p++ = '0';
+		      }
+		    else
+		      {
+			/* Pad with spaces on the left.  */
+			CHAR_T *q = end;
+
+			while (p > tmp)
+			  *--q = *--p;
+			for (; pad > 0; pad--)
+			  *p++ = ' ';
+		      }
+
+		    p = end;
+		  }
+
+		{
+		  size_t count = p - tmp;
+
+		  if (count >= tmp_length)
+		    /* tmp_length was incorrectly calculated - fix the
+		       code above!  */
+		    abort ();
+
+		  /* Make room for the result.  */
+		  if (count >= allocated - length)
+		    {
+		      size_t n = xsum (length, count);
+
+		      ENSURE_ALLOCATION (n);
+		    }
+
+		  /* Append the result.  */
+		  memcpy (result + length, tmp, count * sizeof (CHAR_T));
+		  if (tmp != tmpbuf)
+		    free (tmp);
+		  length += count;
+		}
+	      }
+#endif
 #if (NEED_PRINTF_INFINITE_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
 	    else if ((dp->conversion == 'f' || dp->conversion == 'F'
 		      || dp->conversion == 'e' || dp->conversion == 'E'
-		      || dp->conversion == 'g' || dp->conversion == 'G')
+		      || dp->conversion == 'g' || dp->conversion == 'G'
+		      || dp->conversion == 'a' || dp->conversion == 'A')
 		     && (0
 # if NEED_PRINTF_INFINITE_DOUBLE
 			 || (a.arg[dp->arg_index].type == TYPE_DOUBLE
@@ -1944,453 +2394,6 @@ VASNPRINTF (CHAR_T *resultbuf, size_t *lengthp, const CHAR_T *format, va_list ar
 		}
 	      }
 #endif
-#if NEED_PRINTF_DIRECTIVE_A && !defined IN_LIBINTL
-	    else if (dp->conversion == 'a' || dp->conversion == 'A')
-	      {
-		arg_type type = a.arg[dp->arg_index].type;
-		int flags = dp->flags;
-		int has_width;
-		size_t width;
-		int has_precision;
-		size_t precision;
-		size_t tmp_length;
-		CHAR_T tmpbuf[700];
-		CHAR_T *tmp;
-		CHAR_T *pad_ptr;
-		CHAR_T *p;
-
-		has_width = 0;
-		width = 0;
-		if (dp->width_start != dp->width_end)
-		  {
-		    if (dp->width_arg_index != ARG_NONE)
-		      {
-			int arg;
-
-			if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
-			  abort ();
-			arg = a.arg[dp->width_arg_index].a.a_int;
-			if (arg < 0)
-			  {
-			    /* "A negative field width is taken as a '-' flag
-			        followed by a positive field width."  */
-			    flags |= FLAG_LEFT;
-			    width = (unsigned int) (-arg);
-			  }
-			else
-			  width = arg;
-		      }
-		    else
-		      {
-			const CHAR_T *digitp = dp->width_start;
-
-			do
-			  width = xsum (xtimes (width, 10), *digitp++ - '0');
-			while (digitp != dp->width_end);
-		      }
-		    has_width = 1;
-		  }
-
-		has_precision = 0;
-		precision = 0;
-		if (dp->precision_start != dp->precision_end)
-		  {
-		    if (dp->precision_arg_index != ARG_NONE)
-		      {
-			int arg;
-
-			if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
-			  abort ();
-			arg = a.arg[dp->precision_arg_index].a.a_int;
-			/* "A negative precision is taken as if the precision
-			    were omitted."  */
-			if (arg >= 0)
-			  {
-			    precision = arg;
-			    has_precision = 1;
-			  }
-		      }
-		    else
-		      {
-			const CHAR_T *digitp = dp->precision_start + 1;
-
-			precision = 0;
-			while (digitp != dp->precision_end)
-			  precision = xsum (xtimes (precision, 10), *digitp++ - '0');
-			has_precision = 1;
-		      }
-		  }
-
-		/* Allocate a temporary buffer of sufficient size.  */
-		if (type == TYPE_LONGDOUBLE)
-		  tmp_length =
-		    (unsigned int) ((LDBL_DIG + 1)
-				    * 0.831 /* decimal -> hexadecimal */
-				   )
-		    + 1; /* turn floor into ceil */
-		else
-		  tmp_length =
-		    (unsigned int) ((DBL_DIG + 1)
-				    * 0.831 /* decimal -> hexadecimal */
-				   )
-		    + 1; /* turn floor into ceil */
-		if (tmp_length < precision)
-		  tmp_length = precision;
-		/* Account for sign, decimal point etc. */
-		tmp_length = xsum (tmp_length, 12);
-
-		if (tmp_length < width)
-		  tmp_length = width;
-
-		tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
-
-		if (tmp_length <= sizeof (tmpbuf) / sizeof (CHAR_T))
-		  tmp = tmpbuf;
-		else
-		  {
-		    size_t tmp_memsize = xtimes (tmp_length, sizeof (CHAR_T));
-
-		    if (size_overflow_p (tmp_memsize))
-		      /* Overflow, would lead to out of memory.  */
-		      goto out_of_memory;
-		    tmp = (CHAR_T *) malloc (tmp_memsize);
-		    if (tmp == NULL)
-		      /* Out of memory.  */
-		      goto out_of_memory;
-		  }
-
-		pad_ptr = NULL;
-		p = tmp;
-		if (type == TYPE_LONGDOUBLE)
-		  {
-		    long double arg = a.arg[dp->arg_index].a.a_longdouble;
-
-		    if (isnanl (arg))
-		      {
-			if (dp->conversion == 'A')
-			  {
-			    *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
-			  }
-			else
-			  {
-			    *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
-			  }
-		      }
-		    else
-		      {
-			int sign = 0;
-			DECL_LONG_DOUBLE_ROUNDING
-
-			BEGIN_LONG_DOUBLE_ROUNDING ();
-
-			if (signbit (arg)) /* arg < 0.0L or negative zero */
-			  {
-			    sign = -1;
-			    arg = -arg;
-			  }
-
-			if (sign < 0)
-			  *p++ = '-';
-			else if (flags & FLAG_SHOWSIGN)
-			  *p++ = '+';
-			else if (flags & FLAG_SPACE)
-			  *p++ = ' ';
-
-			if (arg > 0.0L && arg + arg == arg)
-			  {
-			    if (dp->conversion == 'A')
-			      {
-				*p++ = 'I'; *p++ = 'N'; *p++ = 'F';
-			      }
-			    else
-			      {
-				*p++ = 'i'; *p++ = 'n'; *p++ = 'f';
-			      }
-			  }
-			else
-			  {
-			    int exponent;
-			    long double mantissa;
-
-			    if (arg > 0.0L)
-			      mantissa = printf_frexpl (arg, &exponent);
-			    else
-			      {
-				exponent = 0;
-				mantissa = 0.0L;
-			      }
-
-			    if (has_precision
-				&& precision < (unsigned int) ((LDBL_DIG + 1) * 0.831) + 1)
-			      {
-				/* Round the mantissa.  */
-				long double tail = mantissa;
-				size_t q;
-
-				for (q = precision; ; q--)
-				  {
-				    int digit = (int) tail;
-				    tail -= digit;
-				    if (q == 0)
-				      {
-					if (digit & 1 ? tail >= 0.5L : tail > 0.5L)
-					  tail = 1 - tail;
-					else
-					  tail = - tail;
-					break;
-				      }
-				    tail *= 16.0L;
-				  }
-				if (tail != 0.0L)
-				  for (q = precision; q > 0; q--)
-				    tail *= 0.0625L;
-				mantissa += tail;
-			      }
-
-			    *p++ = '0';
-			    *p++ = dp->conversion - 'A' + 'X';
-			    pad_ptr = p;
-			    {
-			      int digit;
-
-			      digit = (int) mantissa;
-			      mantissa -= digit;
-			      *p++ = '0' + digit;
-			      if ((flags & FLAG_ALT)
-				  || mantissa > 0.0L || precision > 0)
-				{
-				  *p++ = decimal_point_char ();
-				  /* This loop terminates because we assume
-				     that FLT_RADIX is a power of 2.  */
-				  while (mantissa > 0.0L)
-				    {
-				      mantissa *= 16.0L;
-				      digit = (int) mantissa;
-				      mantissa -= digit;
-				      *p++ = digit
-					     + (digit < 10
-						? '0'
-						: dp->conversion - 10);
-				      if (precision > 0)
-					precision--;
-				    }
-				  while (precision > 0)
-				    {
-				      *p++ = '0';
-				      precision--;
-				    }
-				}
-			      }
-			      *p++ = dp->conversion - 'A' + 'P';
-# if WIDE_CHAR_VERSION
-			      {
-				static const wchar_t decimal_format[] =
-				  { '%', '+', 'd', '\0' };
-				SNPRINTF (p, 6 + 1, decimal_format, exponent);
-			      }
-# else
-			      sprintf (p, "%+d", exponent);
-# endif
-			      while (*p != '\0')
-				p++;
-			  }
-
-			END_LONG_DOUBLE_ROUNDING ();
-		      }
-		  }
-		else
-		  {
-		    double arg = a.arg[dp->arg_index].a.a_double;
-
-		    if (isnan (arg))
-		      {
-			if (dp->conversion == 'A')
-			  {
-			    *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
-			  }
-			else
-			  {
-			    *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
-			  }
-		      }
-		    else
-		      {
-			int sign = 0;
-
-			if (signbit (arg)) /* arg < 0.0 or negative zero */
-			  {
-			    sign = -1;
-			    arg = -arg;
-			  }
-
-			if (sign < 0)
-			  *p++ = '-';
-			else if (flags & FLAG_SHOWSIGN)
-			  *p++ = '+';
-			else if (flags & FLAG_SPACE)
-			  *p++ = ' ';
-
-			if (arg > 0.0 && arg + arg == arg)
-			  {
-			    if (dp->conversion == 'A')
-			      {
-				*p++ = 'I'; *p++ = 'N'; *p++ = 'F';
-			      }
-			    else
-			      {
-				*p++ = 'i'; *p++ = 'n'; *p++ = 'f';
-			      }
-			  }
-			else
-			  {
-			    int exponent;
-			    double mantissa;
-
-			    if (arg > 0.0)
-			      mantissa = printf_frexp (arg, &exponent);
-			    else
-			      {
-				exponent = 0;
-				mantissa = 0.0;
-			      }
-
-			    if (has_precision
-				&& precision < (unsigned int) ((DBL_DIG + 1) * 0.831) + 1)
-			      {
-				/* Round the mantissa.  */
-				double tail = mantissa;
-				size_t q;
-
-				for (q = precision; ; q--)
-				  {
-				    int digit = (int) tail;
-				    tail -= digit;
-				    if (q == 0)
-				      {
-					if (digit & 1 ? tail >= 0.5 : tail > 0.5)
-					  tail = 1 - tail;
-					else
-					  tail = - tail;
-					break;
-				      }
-				    tail *= 16.0;
-				  }
-				if (tail != 0.0)
-				  for (q = precision; q > 0; q--)
-				    tail *= 0.0625;
-				mantissa += tail;
-			      }
-
-			    *p++ = '0';
-			    *p++ = dp->conversion - 'A' + 'X';
-			    pad_ptr = p;
-			    {
-			      int digit;
-
-			      digit = (int) mantissa;
-			      mantissa -= digit;
-			      *p++ = '0' + digit;
-			      if ((flags & FLAG_ALT)
-				  || mantissa > 0.0 || precision > 0)
-				{
-				  *p++ = decimal_point_char ();
-				  /* This loop terminates because we assume
-				     that FLT_RADIX is a power of 2.  */
-				  while (mantissa > 0.0)
-				    {
-				      mantissa *= 16.0;
-				      digit = (int) mantissa;
-				      mantissa -= digit;
-				      *p++ = digit
-					     + (digit < 10
-						? '0'
-						: dp->conversion - 10);
-				      if (precision > 0)
-					precision--;
-				    }
-				  while (precision > 0)
-				    {
-				      *p++ = '0';
-				      precision--;
-				    }
-				}
-			      }
-			      *p++ = dp->conversion - 'A' + 'P';
-# if WIDE_CHAR_VERSION
-			      {
-				static const wchar_t decimal_format[] =
-				  { '%', '+', 'd', '\0' };
-				SNPRINTF (p, 6 + 1, decimal_format, exponent);
-			      }
-# else
-			      sprintf (p, "%+d", exponent);
-# endif
-			      while (*p != '\0')
-				p++;
-			  }
-		      }
-		  }
-		/* The generated string now extends from tmp to p, with the
-		   zero padding insertion point being at pad_ptr.  */
-		if (has_width && p - tmp < width)
-		  {
-		    size_t pad = width - (p - tmp);
-		    CHAR_T *end = p + pad;
-
-		    if (flags & FLAG_LEFT)
-		      {
-			/* Pad with spaces on the right.  */
-			for (; pad > 0; pad--)
-			  *p++ = ' ';
-		      }
-		    else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
-		      {
-			/* Pad with zeroes.  */
-			CHAR_T *q = end;
-
-			while (p > pad_ptr)
-			  *--q = *--p;
-			for (; pad > 0; pad--)
-			  *p++ = '0';
-		      }
-		    else
-		      {
-			/* Pad with spaces on the left.  */
-			CHAR_T *q = end;
-
-			while (p > tmp)
-			  *--q = *--p;
-			for (; pad > 0; pad--)
-			  *p++ = ' ';
-		      }
-
-		    p = end;
-		  }
-
-		{
-		  size_t count = p - tmp;
-
-		  if (count >= tmp_length)
-		    /* tmp_length was incorrectly calculated - fix the
-		       code above!  */
-		    abort ();
-
-		  /* Make room for the result.  */
-		  if (count >= allocated - length)
-		    {
-		      size_t n = xsum (length, count);
-
-		      ENSURE_ALLOCATION (n);
-		    }
-
-		  /* Append the result.  */
-		  memcpy (result + length, tmp, count * sizeof (CHAR_T));
-		  if (tmp != tmpbuf)
-		    free (tmp);
-		  length += count;
-		}
-	      }
-#endif
 	    else
 	      {
 		arg_type type = a.arg[dp->arg_index].type;
diff --git a/lgl/wchar_.h b/lgl/wchar_.h
index 45652fc0d4..6f31ccd547 100644
--- a/lgl/wchar_.h
+++ b/lgl/wchar_.h
@@ -35,12 +35,15 @@
 #include <stdio.h>
 #include <time.h>
 
-/* Include the original <wchar.h>.  */
+/* Include the original <wchar.h> if it exists.
+   Some builds of uClibc lack it.  */
 /* The include_next requires a split double-inclusion guard.  */
-#if @HAVE_INCLUDE_NEXT@
-# include_next <wchar.h>
-#else
-# include @ABSOLUTE_WCHAR_H@
+#if @HAVE_WCHAR_H@
+# if @HAVE_INCLUDE_NEXT@
+#  include_next <wchar.h>
+# else
+#  include @ABSOLUTE_WCHAR_H@
+# endif
 #endif
 
 #ifndef _GL_WCHAR_H