src/extra/intl/vasnprintf.c - R - Git at Google

 /* vsprintf with automatic memory allocation.
    Copyright (C) 1999, 2002-2007 Free Software Foundation, Inc.

    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published
    by the Free Software Foundation; either version 2, or (at your option)
    any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    USA.  */

 /* This file can be parametrized with the following macros:
      VASNPRINTF         The name of the function being defined.
      FCHAR_T            The element type of the format string.
      DCHAR_T            The element type of the destination (result) string.
      FCHAR_T_ONLY_ASCII Set to 1 to enable verification that all characters
                         in the format string are ASCII. MUST be set if
                         FCHAR_T and DCHAR_T are not the same type.
      DIRECTIVE          Structure denoting a format directive.
                         Depends on FCHAR_T.
      DIRECTIVES         Structure denoting the set of format directives of a
                         format string.  Depends on FCHAR_T.
      PRINTF_PARSE       Function that parses a format string.
                         Depends on FCHAR_T.
      DCHAR_CPY          memcpy like function for DCHAR_T[] arrays.
      DCHAR_SET          memset like function for DCHAR_T[] arrays.
      DCHAR_MBSNLEN      mbsnlen like function for DCHAR_T[] arrays.
      SNPRINTF           The system's snprintf (or similar) function.
                         This may be either snprintf or swprintf.
      TCHAR_T            The element type of the argument and result string
                         of the said SNPRINTF function.  This may be either
                         char or wchar_t.  The code exploits that
                         sizeof (TCHAR_T) | sizeof (DCHAR_T) and
                         alignof (TCHAR_T) <= alignof (DCHAR_T).
      DCHAR_IS_TCHAR     Set to 1 if DCHAR_T and TCHAR_T are the same type.
      DCHAR_CONV_FROM_ENCODING A function to convert from char[] to DCHAR[].
      DCHAR_IS_UINT8_T   Set to 1 if DCHAR_T is uint8_t.
      DCHAR_IS_UINT16_T  Set to 1 if DCHAR_T is uint16_t.
      DCHAR_IS_UINT32_T  Set to 1 if DCHAR_T is uint32_t.  */

 /* Tell glibc's <stdio.h> to provide a prototype for snprintf().
    This must come before <config.h> because <config.h> may include
    <features.h>, and once <features.h> has been included, it's too late.  */
 #ifndef _GNU_SOURCE
 # define _GNU_SOURCE    1
 #endif

 #ifndef VASNPRINTF
 # include <config.h>
 #endif
 #ifndef IN_LIBINTL
 # include <alloca.h>
 #endif

 /* Specification.  */
 #ifndef VASNPRINTF
 # if WIDE_CHAR_VERSION
 #  include "vasnwprintf.h"
 # else
 #  include "vasnprintf.h"
 # endif
 #endif

 #include <locale.h>	/* localeconv() */
 #include <stdio.h>	/* snprintf(), sprintf() */
 #include <stdlib.h>	/* abort(), malloc(), realloc(), free() */
 #include <string.h>	/* memcpy(), strlen() */
 #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
 #ifndef VASNPRINTF
 # if WIDE_CHAR_VERSION
 #  include "wprintf-parse.h"
 # else
 #  include "printf-parse.h"
 # endif
 #endif

 /* Checked size_t computations.  */
 #include "xsize.h"

 #if (NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
 # include <math.h>
 # include "float+.h"
 #endif

 #if (NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && !defined IN_LIBINTL
 # include <math.h>
 # include "isnan.h"
 #endif

 #if (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE) && !defined IN_LIBINTL
 # include <math.h>
 # include "isnanl-nolibm.h"
 # include "fpucw.h"
 #endif

 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
 # include <math.h>
 # include "isnan.h"
 # include "printf-frexp.h"
 #endif

 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
 # include <math.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
 # if HAVE_WCSLEN
 #  define local_wcslen wcslen
 # else
    /* Solaris 2.5.1 has wcslen() in a separate library libw.so. To avoid
       a dependency towards this library, here is a local substitute.
       Define this substitute only once, even if this file is included
       twice in the same compilation unit.  */
 #  ifndef local_wcslen_defined
 #   define local_wcslen_defined 1
 static size_t
 local_wcslen (const wchar_t *s)
 {
   const wchar_t *ptr;

   for (ptr = s; *ptr != (wchar_t) 0; ptr++)
     ;
   return ptr - s;
 }
 #  endif
 # endif
 #endif

 /* Default parameters.  */
 #ifndef VASNPRINTF
 # if WIDE_CHAR_VERSION
 #  define VASNPRINTF vasnwprintf
 #  define FCHAR_T wchar_t
 #  define DCHAR_T wchar_t
 #  define TCHAR_T wchar_t
 #  define DCHAR_IS_TCHAR 1
 #  define DIRECTIVE wchar_t_directive
 #  define DIRECTIVES wchar_t_directives
 #  define PRINTF_PARSE wprintf_parse
 #  define DCHAR_CPY wmemcpy
 # else
 #  define VASNPRINTF vasnprintf
 #  define FCHAR_T char
 #  define DCHAR_T char
 #  define TCHAR_T char
 #  define DCHAR_IS_TCHAR 1
 #  define DIRECTIVE char_directive
 #  define DIRECTIVES char_directives
 #  define PRINTF_PARSE printf_parse
 #  define DCHAR_CPY memcpy
 # endif
 #endif
 #if WIDE_CHAR_VERSION
   /* TCHAR_T is wchar_t.  */
 # define USE_SNPRINTF 1
 # if HAVE_DECL__SNWPRINTF
    /* On Windows, the function swprintf() has a different signature than
       on Unix; we use the _snwprintf() function instead.  */
 #  define SNPRINTF _snwprintf
 # else
    /* Unix.  */
 #  define SNPRINTF swprintf
 # endif
 #else
   /* TCHAR_T is char.  */
 # /* Use snprintf if it exists under the name 'snprintf' or '_snprintf'.
      But don't use it on BeOS, since BeOS snprintf produces no output if the
      size argument is >= 0x3000000.  */
 # if (HAVE_DECL__SNPRINTF || HAVE_SNPRINTF) && !defined __BEOS__
 #  define USE_SNPRINTF 1
 # else
 #  define USE_SNPRINTF 0
 # endif
 # if HAVE_DECL__SNPRINTF
    /* Windows.  */
 #  define SNPRINTF _snprintf
 # else
    /* Unix.  */
 #  define SNPRINTF snprintf
    /* Here we need to call the native snprintf, not rpl_snprintf.  */
 #  undef snprintf
 # endif
 #endif
 /* Here we need to call the native sprintf, not rpl_sprintf.  */
 #undef sprintf

 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && !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

 #if NEED_PRINTF_INFINITE_DOUBLE && !NEED_PRINTF_DOUBLE && !defined IN_LIBINTL

 /* Equivalent to !isfinite(x) || x == 0, but does not require libm.  */
 static int
 is_infinite_or_zero (double x)
 {
   return isnan (x) || x + x == x;
 }

 #endif

 #if NEED_PRINTF_INFINITE_LONG_DOUBLE && !NEED_PRINTF_LONG_DOUBLE && !defined IN_LIBINTL

 /* Equivalent to !isfinite(x), but does not require libm.  */
 static int
 is_infinitel (long double x)
 {
   return isnanl (x) || (x + x == x && x != 0.0L);
 }

 #endif

 #if (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL

 /* Converting 'long double' to decimal without rare rounding bugs requires
    real bignums.  We use the naming conventions of GNU gmp, but vastly simpler
    (and slower) algorithms.  */

 typedef unsigned int mp_limb_t;
 # define GMP_LIMB_BITS 32
 typedef int mp_limb_verify[2 * (sizeof (mp_limb_t) * CHAR_BIT == GMP_LIMB_BITS) - 1];

 typedef unsigned long long mp_twolimb_t;
 # define GMP_TWOLIMB_BITS 64
 typedef int mp_twolimb_verify[2 * (sizeof (mp_twolimb_t) * CHAR_BIT == GMP_TWOLIMB_BITS) - 1];

 /* Representation of a bignum >= 0.  */
 typedef struct
 {
   size_t nlimbs;
   mp_limb_t *limbs; /* Bits in little-endian order, allocated with malloc().  */
 } mpn_t;

 /* Compute the product of two bignums >= 0.
    Return the allocated memory in case of success, NULL in case of memory
    allocation failure.  */
 static void *
 multiply (mpn_t src1, mpn_t src2, mpn_t *dest)
 {
   const mp_limb_t *p1;
   const mp_limb_t *p2;
   size_t len1;
   size_t len2;

   if (src1.nlimbs <= src2.nlimbs)
     {
       len1 = src1.nlimbs;
       p1 = src1.limbs;
       len2 = src2.nlimbs;
       p2 = src2.limbs;
     }
   else
     {
       len1 = src2.nlimbs;
       p1 = src2.limbs;
       len2 = src1.nlimbs;
       p2 = src1.limbs;
     }
   /* Now 0 <= len1 <= len2.  */
   if (len1 == 0)
     {
       /* src1 or src2 is zero.  */
       dest->nlimbs = 0;
       dest->limbs = (mp_limb_t *) malloc (1);
     }
   else
     {
       /* Here 1 <= len1 <= len2.  */
       size_t dlen;
       mp_limb_t *dp;
       size_t k, i, j;

       dlen = len1 + len2;
       dp = (mp_limb_t *) malloc (dlen * sizeof (mp_limb_t));
       if (dp == NULL)
 	return NULL;
       for (k = len2; k > 0; )
 	dp[--k] = 0;
       for (i = 0; i < len1; i++)
 	{
 	  mp_limb_t digit1 = p1[i];
 	  mp_twolimb_t carry = 0;
 	  for (j = 0; j < len2; j++)
 	    {
 	      mp_limb_t digit2 = p2[j];
 	      carry += (mp_twolimb_t) digit1 * (mp_twolimb_t) digit2;
 	      carry += dp[i + j];
 	      dp[i + j] = (mp_limb_t) carry;
 	      carry = carry >> GMP_LIMB_BITS;
 	    }
 	  dp[i + len2] = (mp_limb_t) carry;
 	}
       /* Normalise.  */
       while (dlen > 0 && dp[dlen - 1] == 0)
 	dlen--;
       dest->nlimbs = dlen;
       dest->limbs = dp;
     }
   return dest->limbs;
 }

 /* Compute the quotient of a bignum a >= 0 and a bignum b > 0.
    a is written as  a = q * b + r  with 0 <= r < b.  q is the quotient, r
    the remainder.
    Finally, round-to-even is performed: If r > b/2 or if r = b/2 and q is odd,
    q is incremented.
    Return the allocated memory in case of success, NULL in case of memory
    allocation failure.  */
 static void *
 divide (mpn_t a, mpn_t b, mpn_t *q)
 {
   /* Algorithm:
      First normalise a and b: a=[a[m-1],...,a[0]], b=[b[n-1],...,b[0]]
      with m>=0 and n>0 (in base beta = 2^GMP_LIMB_BITS).
      If m<n, then q:=0 and r:=a.
      If m>=n=1, perform a single-precision division:
        r:=0, j:=m,
        while j>0 do
          {Here (q[m-1]*beta^(m-1)+...+q[j]*beta^j) * b[0] + r*beta^j =
                = a[m-1]*beta^(m-1)+...+a[j]*beta^j und 0<=r<b[0]<beta}
          j:=j-1, r:=r*beta+a[j], q[j]:=floor(r/b[0]), r:=r-b[0]*q[j].
        Normalise [q[m-1],...,q[0]], yields q.
      If m>=n>1, perform a multiple-precision division:
        We have a/b < beta^(m-n+1).
        s:=intDsize-1-(hightest bit in b[n-1]), 0<=s<intDsize.
        Shift a and b left by s bits, copying them. r:=a.
        r=[r[m],...,r[0]], b=[b[n-1],...,b[0]] with b[n-1]>=beta/2.
        For j=m-n,...,0: {Here 0 <= r < b*beta^(j+1).}
          Compute q* :
            q* := floor((r[j+n]*beta+r[j+n-1])/b[n-1]).
            In case of overflow (q* >= beta) set q* := beta-1.
            Compute c2 := ((r[j+n]*beta+r[j+n-1]) - q* * b[n-1])*beta + r[j+n-2]
            and c3 := b[n-2] * q*.
            {We have 0 <= c2 < 2*beta^2, even 0 <= c2 < beta^2 if no overflow
             occurred.  Furthermore 0 <= c3 < beta^2.
             If there was overflow and
             r[j+n]*beta+r[j+n-1] - q* * b[n-1] >= beta, i.e. c2 >= beta^2,
             the next test can be skipped.}
            While c3 > c2, {Here 0 <= c2 < c3 < beta^2}
              Put q* := q* - 1, c2 := c2 + b[n-1]*beta, c3 := c3 - b[n-2].
            If q* > 0:
              Put r := r - b * q* * beta^j. In detail:
                [r[n+j],...,r[j]] := [r[n+j],...,r[j]] - q* * [b[n-1],...,b[0]].
                hence: u:=0, for i:=0 to n-1 do
                               u := u + q* * b[i],
                               r[j+i]:=r[j+i]-(u mod beta) (+ beta, if carry),
                               u:=u div beta (+ 1, if carry in subtraction)
                       r[n+j]:=r[n+j]-u.
                {Since always u = (q* * [b[i-1],...,b[0]] div beta^i) + 1
                                < q* + 1 <= beta,
                 the carry u does not overflow.}
              If a negative carry occurs, put q* := q* - 1
                and [r[n+j],...,r[j]] := [r[n+j],...,r[j]] + [0,b[n-1],...,b[0]].
          Set q[j] := q*.
        Normalise [q[m-n],..,q[0]]; this yields the quotient q.
        Shift [r[n-1],...,r[0]] right by s bits and normalise; this yields the
        rest r.
        The room for q[j] can be allocated at the memory location of r[n+j].
      Finally, round-to-even:
        Shift r left by 1 bit.
        If r > b or if r = b and q[0] is odd, q := q+1.
    */
   const mp_limb_t *a_ptr = a.limbs;
   size_t a_len = a.nlimbs;
   const mp_limb_t *b_ptr = b.limbs;
   size_t b_len = b.nlimbs;
   mp_limb_t *roomptr;
   mp_limb_t *tmp_roomptr = NULL;
   mp_limb_t *q_ptr;
   size_t q_len;
   mp_limb_t *r_ptr;
   size_t r_len;

   /* Allocate room for a_len+2 digits.
      (Need a_len+1 digits for the real division and 1 more digit for the
      final rounding of q.)  */
   roomptr = (mp_limb_t *) malloc ((a_len + 2) * sizeof (mp_limb_t));
   if (roomptr == NULL)
     return NULL;

   /* Normalise a.  */
   while (a_len > 0 && a_ptr[a_len - 1] == 0)
     a_len--;

   /* Normalise b.  */
   for (;;)
     {
       if (b_len == 0)
 	/* Division by zero.  */
 	abort ();
       if (b_ptr[b_len - 1] == 0)
 	b_len--;
       else
 	break;
     }

   /* Here m = a_len >= 0 and n = b_len > 0.  */

   if (a_len < b_len)
     {
       /* m<n: trivial case.  q=0, r := copy of a.  */
       r_ptr = roomptr;
       r_len = a_len;
       memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));
       q_ptr = roomptr + a_len;
       q_len = 0;
     }
   else if (b_len == 1)
     {
       /* n=1: single precision division.
 	 beta^(m-1) <= a < beta^m  ==>  beta^(m-2) <= a/b < beta^m  */
       r_ptr = roomptr;
       q_ptr = roomptr + 1;
       {
 	mp_limb_t den = b_ptr[0];
 	mp_limb_t remainder = 0;
 	const mp_limb_t *sourceptr = a_ptr + a_len;
 	mp_limb_t *destptr = q_ptr + a_len;
 	size_t count;
 	for (count = a_len; count > 0; count--)
 	  {
 	    mp_twolimb_t num =
 	      ((mp_twolimb_t) remainder << GMP_LIMB_BITS) | *--sourceptr;
 	    *--destptr = num / den;
 	    remainder = num % den;
 	  }
 	/* Normalise and store r.  */
 	if (remainder > 0)
 	  {
 	    r_ptr[0] = remainder;
 	    r_len = 1;
 	  }
 	else
 	  r_len = 0;
 	/* Normalise q.  */
 	q_len = a_len;
 	if (q_ptr[q_len - 1] == 0)
 	  q_len--;
       }
     }
   else
     {
       /* n>1: multiple precision division.
 	 beta^(m-1) <= a < beta^m, beta^(n-1) <= b < beta^n  ==>
 	 beta^(m-n-1) <= a/b < beta^(m-n+1).  */
       /* Determine s.  */
       size_t s;
       {
 	mp_limb_t msd = b_ptr[b_len - 1]; /* = b[n-1], > 0 */
 	s = 31;
 	if (msd >= 0x10000)
 	  {
 	    msd = msd >> 16;
 	    s -= 16;
 	  }
 	if (msd >= 0x100)
 	  {
 	    msd = msd >> 8;
 	    s -= 8;
 	  }
 	if (msd >= 0x10)
 	  {
 	    msd = msd >> 4;
 	    s -= 4;
 	  }
 	if (msd >= 0x4)
 	  {
 	    msd = msd >> 2;
 	    s -= 2;
 	  }
 	if (msd >= 0x2)
 	  {
 	    msd = msd >> 1;
 	    s -= 1;
 	  }
       }
       /* 0 <= s < GMP_LIMB_BITS.
 	 Copy b, shifting it left by s bits.  */
       if (s > 0)
 	{
 	  tmp_roomptr = (mp_limb_t *) malloc (b_len * sizeof (mp_limb_t));
 	  if (tmp_roomptr == NULL)
 	    {
 	      free (roomptr);
 	      return NULL;
 	    }
 	  {
 	    const mp_limb_t *sourceptr = b_ptr;
 	    mp_limb_t *destptr = tmp_roomptr;
 	    mp_twolimb_t accu = 0;
 	    size_t count;
 	    for (count = b_len; count > 0; count--)
 	      {
 		accu += (mp_twolimb_t) *sourceptr++ << s;
 		*destptr++ = (mp_limb_t) accu;
 		accu = accu >> GMP_LIMB_BITS;
 	      }
 	    /* accu must be zero, since that was how s was determined.  */
 	    if (accu != 0)
 	      abort ();
 	  }
 	  b_ptr = tmp_roomptr;
 	}
       /* Copy a, shifting it left by s bits, yields r.
 	 Memory layout:
 	 At the beginning: r = roomptr[0..a_len],
 	 at the end: r = roomptr[0..b_len-1], q = roomptr[b_len..a_len]  */
       r_ptr = roomptr;
       if (s == 0)
 	{
 	  memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));
 	  r_ptr[a_len] = 0;
 	}
       else
 	{
 	  const mp_limb_t *sourceptr = a_ptr;
 	  mp_limb_t *destptr = r_ptr;
 	  mp_twolimb_t accu = 0;
 	  size_t count;
 	  for (count = a_len; count > 0; count--)
 	    {
 	      accu += (mp_twolimb_t) *sourceptr++ << s;
 	      *destptr++ = (mp_limb_t) accu;
 	      accu = accu >> GMP_LIMB_BITS;
 	    }
 	  *destptr++ = (mp_limb_t) accu;
 	}
       q_ptr = roomptr + b_len;
       q_len = a_len - b_len + 1; /* q will have m-n+1 limbs */
       {
 	size_t j = a_len - b_len; /* m-n */
 	mp_limb_t b_msd = b_ptr[b_len - 1]; /* b[n-1] */
 	mp_limb_t b_2msd = b_ptr[b_len - 2]; /* b[n-2] */
 	mp_twolimb_t b_msdd = /* b[n-1]*beta+b[n-2] */
 	  ((mp_twolimb_t) b_msd << GMP_LIMB_BITS) | b_2msd;
 	/* Division loop, traversed m-n+1 times.
 	   j counts down, b is unchanged, beta/2 <= b[n-1] < beta.  */
 	for (;;)
 	  {
 	    mp_limb_t q_star;
 	    mp_limb_t c1;
 	    if (r_ptr[j + b_len] < b_msd) /* r[j+n] < b[n-1] ? */
 	      {
 		/* Divide r[j+n]*beta+r[j+n-1] by b[n-1], no overflow.  */
 		mp_twolimb_t num =
 		  ((mp_twolimb_t) r_ptr[j + b_len] << GMP_LIMB_BITS)
 		  | r_ptr[j + b_len - 1];
 		q_star = num / b_msd;
 		c1 = num % b_msd;
 	      }
 	    else
 	      {
 		/* Overflow, hence r[j+n]*beta+r[j+n-1] >= beta*b[n-1].  */
 		q_star = (mp_limb_t)~(mp_limb_t)0; /* q* = beta-1 */
 		/* Test whether r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] >= beta
 		   <==> r[j+n]*beta+r[j+n-1] + b[n-1] >= beta*b[n-1]+beta
 		   <==> b[n-1] < floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta)
 		        {<= beta !}.
 		   If yes, jump directly to the subtraction loop.
 		   (Otherwise, r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] < beta
 		    <==> floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta) = b[n-1] ) */
 		if (r_ptr[j + b_len] > b_msd
 		    || (c1 = r_ptr[j + b_len - 1] + b_msd) < b_msd)
 		  /* r[j+n] >= b[n-1]+1 or
 		     r[j+n] = b[n-1] and the addition r[j+n-1]+b[n-1] gives a
 		     carry.  */
 		  goto subtract;
 	      }
 	    /* q_star = q*,
 	       c1 = (r[j+n]*beta+r[j+n-1]) - q* * b[n-1] (>=0, <beta).  */
 	    {
 	      mp_twolimb_t c2 = /* c1*beta+r[j+n-2] */
 		((mp_twolimb_t) c1 << GMP_LIMB_BITS) | r_ptr[j + b_len - 2];
 	      mp_twolimb_t c3 = /* b[n-2] * q* */
 		(mp_twolimb_t) b_2msd * (mp_twolimb_t) q_star;
 	      /* While c2 < c3, increase c2 and decrease c3.
 		 Consider c3-c2.  While it is > 0, decrease it by
 		 b[n-1]*beta+b[n-2].  Because of b[n-1]*beta+b[n-2] >= beta^2/2
 		 this can happen only twice.  */
 	      if (c3 > c2)
 		{
 		  q_star = q_star - 1; /* q* := q* - 1 */
 		  if (c3 - c2 > b_msdd)
 		    q_star = q_star - 1; /* q* := q* - 1 */
 		}
 	    }
 	    if (q_star > 0)
 	      subtract:
 	      {
 		/* Subtract r := r - b * q* * beta^j.  */
 		mp_limb_t cr;
 		{
 		  const mp_limb_t *sourceptr = b_ptr;
 		  mp_limb_t *destptr = r_ptr + j;
 		  mp_twolimb_t carry = 0;
 		  size_t count;
 		  for (count = b_len; count > 0; count--)
 		    {
 		      /* Here 0 <= carry <= q*.  */
 		      carry =
 			carry
 			+ (mp_twolimb_t) q_star * (mp_twolimb_t) *sourceptr++
 			+ (mp_limb_t) ~(*destptr);
 		      /* Here 0 <= carry <= beta*q* + beta-1.  */
 		      *destptr++ = ~(mp_limb_t) carry;
 		      carry = carry >> GMP_LIMB_BITS; /* <= q* */
 		    }
 		  cr = (mp_limb_t) carry;
 		}
 		/* Subtract cr from r_ptr[j + b_len], then forget about
 		   r_ptr[j + b_len].  */
 		if (cr > r_ptr[j + b_len])
 		  {
 		    /* Subtraction gave a carry.  */
 		    q_star = q_star - 1; /* q* := q* - 1 */
 		    /* Add b back.  */
 		    {
 		      const mp_limb_t *sourceptr = b_ptr;
 		      mp_limb_t *destptr = r_ptr + j;
 		      mp_limb_t carry = 0;
 		      size_t count;
 		      for (count = b_len; count > 0; count--)
 			{
 			  mp_limb_t source1 = *sourceptr++;
 			  mp_limb_t source2 = *destptr;
 			  *destptr++ = source1 + source2 + carry;
 			  carry =
 			    (carry
 			     ? source1 >= (mp_limb_t) ~source2
 			     : source1 > (mp_limb_t) ~source2);
 			}
 		    }
 		    /* Forget about the carry and about r[j+n].  */
 		  }
 	      }
 	    /* q* is determined.  Store it as q[j].  */
 	    q_ptr[j] = q_star;
 	    if (j == 0)
 	      break;
 	    j--;
 	  }
       }
       r_len = b_len;
       /* Normalise q.  */
       if (q_ptr[q_len - 1] == 0)
 	q_len--;
 # if 0 /* Not needed here, since we need r only to compare it with b/2, and
 	  b is shifted left by s bits.  */
       /* Shift r right by s bits.  */
       if (s > 0)
 	{
 	  mp_limb_t ptr = r_ptr + r_len;
 	  mp_twolimb_t accu = 0;
 	  size_t count;
 	  for (count = r_len; count > 0; count--)
 	    {
 	      accu = (mp_twolimb_t) (mp_limb_t) accu << GMP_LIMB_BITS;
 	      accu += (mp_twolimb_t) *--ptr << (GMP_LIMB_BITS - s);
 	      *ptr = (mp_limb_t) (accu >> GMP_LIMB_BITS);
 	    }
 	}
 # endif
       /* Normalise r.  */
       while (r_len > 0 && r_ptr[r_len - 1] == 0)
 	r_len--;
     }
   /* Compare r << 1 with b.  */
   if (r_len > b_len)
     goto increment_q;
   {
     size_t i;
     for (i = b_len;;)
       {
 	mp_limb_t r_i =
 	  (i <= r_len && i > 0 ? r_ptr[i - 1] >> (GMP_LIMB_BITS - 1) : 0)
 	  | (i < r_len ? r_ptr[i] << 1 : 0);
 	mp_limb_t b_i = (i < b_len ? b_ptr[i] : 0);
 	if (r_i > b_i)
 	  goto increment_q;
 	if (r_i < b_i)
 	  goto keep_q;
 	if (i == 0)
 	  break;
 	i--;
       }
   }
   if (q_len > 0 && ((q_ptr[0] & 1) != 0))
     /* q is odd.  */
     increment_q:
     {
       size_t i;
       for (i = 0; i < q_len; i++)
 	if (++(q_ptr[i]) != 0)
 	  goto keep_q;
       q_ptr[q_len++] = 1;
     }
   keep_q:
   if (tmp_roomptr != NULL)
     free (tmp_roomptr);
   q->limbs = q_ptr;
   q->nlimbs = q_len;
   return roomptr;
 }

 /* Convert a bignum a >= 0, multiplied with 10^extra_zeroes, to decimal
    representation.
    Destroys the contents of a.
    Return the allocated memory - containing the decimal digits in low-to-high
    order, terminated with a NUL character - in case of success, NULL in case
    of memory allocation failure.  */
 static char *
 convert_to_decimal (mpn_t a, size_t extra_zeroes)
 {
   mp_limb_t *a_ptr = a.limbs;
   size_t a_len = a.nlimbs;
   /* 0.03345 is slightly larger than log(2)/(9*log(10)).  */
   size_t c_len = 9 * ((size_t)(a_len * (GMP_LIMB_BITS * 0.03345f)) + 1);
   char *c_ptr = (char *) malloc (xsum (c_len, extra_zeroes));
   if (c_ptr != NULL)
     {
       char *d_ptr = c_ptr;
       for (; extra_zeroes > 0; extra_zeroes--)
 	*d_ptr++ = '0';
       while (a_len > 0)
 	{
 	  /* Divide a by 10^9, in-place.  */
 	  mp_limb_t remainder = 0;
 	  mp_limb_t *ptr = a_ptr + a_len;
 	  size_t count;
 	  for (count = a_len; count > 0; count--)
 	    {
 	      mp_twolimb_t num =
 		((mp_twolimb_t) remainder << GMP_LIMB_BITS) | *--ptr;
 	      *ptr = num / 1000000000;
 	      remainder = num % 1000000000;
 	    }
 	  /* Store the remainder as 9 decimal digits.  */
 	  for (count = 9; count > 0; count--)
 	    {
 	      *d_ptr++ = '0' + (remainder % 10);
 	      remainder = remainder / 10;
 	    }
 	  /* Normalize a.  */
 	  if (a_ptr[a_len - 1] == 0)
 	    a_len--;
 	}
       /* Remove leading zeroes.  */
       while (d_ptr > c_ptr && d_ptr[-1] == '0')
 	d_ptr--;
       /* But keep at least one zero.  */
       if (d_ptr == c_ptr)
 	*d_ptr++ = '0';
       /* Terminate the string.  */
       *d_ptr = '\0';
     }
   return c_ptr;
 }

 # if NEED_PRINTF_LONG_DOUBLE

 /* Assuming x is finite and >= 0:
    write x as x = 2^e * m, where m is a bignum.
    Return the allocated memory in case of success, NULL in case of memory
    allocation failure.  */
 static void *
 decode_long_double (long double x, int *ep, mpn_t *mp)
 {
   mpn_t m;
   int exp;
   long double y;
   size_t i;

   /* Allocate memory for result.  */
   m.nlimbs = (LDBL_MANT_BIT + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
   m.limbs = (mp_limb_t *) malloc (m.nlimbs * sizeof (mp_limb_t));
   if (m.limbs == NULL)
     return NULL;
   /* Split into exponential part and mantissa.  */
   y = frexpl (x, &exp);
   if (!(y >= 0.0L && y < 1.0L))
     abort ();
   /* x = 2^exp * y = 2^(exp - LDBL_MANT_BIT) * (y * LDBL_MANT_BIT), and the
      latter is an integer.  */
   /* Convert the mantissa (y * LDBL_MANT_BIT) to a sequence of limbs.
      I'm not sure whether it's safe to cast a 'long double' value between
      2^31 and 2^32 to 'unsigned int', therefore play safe and cast only
      'long double' values between 0 and 2^16 (to 'unsigned int' or 'int',
      doesn't matter).  */
 #  if (LDBL_MANT_BIT % GMP_LIMB_BITS) != 0
 #   if (LDBL_MANT_BIT % GMP_LIMB_BITS) > GMP_LIMB_BITS / 2
     {
       mp_limb_t hi, lo;
       y *= (mp_limb_t) 1 << (LDBL_MANT_BIT % (GMP_LIMB_BITS / 2));
       hi = (int) y;
       y -= hi;
       if (!(y >= 0.0L && y < 1.0L))
 	abort ();
       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
       lo = (int) y;
       y -= lo;
       if (!(y >= 0.0L && y < 1.0L))
 	abort ();
       m.limbs[LDBL_MANT_BIT / GMP_LIMB_BITS] = (hi << (GMP_LIMB_BITS / 2)) | lo;
     }
 #   else
     {
       mp_limb_t d;
       y *= (mp_limb_t) 1 << (LDBL_MANT_BIT % GMP_LIMB_BITS);
       d = (int) y;
       y -= d;
       if (!(y >= 0.0L && y < 1.0L))
 	abort ();
       m.limbs[LDBL_MANT_BIT / GMP_LIMB_BITS] = d;
     }
 #   endif
 #  endif
   for (i = LDBL_MANT_BIT / GMP_LIMB_BITS; i > 0; )
     {
       mp_limb_t hi, lo;
       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
       hi = (int) y;
       y -= hi;
       if (!(y >= 0.0L && y < 1.0L))
 	abort ();
       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
       lo = (int) y;
       y -= lo;
       if (!(y >= 0.0L && y < 1.0L))
 	abort ();
       m.limbs[--i] = (hi << (GMP_LIMB_BITS / 2)) | lo;
     }
   if (!(y == 0.0L))
     abort ();
   /* Normalise.  */
   while (m.nlimbs > 0 && m.limbs[m.nlimbs - 1] == 0)
     m.nlimbs--;
   *mp = m;
   *ep = exp - LDBL_MANT_BIT;
   return m.limbs;
 }

 # endif

 # if NEED_PRINTF_DOUBLE

 /* Assuming x is finite and >= 0:
    write x as x = 2^e * m, where m is a bignum.
    Return the allocated memory in case of success, NULL in case of memory
    allocation failure.  */
 static void *
 decode_double (double x, int *ep, mpn_t *mp)
 {
   mpn_t m;
   int exp;
   double y;
   size_t i;

   /* Allocate memory for result.  */
   m.nlimbs = (DBL_MANT_BIT + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
   m.limbs = (mp_limb_t *) malloc (m.nlimbs * sizeof (mp_limb_t));
   if (m.limbs == NULL)
     return NULL;
   /* Split into exponential part and mantissa.  */
   y = frexp (x, &exp);
   if (!(y >= 0.0 && y < 1.0))
     abort ();
   /* x = 2^exp * y = 2^(exp - DBL_MANT_BIT) * (y * DBL_MANT_BIT), and the
      latter is an integer.  */
   /* Convert the mantissa (y * DBL_MANT_BIT) to a sequence of limbs.
      I'm not sure whether it's safe to cast a 'double' value between
      2^31 and 2^32 to 'unsigned int', therefore play safe and cast only
      'double' values between 0 and 2^16 (to 'unsigned int' or 'int',
      doesn't matter).  */
 #  if (DBL_MANT_BIT % GMP_LIMB_BITS) != 0
 #   if (DBL_MANT_BIT % GMP_LIMB_BITS) > GMP_LIMB_BITS / 2
     {
       mp_limb_t hi, lo;
       y *= (mp_limb_t) 1 << (DBL_MANT_BIT % (GMP_LIMB_BITS / 2));
       hi = (int) y;
       y -= hi;
       if (!(y >= 0.0 && y < 1.0))
 	abort ();
       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
       lo = (int) y;
       y -= lo;
       if (!(y >= 0.0 && y < 1.0))
 	abort ();
       m.limbs[DBL_MANT_BIT / GMP_LIMB_BITS] = (hi << (GMP_LIMB_BITS / 2)) | lo;
     }
 #   else
     {
       mp_limb_t d;
       y *= (mp_limb_t) 1 << (DBL_MANT_BIT % GMP_LIMB_BITS);
       d = (int) y;
       y -= d;
       if (!(y >= 0.0 && y < 1.0))
 	abort ();
       m.limbs[DBL_MANT_BIT / GMP_LIMB_BITS] = d;
     }
 #   endif
 #  endif
   for (i = DBL_MANT_BIT / GMP_LIMB_BITS; i > 0; )
     {
       mp_limb_t hi, lo;
       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
       hi = (int) y;
       y -= hi;
       if (!(y >= 0.0 && y < 1.0))
 	abort ();
       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
       lo = (int) y;
       y -= lo;
       if (!(y >= 0.0 && y < 1.0))
 	abort ();
       m.limbs[--i] = (hi << (GMP_LIMB_BITS / 2)) | lo;
     }
   if (!(y == 0.0))
     abort ();
   /* Normalise.  */
   while (m.nlimbs > 0 && m.limbs[m.nlimbs - 1] == 0)
     m.nlimbs--;
   *mp = m;
   *ep = exp - DBL_MANT_BIT;
   return m.limbs;
 }

 # endif

 /* Assuming x = 2^e * m is finite and >= 0, and n is an integer:
    Returns the decimal representation of round (x * 10^n).
    Return the allocated memory - containing the decimal digits in low-to-high
    order, terminated with a NUL character - in case of success, NULL in case
    of memory allocation failure.  */
 static char *
 scale10_round_decimal_decoded (int e, mpn_t m, void *memory, int n)
 {
   int s;
   size_t extra_zeroes;
   unsigned int abs_n;
   unsigned int abs_s;
   mp_limb_t *pow5_ptr;
   size_t pow5_len;
   unsigned int s_limbs;
   unsigned int s_bits;
   mpn_t pow5;
   mpn_t z;
   void *z_memory;
   char *digits;

   if (memory == NULL)
     return NULL;
   /* x = 2^e * m, hence
      y = round (2^e * 10^n * m) = round (2^(e+n) * 5^n * m)
        = round (2^s * 5^n * m).  */
   s = e + n;
   extra_zeroes = 0;
   /* Factor out a common power of 10 if possible.  */
   if (s > 0 && n > 0)
     {
       extra_zeroes = (s < n ? s : n);
       s -= extra_zeroes;
       n -= extra_zeroes;
     }
   /* Here y = round (2^s * 5^n * m) * 10^extra_zeroes.
      Before converting to decimal, we need to compute
      z = round (2^s * 5^n * m).  */
   /* Compute 5^|n|, possibly shifted by |s| bits if n and s have the same
      sign.  2.322 is slightly larger than log(5)/log(2).  */
   abs_n = (n >= 0 ? n : -n);
   abs_s = (s >= 0 ? s : -s);
   pow5_ptr = (mp_limb_t *) malloc (((int)(abs_n * (2.322f / GMP_LIMB_BITS)) + 1
 				    + abs_s / GMP_LIMB_BITS + 1)
 				   * sizeof (mp_limb_t));
   if (pow5_ptr == NULL)
     {
       free (memory);
       return NULL;
     }
   /* Initialize with 1.  */
   pow5_ptr[0] = 1;
   pow5_len = 1;
   /* Multiply with 5^|n|.  */
   if (abs_n > 0)
     {
       static mp_limb_t const small_pow5[13 + 1] =
 	{
 	  1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625,
 	  48828125, 244140625, 1220703125
 	};
       unsigned int n13;
       for (n13 = 0; n13 <= abs_n; n13 += 13)
 	{
 	  mp_limb_t digit1 = small_pow5[n13 + 13 <= abs_n ? 13 : abs_n - n13];
 	  size_t j;
 	  mp_twolimb_t carry = 0;
 	  for (j = 0; j < pow5_len; j++)
 	    {
 	      mp_limb_t digit2 = pow5_ptr[j];
 	      carry += (mp_twolimb_t) digit1 * (mp_twolimb_t) digit2;
 	      pow5_ptr[j] = (mp_limb_t) carry;
 	      carry = carry >> GMP_LIMB_BITS;
 	    }
 	  if (carry > 0)
 	    pow5_ptr[pow5_len++] = (mp_limb_t) carry;
 	}
     }
   s_limbs = abs_s / GMP_LIMB_BITS;
   s_bits = abs_s % GMP_LIMB_BITS;
   if (n >= 0 ? s >= 0 : s <= 0)
     {
       /* Multiply with 2^|s|.  */
       if (s_bits > 0)
 	{
 	  mp_limb_t *ptr = pow5_ptr;
 	  mp_twolimb_t accu = 0;
 	  size_t count;
 	  for (count = pow5_len; count > 0; count--)
 	    {
 	      accu += (mp_twolimb_t) *ptr << s_bits;
 	      *ptr++ = (mp_limb_t) accu;
 	      accu = accu >> GMP_LIMB_BITS;
 	    }
 	  if (accu > 0)
 	    {
 	      *ptr = (mp_limb_t) accu;
 	      pow5_len++;
 	    }
 	}
       if (s_limbs > 0)
 	{
 	  size_t count;
 	  for (count = pow5_len; count > 0;)
 	    {
 	      count--;
 	      pow5_ptr[s_limbs + count] = pow5_ptr[count];
 	    }
 	  for (count = s_limbs; count > 0;)
 	    {
 	      count--;
 	      pow5_ptr[count] = 0;
 	    }
 	  pow5_len += s_limbs;
 	}
       pow5.limbs = pow5_ptr;
       pow5.nlimbs = pow5_len;
       if (n >= 0)
 	{
 	  /* Multiply m with pow5.  No division needed.  */
 	  z_memory = multiply (m, pow5, &z);
 	}
       else
 	{
 	  /* Divide m by pow5 and round.  */
 	  z_memory = divide (m, pow5, &z);
 	}
     }
   else
     {
       pow5.limbs = pow5_ptr;
       pow5.nlimbs = pow5_len;
       if (n >= 0)
 	{
 	  /* n >= 0, s < 0.
 	     Multiply m with pow5, then divide by 2^|s|.  */
 	  mpn_t numerator;
 	  mpn_t denominator;
 	  void *tmp_memory;
 	  tmp_memory = multiply (m, pow5, &numerator);
 	  if (tmp_memory == NULL)
 	    {
 	      free (pow5_ptr);
 	      free (memory);
 	      return NULL;
 	    }
 	  /* Construct 2^|s|.  */
 	  {
 	    mp_limb_t *ptr = pow5_ptr + pow5_len;
 	    size_t i;
 	    for (i = 0; i < s_limbs; i++)
 	      ptr[i] = 0;
 	    ptr[s_limbs] = (mp_limb_t) 1 << s_bits;
 	    denominator.limbs = ptr;
 	    denominator.nlimbs = s_limbs + 1;
 	  }
 	  z_memory = divide (numerator, denominator, &z);
 	  free (tmp_memory);
 	}
       else
 	{
 	  /* n < 0, s > 0.
 	     Multiply m with 2^s, then divide by pow5.  */
 	  mpn_t numerator;
 	  mp_limb_t *num_ptr;
 	  num_ptr = (mp_limb_t *) malloc ((m.nlimbs + s_limbs + 1)
 					  * sizeof (mp_limb_t));
 	  if (num_ptr == NULL)
 	    {
 	      free (pow5_ptr);
 	      free (memory);
 	      return NULL;
 	    }
 	  {
 	    mp_limb_t *destptr = num_ptr;
 	    {
 	      size_t i;
 	      for (i = 0; i < s_limbs; i++)
 		*destptr++ = 0;
 	    }
 	    if (s_bits > 0)
 	      {
 		const mp_limb_t *sourceptr = m.limbs;
 		mp_twolimb_t accu = 0;
 		size_t count;
 		for (count = m.nlimbs; count > 0; count--)
 		  {
 		    accu += (mp_twolimb_t) *sourceptr++ << s_bits;
 		    *destptr++ = (mp_limb_t) accu;
 		    accu = accu >> GMP_LIMB_BITS;
 		  }
 		if (accu > 0)
 		  *destptr++ = (mp_limb_t) accu;
 	      }
 	    else
 	      {
 		const mp_limb_t *sourceptr = m.limbs;
 		size_t count;
 		for (count = m.nlimbs; count > 0; count--)
 		  *destptr++ = *sourceptr++;
 	      }
 	    numerator.limbs = num_ptr;
 	    numerator.nlimbs = destptr - num_ptr;
 	  }
 	  z_memory = divide (numerator, pow5, &z);
 	  free (num_ptr);
 	}
     }
   free (pow5_ptr);
   free (memory);

   /* Here y = round (x * 10^n) = z * 10^extra_zeroes.  */

   if (z_memory == NULL)
     return NULL;
   digits = convert_to_decimal (z, extra_zeroes);
   free (z_memory);
   return digits;
 }

 # if NEED_PRINTF_LONG_DOUBLE

 /* Assuming x is finite and >= 0, and n is an integer:
    Returns the decimal representation of round (x * 10^n).
    Return the allocated memory - containing the decimal digits in low-to-high
    order, terminated with a NUL character - in case of success, NULL in case
    of memory allocation failure.  */
 static char *
 scale10_round_decimal_long_double (long double x, int n)
 {
   int e;
   mpn_t m;
   void *memory = decode_long_double (x, &e, &m);
   return scale10_round_decimal_decoded (e, m, memory, n);
 }

 # endif

 # if NEED_PRINTF_DOUBLE

 /* Assuming x is finite and >= 0, and n is an integer:
    Returns the decimal representation of round (x * 10^n).
    Return the allocated memory - containing the decimal digits in low-to-high
    order, terminated with a NUL character - in case of success, NULL in case
    of memory allocation failure.  */
 static char *
 scale10_round_decimal_double (double x, int n)
 {
   int e;
   mpn_t m;
   void *memory = decode_double (x, &e, &m);
   return scale10_round_decimal_decoded (e, m, memory, n);
 }

 # endif

 # if NEED_PRINTF_LONG_DOUBLE

 /* Assuming x is finite and > 0:
    Return an approximation for n with 10^n <= x < 10^(n+1).
    The approximation is usually the right n, but may be off by 1 sometimes.  */
 static int
 floorlog10l (long double x)
 {
   int exp;
   long double y;
   double z;
   double l;

   /* Split into exponential part and mantissa.  */
   y = frexpl (x, &exp);
   if (!(y >= 0.0L && y < 1.0L))
     abort ();
   if (y == 0.0L)
     return INT_MIN;
   if (y < 0.5L)
     {
       while (y < (1.0L / (1 << (GMP_LIMB_BITS / 2)) / (1 << (GMP_LIMB_BITS / 2))))
 	{
 	  y *= 1.0L * (1 << (GMP_LIMB_BITS / 2)) * (1 << (GMP_LIMB_BITS / 2));
 	  exp -= GMP_LIMB_BITS;
 	}
       if (y < (1.0L / (1 << 16)))
 	{
 	  y *= 1.0L * (1 << 16);
 	  exp -= 16;
 	}
       if (y < (1.0L / (1 << 8)))
 	{
 	  y *= 1.0L * (1 << 8);
 	  exp -= 8;
 	}
       if (y < (1.0L / (1 << 4)))
 	{
 	  y *= 1.0L * (1 << 4);
 	  exp -= 4;
 	}
       if (y < (1.0L / (1 << 2)))
 	{
 	  y *= 1.0L * (1 << 2);
 	  exp -= 2;
 	}
       if (y < (1.0L / (1 << 1)))
 	{
 	  y *= 1.0L * (1 << 1);
 	  exp -= 1;
 	}
     }
   if (!(y >= 0.5L && y < 1.0L))
     abort ();
   /* Compute an approximation for l = log2(x) = exp + log2(y).  */
   l = exp;
   z = y;
   if (z < 0.70710678118654752444)
     {
       z *= 1.4142135623730950488;
       l -= 0.5;
     }
   if (z < 0.8408964152537145431)
     {
       z *= 1.1892071150027210667;
       l -= 0.25;
     }
   if (z < 0.91700404320467123175)
     {
       z *= 1.0905077326652576592;
       l -= 0.125;
     }
   if (z < 0.9576032806985736469)
     {
       z *= 1.0442737824274138403;
       l -= 0.0625;
     }
   /* Now 0.95 <= z <= 1.01.  */
   z = 1 - z;
   /* log(1-z) = - z - z^2/2 - z^3/3 - z^4/4 - ...
      Four terms are enough to get an approximation with error < 10^-7.  */
   l -= z * (1.0 + z * (0.5 + z * ((1.0 / 3) + z * 0.25)));
   /* Finally multiply with log(2)/log(10), yields an approximation for
      log10(x).  */
   l *= 0.30102999566398119523;
   /* Round down to the next integer.  */
   return (int) l + (l < 0 ? -1 : 0);
 }

 # endif

 # if NEED_PRINTF_DOUBLE

 /* Assuming x is finite and > 0:
    Return an approximation for n with 10^n <= x < 10^(n+1).
    The approximation is usually the right n, but may be off by 1 sometimes.  */
 static int
 floorlog10 (double x)
 {
   int exp;
   double y;
   double z;
   double l;

   /* Split into exponential part and mantissa.  */
   y = frexp (x, &exp);
   if (!(y >= 0.0 && y < 1.0))
     abort ();
   if (y == 0.0)
     return INT_MIN;
   if (y < 0.5)
     {
       while (y < (1.0 / (1 << (GMP_LIMB_BITS / 2)) / (1 << (GMP_LIMB_BITS / 2))))
 	{
 	  y *= 1.0 * (1 << (GMP_LIMB_BITS / 2)) * (1 << (GMP_LIMB_BITS / 2));
 	  exp -= GMP_LIMB_BITS;
 	}
       if (y < (1.0 / (1 << 16)))
 	{
 	  y *= 1.0 * (1 << 16);
 	  exp -= 16;
 	}
       if (y < (1.0 / (1 << 8)))
 	{
 	  y *= 1.0 * (1 << 8);
 	  exp -= 8;
 	}
       if (y < (1.0 / (1 << 4)))
 	{
 	  y *= 1.0 * (1 << 4);
 	  exp -= 4;
 	}
       if (y < (1.0 / (1 << 2)))
 	{
 	  y *= 1.0 * (1 << 2);
 	  exp -= 2;
 	}
       if (y < (1.0 / (1 << 1)))
 	{
 	  y *= 1.0 * (1 << 1);
 	  exp -= 1;
 	}
     }
   if (!(y >= 0.5 && y < 1.0))
     abort ();
   /* Compute an approximation for l = log2(x) = exp + log2(y).  */
   l = exp;
   z = y;
   if (z < 0.70710678118654752444)
     {
       z *= 1.4142135623730950488;
       l -= 0.5;
     }
   if (z < 0.8408964152537145431)
     {
       z *= 1.1892071150027210667;
       l -= 0.25;
     }
   if (z < 0.91700404320467123175)
     {
       z *= 1.0905077326652576592;
       l -= 0.125;
     }
   if (z < 0.9576032806985736469)
     {
       z *= 1.0442737824274138403;
       l -= 0.0625;
     }
   /* Now 0.95 <= z <= 1.01.  */
   z = 1 - z;
   /* log(1-z) = - z - z^2/2 - z^3/3 - z^4/4 - ...
      Four terms are enough to get an approximation with error < 10^-7.  */
   l -= z * (1.0 + z * (0.5 + z * ((1.0 / 3) + z * 0.25)));
   /* Finally multiply with log(2)/log(10), yields an approximation for
      log10(x).  */
   l *= 0.30102999566398119523;
   /* Round down to the next integer.  */
   return (int) l + (l < 0 ? -1 : 0);
 }

 # endif

 #endif

 DCHAR_T *
 VASNPRINTF (DCHAR_T *resultbuf, size_t *lengthp,
 	    const FCHAR_T *format, va_list args)
 {
   DIRECTIVES d;
   arguments a;

   if (PRINTF_PARSE (format, &d, &a) < 0)
     /* errno is already set.  */
     return NULL;

 #define CLEANUP() \
   free (d.dir);								\
   if (a.arg)								\
     free (a.arg);

   if (PRINTF_FETCHARGS (args, &a) < 0)
     {
       CLEANUP ();
       errno = EINVAL;
       return NULL;
     }

   {
     size_t buf_neededlength;
     TCHAR_T *buf;
     TCHAR_T *buf_malloced;
     const FCHAR_T *cp;
     size_t i;
     DIRECTIVE *dp;
     /* Output string accumulator.  */
     DCHAR_T *result;
     size_t allocated;
     size_t length;

     /* Allocate a small buffer that will hold a directive passed to
        sprintf or snprintf.  */
     buf_neededlength =
       xsum4 (7, d.max_width_length, d.max_precision_length, 6);
 #if HAVE_ALLOCA
     if (buf_neededlength < 4000 / sizeof (TCHAR_T))
       {
 	buf = (TCHAR_T *) alloca (buf_neededlength * sizeof (TCHAR_T));
 	buf_malloced = NULL;
       }
     else
 #endif
       {
 	size_t buf_memsize = xtimes (buf_neededlength, sizeof (TCHAR_T));
 	if (size_overflow_p (buf_memsize))
 	  goto out_of_memory_1;
 	buf = (TCHAR_T *) malloc (buf_memsize);
 	if (buf == NULL)
 	  goto out_of_memory_1;
 	buf_malloced = buf;
       }

     if (resultbuf != NULL)
       {
 	result = resultbuf;
 	allocated = *lengthp;
       }
     else
       {
 	result = NULL;
 	allocated = 0;
       }
     length = 0;
     /* Invariants:
        result is either == resultbuf or == NULL or malloc-allocated.
        If length > 0, then result != NULL.  */

     /* Ensures that allocated >= needed.  Aborts through a jump to
        out_of_memory if needed is SIZE_MAX or otherwise too big.  */
 #define ENSURE_ALLOCATION(needed) \
     if ((needed) > allocated)						     \
       {									     \
 	size_t memory_size;						     \
 	DCHAR_T *memory;						     \
 									     \
 	allocated = (allocated > 0 ? xtimes (allocated, 2) : 12);	     \
 	if ((needed) > allocated)					     \
 	  allocated = (needed);						     \
 	memory_size = xtimes (allocated, sizeof (DCHAR_T));		     \
 	if (size_overflow_p (memory_size))				     \
 	  goto out_of_memory;						     \
 	if (result == resultbuf || result == NULL)			     \
 	  memory = (DCHAR_T *) malloc (memory_size);			     \
 	else								     \
 	  memory = (DCHAR_T *) realloc (result, memory_size);		     \
 	if (memory == NULL)						     \
 	  goto out_of_memory;						     \
 	if (result == resultbuf && length > 0)				     \
 	  DCHAR_CPY (memory, result, length);				     \
 	result = memory;						     \
       }

     for (cp = format, i = 0, dp = &d.dir[0]; ; cp = dp->dir_end, i++, dp++)
       {
 	if (cp != dp->dir_start)
 	  {
 	    size_t n = dp->dir_start - cp;
 	    size_t augmented_length = xsum (length, n);

 	    ENSURE_ALLOCATION (augmented_length);
 	    /* This copies a piece of FCHAR_T[] into a DCHAR_T[].  Here we
 	       need that the format string contains only ASCII characters
 	       if FCHAR_T and DCHAR_T are not the same type.  */
 	    if (sizeof (FCHAR_T) == sizeof (DCHAR_T))
 	      {
 		DCHAR_CPY (result + length, (const DCHAR_T *) cp, n);
 		length = augmented_length;
 	      }
 	    else
 	      {
 		do
 		  result[length++] = (unsigned char) *cp++;
 		while (--n > 0);
 	      }
 	  }
 	if (i == d.count)
 	  break;

 	/* Execute a single directive.  */
 	if (dp->conversion == '%')
 	  {
 	    size_t augmented_length;

 	    if (!(dp->arg_index == ARG_NONE))
 	      abort ();
 	    augmented_length = xsum (length, 1);
 	    ENSURE_ALLOCATION (augmented_length);
 	    result[length] = '%';
 	    length = augmented_length;
 	  }
 	else
 	  {
 	    if (!(dp->arg_index != ARG_NONE))
 	      abort ();

 	    if (dp->conversion == 'n')
 	      {
 		switch (a.arg[dp->arg_index].type)
 		  {
 		  case TYPE_COUNT_SCHAR_POINTER:
 		    *a.arg[dp->arg_index].a.a_count_schar_pointer = length;
 		    break;
 		  case TYPE_COUNT_SHORT_POINTER:
 		    *a.arg[dp->arg_index].a.a_count_short_pointer = length;
 		    break;
 		  case TYPE_COUNT_INT_POINTER:
 		    *a.arg[dp->arg_index].a.a_count_int_pointer = length;
 		    break;
 		  case TYPE_COUNT_LONGINT_POINTER:
 		    *a.arg[dp->arg_index].a.a_count_longint_pointer = length;
 		    break;
 #if HAVE_LONG_LONG_INT
 		  case TYPE_COUNT_LONGLONGINT_POINTER:
 		    *a.arg[dp->arg_index].a.a_count_longlongint_pointer = length;
 		    break;
 #endif
 		  default:
 		    abort ();
 		  }
 	      }
 #if ENABLE_UNISTDIO
 	    /* The unistdio extensions.  */
 	    else if (dp->conversion == 'U')
 	      {
 		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;

 		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 FCHAR_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 FCHAR_T *digitp = dp->precision_start + 1;

 			precision = 0;
 			while (digitp != dp->precision_end)
 			  precision = xsum (xtimes (precision, 10), *digitp++ - '0');
 			has_precision = 1;
 		      }
 		  }

 		switch (type)
 		  {
 		  case TYPE_U8_STRING:
 		    {
 		      const uint8_t *arg = a.arg[dp->arg_index].a.a_u8_string;
 		      const uint8_t *arg_end;
 		      size_t characters;

 		      if (has_precision)
 			{
 			  /* Use only PRECISION characters, from the left.  */
 			  arg_end = arg;
 			  characters = 0;
 			  for (; precision > 0; precision--)
 			    {
 			      int count = u8_strmblen (arg_end);
 			      if (count == 0)
 				break;
 			      if (count < 0)
 				{
 				  if (!(result == resultbuf || result == NULL))
 				    free (result);
 				  if (buf_malloced != NULL)
 				    free (buf_malloced);
 				  CLEANUP ();
 				  errno = EILSEQ;
 				  return NULL;
 				}
 			      arg_end += count;
 			      characters++;
 			    }
 			}
 		      else if (has_width)
 			{
 			  /* Use the entire string, and count the number of
 			     characters.  */
 			  arg_end = arg;
 			  characters = 0;
 			  for (;;)
 			    {
 			      int count = u8_strmblen (arg_end);
 			      if (count == 0)
 				break;
 			      if (count < 0)
 				{
 				  if (!(result == resultbuf || result == NULL))
 				    free (result);
 				  if (buf_malloced != NULL)
 				    free (buf_malloced);
 				  CLEANUP ();
 				  errno = EILSEQ;
 				  return NULL;
 				}
 			      arg_end += count;
 			      characters++;
 			    }
 			}
 		      else
 			{
 			  /* Use the entire string.  */
 			  arg_end = arg + u8_strlen (arg);
 			  /* The number of characters doesn't matter.  */
 			  characters = 0;
 			}

 		      if (has_width && width > characters
 			  && !(dp->flags & FLAG_LEFT))
 			{
 			  size_t n = width - characters;
 			  ENSURE_ALLOCATION (xsum (length, n));
 			  DCHAR_SET (result + length, ' ', n);
 			  length += n;
 			}

 # if DCHAR_IS_UINT8_T
 		      {
 			size_t n = arg_end - arg;
 			ENSURE_ALLOCATION (xsum (length, n));
 			DCHAR_CPY (result + length, arg, n);
 			length += n;
 		      }
 # else
 		      { /* Convert.  */
 			DCHAR_T *converted = result + length;
 			size_t converted_len = allocated - length;
 #  if DCHAR_IS_TCHAR
 			/* Convert from UTF-8 to locale encoding.  */
 			if (u8_conv_to_encoding (locale_charset (),
 						 iconveh_question_mark,
 						 arg, arg_end - arg, NULL,
 						 &converted, &converted_len)
 			    < 0)
 #  else
 			/* Convert from UTF-8 to UTF-16/UTF-32.  */
 			converted =
 			  U8_TO_DCHAR (arg, arg_end - arg,
 				       converted, &converted_len);
 			if (converted == NULL)
 #  endif
 			  {
 			    int saved_errno = errno;
 			    if (!(result == resultbuf || result == NULL))
 			      free (result);
 			    if (buf_malloced != NULL)
 			      free (buf_malloced);
 			    CLEANUP ();
 			    errno = saved_errno;
 			    return NULL;
 			  }
 			if (converted != result + length)
 			  {
 			    ENSURE_ALLOCATION (xsum (length, converted_len));
 			    DCHAR_CPY (result + length, converted, converted_len);
 			    free (converted);
 			  }
 			length += converted_len;
 		      }
 # endif

 		      if (has_width && width > characters
 			  && (dp->flags & FLAG_LEFT))
 			{
 			  size_t n = width - characters;
 			  ENSURE_ALLOCATION (xsum (length, n));
 			  DCHAR_SET (result + length, ' ', n);
 			  length += n;
 			}
 		    }
 		    break;

 		  case TYPE_U16_STRING:
 		    {
 		      const uint16_t *arg = a.arg[dp->arg_index].a.a_u16_string;
 		      const uint16_t *arg_end;
 		      size_t characters;

 		      if (has_precision)
 			{
 			  /* Use only PRECISION characters, from the left.  */
 			  arg_end = arg;
 			  characters = 0;
 			  for (; precision > 0; precision--)
 			    {
 			      int count = u16_strmblen (arg_end);
 			      if (count == 0)
 				break;
 			      if (count < 0)
 				{
 				  if (!(result == resultbuf || result == NULL))
 				    free (result);
 				  if (buf_malloced != NULL)
 				    free (buf_malloced);
 				  CLEANUP ();
 				  errno = EILSEQ;
 				  return NULL;
 				}
 			      arg_end += count;
 			      characters++;
 			    }
 			}
 		      else if (has_width)
 			{
 			  /* Use the entire string, and count the number of
 			     characters.  */
 			  arg_end = arg;
 			  characters = 0;
 			  for (;;)
 			    {
 			      int count = u16_strmblen (arg_end);
 			      if (count == 0)
 				break;
 			      if (count < 0)
 				{
 				  if (!(result == resultbuf || result == NULL))
 				    free (result);
 				  if (buf_malloced != NULL)
 				    free (buf_malloced);
 				  CLEANUP ();
 				  errno = EILSEQ;
 				  return NULL;
 				}
 			      arg_end += count;
 			      characters++;
 			    }
 			}
 		      else
 			{
 			  /* Use the entire string.  */
 			  arg_end = arg + u16_strlen (arg);
 			  /* The number of characters doesn't matter.  */
 			  characters = 0;
 			}

 		      if (has_width && width > characters
 			  && !(dp->flags & FLAG_LEFT))
 			{
 			  size_t n = width - characters;
 			  ENSURE_ALLOCATION (xsum (length, n));
 			  DCHAR_SET (result + length, ' ', n);
 			  length += n;
 			}

 # if DCHAR_IS_UINT16_T
 		      {
 			size_t n = arg_end - arg;
 			ENSURE_ALLOCATION (xsum (length, n));
 			DCHAR_CPY (result + length, arg, n);
 			length += n;
 		      }
 # else
 		      { /* Convert.  */
 			DCHAR_T *converted = result + length;
 			size_t converted_len = allocated - length;
 #  if DCHAR_IS_TCHAR
 			/* Convert from UTF-16 to locale encoding.  */
 			if (u16_conv_to_encoding (locale_charset (),
 						  iconveh_question_mark,
 						  arg, arg_end - arg, NULL,
 						  &converted, &converted_len)
 			    < 0)
 #  else
 			/* Convert from UTF-16 to UTF-8/UTF-32.  */
 			converted =
 			  U16_TO_DCHAR (arg, arg_end - arg,
 					converted, &converted_len);
 			if (converted == NULL)
 #  endif
 			  {
 			    int saved_errno = errno;
 			    if (!(result == resultbuf || result == NULL))
 			      free (result);
 			    if (buf_malloced != NULL)
 			      free (buf_malloced);
 			    CLEANUP ();
 			    errno = saved_errno;
 			    return NULL;
 			  }
 			if (converted != result + length)
 			  {
 			    ENSURE_ALLOCATION (xsum (length, converted_len));
 			    DCHAR_CPY (result + length, converted, converted_len);
 			    free (converted);
 			  }
 			length += converted_len;
 		      }
 # endif

 		      if (has_width && width > characters
 			  && (dp->flags & FLAG_LEFT))
 			{
 			  size_t n = width - characters;
 			  ENSURE_ALLOCATION (xsum (length, n));
 			  DCHAR_SET (result + length, ' ', n);
 			  length += n;
 			}
 		    }
 		    break;

 		  case TYPE_U32_STRING:
 		    {
 		      const uint32_t *arg = a.arg[dp->arg_index].a.a_u32_string;
 		      const uint32_t *arg_end;
 		      size_t characters;

 		      if (has_precision)
 			{
 			  /* Use only PRECISION characters, from the left.  */
 			  arg_end = arg;
 			  characters = 0;
 			  for (; precision > 0; precision--)
 			    {
 			      int count = u32_strmblen (arg_end);
 			      if (count == 0)
 				break;
 			      if (count < 0)
 				{
 				  if (!(result == resultbuf || result == NULL))
 				    free (result);
 				  if (buf_malloced != NULL)
 				    free (buf_malloced);
 				  CLEANUP ();
 				  errno = EILSEQ;
 				  return NULL;
 				}
 			      arg_end += count;
 			      characters++;
 			    }
 			}
 		      else if (has_width)
 			{
 			  /* Use the entire string, and count the number of
 			     characters.  */
 			  arg_end = arg;
 			  characters = 0;
 			  for (;;)
 			    {
 			      int count = u32_strmblen (arg_end);
 			      if (count == 0)
 				break;
 			      if (count < 0)
 				{
 				  if (!(result == resultbuf || result == NULL))
 				    free (result);
 				  if (buf_malloced != NULL)
 				    free (buf_malloced);
 				  CLEANUP ();
 				  errno = EILSEQ;
 				  return NULL;
 				}
 			      arg_end += count;
 			      characters++;
 			    }
 			}
 		      else
 			{
 			  /* Use the entire string.  */
 			  arg_end = arg + u32_strlen (arg);
 			  /* The number of characters doesn't matter.  */
 			  characters = 0;
 			}

 		      if (has_width && width > characters
 			  && !(dp->flags & FLAG_LEFT))
 			{
 			  size_t n = width - characters;
 			  ENSURE_ALLOCATION (xsum (length, n));
 			  DCHAR_SET (result + length, ' ', n);
 			  length += n;
 			}

 # if DCHAR_IS_UINT32_T
 		      {
 			size_t n = arg_end - arg;
 			ENSURE_ALLOCATION (xsum (length, n));
 			DCHAR_CPY (result + length, arg, n);
 			length += n;
 		      }
 # else
 		      { /* Convert.  */
 			DCHAR_T *converted = result + length;
 			size_t converted_len = allocated - length;
 #  if DCHAR_IS_TCHAR
 			/* Convert from UTF-32 to locale encoding.  */
 			if (u32_conv_to_encoding (locale_charset (),
 						  iconveh_question_mark,
 						  arg, arg_end - arg, NULL,
 						  &converted, &converted_len)
 			    < 0)
 #  else
 			/* Convert from UTF-32 to UTF-8/UTF-16.  */
 			converted =
 			  U32_TO_DCHAR (arg, arg_end - arg,
 					converted, &converted_len);
 			if (converted == NULL)
 #  endif
 			  {
 			    int saved_errno = errno;
 			    if (!(result == resultbuf || result == NULL))
 			      free (result);
 			    if (buf_malloced != NULL)
 			      free (buf_malloced);
 			    CLEANUP ();
 			    errno = saved_errno;
 			    return NULL;
 			  }
 			if (converted != result + length)
 			  {
 			    ENSURE_ALLOCATION (xsum (length, converted_len));
 			    DCHAR_CPY (result + length, converted, converted_len);
 			    free (converted);
 			  }
 			length += converted_len;
 		      }
 # endif

 		      if (has_width && width > characters
 			  && (dp->flags & FLAG_LEFT))
 			{
 			  size_t n = width - characters;
 			  ENSURE_ALLOCATION (xsum (length, n));
 			  DCHAR_SET (result + length, ' ', n);
 			  length += n;
 			}
 		    }
 		    break;

 		  default:
 		    abort ();
 		  }
 	      }
 #endif
 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
 	    else if ((dp->conversion == 'a' || dp->conversion == 'A')
 # if !(NEED_PRINTF_DIRECTIVE_A || (NEED_PRINTF_LONG_DOUBLE && NEED_PRINTF_DOUBLE))
 		     && (0
 #  if NEED_PRINTF_DOUBLE
 			 || a.arg[dp->arg_index].type == TYPE_DOUBLE
 #  endif
 #  if NEED_PRINTF_LONG_DOUBLE
 			 || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
 #  endif
 			)
 # endif
 		    )
 	      {
 		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;
 		DCHAR_T tmpbuf[700];
 		DCHAR_T *tmp;
 		DCHAR_T *pad_ptr;
 		DCHAR_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 FCHAR_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 FCHAR_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 (DCHAR_T))
 		  tmp = tmpbuf;
 		else
 		  {
 		    size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T));

 		    if (size_overflow_p (tmp_memsize))
 		      /* Overflow, would lead to out of memory.  */
 		      goto out_of_memory;
 		    tmp = (DCHAR_T *) malloc (tmp_memsize);
 		    if (tmp == NULL)
 		      /* Out of memory.  */
 		      goto out_of_memory;
 		  }

 		pad_ptr = NULL;
 		p = tmp;
 		if (type == TYPE_LONGDOUBLE)
 		  {
 # if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE
 		    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);
 			      }
 			      while (*p != '\0')
 				p++;
 #  else
 			      if (sizeof (DCHAR_T) == 1)
 				{
 				  sprintf ((char *) p, "%+d", exponent);
 				  while (*p != '\0')
 				    p++;
 				}
 			      else
 				{
 				  char expbuf[6 + 1];
 				  const char *ep;
 				  sprintf (expbuf, "%+d", exponent);
 				  for (ep = expbuf; (*p = *ep) != '\0'; ep++)
 				    p++;
 				}
 #  endif
 			  }

 			END_LONG_DOUBLE_ROUNDING ();
 		      }
 # else
 		    abort ();
 # endif
 		  }
 		else
 		  {
 # if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE
 		    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);
 			      }
 			      while (*p != '\0')
 				p++;
 #  else
 			      if (sizeof (DCHAR_T) == 1)
 				{
 				  sprintf ((char *) p, "%+d", exponent);
 				  while (*p != '\0')
 				    p++;
 				}
 			      else
 				{
 				  char expbuf[6 + 1];
 				  const char *ep;
 				  sprintf (expbuf, "%+d", exponent);
 				  for (ep = expbuf; (*p = *ep) != '\0'; ep++)
 				    p++;
 				}
 #  endif
 			  }
 		      }
 # else
 		    abort ();
 # endif
 		  }
 		/* 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);
 		    DCHAR_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.  */
 			DCHAR_T *q = end;

 			while (p > pad_ptr)
 			  *--q = *--p;
 			for (; pad > 0; pad--)
 			  *p++ = '0';
 		      }
 		    else
 		      {
 			/* Pad with spaces on the left.  */
 			DCHAR_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 (DCHAR_T));
 		  if (tmp != tmpbuf)
 		    free (tmp);
 		  length += count;
 		}
 	      }
 #endif
 #if (NEED_PRINTF_INFINITE_DOUBLE || NEED_PRINTF_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 == 'a' || dp->conversion == 'A')
 		     && (0
 # if NEED_PRINTF_DOUBLE
 			 || a.arg[dp->arg_index].type == TYPE_DOUBLE
 # elif NEED_PRINTF_INFINITE_DOUBLE
 			 || (a.arg[dp->arg_index].type == TYPE_DOUBLE
 			     /* The systems (mingw) which produce wrong output
 				for Inf, -Inf, and NaN also do so for -0.0.
 				Therefore we treat this case here as well.  */
 			     && is_infinite_or_zero (a.arg[dp->arg_index].a.a_double))
 # endif
 # if NEED_PRINTF_LONG_DOUBLE
 			 || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
 # elif NEED_PRINTF_INFINITE_LONG_DOUBLE
 			 || (a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
 			     /* Some systems produce wrong output for Inf,
 				-Inf, and NaN.  */
 			     && is_infinitel (a.arg[dp->arg_index].a.a_longdouble))
 # endif
 			))
 	      {
 # if (NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE)
 		arg_type type = a.arg[dp->arg_index].type;
 # endif
 		int flags = dp->flags;
 		int has_width;
 		size_t width;
 		int has_precision;
 		size_t precision;
 		size_t tmp_length;
 		DCHAR_T tmpbuf[700];
 		DCHAR_T *tmp;
 		DCHAR_T *pad_ptr;
 		DCHAR_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 FCHAR_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 FCHAR_T *digitp = dp->precision_start + 1;

 			precision = 0;
 			while (digitp != dp->precision_end)
 			  precision = xsum (xtimes (precision, 10), *digitp++ - '0');
 			has_precision = 1;
 		      }
 		  }

 		/* POSIX specifies the default precision to be 6 for %f, %F,
 		   %e, %E, but not for %g, %G.  Implementations appear to use
 		   the same default precision also for %g, %G.  */
 		if (!has_precision)
 		  precision = 6;

 		/* Allocate a temporary buffer of sufficient size.  */
 # if NEED_PRINTF_DOUBLE && NEED_PRINTF_LONG_DOUBLE
 		tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : DBL_DIG + 1);
 # elif NEED_PRINTF_INFINITE_DOUBLE && NEED_PRINTF_LONG_DOUBLE
 		tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : 0);
 # elif NEED_PRINTF_LONG_DOUBLE
 		tmp_length = LDBL_DIG + 1;
 # elif NEED_PRINTF_DOUBLE
 		tmp_length = DBL_DIG + 1;
 # else
 		tmp_length = 0;
 # endif
 		if (tmp_length < precision)
 		  tmp_length = precision;
 # if NEED_PRINTF_LONG_DOUBLE
 #  if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
 		if (type == TYPE_LONGDOUBLE)
 #  endif
 		  if (dp->conversion == 'f' || dp->conversion == 'F')
 		    {
 		      long double arg = a.arg[dp->arg_index].a.a_longdouble;
 		      if (!(isnanl (arg) || arg + arg == arg))
 			{
 			  /* arg is finite and nonzero.  */
 			  int exponent = floorlog10l (arg < 0 ? -arg : arg);
 			  if (exponent >= 0 && tmp_length < exponent + precision)
 			    tmp_length = exponent + precision;
 			}
 		    }
 # endif
 # if NEED_PRINTF_DOUBLE
 #  if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE
 		if (type == TYPE_DOUBLE)
 #  endif
 		  if (dp->conversion == 'f' || dp->conversion == 'F')
 		    {
 		      double arg = a.arg[dp->arg_index].a.a_double;
 		      if (!(isnan (arg) || arg + arg == arg))
 			{
 			  /* arg is finite and nonzero.  */
 			  int exponent = floorlog10 (arg < 0 ? -arg : arg);
 			  if (exponent >= 0 && tmp_length < exponent + precision)
 			    tmp_length = exponent + precision;
 			}
 		    }
 # endif
 		/* 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 (DCHAR_T))
 		  tmp = tmpbuf;
 		else
 		  {
 		    size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T));

 		    if (size_overflow_p (tmp_memsize))
 		      /* Overflow, would lead to out of memory.  */
 		      goto out_of_memory;
 		    tmp = (DCHAR_T *) malloc (tmp_memsize);
 		    if (tmp == NULL)
 		      /* Out of memory.  */
 		      goto out_of_memory;
 		  }

 		pad_ptr = NULL;
 		p = tmp;

 # if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE
 #  if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
 		if (type == TYPE_LONGDOUBLE)
 #  endif
 		  {
 		    long double arg = a.arg[dp->arg_index].a.a_longdouble;

 		    if (isnanl (arg))
 		      {
 			if (dp->conversion >= 'A' && dp->conversion <= 'Z')
 			  {
 			    *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' && dp->conversion <= 'Z')
 			      {
 				*p++ = 'I'; *p++ = 'N'; *p++ = 'F';
 			      }
 			    else
 			      {
 				*p++ = 'i'; *p++ = 'n'; *p++ = 'f';
 			      }
 			  }
 			else
 			  {
 #  if NEED_PRINTF_LONG_DOUBLE
 			    pad_ptr = p;

 			    if (dp->conversion == 'f' || dp->conversion == 'F')
 			      {
 				char *digits;
 				size_t ndigits;

 				digits =
 				  scale10_round_decimal_long_double (arg, precision);
 				if (digits == NULL)
 				  {
 				    END_LONG_DOUBLE_ROUNDING ();
 				    goto out_of_memory;
 				  }
 				ndigits = strlen (digits);

 				if (ndigits > precision)
 				  do
 				    {
 				      --ndigits;
 				      *p++ = digits[ndigits];
 				    }
 				  while (ndigits > precision);
 				else
 				  *p++ = '0';
 				/* Here ndigits <= precision.  */
 				if ((flags & FLAG_ALT) || precision > 0)
 				  {
 				    *p++ = decimal_point_char ();
 				    for (; precision > ndigits; precision--)
 				      *p++ = '0';
 				    while (ndigits > 0)
 				      {
 					--ndigits;
 					*p++ = digits[ndigits];
 				      }
 				  }

 				free (digits);
 			      }
 			    else if (dp->conversion == 'e' || dp->conversion == 'E')
 			      {
 				int exponent;

 				if (arg == 0.0L)
 				  {
 				    exponent = 0;
 				    *p++ = '0';
 				    if ((flags & FLAG_ALT) || precision > 0)
 				      {
 					*p++ = decimal_point_char ();
 					for (; precision > 0; precision--)
 					  *p++ = '0';
 				      }
 				  }
 				else
 				  {
 				    /* arg > 0.0L.  */
 				    int adjusted;
 				    char *digits;
 				    size_t ndigits;

 				    exponent = floorlog10l (arg);
 				    adjusted = 0;
 				    for (;;)
 				      {
 					digits =
 					  scale10_round_decimal_long_double (arg,
 									     (int)precision - exponent);
 					if (digits == NULL)
 					  {
 					    END_LONG_DOUBLE_ROUNDING ();
 					    goto out_of_memory;
 					  }
 					ndigits = strlen (digits);

 					if (ndigits == precision + 1)
 					  break;
 					if (ndigits < precision
 					    || ndigits > precision + 2)
 					  /* The exponent was not guessed
 					     precisely enough.  */
 					  abort ();
 					if (adjusted)
 					  /* None of two values of exponent is
 					     the right one.  Prevent an endless
 					     loop.  */
 					  abort ();
 					free (digits);
 					if (ndigits == precision)
 					  exponent -= 1;
 					else
 					  exponent += 1;
 					adjusted = 1;
 				      }

 				    /* Here ndigits = precision+1.  */
 				    *p++ = digits[--ndigits];
 				    if ((flags & FLAG_ALT) || precision > 0)
 				      {
 					*p++ = decimal_point_char ();
 					while (ndigits > 0)
 					  {
 					    --ndigits;
 					    *p++ = digits[ndigits];
 					  }
 				      }

 				    free (digits);
 				  }

 				*p++ = dp->conversion; /* 'e' or 'E' */
 #   if WIDE_CHAR_VERSION
 				{
 				  static const wchar_t decimal_format[] =
 				    { '%', '+', '.', '2', 'd', '\0' };
 				  SNPRINTF (p, 6 + 1, decimal_format, exponent);
 				}
 				while (*p != '\0')
 				  p++;
 #   else
 				if (sizeof (DCHAR_T) == 1)
 				  {
 				    sprintf ((char *) p, "%+.2d", exponent);
 				    while (*p != '\0')
 				      p++;
 				  }
 				else
 				  {
 				    char expbuf[6 + 1];
 				    const char *ep;
 				    sprintf (expbuf, "%+.2d", exponent);
 				    for (ep = expbuf; (*p = *ep) != '\0'; ep++)
 				      p++;
 				  }
 #   endif
 			      }
 			    else if (dp->conversion == 'g' || dp->conversion == 'G')
 			      {
 				if (precision == 0)
 				  precision = 1;
 				/* precision >= 1.  */

 				if (arg == 0.0L)
 				  /* The exponent is 0, >= -4, < precision.
 				     Use fixed-point notation.  */
 				  {
 				    size_t ndigits = precision;
 				    /* Number of trailing zeroes that have to be
 				       dropped.  */
 				    size_t nzeroes =
 				      (flags & FLAG_ALT ? 0 : precision - 1);

 				    --ndigits;
 				    *p++ = '0';
 				    if ((flags & FLAG_ALT) || ndigits > nzeroes)
 				      {
 					*p++ = decimal_point_char ();
 					while (ndigits > nzeroes)
 					  {
 					    --ndigits;
 					    *p++ = '0';
 					  }
 				      }
 				  }
 				else
 				  {
 				    /* arg > 0.0L.  */
 				    int exponent;
 				    int adjusted;
 				    char *digits;
 				    size_t ndigits;
 				    size_t nzeroes;

 				    exponent = floorlog10l (arg);
 				    adjusted = 0;
 				    for (;;)
 				      {
 					digits =
 					  scale10_round_decimal_long_double (arg,
 									     (int)(precision - 1) - exponent);
 					if (digits == NULL)
 					  {
 					    END_LONG_DOUBLE_ROUNDING ();
 					    goto out_of_memory;
 					  }
 					ndigits = strlen (digits);

 					if (ndigits == precision)
 					  break;
 					if (ndigits < precision - 1
 					    || ndigits > precision + 1)
 					  /* The exponent was not guessed
 					     precisely enough.  */
 					  abort ();
 					if (adjusted)
 					  /* None of two values of exponent is
 					     the right one.  Prevent an endless
 					     loop.  */
 					  abort ();
 					free (digits);
 					if (ndigits < precision)
 					  exponent -= 1;
 					else
 					  exponent += 1;
 					adjusted = 1;
 				      }
 				    /* Here ndigits = precision.  */

 				    /* Determine the number of trailing zeroes
 				       that have to be dropped.  */
 				    nzeroes = 0;
 				    if ((flags & FLAG_ALT) == 0)
 				      while (nzeroes < ndigits
 					     && digits[nzeroes] == '0')
 					nzeroes++;

 				    /* The exponent is now determined.  */
 				    if (exponent >= -4
 					&& exponent < (long)precision)
 				      {
 					/* Fixed-point notation:
 					   max(exponent,0)+1 digits, then the
 					   decimal point, then the remaining
 					   digits without trailing zeroes.  */
 					if (exponent >= 0)
 					  {
 					    size_t count = exponent + 1;
 					    /* Note: count <= precision = ndigits.  */
 					    for (; count > 0; count--)
 					      *p++ = digits[--ndigits];
 					    if ((flags & FLAG_ALT) || ndigits > nzeroes)
 					      {
 						*p++ = decimal_point_char ();
 						while (ndigits > nzeroes)
 						  {
 						    --ndigits;
 						    *p++ = digits[ndigits];
 						  }
 					      }
 					  }
 					else
 					  {
 					    size_t count = -exponent - 1;
 					    *p++ = '0';
 					    *p++ = decimal_point_char ();
 					    for (; count > 0; count--)
 					      *p++ = '0';
 					    while (ndigits > nzeroes)
 					      {
 						--ndigits;
 						*p++ = digits[ndigits];
 					      }
 					  }
 				      }
 				    else
 				      {
 					/* Exponential notation.  */
 					*p++ = digits[--ndigits];
 					if ((flags & FLAG_ALT) || ndigits > nzeroes)
 					  {
 					    *p++ = decimal_point_char ();
 					    while (ndigits > nzeroes)
 					      {
 						--ndigits;
 						*p++ = digits[ndigits];
 					      }
 					  }
 					*p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */
 #   if WIDE_CHAR_VERSION
 					{
 					  static const wchar_t decimal_format[] =
 					    { '%', '+', '.', '2', 'd', '\0' };
 					  SNPRINTF (p, 6 + 1, decimal_format, exponent);
 					}
 					while (*p != '\0')
 					  p++;
 #   else
 					if (sizeof (DCHAR_T) == 1)
 					  {
 					    sprintf ((char *) p, "%+.2d", exponent);
 					    while (*p != '\0')
 					      p++;
 					  }
 					else
 					  {
 					    char expbuf[6 + 1];
 					    const char *ep;
 					    sprintf (expbuf, "%+.2d", exponent);
 					    for (ep = expbuf; (*p = *ep) != '\0'; ep++)
 					      p++;
 					  }
 #   endif
 				      }

 				    free (digits);
 				  }
 			      }
 			    else
 			      abort ();
 #  else
 			    /* arg is finite.  */
 			    abort ();
 #  endif
 			  }

 			END_LONG_DOUBLE_ROUNDING ();
 		      }
 		  }
 #  if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
 		else
 #  endif
 # endif
 # if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
 		  {
 		    double arg = a.arg[dp->arg_index].a.a_double;

 		    if (isnan (arg))
 		      {
 			if (dp->conversion >= 'A' && dp->conversion <= 'Z')
 			  {
 			    *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' && dp->conversion <= 'Z')
 			      {
 				*p++ = 'I'; *p++ = 'N'; *p++ = 'F';
 			      }
 			    else
 			      {
 				*p++ = 'i'; *p++ = 'n'; *p++ = 'f';
 			      }
 			  }
 			else
 			  {
 #  if NEED_PRINTF_DOUBLE
 			    pad_ptr = p;

 			    if (dp->conversion == 'f' || dp->conversion == 'F')
 			      {
 				char *digits;
 				size_t ndigits;

 				digits =
 				  scale10_round_decimal_double (arg, precision);
 				if (digits == NULL)
 				  goto out_of_memory;
 				ndigits = strlen (digits);

 				if (ndigits > precision)
 				  do
 				    {
 				      --ndigits;
 				      *p++ = digits[ndigits];
 				    }
 				  while (ndigits > precision);
 				else
 				  *p++ = '0';
 				/* Here ndigits <= precision.  */
 				if ((flags & FLAG_ALT) || precision > 0)
 				  {
 				    *p++ = decimal_point_char ();
 				    for (; precision > ndigits; precision--)
 				      *p++ = '0';
 				    while (ndigits > 0)
 				      {
 					--ndigits;
 					*p++ = digits[ndigits];
 				      }
 				  }

 				free (digits);
 			      }
 			    else if (dp->conversion == 'e' || dp->conversion == 'E')
 			      {
 				int exponent;

 				if (arg == 0.0)
 				  {
 				    exponent = 0;
 				    *p++ = '0';
 				    if ((flags & FLAG_ALT) || precision > 0)
 				      {
 					*p++ = decimal_point_char ();
 					for (; precision > 0; precision--)
 					  *p++ = '0';
 				      }
 				  }
 				else
 				  {
 				    /* arg > 0.0.  */
 				    int adjusted;
 				    char *digits;
 				    size_t ndigits;

 				    exponent = floorlog10 (arg);
 				    adjusted = 0;
 				    for (;;)
 				      {
 					digits =
 					  scale10_round_decimal_double (arg,
 									(int)precision - exponent);
 					if (digits == NULL)
 					  goto out_of_memory;
 					ndigits = strlen (digits);

 					if (ndigits == precision + 1)
 					  break;
 					if (ndigits < precision
 					    || ndigits > precision + 2)
 					  /* The exponent was not guessed
 					     precisely enough.  */
 					  abort ();
 					if (adjusted)
 					  /* None of two values of exponent is
 					     the right one.  Prevent an endless
 					     loop.  */
 					  abort ();
 					free (digits);
 					if (ndigits == precision)
 					  exponent -= 1;
 					else
 					  exponent += 1;
 					adjusted = 1;
 				      }

 				    /* Here ndigits = precision+1.  */
 				    *p++ = digits[--ndigits];
 				    if ((flags & FLAG_ALT) || precision > 0)
 				      {
 					*p++ = decimal_point_char ();
 					while (ndigits > 0)
 					  {
 					    --ndigits;
 					    *p++ = digits[ndigits];
 					  }
 				      }

 				    free (digits);
 				  }

 				*p++ = dp->conversion; /* 'e' or 'E' */
 #   if WIDE_CHAR_VERSION
 				{
 				  static const wchar_t decimal_format[] =
 				    /* Produce the same number of exponent digits
 				       as the native printf implementation.  */
 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 				    { '%', '+', '.', '3', 'd', '\0' };
 #    else
 				    { '%', '+', '.', '2', 'd', '\0' };
 #    endif
 				  SNPRINTF (p, 6 + 1, decimal_format, exponent);
 				}
 				while (*p != '\0')
 				  p++;
 #   else
 				{
 				  static const char decimal_format[] =
 				    /* Produce the same number of exponent digits
 				       as the native printf implementation.  */
 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 				    "%+.3d";
 #    else
 				    "%+.2d";
 #    endif
 				  if (sizeof (DCHAR_T) == 1)
 				    {
 				      sprintf ((char *) p, decimal_format, exponent);
 				      while (*p != '\0')
 					p++;
 				    }
 				  else
 				    {
 				      char expbuf[6 + 1];
 				      const char *ep;
 				      sprintf (expbuf, decimal_format, exponent);
 				      for (ep = expbuf; (*p = *ep) != '\0'; ep++)
 					p++;
 				    }
 				}
 #   endif
 			      }
 			    else if (dp->conversion == 'g' || dp->conversion == 'G')
 			      {
 				if (precision == 0)
 				  precision = 1;
 				/* precision >= 1.  */

 				if (arg == 0.0)
 				  /* The exponent is 0, >= -4, < precision.
 				     Use fixed-point notation.  */
 				  {
 				    size_t ndigits = precision;
 				    /* Number of trailing zeroes that have to be
 				       dropped.  */
 				    size_t nzeroes =
 				      (flags & FLAG_ALT ? 0 : precision - 1);

 				    --ndigits;
 				    *p++ = '0';
 				    if ((flags & FLAG_ALT) || ndigits > nzeroes)
 				      {
 					*p++ = decimal_point_char ();
 					while (ndigits > nzeroes)
 					  {
 					    --ndigits;
 					    *p++ = '0';
 					  }
 				      }
 				  }
 				else
 				  {
 				    /* arg > 0.0.  */
 				    int exponent;
 				    int adjusted;
 				    char *digits;
 				    size_t ndigits;
 				    size_t nzeroes;

 				    exponent = floorlog10 (arg);
 				    adjusted = 0;
 				    for (;;)
 				      {
 					digits =
 					  scale10_round_decimal_double (arg,
 									(int)(precision - 1) - exponent);
 					if (digits == NULL)
 					  goto out_of_memory;
 					ndigits = strlen (digits);

 					if (ndigits == precision)
 					  break;
 					if (ndigits < precision - 1
 					    || ndigits > precision + 1)
 					  /* The exponent was not guessed
 					     precisely enough.  */
 					  abort ();
 					if (adjusted)
 					  /* None of two values of exponent is
 					     the right one.  Prevent an endless
 					     loop.  */
 					  abort ();
 					free (digits);
 					if (ndigits < precision)
 					  exponent -= 1;
 					else
 					  exponent += 1;
 					adjusted = 1;
 				      }
 				    /* Here ndigits = precision.  */

 				    /* Determine the number of trailing zeroes
 				       that have to be dropped.  */
 				    nzeroes = 0;
 				    if ((flags & FLAG_ALT) == 0)
 				      while (nzeroes < ndigits
 					     && digits[nzeroes] == '0')
 					nzeroes++;

 				    /* The exponent is now determined.  */
 				    if (exponent >= -4
 					&& exponent < (long)precision)
 				      {
 					/* Fixed-point notation:
 					   max(exponent,0)+1 digits, then the
 					   decimal point, then the remaining
 					   digits without trailing zeroes.  */
 					if (exponent >= 0)
 					  {
 					    size_t count = exponent + 1;
 					    /* Note: count <= precision = ndigits.  */
 					    for (; count > 0; count--)
 					      *p++ = digits[--ndigits];
 					    if ((flags & FLAG_ALT) || ndigits > nzeroes)
 					      {
 						*p++ = decimal_point_char ();
 						while (ndigits > nzeroes)
 						  {
 						    --ndigits;
 						    *p++ = digits[ndigits];
 						  }
 					      }
 					  }
 					else
 					  {
 					    size_t count = -exponent - 1;
 					    *p++ = '0';
 					    *p++ = decimal_point_char ();
 					    for (; count > 0; count--)
 					      *p++ = '0';
 					    while (ndigits > nzeroes)
 					      {
 						--ndigits;
 						*p++ = digits[ndigits];
 					      }
 					  }
 				      }
 				    else
 				      {
 					/* Exponential notation.  */
 					*p++ = digits[--ndigits];
 					if ((flags & FLAG_ALT) || ndigits > nzeroes)
 					  {
 					    *p++ = decimal_point_char ();
 					    while (ndigits > nzeroes)
 					      {
 						--ndigits;
 						*p++ = digits[ndigits];
 					      }
 					  }
 					*p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */
 #   if WIDE_CHAR_VERSION
 					{
 					  static const wchar_t decimal_format[] =
 					    /* Produce the same number of exponent digits
 					       as the native printf implementation.  */
 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 					    { '%', '+', '.', '3', 'd', '\0' };
 #    else
 					    { '%', '+', '.', '2', 'd', '\0' };
 #    endif
 					  SNPRINTF (p, 6 + 1, decimal_format, exponent);
 					}
 					while (*p != '\0')
 					  p++;
 #   else
 					{
 					  static const char decimal_format[] =
 					    /* Produce the same number of exponent digits
 					       as the native printf implementation.  */
 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 					    "%+.3d";
 #    else
 					    "%+.2d";
 #    endif
 					  if (sizeof (DCHAR_T) == 1)
 					    {
 					      sprintf ((char *) p, decimal_format, exponent);
 					      while (*p != '\0')
 						p++;
 					    }
 					  else
 					    {
 					      char expbuf[6 + 1];
 					      const char *ep;
 					      sprintf (expbuf, decimal_format, exponent);
 					      for (ep = expbuf; (*p = *ep) != '\0'; ep++)
 						p++;
 					    }
 					}
 #   endif
 				      }

 				    free (digits);
 				  }
 			      }
 			    else
 			      abort ();
 #  else
 			    /* arg is finite.  */
 			    if (!(arg == 0.0))
 			      abort ();

 			    pad_ptr = p;

 			    if (dp->conversion == 'f' || dp->conversion == 'F')
 			      {
 				*p++ = '0';
 				if ((flags & FLAG_ALT) || precision > 0)
 				  {
 				    *p++ = decimal_point_char ();
 				    for (; precision > 0; precision--)
 				      *p++ = '0';
 				  }
 			      }
 			    else if (dp->conversion == 'e' || dp->conversion == 'E')
 			      {
 				*p++ = '0';
 				if ((flags & FLAG_ALT) || precision > 0)
 				  {
 				    *p++ = decimal_point_char ();
 				    for (; precision > 0; precision--)
 				      *p++ = '0';
 				  }
 				*p++ = dp->conversion; /* 'e' or 'E' */
 				*p++ = '+';
 				/* Produce the same number of exponent digits as
 				   the native printf implementation.  */
 #   if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 				*p++ = '0';
 #   endif
 				*p++ = '0';
 				*p++ = '0';
 			      }
 			    else if (dp->conversion == 'g' || dp->conversion == 'G')
 			      {
 				*p++ = '0';
 				if (flags & FLAG_ALT)
 				  {
 				    size_t ndigits =
 				      (precision > 0 ? precision - 1 : 0);
 				    *p++ = decimal_point_char ();
 				    for (; ndigits > 0; --ndigits)
 				      *p++ = '0';
 				  }
 			      }
 			    else
 			      abort ();
 #  endif
 			  }
 		      }
 		  }
 # endif

 		/* 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);
 		    DCHAR_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.  */
 			DCHAR_T *q = end;

 			while (p > pad_ptr)
 			  *--q = *--p;
 			for (; pad > 0; pad--)
 			  *p++ = '0';
 		      }
 		    else
 		      {
 			/* Pad with spaces on the left.  */
 			DCHAR_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 (DCHAR_T));
 		  if (tmp != tmpbuf)
 		    free (tmp);
 		  length += count;
 		}
 	      }
 #endif
 	    else
 	      {
 		arg_type type = a.arg[dp->arg_index].type;
 		int flags = dp->flags;
 #if !USE_SNPRINTF || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
 		int has_width;
 		size_t width;
 #endif
 #if !USE_SNPRINTF || NEED_PRINTF_UNBOUNDED_PRECISION
 		int has_precision;
 		size_t precision;
 #endif
 #if NEED_PRINTF_UNBOUNDED_PRECISION
 		int prec_ourselves;
 #else
 #		define prec_ourselves 0
 #endif
 #if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
 		int pad_ourselves;
 #else
 #		define pad_ourselves 0
 #endif
 		TCHAR_T *fbp;
 		unsigned int prefix_count;
 		int prefixes[2];
 #if !USE_SNPRINTF
 		size_t tmp_length;
 		TCHAR_T tmpbuf[700];
 		TCHAR_T *tmp;
 #endif

 #if !USE_SNPRINTF || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
 		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 FCHAR_T *digitp = dp->width_start;

 			do
 			  width = xsum (xtimes (width, 10), *digitp++ - '0');
 			while (digitp != dp->width_end);
 		      }
 		    has_width = 1;
 		  }
 #endif

 #if !USE_SNPRINTF || NEED_PRINTF_UNBOUNDED_PRECISION
 		has_precision = 0;
 		precision = 6;
 		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 FCHAR_T *digitp = dp->precision_start + 1;

 			precision = 0;
 			while (digitp != dp->precision_end)
 			  precision = xsum (xtimes (precision, 10), *digitp++ - '0');
 			has_precision = 1;
 		      }
 		  }
 #endif

 #if !USE_SNPRINTF
 		/* Allocate a temporary buffer of sufficient size for calling
 		   sprintf.  */
 		{
 		  switch (dp->conversion)
 		    {

 		    case 'd': case 'i': case 'u':
 # if HAVE_LONG_LONG_INT
 		      if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
 					  * 0.30103 /* binary -> decimal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      else
 # endif
 		      if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned long) * CHAR_BIT
 					  * 0.30103 /* binary -> decimal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      else
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned int) * CHAR_BIT
 					  * 0.30103 /* binary -> decimal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      if (tmp_length < precision)
 			tmp_length = precision;
 		      /* Multiply by 2, as an estimate for FLAG_GROUP.  */
 		      tmp_length = xsum (tmp_length, tmp_length);
 		      /* Add 1, to account for a leading sign.  */
 		      tmp_length = xsum (tmp_length, 1);
 		      break;

 		    case 'o':
 # if HAVE_LONG_LONG_INT
 		      if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
 					  * 0.333334 /* binary -> octal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      else
 # endif
 		      if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned long) * CHAR_BIT
 					  * 0.333334 /* binary -> octal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      else
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned int) * CHAR_BIT
 					  * 0.333334 /* binary -> octal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      if (tmp_length < precision)
 			tmp_length = precision;
 		      /* Add 1, to account for a leading sign.  */
 		      tmp_length = xsum (tmp_length, 1);
 		      break;

 		    case 'x': case 'X':
 # if HAVE_LONG_LONG_INT
 		      if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
 					  * 0.25 /* binary -> hexadecimal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      else
 # endif
 		      if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned long) * CHAR_BIT
 					  * 0.25 /* binary -> hexadecimal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      else
 			tmp_length =
 			  (unsigned int) (sizeof (unsigned int) * CHAR_BIT
 					  * 0.25 /* binary -> hexadecimal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      if (tmp_length < precision)
 			tmp_length = precision;
 		      /* Add 2, to account for a leading sign or alternate form.  */
 		      tmp_length = xsum (tmp_length, 2);
 		      break;

 		    case 'f': case 'F':
 		      if (type == TYPE_LONGDOUBLE)
 			tmp_length =
 			  (unsigned int) (LDBL_MAX_EXP
 					  * 0.30103 /* binary -> decimal */
 					  * 2 /* estimate for FLAG_GROUP */
 					 )
 			  + 1 /* turn floor into ceil */
 			  + 10; /* sign, decimal point etc. */
 		      else
 			tmp_length =
 			  (unsigned int) (DBL_MAX_EXP
 					  * 0.30103 /* binary -> decimal */
 					  * 2 /* estimate for FLAG_GROUP */
 					 )
 			  + 1 /* turn floor into ceil */
 			  + 10; /* sign, decimal point etc. */
 		      tmp_length = xsum (tmp_length, precision);
 		      break;

 		    case 'e': case 'E': case 'g': case 'G':
 		      tmp_length =
 			12; /* sign, decimal point, exponent etc. */
 		      tmp_length = xsum (tmp_length, precision);
 		      break;

 		    case 'a': case 'A':
 		      if (type == TYPE_LONGDOUBLE)
 			tmp_length =
 			  (unsigned int) (LDBL_DIG
 					  * 0.831 /* decimal -> hexadecimal */
 					 )
 			  + 1; /* turn floor into ceil */
 		      else
 			tmp_length =
 			  (unsigned int) (DBL_DIG
 					  * 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);
 		      break;

 		    case 'c':
 # if HAVE_WINT_T && !WIDE_CHAR_VERSION
 		      if (type == TYPE_WIDE_CHAR)
 			tmp_length = MB_CUR_MAX;
 		      else
 # endif
 			tmp_length = 1;
 		      break;

 		    case 's':
 # if HAVE_WCHAR_T
 		      if (type == TYPE_WIDE_STRING)
 			{
 			  tmp_length =
 			    local_wcslen (a.arg[dp->arg_index].a.a_wide_string);

 #  if !WIDE_CHAR_VERSION
 			  tmp_length = xtimes (tmp_length, MB_CUR_MAX);
 #  endif
 			}
 		      else
 # endif
 			tmp_length = strlen (a.arg[dp->arg_index].a.a_string);
 		      break;

 		    case 'p':
 		      tmp_length =
 			(unsigned int) (sizeof (void *) * CHAR_BIT
 					* 0.25 /* binary -> hexadecimal */
 				       )
 			  + 1 /* turn floor into ceil */
 			  + 2; /* account for leading 0x */
 		      break;

 		    default:
 		      abort ();
 		    }

 # if ENABLE_UNISTDIO
 		  /* Padding considers the number of characters, therefore the
 		     number of elements after padding may be
 		       > max (tmp_length, width)
 		     but is certainly
 		       <= tmp_length + width.  */
 		  tmp_length = xsum (tmp_length, width);
 # else
 		  /* Padding considers the number of elements, says POSIX.  */
 		  if (tmp_length < width)
 		    tmp_length = width;
 # endif

 		  tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
 		}

 		if (tmp_length <= sizeof (tmpbuf) / sizeof (TCHAR_T))
 		  tmp = tmpbuf;
 		else
 		  {
 		    size_t tmp_memsize = xtimes (tmp_length, sizeof (TCHAR_T));

 		    if (size_overflow_p (tmp_memsize))
 		      /* Overflow, would lead to out of memory.  */
 		      goto out_of_memory;
 		    tmp = (TCHAR_T *) malloc (tmp_memsize);
 		    if (tmp == NULL)
 		      /* Out of memory.  */
 		      goto out_of_memory;
 		  }
 #endif

 		/* Decide whether to handle the precision ourselves.  */
 #if NEED_PRINTF_UNBOUNDED_PRECISION
 		switch (dp->conversion)
 		  {
 		  case 'd': case 'i': case 'u':
 		  case 'o':
 		  case 'x': case 'X': case 'p':
 		    prec_ourselves = has_precision && (precision > 0);
 		    break;
 		  default:
 		    prec_ourselves = 0;
 		    break;
 		  }
 #endif

 		/* Decide whether to perform the padding ourselves.  */
 #if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
 		switch (dp->conversion)
 		  {
 # if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO
 		  /* If we need conversion from TCHAR_T[] to DCHAR_T[], we need
 		     to perform the padding after this conversion.  Functions
 		     with unistdio extensions perform the padding based on
 		     character count rather than element count.  */
 		  case 'c': case 's':
 # endif
 # if NEED_PRINTF_FLAG_ZERO
 		  case 'f': case 'F': case 'e': case 'E': case 'g': case 'G':
 		  case 'a': case 'A':
 # endif
 		    pad_ourselves = 1;
 		    break;
 		  default:
 		    pad_ourselves = prec_ourselves;
 		    break;
 		  }
 #endif

 		/* Construct the format string for calling snprintf or
 		   sprintf.  */
 		fbp = buf;
 		*fbp++ = '%';
 #if NEED_PRINTF_FLAG_GROUPING
 		/* The underlying implementation doesn't support the ' flag.
 		   Produce no grouping characters in this case; this is
 		   acceptable because the grouping is locale dependent.  */
 #else
 		if (flags & FLAG_GROUP)
 		  *fbp++ = '\'';
 #endif
 		if (flags & FLAG_LEFT)
 		  *fbp++ = '-';
 		if (flags & FLAG_SHOWSIGN)
 		  *fbp++ = '+';
 		if (flags & FLAG_SPACE)
 		  *fbp++ = ' ';
 		if (flags & FLAG_ALT)
 		  *fbp++ = '#';
 		if (!pad_ourselves)
 		  {
 		    if (flags & FLAG_ZERO)
 		      *fbp++ = '0';
 		    if (dp->width_start != dp->width_end)
 		      {
 			size_t n = dp->width_end - dp->width_start;
 			/* The width specification is known to consist only
 			   of standard ASCII characters.  */
 			if (sizeof (FCHAR_T) == sizeof (TCHAR_T))
 			  {
 			    memcpy (fbp, dp->width_start, n * sizeof (TCHAR_T));
 			    fbp += n;
 			  }
 			else
 			  {
 			    const FCHAR_T *mp = dp->width_start;
 			    do
 			      *fbp++ = (unsigned char) *mp++;
 			    while (--n > 0);
 			  }
 		      }
 		  }
 		if (!prec_ourselves)
 		  {
 		    if (dp->precision_start != dp->precision_end)
 		      {
 			size_t n = dp->precision_end - dp->precision_start;
 			/* The precision specification is known to consist only
 			   of standard ASCII characters.  */
 			if (sizeof (FCHAR_T) == sizeof (TCHAR_T))
 			  {
 			    memcpy (fbp, dp->precision_start, n * sizeof (TCHAR_T));
 			    fbp += n;
 			  }
 			else
 			  {
 			    const FCHAR_T *mp = dp->precision_start;
 			    do
 			      *fbp++ = (unsigned char) *mp++;
 			    while (--n > 0);
 			  }
 		      }
 		  }

 		switch (type)
 		  {
 #if HAVE_LONG_LONG_INT
 		  case TYPE_LONGLONGINT:
 		  case TYPE_ULONGLONGINT:
 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 		    *fbp++ = 'I';
 		    *fbp++ = '6';
 		    *fbp++ = '4';
 		    break;
 # else
 		    *fbp++ = 'l';
 		    /*FALLTHROUGH*/
 # endif
 #endif
 		  case TYPE_LONGINT:
 		  case TYPE_ULONGINT:
 #if HAVE_WINT_T
 		  case TYPE_WIDE_CHAR:
 #endif
 #if HAVE_WCHAR_T
 		  case TYPE_WIDE_STRING:
 #endif
 		    *fbp++ = 'l';
 		    break;
 		  case TYPE_LONGDOUBLE:
 		    *fbp++ = 'L';
 		    break;
 		  default:
 		    break;
 		  }
 #if NEED_PRINTF_DIRECTIVE_F
 		if (dp->conversion == 'F')
 		  *fbp = 'f';
 		else
 #endif
 		  *fbp = dp->conversion;
 #if USE_SNPRINTF
 # if !(__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3))
 		fbp[1] = '%';
 		fbp[2] = 'n';
 		fbp[3] = '\0';
 # else
 		/* On glibc2 systems from glibc >= 2.3 - probably also older
 		   ones - we know that snprintf's returns value conforms to
 		   ISO C 99: the gl_SNPRINTF_DIRECTIVE_N test passes.
 		   Therefore we can avoid using %n in this situation.
 		   On glibc2 systems from 2004-10-18 or newer, the use of %n
 		   in format strings in writable memory may crash the program
 		   (if compiled with _FORTIFY_SOURCE=2), so we should avoid it
 		   in this situation.  */
 		fbp[1] = '\0';
 # endif
 #else
 		fbp[1] = '\0';
 #endif

 		/* Construct the arguments for calling snprintf or sprintf.  */
 		prefix_count = 0;
 		if (!pad_ourselves && dp->width_arg_index != ARG_NONE)
 		  {
 		    if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
 		      abort ();
 		    prefixes[prefix_count++] = a.arg[dp->width_arg_index].a.a_int;
 		  }
 		if (dp->precision_arg_index != ARG_NONE)
 		  {
 		    if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
 		      abort ();
 		    prefixes[prefix_count++] = a.arg[dp->precision_arg_index].a.a_int;
 		  }

 #if USE_SNPRINTF
 		/* The SNPRINTF result is appended after result[0..length].
 		   The latter is an array of DCHAR_T; SNPRINTF appends an
 		   array of TCHAR_T to it.  This is possible because
 		   sizeof (TCHAR_T) divides sizeof (DCHAR_T) and
 		   alignof (TCHAR_T) <= alignof (DCHAR_T).  */
 # define TCHARS_PER_DCHAR (sizeof (DCHAR_T) / sizeof (TCHAR_T))
 		/* Prepare checking whether snprintf returns the count
 		   via %n.  */
 		ENSURE_ALLOCATION (xsum (length, 1));
 		*(TCHAR_T *) (result + length) = '\0';
 #endif

 		for (;;)
 		  {
 		    int count = -1;

 #if USE_SNPRINTF
 		    int retcount = 0;
 		    size_t maxlen = allocated - length;
 		    /* SNPRINTF can fail if its second argument is
 		       > INT_MAX.  */
 		    if (maxlen > INT_MAX / TCHARS_PER_DCHAR)
 		      maxlen = INT_MAX / TCHARS_PER_DCHAR;
 		    maxlen = maxlen * TCHARS_PER_DCHAR;
 # define SNPRINTF_BUF(arg) \
 		    switch (prefix_count)				    \
 		      {							    \
 		      case 0:						    \
 			retcount = SNPRINTF ((TCHAR_T *) (result + length), \
 					     maxlen, buf,		    \
 					     arg, &count);		    \
 			break;						    \
 		      case 1:						    \
 			retcount = SNPRINTF ((TCHAR_T *) (result + length), \
 					     maxlen, buf,		    \
 					     prefixes[0], arg, &count);	    \
 			break;						    \
 		      case 2:						    \
 			retcount = SNPRINTF ((TCHAR_T *) (result + length), \
 					     maxlen, buf,		    \
 					     prefixes[0], prefixes[1], arg, \
 					     &count);			    \
 			break;						    \
 		      default:						    \
 			abort ();					    \
 		      }
 #else
 # define SNPRINTF_BUF(arg) \
 		    switch (prefix_count)				    \
 		      {							    \
 		      case 0:						    \
 			count = sprintf (tmp, buf, arg);		    \
 			break;						    \
 		      case 1:						    \
 			count = sprintf (tmp, buf, prefixes[0], arg);	    \
 			break;						    \
 		      case 2:						    \
 			count = sprintf (tmp, buf, prefixes[0], prefixes[1],\
 					 arg);				    \
 			break;						    \
 		      default:						    \
 			abort ();					    \
 		      }
 #endif

 		    switch (type)
 		      {
 		      case TYPE_SCHAR:
 			{
 			  int arg = a.arg[dp->arg_index].a.a_schar;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_UCHAR:
 			{
 			  unsigned int arg = a.arg[dp->arg_index].a.a_uchar;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_SHORT:
 			{
 			  int arg = a.arg[dp->arg_index].a.a_short;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_USHORT:
 			{
 			  unsigned int arg = a.arg[dp->arg_index].a.a_ushort;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_INT:
 			{
 			  int arg = a.arg[dp->arg_index].a.a_int;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_UINT:
 			{
 			  unsigned int arg = a.arg[dp->arg_index].a.a_uint;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_LONGINT:
 			{
 			  long int arg = a.arg[dp->arg_index].a.a_longint;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_ULONGINT:
 			{
 			  unsigned long int arg = a.arg[dp->arg_index].a.a_ulongint;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 #if HAVE_LONG_LONG_INT
 		      case TYPE_LONGLONGINT:
 			{
 			  long long int arg = a.arg[dp->arg_index].a.a_longlongint;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_ULONGLONGINT:
 			{
 			  unsigned long long int arg = a.arg[dp->arg_index].a.a_ulonglongint;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 #endif
 		      case TYPE_DOUBLE:
 			{
 			  double arg = a.arg[dp->arg_index].a.a_double;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_LONGDOUBLE:
 			{
 			  long double arg = a.arg[dp->arg_index].a.a_longdouble;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      case TYPE_CHAR:
 			{
 			  int arg = a.arg[dp->arg_index].a.a_char;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 #if HAVE_WINT_T
 		      case TYPE_WIDE_CHAR:
 			{
 			  wint_t arg = a.arg[dp->arg_index].a.a_wide_char;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 #endif
 		      case TYPE_STRING:
 			{
 			  const char *arg = a.arg[dp->arg_index].a.a_string;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 #if HAVE_WCHAR_T
 		      case TYPE_WIDE_STRING:
 			{
 			  const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 #endif
 		      case TYPE_POINTER:
 			{
 			  void *arg = a.arg[dp->arg_index].a.a_pointer;
 			  SNPRINTF_BUF (arg);
 			}
 			break;
 		      default:
 			abort ();
 		      }

 #if USE_SNPRINTF
 		    /* Portability: Not all implementations of snprintf()
 		       are ISO C 99 compliant.  Determine the number of
 		       bytes that snprintf() has produced or would have
 		       produced.  */
 		    if (count >= 0)
 		      {
 			/* Verify that snprintf() has NUL-terminated its
 			   result.  */
 			if (count < maxlen
 			    && ((TCHAR_T *) (result + length)) [count] != '\0')
 			  abort ();
 			/* Portability hack.  */
 			if (retcount > count)
 			  count = retcount;
 		      }
 		    else
 		      {
 			/* snprintf() doesn't understand the '%n'
 			   directive.  */
 			if (fbp[1] != '\0')
 			  {
 			    /* Don't use the '%n' directive; instead, look
 			       at the snprintf() return value.  */
 			    fbp[1] = '\0';
 			    continue;
 			  }
 			else
 			  {
 			    /* Look at the snprintf() return value.  */
 			    if (retcount < 0)
 			      {
 				/* HP-UX 10.20 snprintf() is doubly deficient:
 				   It doesn't understand the '%n' directive,
 				   *and* it returns -1 (rather than the length
 				   that would have been required) when the
 				   buffer is too small.  */
 				size_t bigger_need =
 				  xsum (xtimes (allocated, 2), 12);
 				ENSURE_ALLOCATION (bigger_need);
 				continue;
 			      }
 			    else
 			      count = retcount;
 			  }
 		      }
 #endif

 		    /* Attempt to handle failure.  */
 		    if (count < 0)
 		      {
 			if (!(result == resultbuf || result == NULL))
 			  free (result);
 			if (buf_malloced != NULL)
 			  free (buf_malloced);
 			CLEANUP ();
 			errno = EINVAL;
 			return NULL;
 		      }

 #if USE_SNPRINTF
 		    /* Handle overflow of the allocated buffer.
 		       If such an overflow occurs, a C99 compliant snprintf()
 		       returns a count >= maxlen.  However, a non-compliant
 		       snprintf() function returns only count = maxlen - 1.  To
 		       cover both cases, test whether count >= maxlen - 1.  */
 		    if ((unsigned int) count + 1 >= maxlen)
 		      {
 			/* If maxlen already has attained its allowed maximum,
 			   allocating more memory will not increase maxlen.
 			   Instead of looping, bail out.  */
 			if (maxlen == INT_MAX / TCHARS_PER_DCHAR)
 			  goto overflow;
 			else
 			  {
 			    /* Need at least count * sizeof (TCHAR_T) bytes.
 			       But allocate proportionally, to avoid looping
 			       eternally if snprintf() reports a too small
 			       count.  */
 			    size_t n =
 			      xmax (xsum (length,
 					  (count + TCHARS_PER_DCHAR - 1)
 					  / TCHARS_PER_DCHAR),
 				    xtimes (allocated, 2));

 			    ENSURE_ALLOCATION (n);
 			    continue;
 			  }
 		      }
 #endif

 #if NEED_PRINTF_UNBOUNDED_PRECISION
 		    if (prec_ourselves)
 		      {
 			/* Handle the precision.  */
 			TCHAR_T *prec_ptr =
 # if USE_SNPRINTF
 			  (TCHAR_T *) (result + length);
 # else
 			  tmp;
 # endif
 			size_t prefix_count;
 			size_t move;

 			prefix_count = 0;
 			/* Put the additional zeroes after the sign.  */
 			if (count >= 1
 			    && (*prec_ptr == '-' || *prec_ptr == '+'
 				|| *prec_ptr == ' '))
 			  prefix_count = 1;
 			/* Put the additional zeroes after the 0x prefix if
 			   (flags & FLAG_ALT) || (dp->conversion == 'p').  */
 			else if (count >= 2
 				 && prec_ptr[0] == '0'
 				 && (prec_ptr[1] == 'x' || prec_ptr[1] == 'X'))
 			  prefix_count = 2;

 			move = count - prefix_count;
 			if (precision > move)
 			  {
 			    /* Insert zeroes.  */
 			    size_t insert = precision - move;
 			    TCHAR_T *prec_end;

 # if USE_SNPRINTF
 			    size_t n =
 			      xsum (length,
 				    (count + insert + TCHARS_PER_DCHAR - 1)
 				    / TCHARS_PER_DCHAR);
 			    length += (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR;
 			    ENSURE_ALLOCATION (n);
 			    length -= (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR;
 			    prec_ptr = (TCHAR_T *) (result + length);
 # endif

 			    prec_end = prec_ptr + count;
 			    prec_ptr += prefix_count;

 			    while (prec_end > prec_ptr)
 			      {
 				prec_end--;
 				prec_end[insert] = prec_end[0];
 			      }

 			    prec_end += insert;
 			    do
 			      *--prec_end = '0';
 			    while (prec_end > prec_ptr);

 			    count += insert;
 			  }
 		      }
 #endif

 #if !DCHAR_IS_TCHAR
 # if !USE_SNPRINTF
 		    if (count >= tmp_length)
 		      /* tmp_length was incorrectly calculated - fix the
 			 code above!  */
 		      abort ();
 # endif

 		    /* Convert from TCHAR_T[] to DCHAR_T[].  */
 		    if (dp->conversion == 'c' || dp->conversion == 's')
 		      {
 			/* type = TYPE_CHAR or TYPE_WIDE_CHAR or TYPE_STRING
 			   TYPE_WIDE_STRING.
 			   The result string is not certainly ASCII.  */
 			const TCHAR_T *tmpsrc;
 			DCHAR_T *tmpdst;
 			size_t tmpdst_len;
 			/* This code assumes that TCHAR_T is 'char'.  */
 			typedef int TCHAR_T_verify
 				    [2 * (sizeof (TCHAR_T) == 1) - 1];
 # if USE_SNPRINTF
 			tmpsrc = (TCHAR_T *) (result + length);
 # else
 			tmpsrc = tmp;
 # endif
 			tmpdst = NULL;
 			tmpdst_len = 0;
 			if (DCHAR_CONV_FROM_ENCODING (locale_charset (),
 						      iconveh_question_mark,
 						      tmpsrc, count,
 						      NULL,
 						      &tmpdst, &tmpdst_len)
 			    < 0)
 			  {
 			    int saved_errno = errno;
 			    if (!(result == resultbuf || result == NULL))
 			      free (result);
 			    if (buf_malloced != NULL)
 			      free (buf_malloced);
 			    CLEANUP ();
 			    errno = saved_errno;
 			    return NULL;
 			  }
 			ENSURE_ALLOCATION (xsum (length, tmpdst_len));
 			DCHAR_CPY (result + length, tmpdst, tmpdst_len);
 			free (tmpdst);
 			count = tmpdst_len;
 		      }
 		    else
 		      {
 			/* The result string is ASCII.
 			   Simple 1:1 conversion.  */
 # if USE_SNPRINTF
 			/* If sizeof (DCHAR_T) == sizeof (TCHAR_T), it's a
 			   no-op conversion, in-place on the array starting
 			   at (result + length).  */
 			if (sizeof (DCHAR_T) != sizeof (TCHAR_T))
 # endif
 			  {
 			    const TCHAR_T *tmpsrc;
 			    DCHAR_T *tmpdst;
 			    size_t n;

 # if USE_SNPRINTF
 			    if (result == resultbuf)
 			      {
 				tmpsrc = (TCHAR_T *) (result + length);
 				/* ENSURE_ALLOCATION will not move tmpsrc
 				   (because it's part of resultbuf).  */
 				ENSURE_ALLOCATION (xsum (length, count));
 			      }
 			    else
 			      {
 				/* ENSURE_ALLOCATION will move the array
 				   (because it uses realloc().  */
 				ENSURE_ALLOCATION (xsum (length, count));
 				tmpsrc = (TCHAR_T *) (result + length);
 			      }
 # else
 			    tmpsrc = tmp;
 			    ENSURE_ALLOCATION (xsum (length, count));
 # endif
 			    tmpdst = result + length;
 			    /* Copy backwards, because of overlapping.  */
 			    tmpsrc += count;
 			    tmpdst += count;
 			    for (n = count; n > 0; n--)
 			      *--tmpdst = (unsigned char) *--tmpsrc;
 			  }
 		      }
 #endif

 #if DCHAR_IS_TCHAR && !USE_SNPRINTF
 		    /* Make room for the result.  */
 		    if (count > allocated - length)
 		      {
 			/* Need at least count elements.  But allocate
 			   proportionally.  */
 			size_t n =
 			  xmax (xsum (length, count), xtimes (allocated, 2));

 			ENSURE_ALLOCATION (n);
 		      }
 #endif

 		    /* Here count <= allocated - length.  */

 		    /* Perform padding.  */
 #if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
 		    if (pad_ourselves && has_width)
 		      {
 			size_t w;
 # if ENABLE_UNISTDIO
 			/* Outside POSIX, it's preferrable to compare the width
 			   against the number of _characters_ of the converted
 			   value.  */
 			w = DCHAR_MBSNLEN (result + length, count);
 # else
 			/* The width is compared against the number of _bytes_
 			   of the converted value, says POSIX.  */
 			w = count;
 # endif
 			if (w < width)
 			  {
 			    size_t pad = width - w;
 # if USE_SNPRINTF
 			    /* Make room for the result.  */
 			    if (xsum (count, pad) > allocated - length)
 			      {
 				/* Need at least count + pad elements.  But
 				   allocate proportionally.  */
 				size_t n =
 				  xmax (xsum3 (length, count, pad),
 					xtimes (allocated, 2));

 				length += count;
 				ENSURE_ALLOCATION (n);
 				length -= count;
 			      }
 			    /* Here count + pad <= allocated - length.  */
 # endif
 			    {
 # if !DCHAR_IS_TCHAR || USE_SNPRINTF
 			      DCHAR_T * const rp = result + length;
 # else
 			      DCHAR_T * const rp = tmp;
 # endif
 			      DCHAR_T *p = rp + count;
 			      DCHAR_T *end = p + pad;
 # if NEED_PRINTF_FLAG_ZERO
 			      DCHAR_T *pad_ptr;
 #  if !DCHAR_IS_TCHAR
 			      if (dp->conversion == 'c'
 				  || dp->conversion == 's')
 				/* No zero-padding for string directives.  */
 				pad_ptr = NULL;
 			      else
 #  endif
 				{
 				  pad_ptr = (*rp == '-' ? rp + 1 : rp);
 				  /* No zero-padding of "inf" and "nan".  */
 				  if ((*pad_ptr >= 'A' && *pad_ptr <= 'Z')
 				      || (*pad_ptr >= 'a' && *pad_ptr <= 'z'))
 				    pad_ptr = NULL;
 				}
 # endif
 			      /* The generated string now extends from rp to p,
 				 with the zero padding insertion point being at
 				 pad_ptr.  */

 			      count = count + pad; /* = end - rp */

 			      if (flags & FLAG_LEFT)
 				{
 				  /* Pad with spaces on the right.  */
 				  for (; pad > 0; pad--)
 				    *p++ = ' ';
 				}
 # if NEED_PRINTF_FLAG_ZERO
 			      else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
 				{
 				  /* Pad with zeroes.  */
 				  DCHAR_T *q = end;

 				  while (p > pad_ptr)
 				    *--q = *--p;
 				  for (; pad > 0; pad--)
 				    *p++ = '0';
 				}
 # endif
 			      else
 				{
 				  /* Pad with spaces on the left.  */
 				  DCHAR_T *q = end;

 				  while (p > rp)
 				    *--q = *--p;
 				  for (; pad > 0; pad--)
 				    *p++ = ' ';
 				}
 			    }
 			  }
 		      }
 #endif

 #if DCHAR_IS_TCHAR && !USE_SNPRINTF
 		    if (count >= tmp_length)
 		      /* tmp_length was incorrectly calculated - fix the
 			 code above!  */
 		      abort ();
 #endif

 		    /* Here still count <= allocated - length.  */

 #if !DCHAR_IS_TCHAR || USE_SNPRINTF
 		    /* The snprintf() result did fit.  */
 #else
 		    /* Append the sprintf() result.  */
 		    memcpy (result + length, tmp, count * sizeof (DCHAR_T));
 #endif
 #if !USE_SNPRINTF
 		    if (tmp != tmpbuf)
 		      free (tmp);
 #endif

 #if NEED_PRINTF_DIRECTIVE_F
 		    if (dp->conversion == 'F')
 		      {
 			/* Convert the %f result to upper case for %F.  */
 			DCHAR_T *rp = result + length;
 			size_t rc;
 			for (rc = count; rc > 0; rc--, rp++)
 			  if (*rp >= 'a' && *rp <= 'z')
 			    *rp = *rp - 'a' + 'A';
 		      }
 #endif

 		    length += count;
 		    break;
 		  }
 	      }
 	  }
       }

     /* Add the final NUL.  */
     ENSURE_ALLOCATION (xsum (length, 1));
     result[length] = '\0';

     if (result != resultbuf && length + 1 < allocated)
       {
 	/* Shrink the allocated memory if possible.  */
 	DCHAR_T *memory;

 	memory = (DCHAR_T *) realloc (result, (length + 1) * sizeof (DCHAR_T));
 	if (memory != NULL)
 	  result = memory;
       }

     if (buf_malloced != NULL)
       free (buf_malloced);
     CLEANUP ();
     *lengthp = length;
     /* Note that we can produce a big string of a length > INT_MAX.  POSIX
        says that snprintf() fails with errno = EOVERFLOW in this case, but
        that's only because snprintf() returns an 'int'.  This function does
        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);
     if (buf_malloced != NULL)
       free (buf_malloced);
   out_of_memory_1:
     CLEANUP ();
     errno = ENOMEM;
     return NULL;
   }
 }

 #undef TCHARS_PER_DCHAR
 #undef SNPRINTF
 #undef USE_SNPRINTF
 #undef DCHAR_CPY
 #undef PRINTF_PARSE
 #undef DIRECTIVES
 #undef DIRECTIVE
 #undef DCHAR_IS_TCHAR
 #undef TCHAR_T
 #undef DCHAR_T
 #undef FCHAR_T
 #undef VASNPRINTF