intl/vasnprintf.c

   1 /* vsprintf with automatic memory allocation.
   2    Copyright (C) 1999, 2002-2010 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify it
   5    under the terms of the GNU Library General Public License as published
   6    by the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public
  15    License along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17    USA.  */
  18
  19 /* This file can be parametrized with the following macros:
  20      VASNPRINTF         The name of the function being defined.
  21      FCHAR_T            The element type of the format string.
  22      DCHAR_T            The element type of the destination (result) string.
  23      FCHAR_T_ONLY_ASCII Set to 1 to enable verification that all characters
  24                         in the format string are ASCII. MUST be set if
  25                         FCHAR_T and DCHAR_T are not the same type.
  26      DIRECTIVE          Structure denoting a format directive.
  27                         Depends on FCHAR_T.
  28      DIRECTIVES         Structure denoting the set of format directives of a
  29                         format string.  Depends on FCHAR_T.
  30      PRINTF_PARSE       Function that parses a format string.
  31                         Depends on FCHAR_T.
  32      DCHAR_CPY          memcpy like function for DCHAR_T[] arrays.
  33      DCHAR_SET          memset like function for DCHAR_T[] arrays.
  34      DCHAR_MBSNLEN      mbsnlen like function for DCHAR_T[] arrays.
  35      SNPRINTF           The system's snprintf (or similar) function.
  36                         This may be either snprintf or swprintf.
  37      TCHAR_T            The element type of the argument and result string
  38                         of the said SNPRINTF function.  This may be either
  39                         char or wchar_t.  The code exploits that
  40                         sizeof (TCHAR_T) | sizeof (DCHAR_T) and
  41                         alignof (TCHAR_T) <= alignof (DCHAR_T).
  42      DCHAR_IS_TCHAR     Set to 1 if DCHAR_T and TCHAR_T are the same type.
  43      DCHAR_CONV_FROM_ENCODING A function to convert from char[] to DCHAR[].
  44      DCHAR_IS_UINT8_T   Set to 1 if DCHAR_T is uint8_t.
  45      DCHAR_IS_UINT16_T  Set to 1 if DCHAR_T is uint16_t.
  46      DCHAR_IS_UINT32_T  Set to 1 if DCHAR_T is uint32_t.  */
  47
  48 /* Tell glibc's <stdio.h> to provide a prototype for snprintf().
  49    This must come before <config.h> because <config.h> may include
  50    <features.h>, and once <features.h> has been included, it's too late.  */
  51 #ifndef _GNU_SOURCE
  52 # define _GNU_SOURCE    1
  53 #endif
  54
  55 #ifndef VASNPRINTF
  56 # include <config.h>
  57 #endif
  58 #ifndef IN_LIBINTL
  59 # include <alloca.h>
  60 #endif
  61
  62 /* Specification.  */
  63 #ifndef VASNPRINTF
  64 # if WIDE_CHAR_VERSION
  65 #  include "vasnwprintf.h"
  66 # else
  67 #  include "vasnprintf.h"
  68 # endif
  69 #endif
  70
  71 #include <locale.h>     /* localeconv() */
  72 #include <stdio.h>      /* snprintf(), sprintf() */
  73 #include <stdlib.h>     /* abort(), malloc(), realloc(), free() */
  74 #include <string.h>     /* memcpy(), strlen() */
  75 #include <errno.h>      /* errno */
  76 #include <limits.h>     /* CHAR_BIT */
  77 #include <float.h>      /* DBL_MAX_EXP, LDBL_MAX_EXP */
  78 #if HAVE_NL_LANGINFO
  79 # include <langinfo.h>
  80 #endif
  81 #ifndef VASNPRINTF
  82 # if WIDE_CHAR_VERSION
  83 #  include "wprintf-parse.h"
  84 # else
  85 #  include "printf-parse.h"
  86 # endif
  87 #endif
  88
  89 /* Checked size_t computations.  */
  90 #include "xsize.h"
  91
  92 #if (NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
  93 # include <math.h>
  94 # include "float+.h"
  95 #endif
  96
  97 #if (NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && !defined IN_LIBINTL
  98 # include <math.h>
  99 # include "isnand-nolibm.h"
 100 #endif
 101
 102 #if (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE) && !defined IN_LIBINTL
 103 # include <math.h>
 104 # include "isnanl-nolibm.h"
 105 # include "fpucw.h"
 106 #endif
 107
 108 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
 109 # include <math.h>
 110 # include "isnand-nolibm.h"
 111 # include "printf-frexp.h"
 112 #endif
 113
 114 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
 115 # include <math.h>
 116 # include "isnanl-nolibm.h"
 117 # include "printf-frexpl.h"
 118 # include "fpucw.h"
 119 #endif
 120
 121 /* Default parameters.  */
 122 #ifndef VASNPRINTF
 123 # if WIDE_CHAR_VERSION
 124 #  define VASNPRINTF vasnwprintf
 125 #  define FCHAR_T wchar_t
 126 #  define DCHAR_T wchar_t
 127 #  define TCHAR_T wchar_t
 128 #  define DCHAR_IS_TCHAR 1
 129 #  define DIRECTIVE wchar_t_directive
 130 #  define DIRECTIVES wchar_t_directives
 131 #  define PRINTF_PARSE wprintf_parse
 132 #  define DCHAR_CPY wmemcpy
 133 #  define DCHAR_SET wmemset
 134 # else
 135 #  define VASNPRINTF vasnprintf
 136 #  define FCHAR_T char
 137 #  define DCHAR_T char
 138 #  define TCHAR_T char
 139 #  define DCHAR_IS_TCHAR 1
 140 #  define DIRECTIVE char_directive
 141 #  define DIRECTIVES char_directives
 142 #  define PRINTF_PARSE printf_parse
 143 #  define DCHAR_CPY memcpy
 144 #  define DCHAR_SET memset
 145 # endif
 146 #endif
 147 #if WIDE_CHAR_VERSION
 148   /* TCHAR_T is wchar_t.  */
 149 # define USE_SNPRINTF 1
 150 # if HAVE_DECL__SNWPRINTF
 151    /* On Windows, the function swprintf() has a different signature than
 152       on Unix; we use the function _snwprintf() or - on mingw - snwprintf()
 153       instead.  The mingw function snwprintf() has fewer bugs than the
 154       MSVCRT function _snwprintf(), so prefer that.  */
 155 #  if defined __MINGW32__
 156 #   define SNPRINTF snwprintf
 157 #  else
 158 #   define SNPRINTF _snwprintf
 159 #  endif
 160 # else
 161    /* Unix.  */
 162 #  define SNPRINTF swprintf
 163 # endif
 164 #else
 165   /* TCHAR_T is char.  */
 166   /* Use snprintf if it exists under the name 'snprintf' or '_snprintf'.
 167      But don't use it on BeOS, since BeOS snprintf produces no output if the
 168      size argument is >= 0x3000000.
 169      Also don't use it on Linux libc5, since there snprintf with size = 1
 170      writes any output without bounds, like sprintf.  */
 171 # if (HAVE_DECL__SNPRINTF || HAVE_SNPRINTF) && !defined __BEOS__ && !(__GNU_LIBRARY__ == 1)
 172 #  define USE_SNPRINTF 1
 173 # else
 174 #  define USE_SNPRINTF 0
 175 # endif
 176 # if HAVE_DECL__SNPRINTF
 177    /* Windows.  The mingw function snprintf() has fewer bugs than the MSVCRT
 178       function _snprintf(), so prefer that.  */
 179 #  if defined __MINGW32__
 180 #   define SNPRINTF snprintf
 181     /* Here we need to call the native snprintf, not rpl_snprintf.  */
 182 #   undef snprintf
 183 #  else
 184 #   define SNPRINTF _snprintf
 185 #  endif
 186 # else
 187    /* Unix.  */
 188 #  define SNPRINTF snprintf
 189    /* Here we need to call the native snprintf, not rpl_snprintf.  */
 190 #  undef snprintf
 191 # endif
 192 #endif
 193 /* Here we need to call the native sprintf, not rpl_sprintf.  */
 194 #undef sprintf
 195
 196 /* GCC >= 4.0 with -Wall emits unjustified "... may be used uninitialized"
 197    warnings in this file.  Use -Dlint to suppress them.  */
 198 #ifdef lint
 199 # define IF_LINT(Code) Code
 200 #else
 201 # define IF_LINT(Code) /* empty */
 202 #endif
 203
 204 /* Avoid some warnings from "gcc -Wshadow".
 205    This file doesn't use the exp() and remainder() functions.  */
 206 #undef exp
 207 #define exp expo
 208 #undef remainder
 209 #define remainder rem
 210
 211 #if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99) && !WIDE_CHAR_VERSION
 212 # if (HAVE_STRNLEN && !defined _AIX)
 213 #  define local_strnlen strnlen
 214 # else
 215 #  ifndef local_strnlen_defined
 216 #   define local_strnlen_defined 1
 217 static size_t
 218 local_strnlen (const char *string, size_t maxlen)
 219 {
 220   const char *end = memchr (string, '\0', maxlen);
 221   return end ? (size_t) (end - string) : maxlen;
 222 }
 223 #  endif
 224 # endif
 225 #endif
 226
 227 #if (((!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99) && WIDE_CHAR_VERSION) || ((!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || (NEED_PRINTF_DIRECTIVE_LS && !defined IN_LIBINTL)) && !WIDE_CHAR_VERSION && DCHAR_IS_TCHAR)) && HAVE_WCHAR_T
 228 # if HAVE_WCSLEN
 229 #  define local_wcslen wcslen
 230 # else
 231    /* Solaris 2.5.1 has wcslen() in a separate library libw.so. To avoid
 232       a dependency towards this library, here is a local substitute.
 233       Define this substitute only once, even if this file is included
 234       twice in the same compilation unit.  */
 235 #  ifndef local_wcslen_defined
 236 #   define local_wcslen_defined 1
 237 static size_t
 238 local_wcslen (const wchar_t *s)
 239 {
 240   const wchar_t *ptr;
 241
 242   for (ptr = s; *ptr != (wchar_t) 0; ptr++)
 243     ;
 244   return ptr - s;
 245 }
 246 #  endif
 247 # endif
 248 #endif
 249
 250 #if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99) && HAVE_WCHAR_T && WIDE_CHAR_VERSION
 251 # if HAVE_WCSNLEN
 252 #  define local_wcsnlen wcsnlen
 253 # else
 254 #  ifndef local_wcsnlen_defined
 255 #   define local_wcsnlen_defined 1
 256 static size_t
 257 local_wcsnlen (const wchar_t *s, size_t maxlen)
 258 {
 259   const wchar_t *ptr;
 260
 261   for (ptr = s; maxlen > 0 && *ptr != (wchar_t) 0; ptr++, maxlen--)
 262     ;
 263   return ptr - s;
 264 }
 265 #  endif
 266 # endif
 267 #endif
 268
 269 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && !defined IN_LIBINTL
 270 /* Determine the decimal-point character according to the current locale.  */
 271 # ifndef decimal_point_char_defined
 272 #  define decimal_point_char_defined 1
 273 static char
 274 decimal_point_char (void)
 275 {
 276   const char *point;
 277   /* Determine it in a multithread-safe way.  We know nl_langinfo is
 278      multithread-safe on glibc systems and MacOS X systems, but is not required
 279      to be multithread-safe by POSIX.  sprintf(), however, is multithread-safe.
 280      localeconv() is rarely multithread-safe.  */
 281 #  if HAVE_NL_LANGINFO && (__GLIBC__ || (defined __APPLE__ && defined __MACH__))
 282   point = nl_langinfo (RADIXCHAR);
 283 #  elif 1
 284   char pointbuf[5];
 285   sprintf (pointbuf, "%#.0f", 1.0);
 286   point = &pointbuf[1];
 287 #  else
 288   point = localeconv () -> decimal_point;
 289 #  endif
 290   /* The decimal point is always a single byte: either '.' or ','.  */
 291   return (point[0] != '\0' ? point[0] : '.');
 292 }
 293 # endif
 294 #endif
 295
 296 #if NEED_PRINTF_INFINITE_DOUBLE && !NEED_PRINTF_DOUBLE && !defined IN_LIBINTL
 297
 298 /* Equivalent to !isfinite(x) || x == 0, but does not require libm.  */
 299 static int
 300 is_infinite_or_zero (double x)
 301 {
 302   return isnand (x) || x + x == x;
 303 }
 304
 305 #endif
 306
 307 #if NEED_PRINTF_INFINITE_LONG_DOUBLE && !NEED_PRINTF_LONG_DOUBLE && !defined IN_LIBINTL
 308
 309 /* Equivalent to !isfinite(x) || x == 0, but does not require libm.  */
 310 static int
 311 is_infinite_or_zerol (long double x)
 312 {
 313   return isnanl (x) || x + x == x;
 314 }
 315
 316 #endif
 317
 318 #if (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
 319
 320 /* Converting 'long double' to decimal without rare rounding bugs requires
 321    real bignums.  We use the naming conventions of GNU gmp, but vastly simpler
 322    (and slower) algorithms.  */
 323
 324 typedef unsigned int mp_limb_t;
 325 # define GMP_LIMB_BITS 32
 326 typedef int mp_limb_verify[2 * (sizeof (mp_limb_t) * CHAR_BIT == GMP_LIMB_BITS) - 1];
 327
 328 typedef unsigned long long mp_twolimb_t;
 329 # define GMP_TWOLIMB_BITS 64
 330 typedef int mp_twolimb_verify[2 * (sizeof (mp_twolimb_t) * CHAR_BIT == GMP_TWOLIMB_BITS) - 1];
 331
 332 /* Representation of a bignum >= 0.  */
 333 typedef struct
 334 {
 335   size_t nlimbs;
 336   mp_limb_t *limbs; /* Bits in little-endian order, allocated with malloc().  */
 337 } mpn_t;
 338
 339 /* Compute the product of two bignums >= 0.
 340    Return the allocated memory in case of success, NULL in case of memory
 341    allocation failure.  */
 342 static void *
 343 multiply (mpn_t src1, mpn_t src2, mpn_t *dest)
 344 {
 345   const mp_limb_t *p1;
 346   const mp_limb_t *p2;
 347   size_t len1;
 348   size_t len2;
 349
 350   if (src1.nlimbs <= src2.nlimbs)
 351     {
 352       len1 = src1.nlimbs;
 353       p1 = src1.limbs;
 354       len2 = src2.nlimbs;
 355       p2 = src2.limbs;
 356     }
 357   else
 358     {
 359       len1 = src2.nlimbs;
 360       p1 = src2.limbs;
 361       len2 = src1.nlimbs;
 362       p2 = src1.limbs;
 363     }
 364   /* Now 0 <= len1 <= len2.  */
 365   if (len1 == 0)
 366     {
 367       /* src1 or src2 is zero.  */
 368       dest->nlimbs = 0;
 369       dest->limbs = (mp_limb_t *) malloc (1);
 370     }
 371   else
 372     {
 373       /* Here 1 <= len1 <= len2.  */
 374       size_t dlen;
 375       mp_limb_t *dp;
 376       size_t k, i, j;
 377
 378       dlen = len1 + len2;
 379       dp = (mp_limb_t *) malloc (dlen * sizeof (mp_limb_t));
 380       if (dp == NULL)
 381         return NULL;
 382       for (k = len2; k > 0; )
 383         dp[--k] = 0;
 384       for (i = 0; i < len1; i++)
 385         {
 386           mp_limb_t digit1 = p1[i];
 387           mp_twolimb_t carry = 0;
 388           for (j = 0; j < len2; j++)
 389             {
 390               mp_limb_t digit2 = p2[j];
 391               carry += (mp_twolimb_t) digit1 * (mp_twolimb_t) digit2;
 392               carry += dp[i + j];
 393               dp[i + j] = (mp_limb_t) carry;
 394               carry = carry >> GMP_LIMB_BITS;
 395             }
 396           dp[i + len2] = (mp_limb_t) carry;
 397         }
 398       /* Normalise.  */
 399       while (dlen > 0 && dp[dlen - 1] == 0)
 400         dlen--;
 401       dest->nlimbs = dlen;
 402       dest->limbs = dp;
 403     }
 404   return dest->limbs;
 405 }
 406
 407 /* Compute the quotient of a bignum a >= 0 and a bignum b > 0.
 408    a is written as  a = q * b + r  with 0 <= r < b.  q is the quotient, r
 409    the remainder.
 410    Finally, round-to-even is performed: If r > b/2 or if r = b/2 and q is odd,
 411    q is incremented.
 412    Return the allocated memory in case of success, NULL in case of memory
 413    allocation failure.  */
 414 static void *
 415 divide (mpn_t a, mpn_t b, mpn_t *q)
 416 {
 417   /* Algorithm:
 418      First normalise a and b: a=[a[m-1],...,a[0]], b=[b[n-1],...,b[0]]
 419      with m>=0 and n>0 (in base beta = 2^GMP_LIMB_BITS).
 420      If m<n, then q:=0 and r:=a.
 421      If m>=n=1, perform a single-precision division:
 422        r:=0, j:=m,
 423        while j>0 do
 424          {Here (q[m-1]*beta^(m-1)+...+q[j]*beta^j) * b[0] + r*beta^j =
 425                = a[m-1]*beta^(m-1)+...+a[j]*beta^j und 0<=r<b[0]<beta}
 426          j:=j-1, r:=r*beta+a[j], q[j]:=floor(r/b[0]), r:=r-b[0]*q[j].
 427        Normalise [q[m-1],...,q[0]], yields q.
 428      If m>=n>1, perform a multiple-precision division:
 429        We have a/b < beta^(m-n+1).
 430        s:=intDsize-1-(highest bit in b[n-1]), 0<=s<intDsize.
 431        Shift a and b left by s bits, copying them. r:=a.
 432        r=[r[m],...,r[0]], b=[b[n-1],...,b[0]] with b[n-1]>=beta/2.
 433        For j=m-n,...,0: {Here 0 <= r < b*beta^(j+1).}
 434          Compute q* :
 435            q* := floor((r[j+n]*beta+r[j+n-1])/b[n-1]).
 436            In case of overflow (q* >= beta) set q* := beta-1.
 437            Compute c2 := ((r[j+n]*beta+r[j+n-1]) - q* * b[n-1])*beta + r[j+n-2]
 438            and c3 := b[n-2] * q*.
 439            {We have 0 <= c2 < 2*beta^2, even 0 <= c2 < beta^2 if no overflow
 440             occurred.  Furthermore 0 <= c3 < beta^2.
 441             If there was overflow and
 442             r[j+n]*beta+r[j+n-1] - q* * b[n-1] >= beta, i.e. c2 >= beta^2,
 443             the next test can be skipped.}
 444            While c3 > c2, {Here 0 <= c2 < c3 < beta^2}
 445              Put q* := q* - 1, c2 := c2 + b[n-1]*beta, c3 := c3 - b[n-2].
 446            If q* > 0:
 447              Put r := r - b * q* * beta^j. In detail:
 448                [r[n+j],...,r[j]] := [r[n+j],...,r[j]] - q* * [b[n-1],...,b[0]].
 449                hence: u:=0, for i:=0 to n-1 do
 450                               u := u + q* * b[i],
 451                               r[j+i]:=r[j+i]-(u mod beta) (+ beta, if carry),
 452                               u:=u div beta (+ 1, if carry in subtraction)
 453                       r[n+j]:=r[n+j]-u.
 454                {Since always u = (q* * [b[i-1],...,b[0]] div beta^i) + 1
 455                                < q* + 1 <= beta,
 456                 the carry u does not overflow.}
 457              If a negative carry occurs, put q* := q* - 1
 458                and [r[n+j],...,r[j]] := [r[n+j],...,r[j]] + [0,b[n-1],...,b[0]].
 459          Set q[j] := q*.
 460        Normalise [q[m-n],..,q[0]]; this yields the quotient q.
 461        Shift [r[n-1],...,r[0]] right by s bits and normalise; this yields the
 462        rest r.
 463        The room for q[j] can be allocated at the memory location of r[n+j].
 464      Finally, round-to-even:
 465        Shift r left by 1 bit.
 466        If r > b or if r = b and q[0] is odd, q := q+1.
 467    */
 468   const mp_limb_t *a_ptr = a.limbs;
 469   size_t a_len = a.nlimbs;
 470   const mp_limb_t *b_ptr = b.limbs;
 471   size_t b_len = b.nlimbs;
 472   mp_limb_t *roomptr;
 473   mp_limb_t *tmp_roomptr = NULL;
 474   mp_limb_t *q_ptr;
 475   size_t q_len;
 476   mp_limb_t *r_ptr;
 477   size_t r_len;
 478
 479   /* Allocate room for a_len+2 digits.
 480      (Need a_len+1 digits for the real division and 1 more digit for the
 481      final rounding of q.)  */
 482   roomptr = (mp_limb_t *) malloc ((a_len + 2) * sizeof (mp_limb_t));
 483   if (roomptr == NULL)
 484     return NULL;
 485
 486   /* Normalise a.  */
 487   while (a_len > 0 && a_ptr[a_len - 1] == 0)
 488     a_len--;
 489
 490   /* Normalise b.  */
 491   for (;;)
 492     {
 493       if (b_len == 0)
 494         /* Division by zero.  */
 495         abort ();
 496       if (b_ptr[b_len - 1] == 0)
 497         b_len--;
 498       else
 499         break;
 500     }
 501
 502   /* Here m = a_len >= 0 and n = b_len > 0.  */
 503
 504   if (a_len < b_len)
 505     {
 506       /* m<n: trivial case.  q=0, r := copy of a.  */
 507       r_ptr = roomptr;
 508       r_len = a_len;
 509       memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));
 510       q_ptr = roomptr + a_len;
 511       q_len = 0;
 512     }
 513   else if (b_len == 1)
 514     {
 515       /* n=1: single precision division.
 516          beta^(m-1) <= a < beta^m  ==>  beta^(m-2) <= a/b < beta^m  */
 517       r_ptr = roomptr;
 518       q_ptr = roomptr + 1;
 519       {
 520         mp_limb_t den = b_ptr[0];
 521         mp_limb_t remainder = 0;
 522         const mp_limb_t *sourceptr = a_ptr + a_len;
 523         mp_limb_t *destptr = q_ptr + a_len;
 524         size_t count;
 525         for (count = a_len; count > 0; count--)
 526           {
 527             mp_twolimb_t num =
 528               ((mp_twolimb_t) remainder << GMP_LIMB_BITS) | *--sourceptr;
 529             *--destptr = num / den;
 530             remainder = num % den;
 531           }
 532         /* Normalise and store r.  */
 533         if (remainder > 0)
 534           {
 535             r_ptr[0] = remainder;
 536             r_len = 1;
 537           }
 538         else
 539           r_len = 0;
 540         /* Normalise q.  */
 541         q_len = a_len;
 542         if (q_ptr[q_len - 1] == 0)
 543           q_len--;
 544       }
 545     }
 546   else
 547     {
 548       /* n>1: multiple precision division.
 549          beta^(m-1) <= a < beta^m, beta^(n-1) <= b < beta^n  ==>
 550          beta^(m-n-1) <= a/b < beta^(m-n+1).  */
 551       /* Determine s.  */
 552       size_t s;
 553       {
 554         mp_limb_t msd = b_ptr[b_len - 1]; /* = b[n-1], > 0 */
 555         s = 31;
 556         if (msd >= 0x10000)
 557           {
 558             msd = msd >> 16;
 559             s -= 16;
 560           }
 561         if (msd >= 0x100)
 562           {
 563             msd = msd >> 8;
 564             s -= 8;
 565           }
 566         if (msd >= 0x10)
 567           {
 568             msd = msd >> 4;
 569             s -= 4;
 570           }
 571         if (msd >= 0x4)
 572           {
 573             msd = msd >> 2;
 574             s -= 2;
 575           }
 576         if (msd >= 0x2)
 577           {
 578             msd = msd >> 1;
 579             s -= 1;
 580           }
 581       }
 582       /* 0 <= s < GMP_LIMB_BITS.
 583          Copy b, shifting it left by s bits.  */
 584       if (s > 0)
 585         {
 586           tmp_roomptr = (mp_limb_t *) malloc (b_len * sizeof (mp_limb_t));
 587           if (tmp_roomptr == NULL)
 588             {
 589               free (roomptr);
 590               return NULL;
 591             }
 592           {
 593             const mp_limb_t *sourceptr = b_ptr;
 594             mp_limb_t *destptr = tmp_roomptr;
 595             mp_twolimb_t accu = 0;
 596             size_t count;
 597             for (count = b_len; count > 0; count--)
 598               {
 599                 accu += (mp_twolimb_t) *sourceptr++ << s;
 600                 *destptr++ = (mp_limb_t) accu;
 601                 accu = accu >> GMP_LIMB_BITS;
 602               }
 603             /* accu must be zero, since that was how s was determined.  */
 604             if (accu != 0)
 605               abort ();
 606           }
 607           b_ptr = tmp_roomptr;
 608         }
 609       /* Copy a, shifting it left by s bits, yields r.
 610          Memory layout:
 611          At the beginning: r = roomptr[0..a_len],
 612          at the end: r = roomptr[0..b_len-1], q = roomptr[b_len..a_len]  */
 613       r_ptr = roomptr;
 614       if (s == 0)
 615         {
 616           memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));
 617           r_ptr[a_len] = 0;
 618         }
 619       else
 620         {
 621           const mp_limb_t *sourceptr = a_ptr;
 622           mp_limb_t *destptr = r_ptr;
 623           mp_twolimb_t accu = 0;
 624           size_t count;
 625           for (count = a_len; count > 0; count--)
 626             {
 627               accu += (mp_twolimb_t) *sourceptr++ << s;
 628               *destptr++ = (mp_limb_t) accu;
 629               accu = accu >> GMP_LIMB_BITS;
 630             }
 631           *destptr++ = (mp_limb_t) accu;
 632         }
 633       q_ptr = roomptr + b_len;
 634       q_len = a_len - b_len + 1; /* q will have m-n+1 limbs */
 635       {
 636         size_t j = a_len - b_len; /* m-n */
 637         mp_limb_t b_msd = b_ptr[b_len - 1]; /* b[n-1] */
 638         mp_limb_t b_2msd = b_ptr[b_len - 2]; /* b[n-2] */
 639         mp_twolimb_t b_msdd = /* b[n-1]*beta+b[n-2] */
 640           ((mp_twolimb_t) b_msd << GMP_LIMB_BITS) | b_2msd;
 641         /* Division loop, traversed m-n+1 times.
 642            j counts down, b is unchanged, beta/2 <= b[n-1] < beta.  */
 643         for (;;)
 644           {
 645             mp_limb_t q_star;
 646             mp_limb_t c1;
 647             if (r_ptr[j + b_len] < b_msd) /* r[j+n] < b[n-1] ? */
 648               {
 649                 /* Divide r[j+n]*beta+r[j+n-1] by b[n-1], no overflow.  */
 650                 mp_twolimb_t num =
 651                   ((mp_twolimb_t) r_ptr[j + b_len] << GMP_LIMB_BITS)
 652                   | r_ptr[j + b_len - 1];
 653                 q_star = num / b_msd;
 654                 c1 = num % b_msd;
 655               }
 656             else
 657               {
 658                 /* Overflow, hence r[j+n]*beta+r[j+n-1] >= beta*b[n-1].  */
 659                 q_star = (mp_limb_t)~(mp_limb_t)0; /* q* = beta-1 */
 660                 /* Test whether r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] >= beta
 661                    <==> r[j+n]*beta+r[j+n-1] + b[n-1] >= beta*b[n-1]+beta
 662                    <==> b[n-1] < floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta)
 663                         {<= beta !}.
 664                    If yes, jump directly to the subtraction loop.
 665                    (Otherwise, r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] < beta
 666                     <==> floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta) = b[n-1] ) */
 667                 if (r_ptr[j + b_len] > b_msd
 668                     || (c1 = r_ptr[j + b_len - 1] + b_msd) < b_msd)
 669                   /* r[j+n] >= b[n-1]+1 or
 670                      r[j+n] = b[n-1] and the addition r[j+n-1]+b[n-1] gives a
 671                      carry.  */
 672                   goto subtract;
 673               }
 674             /* q_star = q*,
 675                c1 = (r[j+n]*beta+r[j+n-1]) - q* * b[n-1] (>=0, <beta).  */
 676             {
 677               mp_twolimb_t c2 = /* c1*beta+r[j+n-2] */
 678                 ((mp_twolimb_t) c1 << GMP_LIMB_BITS) | r_ptr[j + b_len - 2];
 679               mp_twolimb_t c3 = /* b[n-2] * q* */
 680                 (mp_twolimb_t) b_2msd * (mp_twolimb_t) q_star;
 681               /* While c2 < c3, increase c2 and decrease c3.
 682                  Consider c3-c2.  While it is > 0, decrease it by
 683                  b[n-1]*beta+b[n-2].  Because of b[n-1]*beta+b[n-2] >= beta^2/2
 684                  this can happen only twice.  */
 685               if (c3 > c2)
 686                 {
 687                   q_star = q_star - 1; /* q* := q* - 1 */
 688                   if (c3 - c2 > b_msdd)
 689                     q_star = q_star - 1; /* q* := q* - 1 */
 690                 }
 691             }
 692             if (q_star > 0)
 693               subtract:
 694               {
 695                 /* Subtract r := r - b * q* * beta^j.  */
 696                 mp_limb_t cr;
 697                 {
 698                   const mp_limb_t *sourceptr = b_ptr;
 699                   mp_limb_t *destptr = r_ptr + j;
 700                   mp_twolimb_t carry = 0;
 701                   size_t count;
 702                   for (count = b_len; count > 0; count--)
 703                     {
 704                       /* Here 0 <= carry <= q*.  */
 705                       carry =
 706                         carry
 707                         + (mp_twolimb_t) q_star * (mp_twolimb_t) *sourceptr++
 708                         + (mp_limb_t) ~(*destptr);
 709                       /* Here 0 <= carry <= beta*q* + beta-1.  */
 710                       *destptr++ = ~(mp_limb_t) carry;
 711                       carry = carry >> GMP_LIMB_BITS; /* <= q* */
 712                     }
 713                   cr = (mp_limb_t) carry;
 714                 }
 715                 /* Subtract cr from r_ptr[j + b_len], then forget about
 716                    r_ptr[j + b_len].  */
 717                 if (cr > r_ptr[j + b_len])
 718                   {
 719                     /* Subtraction gave a carry.  */
 720                     q_star = q_star - 1; /* q* := q* - 1 */
 721                     /* Add b back.  */
 722                     {
 723                       const mp_limb_t *sourceptr = b_ptr;
 724                       mp_limb_t *destptr = r_ptr + j;
 725                       mp_limb_t carry = 0;
 726                       size_t count;
 727                       for (count = b_len; count > 0; count--)
 728                         {
 729                           mp_limb_t source1 = *sourceptr++;
 730                           mp_limb_t source2 = *destptr;
 731                           *destptr++ = source1 + source2 + carry;
 732                           carry =
 733                             (carry
 734                              ? source1 >= (mp_limb_t) ~source2
 735                              : source1 > (mp_limb_t) ~source2);
 736                         }
 737                     }
 738                     /* Forget about the carry and about r[j+n].  */
 739                   }
 740               }
 741             /* q* is determined.  Store it as q[j].  */
 742             q_ptr[j] = q_star;
 743             if (j == 0)
 744               break;
 745             j--;
 746           }
 747       }
 748       r_len = b_len;
 749       /* Normalise q.  */
 750       if (q_ptr[q_len - 1] == 0)
 751         q_len--;
 752 # if 0 /* Not needed here, since we need r only to compare it with b/2, and
 753           b is shifted left by s bits.  */
 754       /* Shift r right by s bits.  */
 755       if (s > 0)
 756         {
 757           mp_limb_t ptr = r_ptr + r_len;
 758           mp_twolimb_t accu = 0;
 759           size_t count;
 760           for (count = r_len; count > 0; count--)
 761             {
 762               accu = (mp_twolimb_t) (mp_limb_t) accu << GMP_LIMB_BITS;
 763               accu += (mp_twolimb_t) *--ptr << (GMP_LIMB_BITS - s);
 764               *ptr = (mp_limb_t) (accu >> GMP_LIMB_BITS);
 765             }
 766         }
 767 # endif
 768       /* Normalise r.  */
 769       while (r_len > 0 && r_ptr[r_len - 1] == 0)
 770         r_len--;
 771     }
 772   /* Compare r << 1 with b.  */
 773   if (r_len > b_len)
 774     goto increment_q;
 775   {
 776     size_t i;
 777     for (i = b_len;;)
 778       {
 779         mp_limb_t r_i =
 780           (i <= r_len && i > 0 ? r_ptr[i - 1] >> (GMP_LIMB_BITS - 1) : 0)
 781           | (i < r_len ? r_ptr[i] << 1 : 0);
 782         mp_limb_t b_i = (i < b_len ? b_ptr[i] : 0);
 783         if (r_i > b_i)
 784           goto increment_q;
 785         if (r_i < b_i)
 786           goto keep_q;
 787         if (i == 0)
 788           break;
 789         i--;
 790       }
 791   }
 792   if (q_len > 0 && ((q_ptr[0] & 1) != 0))
 793     /* q is odd.  */
 794     increment_q:
 795     {
 796       size_t i;
 797       for (i = 0; i < q_len; i++)
 798         if (++(q_ptr[i]) != 0)
 799           goto keep_q;
 800       q_ptr[q_len++] = 1;
 801     }
 802   keep_q:
 803   if (tmp_roomptr != NULL)
 804     free (tmp_roomptr);
 805   q->limbs = q_ptr;
 806   q->nlimbs = q_len;
 807   return roomptr;
 808 }
 809
 810 /* Convert a bignum a >= 0, multiplied with 10^extra_zeroes, to decimal
 811    representation.
 812    Destroys the contents of a.
 813    Return the allocated memory - containing the decimal digits in low-to-high
 814    order, terminated with a NUL character - in case of success, NULL in case
 815    of memory allocation failure.  */
 816 static char *
 817 convert_to_decimal (mpn_t a, size_t extra_zeroes)
 818 {
 819   mp_limb_t *a_ptr = a.limbs;
 820   size_t a_len = a.nlimbs;
 821   /* 0.03345 is slightly larger than log(2)/(9*log(10)).  */
 822   size_t c_len = 9 * ((size_t)(a_len * (GMP_LIMB_BITS * 0.03345f)) + 1);
 823   char *c_ptr = (char *) malloc (xsum (c_len, extra_zeroes));
 824   if (c_ptr != NULL)
 825     {
 826       char *d_ptr = c_ptr;
 827       for (; extra_zeroes > 0; extra_zeroes--)
 828         *d_ptr++ = '0';
 829       while (a_len > 0)
 830         {
 831           /* Divide a by 10^9, in-place.  */
 832           mp_limb_t remainder = 0;
 833           mp_limb_t *ptr = a_ptr + a_len;
 834           size_t count;
 835           for (count = a_len; count > 0; count--)
 836             {
 837               mp_twolimb_t num =
 838                 ((mp_twolimb_t) remainder << GMP_LIMB_BITS) | *--ptr;
 839               *ptr = num / 1000000000;
 840               remainder = num % 1000000000;
 841             }
 842           /* Store the remainder as 9 decimal digits.  */
 843           for (count = 9; count > 0; count--)
 844             {
 845               *d_ptr++ = '0' + (remainder % 10);
 846               remainder = remainder / 10;
 847             }
 848           /* Normalize a.  */
 849           if (a_ptr[a_len - 1] == 0)
 850             a_len--;
 851         }
 852       /* Remove leading zeroes.  */
 853       while (d_ptr > c_ptr && d_ptr[-1] == '0')
 854         d_ptr--;
 855       /* But keep at least one zero.  */
 856       if (d_ptr == c_ptr)
 857         *d_ptr++ = '0';
 858       /* Terminate the string.  */
 859       *d_ptr = '\0';
 860     }
 861   return c_ptr;
 862 }
 863
 864 # if NEED_PRINTF_LONG_DOUBLE
 865
 866 /* Assuming x is finite and >= 0:
 867    write x as x = 2^e * m, where m is a bignum.
 868    Return the allocated memory in case of success, NULL in case of memory
 869    allocation failure.  */
 870 static void *
 871 decode_long_double (long double x, int *ep, mpn_t *mp)
 872 {
 873   mpn_t m;
 874   int exp;
 875   long double y;
 876   size_t i;
 877
 878   /* Allocate memory for result.  */
 879   m.nlimbs = (LDBL_MANT_BIT + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
 880   m.limbs = (mp_limb_t *) malloc (m.nlimbs * sizeof (mp_limb_t));
 881   if (m.limbs == NULL)
 882     return NULL;
 883   /* Split into exponential part and mantissa.  */
 884   y = frexpl (x, &exp);
 885   if (!(y >= 0.0L && y < 1.0L))
 886     abort ();
 887   /* x = 2^exp * y = 2^(exp - LDBL_MANT_BIT) * (y * LDBL_MANT_BIT), and the
 888      latter is an integer.  */
 889   /* Convert the mantissa (y * LDBL_MANT_BIT) to a sequence of limbs.
 890      I'm not sure whether it's safe to cast a 'long double' value between
 891      2^31 and 2^32 to 'unsigned int', therefore play safe and cast only
 892      'long double' values between 0 and 2^16 (to 'unsigned int' or 'int',
 893      doesn't matter).  */
 894 #  if (LDBL_MANT_BIT % GMP_LIMB_BITS) != 0
 895 #   if (LDBL_MANT_BIT % GMP_LIMB_BITS) > GMP_LIMB_BITS / 2
 896     {
 897       mp_limb_t hi, lo;
 898       y *= (mp_limb_t) 1 << (LDBL_MANT_BIT % (GMP_LIMB_BITS / 2));
 899       hi = (int) y;
 900       y -= hi;
 901       if (!(y >= 0.0L && y < 1.0L))
 902         abort ();
 903       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
 904       lo = (int) y;
 905       y -= lo;
 906       if (!(y >= 0.0L && y < 1.0L))
 907         abort ();
 908       m.limbs[LDBL_MANT_BIT / GMP_LIMB_BITS] = (hi << (GMP_LIMB_BITS / 2)) | lo;
 909     }
 910 #   else
 911     {
 912       mp_limb_t d;
 913       y *= (mp_limb_t) 1 << (LDBL_MANT_BIT % GMP_LIMB_BITS);
 914       d = (int) y;
 915       y -= d;
 916       if (!(y >= 0.0L && y < 1.0L))
 917         abort ();
 918       m.limbs[LDBL_MANT_BIT / GMP_LIMB_BITS] = d;
 919     }
 920 #   endif
 921 #  endif
 922   for (i = LDBL_MANT_BIT / GMP_LIMB_BITS; i > 0; )
 923     {
 924       mp_limb_t hi, lo;
 925       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
 926       hi = (int) y;
 927       y -= hi;
 928       if (!(y >= 0.0L && y < 1.0L))
 929         abort ();
 930       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
 931       lo = (int) y;
 932       y -= lo;
 933       if (!(y >= 0.0L && y < 1.0L))
 934         abort ();
 935       m.limbs[--i] = (hi << (GMP_LIMB_BITS / 2)) | lo;
 936     }
 937 #if 0 /* On FreeBSD 6.1/x86, 'long double' numbers sometimes have excess
 938          precision.  */
 939   if (!(y == 0.0L))
 940     abort ();
 941 #endif
 942   /* Normalise.  */
 943   while (m.nlimbs > 0 && m.limbs[m.nlimbs - 1] == 0)
 944     m.nlimbs--;
 945   *mp = m;
 946   *ep = exp - LDBL_MANT_BIT;
 947   return m.limbs;
 948 }
 949
 950 # endif
 951
 952 # if NEED_PRINTF_DOUBLE
 953
 954 /* Assuming x is finite and >= 0:
 955    write x as x = 2^e * m, where m is a bignum.
 956    Return the allocated memory in case of success, NULL in case of memory
 957    allocation failure.  */
 958 static void *
 959 decode_double (double x, int *ep, mpn_t *mp)
 960 {
 961   mpn_t m;
 962   int exp;
 963   double y;
 964   size_t i;
 965
 966   /* Allocate memory for result.  */
 967   m.nlimbs = (DBL_MANT_BIT + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
 968   m.limbs = (mp_limb_t *) malloc (m.nlimbs * sizeof (mp_limb_t));
 969   if (m.limbs == NULL)
 970     return NULL;
 971   /* Split into exponential part and mantissa.  */
 972   y = frexp (x, &exp);
 973   if (!(y >= 0.0 && y < 1.0))
 974     abort ();
 975   /* x = 2^exp * y = 2^(exp - DBL_MANT_BIT) * (y * DBL_MANT_BIT), and the
 976      latter is an integer.  */
 977   /* Convert the mantissa (y * DBL_MANT_BIT) to a sequence of limbs.
 978      I'm not sure whether it's safe to cast a 'double' value between
 979      2^31 and 2^32 to 'unsigned int', therefore play safe and cast only
 980      'double' values between 0 and 2^16 (to 'unsigned int' or 'int',
 981      doesn't matter).  */
 982 #  if (DBL_MANT_BIT % GMP_LIMB_BITS) != 0
 983 #   if (DBL_MANT_BIT % GMP_LIMB_BITS) > GMP_LIMB_BITS / 2
 984     {
 985       mp_limb_t hi, lo;
 986       y *= (mp_limb_t) 1 << (DBL_MANT_BIT % (GMP_LIMB_BITS / 2));
 987       hi = (int) y;
 988       y -= hi;
 989       if (!(y >= 0.0 && y < 1.0))
 990         abort ();
 991       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
 992       lo = (int) y;
 993       y -= lo;
 994       if (!(y >= 0.0 && y < 1.0))
 995         abort ();
 996       m.limbs[DBL_MANT_BIT / GMP_LIMB_BITS] = (hi << (GMP_LIMB_BITS / 2)) | lo;
 997     }
 998 #   else
 999     {
1000       mp_limb_t d;
1001       y *= (mp_limb_t) 1 << (DBL_MANT_BIT % GMP_LIMB_BITS);
1002       d = (int) y;
1003       y -= d;
1004       if (!(y >= 0.0 && y < 1.0))
1005         abort ();
1006       m.limbs[DBL_MANT_BIT / GMP_LIMB_BITS] = d;
1007     }
1008 #   endif
1009 #  endif
1010   for (i = DBL_MANT_BIT / GMP_LIMB_BITS; i > 0; )
1011     {
1012       mp_limb_t hi, lo;
1013       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
1014       hi = (int) y;
1015       y -= hi;
1016       if (!(y >= 0.0 && y < 1.0))
1017         abort ();
1018       y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
1019       lo = (int) y;
1020       y -= lo;
1021       if (!(y >= 0.0 && y < 1.0))
1022         abort ();
1023       m.limbs[--i] = (hi << (GMP_LIMB_BITS / 2)) | lo;
1024     }
1025   if (!(y == 0.0))
1026     abort ();
1027   /* Normalise.  */
1028   while (m.nlimbs > 0 && m.limbs[m.nlimbs - 1] == 0)
1029     m.nlimbs--;
1030   *mp = m;
1031   *ep = exp - DBL_MANT_BIT;
1032   return m.limbs;
1033 }
1034
1035 # endif
1036
1037 /* Assuming x = 2^e * m is finite and >= 0, and n is an integer:
1038    Returns the decimal representation of round (x * 10^n).
1039    Return the allocated memory - containing the decimal digits in low-to-high
1040    order, terminated with a NUL character - in case of success, NULL in case
1041    of memory allocation failure.  */
1042 static char *
1043 scale10_round_decimal_decoded (int e, mpn_t m, void *memory, int n)
1044 {
1045   int s;
1046   size_t extra_zeroes;
1047   unsigned int abs_n;
1048   unsigned int abs_s;
1049   mp_limb_t *pow5_ptr;
1050   size_t pow5_len;
1051   unsigned int s_limbs;
1052   unsigned int s_bits;
1053   mpn_t pow5;
1054   mpn_t z;
1055   void *z_memory;
1056   char *digits;
1057
1058   if (memory == NULL)
1059     return NULL;
1060   /* x = 2^e * m, hence
1061      y = round (2^e * 10^n * m) = round (2^(e+n) * 5^n * m)
1062        = round (2^s * 5^n * m).  */
1063   s = e + n;
1064   extra_zeroes = 0;
1065   /* Factor out a common power of 10 if possible.  */
1066   if (s > 0 && n > 0)
1067     {
1068       extra_zeroes = (s < n ? s : n);
1069       s -= extra_zeroes;
1070       n -= extra_zeroes;
1071     }
1072   /* Here y = round (2^s * 5^n * m) * 10^extra_zeroes.
1073      Before converting to decimal, we need to compute
1074      z = round (2^s * 5^n * m).  */
1075   /* Compute 5^|n|, possibly shifted by |s| bits if n and s have the same
1076      sign.  2.322 is slightly larger than log(5)/log(2).  */
1077   abs_n = (n >= 0 ? n : -n);
1078   abs_s = (s >= 0 ? s : -s);
1079   pow5_ptr = (mp_limb_t *) malloc (((int)(abs_n * (2.322f / GMP_LIMB_BITS)) + 1
1080                                     + abs_s / GMP_LIMB_BITS + 1)
1081                                    * sizeof (mp_limb_t));
1082   if (pow5_ptr == NULL)
1083     {
1084       free (memory);
1085       return NULL;
1086     }
1087   /* Initialize with 1.  */
1088   pow5_ptr[0] = 1;
1089   pow5_len = 1;
1090   /* Multiply with 5^|n|.  */
1091   if (abs_n > 0)
1092     {
1093       static mp_limb_t const small_pow5[13 + 1] =
1094         {
1095           1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625,
1096           48828125, 244140625, 1220703125
1097         };
1098       unsigned int n13;
1099       for (n13 = 0; n13 <= abs_n; n13 += 13)
1100         {
1101           mp_limb_t digit1 = small_pow5[n13 + 13 <= abs_n ? 13 : abs_n - n13];
1102           size_t j;
1103           mp_twolimb_t carry = 0;
1104           for (j = 0; j < pow5_len; j++)
1105             {
1106               mp_limb_t digit2 = pow5_ptr[j];
1107               carry += (mp_twolimb_t) digit1 * (mp_twolimb_t) digit2;
1108               pow5_ptr[j] = (mp_limb_t) carry;
1109               carry = carry >> GMP_LIMB_BITS;
1110             }
1111           if (carry > 0)
1112             pow5_ptr[pow5_len++] = (mp_limb_t) carry;
1113         }
1114     }
1115   s_limbs = abs_s / GMP_LIMB_BITS;
1116   s_bits = abs_s % GMP_LIMB_BITS;
1117   if (n >= 0 ? s >= 0 : s <= 0)
1118     {
1119       /* Multiply with 2^|s|.  */
1120       if (s_bits > 0)
1121         {
1122           mp_limb_t *ptr = pow5_ptr;
1123           mp_twolimb_t accu = 0;
1124           size_t count;
1125           for (count = pow5_len; count > 0; count--)
1126             {
1127               accu += (mp_twolimb_t) *ptr << s_bits;
1128               *ptr++ = (mp_limb_t) accu;
1129               accu = accu >> GMP_LIMB_BITS;
1130             }
1131           if (accu > 0)
1132             {
1133               *ptr = (mp_limb_t) accu;
1134               pow5_len++;
1135             }
1136         }
1137       if (s_limbs > 0)
1138         {
1139           size_t count;
1140           for (count = pow5_len; count > 0;)
1141             {
1142               count--;
1143               pow5_ptr[s_limbs + count] = pow5_ptr[count];
1144             }
1145           for (count = s_limbs; count > 0;)
1146             {
1147               count--;
1148               pow5_ptr[count] = 0;
1149             }
1150           pow5_len += s_limbs;
1151         }
1152       pow5.limbs = pow5_ptr;
1153       pow5.nlimbs = pow5_len;
1154       if (n >= 0)
1155         {
1156           /* Multiply m with pow5.  No division needed.  */
1157           z_memory = multiply (m, pow5, &z);
1158         }
1159       else
1160         {
1161           /* Divide m by pow5 and round.  */
1162           z_memory = divide (m, pow5, &z);
1163         }
1164     }
1165   else
1166     {
1167       pow5.limbs = pow5_ptr;
1168       pow5.nlimbs = pow5_len;
1169       if (n >= 0)
1170         {
1171           /* n >= 0, s < 0.
1172              Multiply m with pow5, then divide by 2^|s|.  */
1173           mpn_t numerator;
1174           mpn_t denominator;
1175           void *tmp_memory;
1176           tmp_memory = multiply (m, pow5, &numerator);
1177           if (tmp_memory == NULL)
1178             {
1179               free (pow5_ptr);
1180               free (memory);
1181               return NULL;
1182             }
1183           /* Construct 2^|s|.  */
1184           {
1185             mp_limb_t *ptr = pow5_ptr + pow5_len;
1186             size_t i;
1187             for (i = 0; i < s_limbs; i++)
1188               ptr[i] = 0;
1189             ptr[s_limbs] = (mp_limb_t) 1 << s_bits;
1190             denominator.limbs = ptr;
1191             denominator.nlimbs = s_limbs + 1;
1192           }
1193           z_memory = divide (numerator, denominator, &z);
1194           free (tmp_memory);
1195         }
1196       else
1197         {
1198           /* n < 0, s > 0.
1199              Multiply m with 2^s, then divide by pow5.  */
1200           mpn_t numerator;
1201           mp_limb_t *num_ptr;
1202           num_ptr = (mp_limb_t *) malloc ((m.nlimbs + s_limbs + 1)
1203                                           * sizeof (mp_limb_t));
1204           if (num_ptr == NULL)
1205             {
1206               free (pow5_ptr);
1207               free (memory);
1208               return NULL;
1209             }
1210           {
1211             mp_limb_t *destptr = num_ptr;
1212             {
1213               size_t i;
1214               for (i = 0; i < s_limbs; i++)
1215                 *destptr++ = 0;
1216             }
1217             if (s_bits > 0)
1218               {
1219                 const mp_limb_t *sourceptr = m.limbs;
1220                 mp_twolimb_t accu = 0;
1221                 size_t count;
1222                 for (count = m.nlimbs; count > 0; count--)
1223                   {
1224                     accu += (mp_twolimb_t) *sourceptr++ << s_bits;
1225                     *destptr++ = (mp_limb_t) accu;
1226                     accu = accu >> GMP_LIMB_BITS;
1227                   }
1228                 if (accu > 0)
1229                   *destptr++ = (mp_limb_t) accu;
1230               }
1231             else
1232               {
1233                 const mp_limb_t *sourceptr = m.limbs;
1234                 size_t count;
1235                 for (count = m.nlimbs; count > 0; count--)
1236                   *destptr++ = *sourceptr++;
1237               }
1238             numerator.limbs = num_ptr;
1239             numerator.nlimbs = destptr - num_ptr;
1240           }
1241           z_memory = divide (numerator, pow5, &z);
1242           free (num_ptr);
1243         }
1244     }
1245   free (pow5_ptr);
1246   free (memory);
1247
1248   /* Here y = round (x * 10^n) = z * 10^extra_zeroes.  */
1249
1250   if (z_memory == NULL)
1251     return NULL;
1252   digits = convert_to_decimal (z, extra_zeroes);
1253   free (z_memory);
1254   return digits;
1255 }
1256
1257 # if NEED_PRINTF_LONG_DOUBLE
1258
1259 /* Assuming x is finite and >= 0, and n is an integer:
1260    Returns the decimal representation of round (x * 10^n).
1261    Return the allocated memory - containing the decimal digits in low-to-high
1262    order, terminated with a NUL character - in case of success, NULL in case
1263    of memory allocation failure.  */
1264 static char *
1265 scale10_round_decimal_long_double (long double x, int n)
1266 {
1267   int e IF_LINT(= 0);
1268   mpn_t m;
1269   void *memory = decode_long_double (x, &e, &m);
1270   return scale10_round_decimal_decoded (e, m, memory, n);
1271 }
1272
1273 # endif
1274
1275 # if NEED_PRINTF_DOUBLE
1276
1277 /* Assuming x is finite and >= 0, and n is an integer:
1278    Returns the decimal representation of round (x * 10^n).
1279    Return the allocated memory - containing the decimal digits in low-to-high
1280    order, terminated with a NUL character - in case of success, NULL in case
1281    of memory allocation failure.  */
1282 static char *
1283 scale10_round_decimal_double (double x, int n)
1284 {
1285   int e IF_LINT(= 0);
1286   mpn_t m;
1287   void *memory = decode_double (x, &e, &m);
1288   return scale10_round_decimal_decoded (e, m, memory, n);
1289 }
1290
1291 # endif
1292
1293 # if NEED_PRINTF_LONG_DOUBLE
1294
1295 /* Assuming x is finite and > 0:
1296    Return an approximation for n with 10^n <= x < 10^(n+1).
1297    The approximation is usually the right n, but may be off by 1 sometimes.  */
1298 static int
1299 floorlog10l (long double x)
1300 {
1301   int exp;
1302   long double y;
1303   double z;
1304   double l;
1305
1306   /* Split into exponential part and mantissa.  */
1307   y = frexpl (x, &exp);
1308   if (!(y >= 0.0L && y < 1.0L))
1309     abort ();
1310   if (y == 0.0L)
1311     return INT_MIN;
1312   if (y < 0.5L)
1313     {
1314       while (y < (1.0L / (1 << (GMP_LIMB_BITS / 2)) / (1 << (GMP_LIMB_BITS / 2))))
1315         {
1316           y *= 1.0L * (1 << (GMP_LIMB_BITS / 2)) * (1 << (GMP_LIMB_BITS / 2));
1317           exp -= GMP_LIMB_BITS;
1318         }
1319       if (y < (1.0L / (1 << 16)))
1320         {
1321           y *= 1.0L * (1 << 16);
1322           exp -= 16;
1323         }
1324       if (y < (1.0L / (1 << 8)))
1325         {
1326           y *= 1.0L * (1 << 8);
1327           exp -= 8;
1328         }
1329       if (y < (1.0L / (1 << 4)))
1330         {
1331           y *= 1.0L * (1 << 4);
1332           exp -= 4;
1333         }
1334       if (y < (1.0L / (1 << 2)))
1335         {
1336           y *= 1.0L * (1 << 2);
1337           exp -= 2;
1338         }
1339       if (y < (1.0L / (1 << 1)))
1340         {
1341           y *= 1.0L * (1 << 1);
1342           exp -= 1;
1343         }
1344     }
1345   if (!(y >= 0.5L && y < 1.0L))
1346     abort ();
1347   /* Compute an approximation for l = log2(x) = exp + log2(y).  */
1348   l = exp;
1349   z = y;
1350   if (z < 0.70710678118654752444)
1351     {
1352       z *= 1.4142135623730950488;
1353       l -= 0.5;
1354     }
1355   if (z < 0.8408964152537145431)
1356     {
1357       z *= 1.1892071150027210667;
1358       l -= 0.25;
1359     }
1360   if (z < 0.91700404320467123175)
1361     {
1362       z *= 1.0905077326652576592;
1363       l -= 0.125;
1364     }
1365   if (z < 0.9576032806985736469)
1366     {
1367       z *= 1.0442737824274138403;
1368       l -= 0.0625;
1369     }
1370   /* Now 0.95 <= z <= 1.01.  */
1371   z = 1 - z;
1372   /* log2(1-z) = 1/log(2) * (- z - z^2/2 - z^3/3 - z^4/4 - ...)
1373      Four terms are enough to get an approximation with error < 10^-7.  */
1374   l -= 1.4426950408889634074 * z * (1.0 + z * (0.5 + z * ((1.0 / 3) + z * 0.25)));
1375   /* Finally multiply with log(2)/log(10), yields an approximation for
1376      log10(x).  */
1377   l *= 0.30102999566398119523;
1378   /* Round down to the next integer.  */
1379   return (int) l + (l < 0 ? -1 : 0);
1380 }
1381
1382 # endif
1383
1384 # if NEED_PRINTF_DOUBLE
1385
1386 /* Assuming x is finite and > 0:
1387    Return an approximation for n with 10^n <= x < 10^(n+1).
1388    The approximation is usually the right n, but may be off by 1 sometimes.  */
1389 static int
1390 floorlog10 (double x)
1391 {
1392   int exp;
1393   double y;
1394   double z;
1395   double l;
1396
1397   /* Split into exponential part and mantissa.  */
1398   y = frexp (x, &exp);
1399   if (!(y >= 0.0 && y < 1.0))
1400     abort ();
1401   if (y == 0.0)
1402     return INT_MIN;
1403   if (y < 0.5)
1404     {
1405       while (y < (1.0 / (1 << (GMP_LIMB_BITS / 2)) / (1 << (GMP_LIMB_BITS / 2))))
1406         {
1407           y *= 1.0 * (1 << (GMP_LIMB_BITS / 2)) * (1 << (GMP_LIMB_BITS / 2));
1408           exp -= GMP_LIMB_BITS;
1409         }
1410       if (y < (1.0 / (1 << 16)))
1411         {
1412           y *= 1.0 * (1 << 16);
1413           exp -= 16;
1414         }
1415       if (y < (1.0 / (1 << 8)))
1416         {
1417           y *= 1.0 * (1 << 8);
1418           exp -= 8;
1419         }
1420       if (y < (1.0 / (1 << 4)))
1421         {
1422           y *= 1.0 * (1 << 4);
1423           exp -= 4;
1424         }
1425       if (y < (1.0 / (1 << 2)))
1426         {
1427           y *= 1.0 * (1 << 2);
1428           exp -= 2;
1429         }
1430       if (y < (1.0 / (1 << 1)))
1431         {
1432           y *= 1.0 * (1 << 1);
1433           exp -= 1;
1434         }
1435     }
1436   if (!(y >= 0.5 && y < 1.0))
1437     abort ();
1438   /* Compute an approximation for l = log2(x) = exp + log2(y).  */
1439   l = exp;
1440   z = y;
1441   if (z < 0.70710678118654752444)
1442     {
1443       z *= 1.4142135623730950488;
1444       l -= 0.5;
1445     }
1446   if (z < 0.8408964152537145431)
1447     {
1448       z *= 1.1892071150027210667;
1449       l -= 0.25;
1450     }
1451   if (z < 0.91700404320467123175)
1452     {
1453       z *= 1.0905077326652576592;
1454       l -= 0.125;
1455     }
1456   if (z < 0.9576032806985736469)
1457     {
1458       z *= 1.0442737824274138403;
1459       l -= 0.0625;
1460     }
1461   /* Now 0.95 <= z <= 1.01.  */
1462   z = 1 - z;
1463   /* log2(1-z) = 1/log(2) * (- z - z^2/2 - z^3/3 - z^4/4 - ...)
1464      Four terms are enough to get an approximation with error < 10^-7.  */
1465   l -= 1.4426950408889634074 * z * (1.0 + z * (0.5 + z * ((1.0 / 3) + z * 0.25)));
1466   /* Finally multiply with log(2)/log(10), yields an approximation for
1467      log10(x).  */
1468   l *= 0.30102999566398119523;
1469   /* Round down to the next integer.  */
1470   return (int) l + (l < 0 ? -1 : 0);
1471 }
1472
1473 # endif
1474
1475 /* Tests whether a string of digits consists of exactly PRECISION zeroes and
1476    a single '1' digit.  */
1477 static int
1478 is_borderline (const char *digits, size_t precision)
1479 {
1480   for (; precision > 0; precision--, digits++)
1481     if (*digits != '0')
1482       return 0;
1483   if (*digits != '1')
1484     return 0;
1485   digits++;
1486   return *digits == '\0';
1487 }
1488
1489 #endif
1490
1491 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99
1492
1493 /* Use a different function name, to make it possible that the 'wchar_t'
1494    parametrization and the 'char' parametrization get compiled in the same
1495    translation unit.  */
1496 # if WIDE_CHAR_VERSION
1497 #  define MAX_ROOM_NEEDED wmax_room_needed
1498 # else
1499 #  define MAX_ROOM_NEEDED max_room_needed
1500 # endif
1501
1502 /* Returns the number of TCHAR_T units needed as temporary space for the result
1503    of sprintf or SNPRINTF of a single conversion directive.  */
1504 static inline size_t
1505 MAX_ROOM_NEEDED (const arguments *ap, size_t arg_index, FCHAR_T conversion,
1506                  arg_type type, int flags, size_t width, int has_precision,
1507                  size_t precision, int pad_ourselves)
1508 {
1509   size_t tmp_length;
1510
1511   switch (conversion)
1512     {
1513     case 'd': case 'i': case 'u':
1514 # if HAVE_LONG_LONG_INT
1515       if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
1516         tmp_length =
1517           (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
1518                           * 0.30103 /* binary -> decimal */
1519                          )
1520           + 1; /* turn floor into ceil */
1521       else
1522 # endif
1523       if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
1524         tmp_length =
1525           (unsigned int) (sizeof (unsigned long) * CHAR_BIT
1526                           * 0.30103 /* binary -> decimal */
1527                          )
1528           + 1; /* turn floor into ceil */
1529       else
1530         tmp_length =
1531           (unsigned int) (sizeof (unsigned int) * CHAR_BIT
1532                           * 0.30103 /* binary -> decimal */
1533                          )
1534           + 1; /* turn floor into ceil */
1535       if (tmp_length < precision)
1536         tmp_length = precision;
1537       /* Multiply by 2, as an estimate for FLAG_GROUP.  */
1538       tmp_length = xsum (tmp_length, tmp_length);
1539       /* Add 1, to account for a leading sign.  */
1540       tmp_length = xsum (tmp_length, 1);
1541       break;
1542
1543     case 'o':
1544 # if HAVE_LONG_LONG_INT
1545       if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
1546         tmp_length =
1547           (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
1548                           * 0.333334 /* binary -> octal */
1549                          )
1550           + 1; /* turn floor into ceil */
1551       else
1552 # endif
1553       if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
1554         tmp_length =
1555           (unsigned int) (sizeof (unsigned long) * CHAR_BIT
1556                           * 0.333334 /* binary -> octal */
1557                          )
1558           + 1; /* turn floor into ceil */
1559       else
1560         tmp_length =
1561           (unsigned int) (sizeof (unsigned int) * CHAR_BIT
1562                           * 0.333334 /* binary -> octal */
1563                          )
1564           + 1; /* turn floor into ceil */
1565       if (tmp_length < precision)
1566         tmp_length = precision;
1567       /* Add 1, to account for a leading sign.  */
1568       tmp_length = xsum (tmp_length, 1);
1569       break;
1570
1571     case 'x': case 'X':
1572 # if HAVE_LONG_LONG_INT
1573       if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
1574         tmp_length =
1575           (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
1576                           * 0.25 /* binary -> hexadecimal */
1577                          )
1578           + 1; /* turn floor into ceil */
1579       else
1580 # endif
1581       if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
1582         tmp_length =
1583           (unsigned int) (sizeof (unsigned long) * CHAR_BIT
1584                           * 0.25 /* binary -> hexadecimal */
1585                          )
1586           + 1; /* turn floor into ceil */
1587       else
1588         tmp_length =
1589           (unsigned int) (sizeof (unsigned int) * CHAR_BIT
1590                           * 0.25 /* binary -> hexadecimal */
1591                          )
1592           + 1; /* turn floor into ceil */
1593       if (tmp_length < precision)
1594         tmp_length = precision;
1595       /* Add 2, to account for a leading sign or alternate form.  */
1596       tmp_length = xsum (tmp_length, 2);
1597       break;
1598
1599     case 'f': case 'F':
1600       if (type == TYPE_LONGDOUBLE)
1601         tmp_length =
1602           (unsigned int) (LDBL_MAX_EXP
1603                           * 0.30103 /* binary -> decimal */
1604                           * 2 /* estimate for FLAG_GROUP */
1605                          )
1606           + 1 /* turn floor into ceil */
1607           + 10; /* sign, decimal point etc. */
1608       else
1609         tmp_length =
1610           (unsigned int) (DBL_MAX_EXP
1611                           * 0.30103 /* binary -> decimal */
1612                           * 2 /* estimate for FLAG_GROUP */
1613                          )
1614           + 1 /* turn floor into ceil */
1615           + 10; /* sign, decimal point etc. */
1616       tmp_length = xsum (tmp_length, precision);
1617       break;
1618
1619     case 'e': case 'E': case 'g': case 'G':
1620       tmp_length =
1621         12; /* sign, decimal point, exponent etc. */
1622       tmp_length = xsum (tmp_length, precision);
1623       break;
1624
1625     case 'a': case 'A':
1626       if (type == TYPE_LONGDOUBLE)
1627         tmp_length =
1628           (unsigned int) (LDBL_DIG
1629                           * 0.831 /* decimal -> hexadecimal */
1630                          )
1631           + 1; /* turn floor into ceil */
1632       else
1633         tmp_length =
1634           (unsigned int) (DBL_DIG
1635                           * 0.831 /* decimal -> hexadecimal */
1636                          )
1637           + 1; /* turn floor into ceil */
1638       if (tmp_length < precision)
1639         tmp_length = precision;
1640       /* Account for sign, decimal point etc. */
1641       tmp_length = xsum (tmp_length, 12);
1642       break;
1643
1644     case 'c':
1645 # if HAVE_WINT_T && !WIDE_CHAR_VERSION
1646       if (type == TYPE_WIDE_CHAR)
1647         tmp_length = MB_CUR_MAX;
1648       else
1649 # endif
1650         tmp_length = 1;
1651       break;
1652
1653     case 's':
1654 # if HAVE_WCHAR_T
1655       if (type == TYPE_WIDE_STRING)
1656         {
1657 #  if WIDE_CHAR_VERSION
1658           /* ISO C says about %ls in fwprintf:
1659                "If the precision is not specified or is greater than the size
1660                 of the array, the array shall contain a null wide character."
1661              So if there is a precision, we must not use wcslen.  */
1662           const wchar_t *arg = ap->arg[arg_index].a.a_wide_string;
1663
1664           if (has_precision)
1665             tmp_length = local_wcsnlen (arg, precision);
1666           else
1667             tmp_length = local_wcslen (arg);
1668 #  else
1669           /* ISO C says about %ls in fprintf:
1670                "If a precision is specified, no more than that many bytes are
1671                 written (including shift sequences, if any), and the array
1672                 shall contain a null wide character if, to equal the multibyte
1673                 character sequence length given by the precision, the function
1674                 would need to access a wide character one past the end of the
1675                 array."
1676              So if there is a precision, we must not use wcslen.  */
1677           /* This case has already been handled separately in VASNPRINTF.  */
1678           abort ();
1679 #  endif
1680         }
1681       else
1682 # endif
1683         {
1684 # if WIDE_CHAR_VERSION
1685           /* ISO C says about %s in fwprintf:
1686                "If the precision is not specified or is greater than the size
1687                 of the converted array, the converted array shall contain a
1688                 null wide character."
1689              So if there is a precision, we must not use strlen.  */
1690           /* This case has already been handled separately in VASNPRINTF.  */
1691           abort ();
1692 # else
1693           /* ISO C says about %s in fprintf:
1694                "If the precision is not specified or greater than the size of
1695                 the array, the array shall contain a null character."
1696              So if there is a precision, we must not use strlen.  */
1697           const char *arg = ap->arg[arg_index].a.a_string;
1698
1699           if (has_precision)
1700             tmp_length = local_strnlen (arg, precision);
1701           else
1702             tmp_length = strlen (arg);
1703 # endif
1704         }
1705       break;
1706
1707     case 'p':
1708       tmp_length =
1709         (unsigned int) (sizeof (void *) * CHAR_BIT
1710                         * 0.25 /* binary -> hexadecimal */
1711                        )
1712           + 1 /* turn floor into ceil */
1713           + 2; /* account for leading 0x */
1714       break;
1715
1716     default:
1717       abort ();
1718     }
1719
1720   if (!pad_ourselves)
1721     {
1722 # if ENABLE_UNISTDIO
1723       /* Padding considers the number of characters, therefore the number of
1724          elements after padding may be
1725            > max (tmp_length, width)
1726          but is certainly
1727            <= tmp_length + width.  */
1728       tmp_length = xsum (tmp_length, width);
1729 # else
1730       /* Padding considers the number of elements, says POSIX.  */
1731       if (tmp_length < width)
1732         tmp_length = width;
1733 # endif
1734     }
1735
1736   tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
1737
1738   return tmp_length;
1739 }
1740
1741 #endif
1742
1743 DCHAR_T *
1744 VASNPRINTF (DCHAR_T *resultbuf, size_t *lengthp,
1745             const FCHAR_T *format, va_list args)
1746 {
1747   DIRECTIVES d;
1748   arguments a;
1749
1750   if (PRINTF_PARSE (format, &d, &a) < 0)
1751     /* errno is already set.  */
1752     return NULL;
1753
1754 #define CLEANUP() \
1755   free (d.dir);                                                         \
1756   if (a.arg)                                                            \
1757     free (a.arg);
1758
1759   if (PRINTF_FETCHARGS (args, &a) < 0)
1760     {
1761       CLEANUP ();
1762       errno = EINVAL;
1763       return NULL;
1764     }
1765
1766   {
1767     size_t buf_neededlength;
1768     TCHAR_T *buf;
1769     TCHAR_T *buf_malloced;
1770     const FCHAR_T *cp;
1771     size_t i;
1772     DIRECTIVE *dp;
1773     /* Output string accumulator.  */
1774     DCHAR_T *result;
1775     size_t allocated;
1776     size_t length;
1777
1778     /* Allocate a small buffer that will hold a directive passed to
1779        sprintf or snprintf.  */
1780     buf_neededlength =
1781       xsum4 (7, d.max_width_length, d.max_precision_length, 6);
1782 #if HAVE_ALLOCA
1783     if (buf_neededlength < 4000 / sizeof (TCHAR_T))
1784       {
1785         buf = (TCHAR_T *) alloca (buf_neededlength * sizeof (TCHAR_T));
1786         buf_malloced = NULL;
1787       }
1788     else
1789 #endif
1790       {
1791         size_t buf_memsize = xtimes (buf_neededlength, sizeof (TCHAR_T));
1792         if (size_overflow_p (buf_memsize))
1793           goto out_of_memory_1;
1794         buf = (TCHAR_T *) malloc (buf_memsize);
1795         if (buf == NULL)
1796           goto out_of_memory_1;
1797         buf_malloced = buf;
1798       }
1799
1800     if (resultbuf != NULL)
1801       {
1802         result = resultbuf;
1803         allocated = *lengthp;
1804       }
1805     else
1806       {
1807         result = NULL;
1808         allocated = 0;
1809       }
1810     length = 0;
1811     /* Invariants:
1812        result is either == resultbuf or == NULL or malloc-allocated.
1813        If length > 0, then result != NULL.  */
1814
1815     /* Ensures that allocated >= needed.  Aborts through a jump to
1816        out_of_memory if needed is SIZE_MAX or otherwise too big.  */
1817 #define ENSURE_ALLOCATION(needed) \
1818     if ((needed) > allocated)                                                \
1819       {                                                                      \
1820         size_t memory_size;                                                  \
1821         DCHAR_T *memory;                                                     \
1822                                                                              \
1823         allocated = (allocated > 0 ? xtimes (allocated, 2) : 12);            \
1824         if ((needed) > allocated)                                            \
1825           allocated = (needed);                                              \
1826         memory_size = xtimes (allocated, sizeof (DCHAR_T));                  \
1827         if (size_overflow_p (memory_size))                                   \
1828           goto out_of_memory;                                                \
1829         if (result == resultbuf || result == NULL)                           \
1830           memory = (DCHAR_T *) malloc (memory_size);                         \
1831         else                                                                 \
1832           memory = (DCHAR_T *) realloc (result, memory_size);                \
1833         if (memory == NULL)                                                  \
1834           goto out_of_memory;                                                \
1835         if (result == resultbuf && length > 0)                               \
1836           DCHAR_CPY (memory, result, length);                                \
1837         result = memory;                                                     \
1838       }
1839
1840     for (cp = format, i = 0, dp = &d.dir[0]; ; cp = dp->dir_end, i++, dp++)
1841       {
1842         if (cp != dp->dir_start)
1843           {
1844             size_t n = dp->dir_start - cp;
1845             size_t augmented_length = xsum (length, n);
1846
1847             ENSURE_ALLOCATION (augmented_length);
1848             /* This copies a piece of FCHAR_T[] into a DCHAR_T[].  Here we
1849                need that the format string contains only ASCII characters
1850                if FCHAR_T and DCHAR_T are not the same type.  */
1851             if (sizeof (FCHAR_T) == sizeof (DCHAR_T))
1852               {
1853                 DCHAR_CPY (result + length, (const DCHAR_T *) cp, n);
1854                 length = augmented_length;
1855               }
1856             else
1857               {
1858                 do
1859                   result[length++] = (unsigned char) *cp++;
1860                 while (--n > 0);
1861               }
1862           }
1863         if (i == d.count)
1864           break;
1865
1866         /* Execute a single directive.  */
1867         if (dp->conversion == '%')
1868           {
1869             size_t augmented_length;
1870
1871             if (!(dp->arg_index == ARG_NONE))
1872               abort ();
1873             augmented_length = xsum (length, 1);
1874             ENSURE_ALLOCATION (augmented_length);
1875             result[length] = '%';
1876             length = augmented_length;
1877           }
1878         else
1879           {
1880             if (!(dp->arg_index != ARG_NONE))
1881               abort ();
1882
1883             if (dp->conversion == 'n')
1884               {
1885                 switch (a.arg[dp->arg_index].type)
1886                   {
1887                   case TYPE_COUNT_SCHAR_POINTER:
1888                     *a.arg[dp->arg_index].a.a_count_schar_pointer = length;
1889                     break;
1890                   case TYPE_COUNT_SHORT_POINTER:
1891                     *a.arg[dp->arg_index].a.a_count_short_pointer = length;
1892                     break;
1893                   case TYPE_COUNT_INT_POINTER:
1894                     *a.arg[dp->arg_index].a.a_count_int_pointer = length;
1895                     break;
1896                   case TYPE_COUNT_LONGINT_POINTER:
1897                     *a.arg[dp->arg_index].a.a_count_longint_pointer = length;
1898                     break;
1899 #if HAVE_LONG_LONG_INT
1900                   case TYPE_COUNT_LONGLONGINT_POINTER:
1901                     *a.arg[dp->arg_index].a.a_count_longlongint_pointer = length;
1902                     break;
1903 #endif
1904                   default:
1905                     abort ();
1906                   }
1907               }
1908 #if ENABLE_UNISTDIO
1909             /* The unistdio extensions.  */
1910             else if (dp->conversion == 'U')
1911               {
1912                 arg_type type = a.arg[dp->arg_index].type;
1913                 int flags = dp->flags;
1914                 int has_width;
1915                 size_t width;
1916                 int has_precision;
1917                 size_t precision;
1918
1919                 has_width = 0;
1920                 width = 0;
1921                 if (dp->width_start != dp->width_end)
1922                   {
1923                     if (dp->width_arg_index != ARG_NONE)
1924                       {
1925                         int arg;
1926
1927                         if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
1928                           abort ();
1929                         arg = a.arg[dp->width_arg_index].a.a_int;
1930                         if (arg < 0)
1931                           {
1932                             /* "A negative field width is taken as a '-' flag
1933                                 followed by a positive field width."  */
1934                             flags |= FLAG_LEFT;
1935                             width = (unsigned int) (-arg);
1936                           }
1937                         else
1938                           width = arg;
1939                       }
1940                     else
1941                       {
1942                         const FCHAR_T *digitp = dp->width_start;
1943
1944                         do
1945                           width = xsum (xtimes (width, 10), *digitp++ - '0');
1946                         while (digitp != dp->width_end);
1947                       }
1948                     has_width = 1;
1949                   }
1950
1951                 has_precision = 0;
1952                 precision = 0;
1953                 if (dp->precision_start != dp->precision_end)
1954                   {
1955                     if (dp->precision_arg_index != ARG_NONE)
1956                       {
1957                         int arg;
1958
1959                         if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
1960                           abort ();
1961                         arg = a.arg[dp->precision_arg_index].a.a_int;
1962                         /* "A negative precision is taken as if the precision
1963                             were omitted."  */
1964                         if (arg >= 0)
1965                           {
1966                             precision = arg;
1967                             has_precision = 1;
1968                           }
1969                       }
1970                     else
1971                       {
1972                         const FCHAR_T *digitp = dp->precision_start + 1;
1973
1974                         precision = 0;
1975                         while (digitp != dp->precision_end)
1976                           precision = xsum (xtimes (precision, 10), *digitp++ - '0');
1977                         has_precision = 1;
1978                       }
1979                   }
1980
1981                 switch (type)
1982                   {
1983                   case TYPE_U8_STRING:
1984                     {
1985                       const uint8_t *arg = a.arg[dp->arg_index].a.a_u8_string;
1986                       const uint8_t *arg_end;
1987                       size_t characters;
1988
1989                       if (has_precision)
1990                         {
1991                           /* Use only PRECISION characters, from the left.  */
1992                           arg_end = arg;
1993                           characters = 0;
1994                           for (; precision > 0; precision--)
1995                             {
1996                               int count = u8_strmblen (arg_end);
1997                               if (count == 0)
1998                                 break;
1999                               if (count < 0)
2000                                 {
2001                                   if (!(result == resultbuf || result == NULL))
2002                                     free (result);
2003                                   if (buf_malloced != NULL)
2004                                     free (buf_malloced);
2005                                   CLEANUP ();
2006                                   errno = EILSEQ;
2007                                   return NULL;
2008                                 }
2009                               arg_end += count;
2010                               characters++;
2011                             }
2012                         }
2013                       else if (has_width)
2014                         {
2015                           /* Use the entire string, and count the number of
2016                              characters.  */
2017                           arg_end = arg;
2018                           characters = 0;
2019                           for (;;)
2020                             {
2021                               int count = u8_strmblen (arg_end);
2022                               if (count == 0)
2023                                 break;
2024                               if (count < 0)
2025                                 {
2026                                   if (!(result == resultbuf || result == NULL))
2027                                     free (result);
2028                                   if (buf_malloced != NULL)
2029                                     free (buf_malloced);
2030                                   CLEANUP ();
2031                                   errno = EILSEQ;
2032                                   return NULL;
2033                                 }
2034                               arg_end += count;
2035                               characters++;
2036                             }
2037                         }
2038                       else
2039                         {
2040                           /* Use the entire string.  */
2041                           arg_end = arg + u8_strlen (arg);
2042                           /* The number of characters doesn't matter.  */
2043                           characters = 0;
2044                         }
2045
2046                       if (has_width && width > characters
2047                           && !(dp->flags & FLAG_LEFT))
2048                         {
2049                           size_t n = width - characters;
2050                           ENSURE_ALLOCATION (xsum (length, n));
2051                           DCHAR_SET (result + length, ' ', n);
2052                           length += n;
2053                         }
2054
2055 # if DCHAR_IS_UINT8_T
2056                       {
2057                         size_t n = arg_end - arg;
2058                         ENSURE_ALLOCATION (xsum (length, n));
2059                         DCHAR_CPY (result + length, arg, n);
2060                         length += n;
2061                       }
2062 # else
2063                       { /* Convert.  */
2064                         DCHAR_T *converted = result + length;
2065                         size_t converted_len = allocated - length;
2066 #  if DCHAR_IS_TCHAR
2067                         /* Convert from UTF-8 to locale encoding.  */
2068                         converted =
2069                           u8_conv_to_encoding (locale_charset (),
2070                                                iconveh_question_mark,
2071                                                arg, arg_end - arg, NULL,
2072                                                converted, &converted_len);
2073 #  else
2074                         /* Convert from UTF-8 to UTF-16/UTF-32.  */
2075                         converted =
2076                           U8_TO_DCHAR (arg, arg_end - arg,
2077                                        converted, &converted_len);
2078 #  endif
2079                         if (converted == NULL)
2080                           {
2081                             int saved_errno = errno;
2082                             if (!(result == resultbuf || result == NULL))
2083                               free (result);
2084                             if (buf_malloced != NULL)
2085                               free (buf_malloced);
2086                             CLEANUP ();
2087                             errno = saved_errno;
2088                             return NULL;
2089                           }
2090                         if (converted != result + length)
2091                           {
2092                             ENSURE_ALLOCATION (xsum (length, converted_len));
2093                             DCHAR_CPY (result + length, converted, converted_len);
2094                             free (converted);
2095                           }
2096                         length += converted_len;
2097                       }
2098 # endif
2099
2100                       if (has_width && width > characters
2101                           && (dp->flags & FLAG_LEFT))
2102                         {
2103                           size_t n = width - characters;
2104                           ENSURE_ALLOCATION (xsum (length, n));
2105                           DCHAR_SET (result + length, ' ', n);
2106                           length += n;
2107                         }
2108                     }
2109                     break;
2110
2111                   case TYPE_U16_STRING:
2112                     {
2113                       const uint16_t *arg = a.arg[dp->arg_index].a.a_u16_string;
2114                       const uint16_t *arg_end;
2115                       size_t characters;
2116
2117                       if (has_precision)
2118                         {
2119                           /* Use only PRECISION characters, from the left.  */
2120                           arg_end = arg;
2121                           characters = 0;
2122                           for (; precision > 0; precision--)
2123                             {
2124                               int count = u16_strmblen (arg_end);
2125                               if (count == 0)
2126                                 break;
2127                               if (count < 0)
2128                                 {
2129                                   if (!(result == resultbuf || result == NULL))
2130                                     free (result);
2131                                   if (buf_malloced != NULL)
2132                                     free (buf_malloced);
2133                                   CLEANUP ();
2134                                   errno = EILSEQ;
2135                                   return NULL;
2136                                 }
2137                               arg_end += count;
2138                               characters++;
2139                             }
2140                         }
2141                       else if (has_width)
2142                         {
2143                           /* Use the entire string, and count the number of
2144                              characters.  */
2145                           arg_end = arg;
2146                           characters = 0;
2147                           for (;;)
2148                             {
2149                               int count = u16_strmblen (arg_end);
2150                               if (count == 0)
2151                                 break;
2152                               if (count < 0)
2153                                 {
2154                                   if (!(result == resultbuf || result == NULL))
2155                                     free (result);
2156                                   if (buf_malloced != NULL)
2157                                     free (buf_malloced);
2158                                   CLEANUP ();
2159                                   errno = EILSEQ;
2160                                   return NULL;
2161                                 }
2162                               arg_end += count;
2163                               characters++;
2164                             }
2165                         }
2166                       else
2167                         {
2168                           /* Use the entire string.  */
2169                           arg_end = arg + u16_strlen (arg);
2170                           /* The number of characters doesn't matter.  */
2171                           characters = 0;
2172                         }
2173
2174                       if (has_width && width > characters
2175                           && !(dp->flags & FLAG_LEFT))
2176                         {
2177                           size_t n = width - characters;
2178                           ENSURE_ALLOCATION (xsum (length, n));
2179                           DCHAR_SET (result + length, ' ', n);
2180                           length += n;
2181                         }
2182
2183 # if DCHAR_IS_UINT16_T
2184                       {
2185                         size_t n = arg_end - arg;
2186                         ENSURE_ALLOCATION (xsum (length, n));
2187                         DCHAR_CPY (result + length, arg, n);
2188                         length += n;
2189                       }
2190 # else
2191                       { /* Convert.  */
2192                         DCHAR_T *converted = result + length;
2193                         size_t converted_len = allocated - length;
2194 #  if DCHAR_IS_TCHAR
2195                         /* Convert from UTF-16 to locale encoding.  */
2196                         converted =
2197                           u16_conv_to_encoding (locale_charset (),
2198                                                 iconveh_question_mark,
2199                                                 arg, arg_end - arg, NULL,
2200                                                 converted, &converted_len);
2201 #  else
2202                         /* Convert from UTF-16 to UTF-8/UTF-32.  */
2203                         converted =
2204                           U16_TO_DCHAR (arg, arg_end - arg,
2205                                         converted, &converted_len);
2206 #  endif
2207                         if (converted == NULL)
2208                           {
2209                             int saved_errno = errno;
2210                             if (!(result == resultbuf || result == NULL))
2211                               free (result);
2212                             if (buf_malloced != NULL)
2213                               free (buf_malloced);
2214                             CLEANUP ();
2215                             errno = saved_errno;
2216                             return NULL;
2217                           }
2218                         if (converted != result + length)
2219                           {
2220                             ENSURE_ALLOCATION (xsum (length, converted_len));
2221                             DCHAR_CPY (result + length, converted, converted_len);
2222                             free (converted);
2223                           }
2224                         length += converted_len;
2225                       }
2226 # endif
2227
2228                       if (has_width && width > characters
2229                           && (dp->flags & FLAG_LEFT))
2230                         {
2231                           size_t n = width - characters;
2232                           ENSURE_ALLOCATION (xsum (length, n));
2233                           DCHAR_SET (result + length, ' ', n);
2234                           length += n;
2235                         }
2236                     }
2237                     break;
2238
2239                   case TYPE_U32_STRING:
2240                     {
2241                       const uint32_t *arg = a.arg[dp->arg_index].a.a_u32_string;
2242                       const uint32_t *arg_end;
2243                       size_t characters;
2244
2245                       if (has_precision)
2246                         {
2247                           /* Use only PRECISION characters, from the left.  */
2248                           arg_end = arg;
2249                           characters = 0;
2250                           for (; precision > 0; precision--)
2251                             {
2252                               int count = u32_strmblen (arg_end);
2253                               if (count == 0)
2254                                 break;
2255                               if (count < 0)
2256                                 {
2257                                   if (!(result == resultbuf || result == NULL))
2258                                     free (result);
2259                                   if (buf_malloced != NULL)
2260                                     free (buf_malloced);
2261                                   CLEANUP ();
2262                                   errno = EILSEQ;
2263                                   return NULL;
2264                                 }
2265                               arg_end += count;
2266                               characters++;
2267                             }
2268                         }
2269                       else if (has_width)
2270                         {
2271                           /* Use the entire string, and count the number of
2272                              characters.  */
2273                           arg_end = arg;
2274                           characters = 0;
2275                           for (;;)
2276                             {
2277                               int count = u32_strmblen (arg_end);
2278                               if (count == 0)
2279                                 break;
2280                               if (count < 0)
2281                                 {
2282                                   if (!(result == resultbuf || result == NULL))
2283                                     free (result);
2284                                   if (buf_malloced != NULL)
2285                                     free (buf_malloced);
2286                                   CLEANUP ();
2287                                   errno = EILSEQ;
2288                                   return NULL;
2289                                 }
2290                               arg_end += count;
2291                               characters++;
2292                             }
2293                         }
2294                       else
2295                         {
2296                           /* Use the entire string.  */
2297                           arg_end = arg + u32_strlen (arg);
2298                           /* The number of characters doesn't matter.  */
2299                           characters = 0;
2300                         }
2301
2302                       if (has_width && width > characters
2303                           && !(dp->flags & FLAG_LEFT))
2304                         {
2305                           size_t n = width - characters;
2306                           ENSURE_ALLOCATION (xsum (length, n));
2307                           DCHAR_SET (result + length, ' ', n);
2308                           length += n;
2309                         }
2310
2311 # if DCHAR_IS_UINT32_T
2312                       {
2313                         size_t n = arg_end - arg;
2314                         ENSURE_ALLOCATION (xsum (length, n));
2315                         DCHAR_CPY (result + length, arg, n);
2316                         length += n;
2317                       }
2318 # else
2319                       { /* Convert.  */
2320                         DCHAR_T *converted = result + length;
2321                         size_t converted_len = allocated - length;
2322 #  if DCHAR_IS_TCHAR
2323                         /* Convert from UTF-32 to locale encoding.  */
2324                         converted =
2325                           u32_conv_to_encoding (locale_charset (),
2326                                                 iconveh_question_mark,
2327                                                 arg, arg_end - arg, NULL,
2328                                                 converted, &converted_len);
2329 #  else
2330                         /* Convert from UTF-32 to UTF-8/UTF-16.  */
2331                         converted =
2332                           U32_TO_DCHAR (arg, arg_end - arg,
2333                                         converted, &converted_len);
2334 #  endif
2335                         if (converted == NULL)
2336                           {
2337                             int saved_errno = errno;
2338                             if (!(result == resultbuf || result == NULL))
2339                               free (result);
2340                             if (buf_malloced != NULL)
2341                               free (buf_malloced);
2342                             CLEANUP ();
2343                             errno = saved_errno;
2344                             return NULL;
2345                           }
2346                         if (converted != result + length)
2347                           {
2348                             ENSURE_ALLOCATION (xsum (length, converted_len));
2349                             DCHAR_CPY (result + length, converted, converted_len);
2350                             free (converted);
2351                           }
2352                         length += converted_len;
2353                       }
2354 # endif
2355
2356                       if (has_width && width > characters
2357                           && (dp->flags & FLAG_LEFT))
2358                         {
2359                           size_t n = width - characters;
2360                           ENSURE_ALLOCATION (xsum (length, n));
2361                           DCHAR_SET (result + length, ' ', n);
2362                           length += n;
2363                         }
2364                     }
2365                     break;
2366
2367                   default:
2368                     abort ();
2369                   }
2370               }
2371 #endif
2372 #if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || (NEED_PRINTF_DIRECTIVE_LS && !defined IN_LIBINTL)) && HAVE_WCHAR_T
2373             else if (dp->conversion == 's'
2374 # if WIDE_CHAR_VERSION
2375                      && a.arg[dp->arg_index].type != TYPE_WIDE_STRING
2376 # else
2377                      && a.arg[dp->arg_index].type == TYPE_WIDE_STRING
2378 # endif
2379                     )
2380               {
2381                 /* The normal handling of the 's' directive below requires
2382                    allocating a temporary buffer.  The determination of its
2383                    length (tmp_length), in the case when a precision is
2384                    specified, below requires a conversion between a char[]
2385                    string and a wchar_t[] wide string.  It could be done, but
2386                    we have no guarantee that the implementation of sprintf will
2387                    use the exactly same algorithm.  Without this guarantee, it
2388                    is possible to have buffer overrun bugs.  In order to avoid
2389                    such bugs, we implement the entire processing of the 's'
2390                    directive ourselves.  */
2391                 int flags = dp->flags;
2392                 int has_width;
2393                 size_t width;
2394                 int has_precision;
2395                 size_t precision;
2396
2397                 has_width = 0;
2398                 width = 0;
2399                 if (dp->width_start != dp->width_end)
2400                   {
2401                     if (dp->width_arg_index != ARG_NONE)
2402                       {
2403                         int arg;
2404
2405                         if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
2406                           abort ();
2407                         arg = a.arg[dp->width_arg_index].a.a_int;
2408                         if (arg < 0)
2409                           {
2410                             /* "A negative field width is taken as a '-' flag
2411                                 followed by a positive field width."  */
2412                             flags |= FLAG_LEFT;
2413                             width = (unsigned int) (-arg);
2414                           }
2415                         else
2416                           width = arg;
2417                       }
2418                     else
2419                       {
2420                         const FCHAR_T *digitp = dp->width_start;
2421
2422                         do
2423                           width = xsum (xtimes (width, 10), *digitp++ - '0');
2424                         while (digitp != dp->width_end);
2425                       }
2426                     has_width = 1;
2427                   }
2428
2429                 has_precision = 0;
2430                 precision = 6;
2431                 if (dp->precision_start != dp->precision_end)
2432                   {
2433                     if (dp->precision_arg_index != ARG_NONE)
2434                       {
2435                         int arg;
2436
2437                         if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
2438                           abort ();
2439                         arg = a.arg[dp->precision_arg_index].a.a_int;
2440                         /* "A negative precision is taken as if the precision
2441                             were omitted."  */
2442                         if (arg >= 0)
2443                           {
2444                             precision = arg;
2445                             has_precision = 1;
2446                           }
2447                       }
2448                     else
2449                       {
2450                         const FCHAR_T *digitp = dp->precision_start + 1;
2451
2452                         precision = 0;
2453                         while (digitp != dp->precision_end)
2454                           precision = xsum (xtimes (precision, 10), *digitp++ - '0');
2455                         has_precision = 1;
2456                       }
2457                   }
2458
2459 # if WIDE_CHAR_VERSION
2460                 /* %s in vasnwprintf.  See the specification of fwprintf.  */
2461                 {
2462                   const char *arg = a.arg[dp->arg_index].a.a_string;
2463                   const char *arg_end;
2464                   size_t characters;
2465
2466                   if (has_precision)
2467                     {
2468                       /* Use only as many bytes as needed to produce PRECISION
2469                          wide characters, from the left.  */
2470 #  if HAVE_MBRTOWC
2471                       mbstate_t state;
2472                       memset (&state, '\0', sizeof (mbstate_t));
2473 #  endif
2474                       arg_end = arg;
2475                       characters = 0;
2476                       for (; precision > 0; precision--)
2477                         {
2478                           int count;
2479 #  if HAVE_MBRTOWC
2480                           count = mbrlen (arg_end, MB_CUR_MAX, &state);
2481 #  else
2482                           count = mblen (arg_end, MB_CUR_MAX);
2483 #  endif
2484                           if (count == 0)
2485                             /* Found the terminating NUL.  */
2486                             break;
2487                           if (count < 0)
2488                             {
2489                               /* Invalid or incomplete multibyte character.  */
2490                               if (!(result == resultbuf || result == NULL))
2491                                 free (result);
2492                               if (buf_malloced != NULL)
2493                                 free (buf_malloced);
2494                               CLEANUP ();
2495                               errno = EILSEQ;
2496                               return NULL;
2497                             }
2498                           arg_end += count;
2499                           characters++;
2500                         }
2501                     }
2502                   else if (has_width)
2503                     {
2504                       /* Use the entire string, and count the number of wide
2505                          characters.  */
2506 #  if HAVE_MBRTOWC
2507                       mbstate_t state;
2508                       memset (&state, '\0', sizeof (mbstate_t));
2509 #  endif
2510                       arg_end = arg;
2511                       characters = 0;
2512                       for (;;)
2513                         {
2514                           int count;
2515 #  if HAVE_MBRTOWC
2516                           count = mbrlen (arg_end, MB_CUR_MAX, &state);
2517 #  else
2518                           count = mblen (arg_end, MB_CUR_MAX);
2519 #  endif
2520                           if (count == 0)
2521                             /* Found the terminating NUL.  */
2522                             break;
2523                           if (count < 0)
2524                             {
2525                               /* Invalid or incomplete multibyte character.  */
2526                               if (!(result == resultbuf || result == NULL))
2527                                 free (result);
2528                               if (buf_malloced != NULL)
2529                                 free (buf_malloced);
2530                               CLEANUP ();
2531                               errno = EILSEQ;
2532                               return NULL;
2533                             }
2534                           arg_end += count;
2535                           characters++;
2536                         }
2537                     }
2538                   else
2539                     {
2540                       /* Use the entire string.  */
2541                       arg_end = arg + strlen (arg);
2542                       /* The number of characters doesn't matter.  */
2543                       characters = 0;
2544                     }
2545
2546                   if (has_width && width > characters
2547                       && !(dp->flags & FLAG_LEFT))
2548                     {
2549                       size_t n = width - characters;
2550                       ENSURE_ALLOCATION (xsum (length, n));
2551                       DCHAR_SET (result + length, ' ', n);
2552                       length += n;
2553                     }
2554
2555                   if (has_precision || has_width)
2556                     {
2557                       /* We know the number of wide characters in advance.  */
2558                       size_t remaining;
2559 #  if HAVE_MBRTOWC
2560                       mbstate_t state;
2561                       memset (&state, '\0', sizeof (mbstate_t));
2562 #  endif
2563                       ENSURE_ALLOCATION (xsum (length, characters));
2564                       for (remaining = characters; remaining > 0; remaining--)
2565                         {
2566                           wchar_t wc;
2567                           int count;
2568 #  if HAVE_MBRTOWC
2569                           count = mbrtowc (&wc, arg, arg_end - arg, &state);
2570 #  else
2571                           count = mbtowc (&wc, arg, arg_end - arg);
2572 #  endif
2573                           if (count <= 0)
2574                             /* mbrtowc not consistent with mbrlen, or mbtowc
2575                                not consistent with mblen.  */
2576                             abort ();
2577                           result[length++] = wc;
2578                           arg += count;
2579                         }
2580                       if (!(arg == arg_end))
2581                         abort ();
2582                     }
2583                   else
2584                     {
2585 #  if HAVE_MBRTOWC
2586                       mbstate_t state;
2587                       memset (&state, '\0', sizeof (mbstate_t));
2588 #  endif
2589                       while (arg < arg_end)
2590                         {
2591                           wchar_t wc;
2592                           int count;
2593 #  if HAVE_MBRTOWC
2594                           count = mbrtowc (&wc, arg, arg_end - arg, &state);
2595 #  else
2596                           count = mbtowc (&wc, arg, arg_end - arg);
2597 #  endif
2598                           if (count <= 0)
2599                             /* mbrtowc not consistent with mbrlen, or mbtowc
2600                                not consistent with mblen.  */
2601                             abort ();
2602                           ENSURE_ALLOCATION (xsum (length, 1));
2603                           result[length++] = wc;
2604                           arg += count;
2605                         }
2606                     }
2607
2608                   if (has_width && width > characters
2609                       && (dp->flags & FLAG_LEFT))
2610                     {
2611                       size_t n = width - characters;
2612                       ENSURE_ALLOCATION (xsum (length, n));
2613                       DCHAR_SET (result + length, ' ', n);
2614                       length += n;
2615                     }
2616                 }
2617 # else
2618                 /* %ls in vasnprintf.  See the specification of fprintf.  */
2619                 {
2620                   const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string;
2621                   const wchar_t *arg_end;
2622                   size_t characters;
2623 #  if !DCHAR_IS_TCHAR
2624                   /* This code assumes that TCHAR_T is 'char'.  */
2625                   typedef int TCHAR_T_verify[2 * (sizeof (TCHAR_T) == 1) - 1];
2626                   TCHAR_T *tmpsrc;
2627                   DCHAR_T *tmpdst;
2628                   size_t tmpdst_len;
2629 #  endif
2630                   size_t w;
2631
2632                   if (has_precision)
2633                     {
2634                       /* Use only as many wide characters as needed to produce
2635                          at most PRECISION bytes, from the left.  */
2636 #  if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2637                       mbstate_t state;
2638                       memset (&state, '\0', sizeof (mbstate_t));
2639 #  endif
2640                       arg_end = arg;
2641                       characters = 0;
2642                       while (precision > 0)
2643                         {
2644                           char cbuf[64]; /* Assume MB_CUR_MAX <= 64.  */
2645                           int count;
2646
2647                           if (*arg_end == 0)
2648                             /* Found the terminating null wide character.  */
2649                             break;
2650 #  if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2651                           count = wcrtomb (cbuf, *arg_end, &state);
2652 #  else
2653                           count = wctomb (cbuf, *arg_end);
2654 #  endif
2655                           if (count < 0)
2656                             {
2657                               /* Cannot convert.  */
2658                               if (!(result == resultbuf || result == NULL))
2659                                 free (result);
2660                               if (buf_malloced != NULL)
2661                                 free (buf_malloced);
2662                               CLEANUP ();
2663                               errno = EILSEQ;
2664                               return NULL;
2665                             }
2666                           if (precision < count)
2667                             break;
2668                           arg_end++;
2669                           characters += count;
2670                           precision -= count;
2671                         }
2672                     }
2673 #  if DCHAR_IS_TCHAR
2674                   else if (has_width)
2675 #  else
2676                   else
2677 #  endif
2678                     {
2679                       /* Use the entire string, and count the number of
2680                          bytes.  */
2681 #  if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2682                       mbstate_t state;
2683                       memset (&state, '\0', sizeof (mbstate_t));
2684 #  endif
2685                       arg_end = arg;
2686                       characters = 0;
2687                       for (;;)
2688                         {
2689                           char cbuf[64]; /* Assume MB_CUR_MAX <= 64.  */
2690                           int count;
2691
2692                           if (*arg_end == 0)
2693                             /* Found the terminating null wide character.  */
2694                             break;
2695 #  if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2696                           count = wcrtomb (cbuf, *arg_end, &state);
2697 #  else
2698                           count = wctomb (cbuf, *arg_end);
2699 #  endif
2700                           if (count < 0)
2701                             {
2702                               /* Cannot convert.  */
2703                               if (!(result == resultbuf || result == NULL))
2704                                 free (result);
2705                               if (buf_malloced != NULL)
2706                                 free (buf_malloced);
2707                               CLEANUP ();
2708                               errno = EILSEQ;
2709                               return NULL;
2710                             }
2711                           arg_end++;
2712                           characters += count;
2713                         }
2714                     }
2715 #  if DCHAR_IS_TCHAR
2716                   else
2717                     {
2718                       /* Use the entire string.  */
2719                       arg_end = arg + local_wcslen (arg);
2720                       /* The number of bytes doesn't matter.  */
2721                       characters = 0;
2722                     }
2723 #  endif
2724
2725 #  if !DCHAR_IS_TCHAR
2726                   /* Convert the string into a piece of temporary memory.  */
2727                   tmpsrc = (TCHAR_T *) malloc (characters * sizeof (TCHAR_T));
2728                   if (tmpsrc == NULL)
2729                     goto out_of_memory;
2730                   {
2731                     TCHAR_T *tmpptr = tmpsrc;
2732                     size_t remaining;
2733 #   if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2734                     mbstate_t state;
2735                     memset (&state, '\0', sizeof (mbstate_t));
2736 #   endif
2737                     for (remaining = characters; remaining > 0; )
2738                       {
2739                         char cbuf[64]; /* Assume MB_CUR_MAX <= 64.  */
2740                         int count;
2741
2742                         if (*arg == 0)
2743                           abort ();
2744 #   if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2745                         count = wcrtomb (cbuf, *arg, &state);
2746 #   else
2747                         count = wctomb (cbuf, *arg);
2748 #   endif
2749                         if (count <= 0)
2750                           /* Inconsistency.  */
2751                           abort ();
2752                         memcpy (tmpptr, cbuf, count);
2753                         tmpptr += count;
2754                         arg++;
2755                         remaining -= count;
2756                       }
2757                     if (!(arg == arg_end))
2758                       abort ();
2759                   }
2760
2761                   /* Convert from TCHAR_T[] to DCHAR_T[].  */
2762                   tmpdst =
2763                     DCHAR_CONV_FROM_ENCODING (locale_charset (),
2764                                               iconveh_question_mark,
2765                                               tmpsrc, characters,
2766                                               NULL,
2767                                               NULL, &tmpdst_len);
2768                   if (tmpdst == NULL)
2769                     {
2770                       int saved_errno = errno;
2771                       free (tmpsrc);
2772                       if (!(result == resultbuf || result == NULL))
2773                         free (result);
2774                       if (buf_malloced != NULL)
2775                         free (buf_malloced);
2776                       CLEANUP ();
2777                       errno = saved_errno;
2778                       return NULL;
2779                     }
2780                   free (tmpsrc);
2781 #  endif
2782
2783                   if (has_width)
2784                     {
2785 #  if ENABLE_UNISTDIO
2786                       /* Outside POSIX, it's preferrable to compare the width
2787                          against the number of _characters_ of the converted
2788                          value.  */
2789                       w = DCHAR_MBSNLEN (result + length, characters);
2790 #  else
2791                       /* The width is compared against the number of _bytes_
2792                          of the converted value, says POSIX.  */
2793                       w = characters;
2794 #  endif
2795                     }
2796                   else
2797                     /* w doesn't matter.  */
2798                     w = 0;
2799
2800                   if (has_width && width > w
2801                       && !(dp->flags & FLAG_LEFT))
2802                     {
2803                       size_t n = width - w;
2804                       ENSURE_ALLOCATION (xsum (length, n));
2805                       DCHAR_SET (result + length, ' ', n);
2806                       length += n;
2807                     }
2808
2809 #  if DCHAR_IS_TCHAR
2810                   if (has_precision || has_width)
2811                     {
2812                       /* We know the number of bytes in advance.  */
2813                       size_t remaining;
2814 #   if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2815                       mbstate_t state;
2816                       memset (&state, '\0', sizeof (mbstate_t));
2817 #   endif
2818                       ENSURE_ALLOCATION (xsum (length, characters));
2819                       for (remaining = characters; remaining > 0; )
2820                         {
2821                           char cbuf[64]; /* Assume MB_CUR_MAX <= 64.  */
2822                           int count;
2823
2824                           if (*arg == 0)
2825                             abort ();
2826 #   if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2827                           count = wcrtomb (cbuf, *arg, &state);
2828 #   else
2829                           count = wctomb (cbuf, *arg);
2830 #   endif
2831                           if (count <= 0)
2832                             /* Inconsistency.  */
2833                             abort ();
2834                           memcpy (result + length, cbuf, count);
2835                           length += count;
2836                           arg++;
2837                           remaining -= count;
2838                         }
2839                       if (!(arg == arg_end))
2840                         abort ();
2841                     }
2842                   else
2843                     {
2844 #   if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2845                       mbstate_t state;
2846                       memset (&state, '\0', sizeof (mbstate_t));
2847 #   endif
2848                       while (arg < arg_end)
2849                         {
2850                           char cbuf[64]; /* Assume MB_CUR_MAX <= 64.  */
2851                           int count;
2852
2853                           if (*arg == 0)
2854                             abort ();
2855 #   if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2856                           count = wcrtomb (cbuf, *arg, &state);
2857 #   else
2858                           count = wctomb (cbuf, *arg);
2859 #   endif
2860                           if (count <= 0)
2861                             {
2862                               /* Cannot convert.  */
2863                               if (!(result == resultbuf || result == NULL))
2864                                 free (result);
2865                               if (buf_malloced != NULL)
2866                                 free (buf_malloced);
2867                               CLEANUP ();
2868                               errno = EILSEQ;
2869                               return NULL;
2870                             }
2871                           ENSURE_ALLOCATION (xsum (length, count));
2872                           memcpy (result + length, cbuf, count);
2873                           length += count;
2874                           arg++;
2875                         }
2876                     }
2877 #  else
2878                   ENSURE_ALLOCATION (xsum (length, tmpdst_len));
2879                   DCHAR_CPY (result + length, tmpdst, tmpdst_len);
2880                   free (tmpdst);
2881                   length += tmpdst_len;
2882 #  endif
2883
2884                   if (has_width && width > w
2885                       && (dp->flags & FLAG_LEFT))
2886                     {
2887                       size_t n = width - w;
2888                       ENSURE_ALLOCATION (xsum (length, n));
2889                       DCHAR_SET (result + length, ' ', n);
2890                       length += n;
2891                     }
2892                 }
2893 # endif
2894               }
2895 #endif
2896 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
2897             else if ((dp->conversion == 'a' || dp->conversion == 'A')
2898 # if !(NEED_PRINTF_DIRECTIVE_A || (NEED_PRINTF_LONG_DOUBLE && NEED_PRINTF_DOUBLE))
2899                      && (0
2900 #  if NEED_PRINTF_DOUBLE
2901                          || a.arg[dp->arg_index].type == TYPE_DOUBLE
2902 #  endif
2903 #  if NEED_PRINTF_LONG_DOUBLE
2904                          || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
2905 #  endif
2906                         )
2907 # endif
2908                     )
2909               {
2910                 arg_type type = a.arg[dp->arg_index].type;
2911                 int flags = dp->flags;
2912                 int has_width;
2913                 size_t width;
2914                 int has_precision;
2915                 size_t precision;
2916                 size_t tmp_length;
2917                 DCHAR_T tmpbuf[700];
2918                 DCHAR_T *tmp;
2919                 DCHAR_T *pad_ptr;
2920                 DCHAR_T *p;
2921
2922                 has_width = 0;
2923                 width = 0;
2924                 if (dp->width_start != dp->width_end)
2925                   {
2926                     if (dp->width_arg_index != ARG_NONE)
2927                       {
2928                         int arg;
2929
2930                         if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
2931                           abort ();
2932                         arg = a.arg[dp->width_arg_index].a.a_int;
2933                         if (arg < 0)
2934                           {
2935                             /* "A negative field width is taken as a '-' flag
2936                                 followed by a positive field width."  */
2937                             flags |= FLAG_LEFT;
2938                             width = (unsigned int) (-arg);
2939                           }
2940                         else
2941                           width = arg;
2942                       }
2943                     else
2944                       {
2945                         const FCHAR_T *digitp = dp->width_start;
2946
2947                         do
2948                           width = xsum (xtimes (width, 10), *digitp++ - '0');
2949                         while (digitp != dp->width_end);
2950                       }
2951                     has_width = 1;
2952                   }
2953
2954                 has_precision = 0;
2955                 precision = 0;
2956                 if (dp->precision_start != dp->precision_end)
2957                   {
2958                     if (dp->precision_arg_index != ARG_NONE)
2959                       {
2960                         int arg;
2961
2962                         if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
2963                           abort ();
2964                         arg = a.arg[dp->precision_arg_index].a.a_int;
2965                         /* "A negative precision is taken as if the precision
2966                             were omitted."  */
2967                         if (arg >= 0)
2968                           {
2969                             precision = arg;
2970                             has_precision = 1;
2971                           }
2972                       }
2973                     else
2974                       {
2975                         const FCHAR_T *digitp = dp->precision_start + 1;
2976
2977                         precision = 0;
2978                         while (digitp != dp->precision_end)
2979                           precision = xsum (xtimes (precision, 10), *digitp++ - '0');
2980                         has_precision = 1;
2981                       }
2982                   }
2983
2984                 /* Allocate a temporary buffer of sufficient size.  */
2985                 if (type == TYPE_LONGDOUBLE)
2986                   tmp_length =
2987                     (unsigned int) ((LDBL_DIG + 1)
2988                                     * 0.831 /* decimal -> hexadecimal */
2989                                    )
2990                     + 1; /* turn floor into ceil */
2991                 else
2992                   tmp_length =
2993                     (unsigned int) ((DBL_DIG + 1)
2994                                     * 0.831 /* decimal -> hexadecimal */
2995                                    )
2996                     + 1; /* turn floor into ceil */
2997                 if (tmp_length < precision)
2998                   tmp_length = precision;
2999                 /* Account for sign, decimal point etc. */
3000                 tmp_length = xsum (tmp_length, 12);
3001
3002                 if (tmp_length < width)
3003                   tmp_length = width;
3004
3005                 tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
3006
3007                 if (tmp_length <= sizeof (tmpbuf) / sizeof (DCHAR_T))
3008                   tmp = tmpbuf;
3009                 else
3010                   {
3011                     size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T));
3012
3013                     if (size_overflow_p (tmp_memsize))
3014                       /* Overflow, would lead to out of memory.  */
3015                       goto out_of_memory;
3016                     tmp = (DCHAR_T *) malloc (tmp_memsize);
3017                     if (tmp == NULL)
3018                       /* Out of memory.  */
3019                       goto out_of_memory;
3020                   }
3021
3022                 pad_ptr = NULL;
3023                 p = tmp;
3024                 if (type == TYPE_LONGDOUBLE)
3025                   {
3026 # if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE
3027                     long double arg = a.arg[dp->arg_index].a.a_longdouble;
3028
3029                     if (isnanl (arg))
3030                       {
3031                         if (dp->conversion == 'A')
3032                           {
3033                             *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
3034                           }
3035                         else
3036                           {
3037                             *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
3038                           }
3039                       }
3040                     else
3041                       {
3042                         int sign = 0;
3043                         DECL_LONG_DOUBLE_ROUNDING
3044
3045                         BEGIN_LONG_DOUBLE_ROUNDING ();
3046
3047                         if (signbit (arg)) /* arg < 0.0L or negative zero */
3048                           {
3049                             sign = -1;
3050                             arg = -arg;
3051                           }
3052
3053                         if (sign < 0)
3054                           *p++ = '-';
3055                         else if (flags & FLAG_SHOWSIGN)
3056                           *p++ = '+';
3057                         else if (flags & FLAG_SPACE)
3058                           *p++ = ' ';
3059
3060                         if (arg > 0.0L && arg + arg == arg)
3061                           {
3062                             if (dp->conversion == 'A')
3063                               {
3064                                 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
3065                               }
3066                             else
3067                               {
3068                                 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
3069                               }
3070                           }
3071                         else
3072                           {
3073                             int exponent;
3074                             long double mantissa;
3075
3076                             if (arg > 0.0L)
3077                               mantissa = printf_frexpl (arg, &exponent);
3078                             else
3079                               {
3080                                 exponent = 0;
3081                                 mantissa = 0.0L;
3082                               }
3083
3084                             if (has_precision
3085                                 && precision < (unsigned int) ((LDBL_DIG + 1) * 0.831) + 1)
3086                               {
3087                                 /* Round the mantissa.  */
3088                                 long double tail = mantissa;
3089                                 size_t q;
3090
3091                                 for (q = precision; ; q--)
3092                                   {
3093                                     int digit = (int) tail;
3094                                     tail -= digit;
3095                                     if (q == 0)
3096                                       {
3097                                         if (digit & 1 ? tail >= 0.5L : tail > 0.5L)
3098                                           tail = 1 - tail;
3099                                         else
3100                                           tail = - tail;
3101                                         break;
3102                                       }
3103                                     tail *= 16.0L;
3104                                   }
3105                                 if (tail != 0.0L)
3106                                   for (q = precision; q > 0; q--)
3107                                     tail *= 0.0625L;
3108                                 mantissa += tail;
3109                               }
3110
3111                             *p++ = '0';
3112                             *p++ = dp->conversion - 'A' + 'X';
3113                             pad_ptr = p;
3114                             {
3115                               int digit;
3116
3117                               digit = (int) mantissa;
3118                               mantissa -= digit;
3119                               *p++ = '0' + digit;
3120                               if ((flags & FLAG_ALT)
3121                                   || mantissa > 0.0L || precision > 0)
3122                                 {
3123                                   *p++ = decimal_point_char ();
3124                                   /* This loop terminates because we assume
3125                                      that FLT_RADIX is a power of 2.  */
3126                                   while (mantissa > 0.0L)
3127                                     {
3128                                       mantissa *= 16.0L;
3129                                       digit = (int) mantissa;
3130                                       mantissa -= digit;
3131                                       *p++ = digit
3132                                              + (digit < 10
3133                                                 ? '0'
3134                                                 : dp->conversion - 10);
3135                                       if (precision > 0)
3136                                         precision--;
3137                                     }
3138                                   while (precision > 0)
3139                                     {
3140                                       *p++ = '0';
3141                                       precision--;
3142                                     }
3143                                 }
3144                               }
3145                               *p++ = dp->conversion - 'A' + 'P';
3146 #  if WIDE_CHAR_VERSION
3147                               {
3148                                 static const wchar_t decimal_format[] =
3149                                   { '%', '+', 'd', '\0' };
3150                                 SNPRINTF (p, 6 + 1, decimal_format, exponent);
3151                               }
3152                               while (*p != '\0')
3153                                 p++;
3154 #  else
3155                               if (sizeof (DCHAR_T) == 1)
3156                                 {
3157                                   sprintf ((char *) p, "%+d", exponent);
3158                                   while (*p != '\0')
3159                                     p++;
3160                                 }
3161                               else
3162                                 {
3163                                   char expbuf[6 + 1];
3164                                   const char *ep;
3165                                   sprintf (expbuf, "%+d", exponent);
3166                                   for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3167                                     p++;
3168                                 }
3169 #  endif
3170                           }
3171
3172                         END_LONG_DOUBLE_ROUNDING ();
3173                       }
3174 # else
3175                     abort ();
3176 # endif
3177                   }
3178                 else
3179                   {
3180 # if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE
3181                     double arg = a.arg[dp->arg_index].a.a_double;
3182
3183                     if (isnand (arg))
3184                       {
3185                         if (dp->conversion == 'A')
3186                           {
3187                             *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
3188                           }
3189                         else
3190                           {
3191                             *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
3192                           }
3193                       }
3194                     else
3195                       {
3196                         int sign = 0;
3197
3198                         if (signbit (arg)) /* arg < 0.0 or negative zero */
3199                           {
3200                             sign = -1;
3201                             arg = -arg;
3202                           }
3203
3204                         if (sign < 0)
3205                           *p++ = '-';
3206                         else if (flags & FLAG_SHOWSIGN)
3207                           *p++ = '+';
3208                         else if (flags & FLAG_SPACE)
3209                           *p++ = ' ';
3210
3211                         if (arg > 0.0 && arg + arg == arg)
3212                           {
3213                             if (dp->conversion == 'A')
3214                               {
3215                                 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
3216                               }
3217                             else
3218                               {
3219                                 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
3220                               }
3221                           }
3222                         else
3223                           {
3224                             int exponent;
3225                             double mantissa;
3226
3227                             if (arg > 0.0)
3228                               mantissa = printf_frexp (arg, &exponent);
3229                             else
3230                               {
3231                                 exponent = 0;
3232                                 mantissa = 0.0;
3233                               }
3234
3235                             if (has_precision
3236                                 && precision < (unsigned int) ((DBL_DIG + 1) * 0.831) + 1)
3237                               {
3238                                 /* Round the mantissa.  */
3239                                 double tail = mantissa;
3240                                 size_t q;
3241
3242                                 for (q = precision; ; q--)
3243                                   {
3244                                     int digit = (int) tail;
3245                                     tail -= digit;
3246                                     if (q == 0)
3247                                       {
3248                                         if (digit & 1 ? tail >= 0.5 : tail > 0.5)
3249                                           tail = 1 - tail;
3250                                         else
3251                                           tail = - tail;
3252                                         break;
3253                                       }
3254                                     tail *= 16.0;
3255                                   }
3256                                 if (tail != 0.0)
3257                                   for (q = precision; q > 0; q--)
3258                                     tail *= 0.0625;
3259                                 mantissa += tail;
3260                               }
3261
3262                             *p++ = '0';
3263                             *p++ = dp->conversion - 'A' + 'X';
3264                             pad_ptr = p;
3265                             {
3266                               int digit;
3267
3268                               digit = (int) mantissa;
3269                               mantissa -= digit;
3270                               *p++ = '0' + digit;
3271                               if ((flags & FLAG_ALT)
3272                                   || mantissa > 0.0 || precision > 0)
3273                                 {
3274                                   *p++ = decimal_point_char ();
3275                                   /* This loop terminates because we assume
3276                                      that FLT_RADIX is a power of 2.  */
3277                                   while (mantissa > 0.0)
3278                                     {
3279                                       mantissa *= 16.0;
3280                                       digit = (int) mantissa;
3281                                       mantissa -= digit;
3282                                       *p++ = digit
3283                                              + (digit < 10
3284                                                 ? '0'
3285                                                 : dp->conversion - 10);
3286                                       if (precision > 0)
3287                                         precision--;
3288                                     }
3289                                   while (precision > 0)
3290                                     {
3291                                       *p++ = '0';
3292                                       precision--;
3293                                     }
3294                                 }
3295                               }
3296                               *p++ = dp->conversion - 'A' + 'P';
3297 #  if WIDE_CHAR_VERSION
3298                               {
3299                                 static const wchar_t decimal_format[] =
3300                                   { '%', '+', 'd', '\0' };
3301                                 SNPRINTF (p, 6 + 1, decimal_format, exponent);
3302                               }
3303                               while (*p != '\0')
3304                                 p++;
3305 #  else
3306                               if (sizeof (DCHAR_T) == 1)
3307                                 {
3308                                   sprintf ((char *) p, "%+d", exponent);
3309                                   while (*p != '\0')
3310                                     p++;
3311                                 }
3312                               else
3313                                 {
3314                                   char expbuf[6 + 1];
3315                                   const char *ep;
3316                                   sprintf (expbuf, "%+d", exponent);
3317                                   for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3318                                     p++;
3319                                 }
3320 #  endif
3321                           }
3322                       }
3323 # else
3324                     abort ();
3325 # endif
3326                   }
3327                 /* The generated string now extends from tmp to p, with the
3328                    zero padding insertion point being at pad_ptr.  */
3329                 if (has_width && p - tmp < width)
3330                   {
3331                     size_t pad = width - (p - tmp);
3332                     DCHAR_T *end = p + pad;
3333
3334                     if (flags & FLAG_LEFT)
3335                       {
3336                         /* Pad with spaces on the right.  */
3337                         for (; pad > 0; pad--)
3338                           *p++ = ' ';
3339                       }
3340                     else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
3341                       {
3342                         /* Pad with zeroes.  */
3343                         DCHAR_T *q = end;
3344
3345                         while (p > pad_ptr)
3346                           *--q = *--p;
3347                         for (; pad > 0; pad--)
3348                           *p++ = '0';
3349                       }
3350                     else
3351                       {
3352                         /* Pad with spaces on the left.  */
3353                         DCHAR_T *q = end;
3354
3355                         while (p > tmp)
3356                           *--q = *--p;
3357                         for (; pad > 0; pad--)
3358                           *p++ = ' ';
3359                       }
3360
3361                     p = end;
3362                   }
3363
3364                 {
3365                   size_t count = p - tmp;
3366
3367                   if (count >= tmp_length)
3368                     /* tmp_length was incorrectly calculated - fix the
3369                        code above!  */
3370                     abort ();
3371
3372                   /* Make room for the result.  */
3373                   if (count >= allocated - length)
3374                     {
3375                       size_t n = xsum (length, count);
3376
3377                       ENSURE_ALLOCATION (n);
3378                     }
3379
3380                   /* Append the result.  */
3381                   memcpy (result + length, tmp, count * sizeof (DCHAR_T));
3382                   if (tmp != tmpbuf)
3383                     free (tmp);
3384                   length += count;
3385                 }
3386               }
3387 #endif
3388 #if (NEED_PRINTF_INFINITE_DOUBLE || NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
3389             else if ((dp->conversion == 'f' || dp->conversion == 'F'
3390                       || dp->conversion == 'e' || dp->conversion == 'E'
3391                       || dp->conversion == 'g' || dp->conversion == 'G'
3392                       || dp->conversion == 'a' || dp->conversion == 'A')
3393                      && (0
3394 # if NEED_PRINTF_DOUBLE
3395                          || a.arg[dp->arg_index].type == TYPE_DOUBLE
3396 # elif NEED_PRINTF_INFINITE_DOUBLE
3397                          || (a.arg[dp->arg_index].type == TYPE_DOUBLE
3398                              /* The systems (mingw) which produce wrong output
3399                                 for Inf, -Inf, and NaN also do so for -0.0.
3400                                 Therefore we treat this case here as well.  */
3401                              && is_infinite_or_zero (a.arg[dp->arg_index].a.a_double))
3402 # endif
3403 # if NEED_PRINTF_LONG_DOUBLE
3404                          || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
3405 # elif NEED_PRINTF_INFINITE_LONG_DOUBLE
3406                          || (a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
3407                              /* Some systems produce wrong output for Inf,
3408                                 -Inf, and NaN.  Some systems in this category
3409                                 (IRIX 5.3) also do so for -0.0.  Therefore we
3410                                 treat this case here as well.  */
3411                              && is_infinite_or_zerol (a.arg[dp->arg_index].a.a_longdouble))
3412 # endif
3413                         ))
3414               {
3415 # if (NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE)
3416                 arg_type type = a.arg[dp->arg_index].type;
3417 # endif
3418                 int flags = dp->flags;
3419                 int has_width;
3420                 size_t width;
3421                 int has_precision;
3422                 size_t precision;
3423                 size_t tmp_length;
3424                 DCHAR_T tmpbuf[700];
3425                 DCHAR_T *tmp;
3426                 DCHAR_T *pad_ptr;
3427                 DCHAR_T *p;
3428
3429                 has_width = 0;
3430                 width = 0;
3431                 if (dp->width_start != dp->width_end)
3432                   {
3433                     if (dp->width_arg_index != ARG_NONE)
3434                       {
3435                         int arg;
3436
3437                         if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
3438                           abort ();
3439                         arg = a.arg[dp->width_arg_index].a.a_int;
3440                         if (arg < 0)
3441                           {
3442                             /* "A negative field width is taken as a '-' flag
3443                                 followed by a positive field width."  */
3444                             flags |= FLAG_LEFT;
3445                             width = (unsigned int) (-arg);
3446                           }
3447                         else
3448                           width = arg;
3449                       }
3450                     else
3451                       {
3452                         const FCHAR_T *digitp = dp->width_start;
3453
3454                         do
3455                           width = xsum (xtimes (width, 10), *digitp++ - '0');
3456                         while (digitp != dp->width_end);
3457                       }
3458                     has_width = 1;
3459                   }
3460
3461                 has_precision = 0;
3462                 precision = 0;
3463                 if (dp->precision_start != dp->precision_end)
3464                   {
3465                     if (dp->precision_arg_index != ARG_NONE)
3466                       {
3467                         int arg;
3468
3469                         if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
3470                           abort ();
3471                         arg = a.arg[dp->precision_arg_index].a.a_int;
3472                         /* "A negative precision is taken as if the precision
3473                             were omitted."  */
3474                         if (arg >= 0)
3475                           {
3476                             precision = arg;
3477                             has_precision = 1;
3478                           }
3479                       }
3480                     else
3481                       {
3482                         const FCHAR_T *digitp = dp->precision_start + 1;
3483
3484                         precision = 0;
3485                         while (digitp != dp->precision_end)
3486                           precision = xsum (xtimes (precision, 10), *digitp++ - '0');
3487                         has_precision = 1;
3488                       }
3489                   }
3490
3491                 /* POSIX specifies the default precision to be 6 for %f, %F,
3492                    %e, %E, but not for %g, %G.  Implementations appear to use
3493                    the same default precision also for %g, %G.  But for %a, %A,
3494                    the default precision is 0.  */
3495                 if (!has_precision)
3496                   if (!(dp->conversion == 'a' || dp->conversion == 'A'))
3497                     precision = 6;
3498
3499                 /* Allocate a temporary buffer of sufficient size.  */
3500 # if NEED_PRINTF_DOUBLE && NEED_PRINTF_LONG_DOUBLE
3501                 tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : DBL_DIG + 1);
3502 # elif NEED_PRINTF_INFINITE_DOUBLE && NEED_PRINTF_LONG_DOUBLE
3503                 tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : 0);
3504 # elif NEED_PRINTF_LONG_DOUBLE
3505                 tmp_length = LDBL_DIG + 1;
3506 # elif NEED_PRINTF_DOUBLE
3507                 tmp_length = DBL_DIG + 1;
3508 # else
3509                 tmp_length = 0;
3510 # endif
3511                 if (tmp_length < precision)
3512                   tmp_length = precision;
3513 # if NEED_PRINTF_LONG_DOUBLE
3514 #  if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
3515                 if (type == TYPE_LONGDOUBLE)
3516 #  endif
3517                   if (dp->conversion == 'f' || dp->conversion == 'F')
3518                     {
3519                       long double arg = a.arg[dp->arg_index].a.a_longdouble;
3520                       if (!(isnanl (arg) || arg + arg == arg))
3521                         {
3522                           /* arg is finite and nonzero.  */
3523                           int exponent = floorlog10l (arg < 0 ? -arg : arg);
3524                           if (exponent >= 0 && tmp_length < exponent + precision)
3525                             tmp_length = exponent + precision;
3526                         }
3527                     }
3528 # endif
3529 # if NEED_PRINTF_DOUBLE
3530 #  if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE
3531                 if (type == TYPE_DOUBLE)
3532 #  endif
3533                   if (dp->conversion == 'f' || dp->conversion == 'F')
3534                     {
3535                       double arg = a.arg[dp->arg_index].a.a_double;
3536                       if (!(isnand (arg) || arg + arg == arg))
3537                         {
3538                           /* arg is finite and nonzero.  */
3539                           int exponent = floorlog10 (arg < 0 ? -arg : arg);
3540                           if (exponent >= 0 && tmp_length < exponent + precision)
3541                             tmp_length = exponent + precision;
3542                         }
3543                     }
3544 # endif
3545                 /* Account for sign, decimal point etc. */
3546                 tmp_length = xsum (tmp_length, 12);
3547
3548                 if (tmp_length < width)
3549                   tmp_length = width;
3550
3551                 tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
3552
3553                 if (tmp_length <= sizeof (tmpbuf) / sizeof (DCHAR_T))
3554                   tmp = tmpbuf;
3555                 else
3556                   {
3557                     size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T));
3558
3559                     if (size_overflow_p (tmp_memsize))
3560                       /* Overflow, would lead to out of memory.  */
3561                       goto out_of_memory;
3562                     tmp = (DCHAR_T *) malloc (tmp_memsize);
3563                     if (tmp == NULL)
3564                       /* Out of memory.  */
3565                       goto out_of_memory;
3566                   }
3567
3568                 pad_ptr = NULL;
3569                 p = tmp;
3570
3571 # if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE
3572 #  if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
3573                 if (type == TYPE_LONGDOUBLE)
3574 #  endif
3575                   {
3576                     long double arg = a.arg[dp->arg_index].a.a_longdouble;
3577
3578                     if (isnanl (arg))
3579                       {
3580                         if (dp->conversion >= 'A' && dp->conversion <= 'Z')
3581                           {
3582                             *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
3583                           }
3584                         else
3585                           {
3586                             *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
3587                           }
3588                       }
3589                     else
3590                       {
3591                         int sign = 0;
3592                         DECL_LONG_DOUBLE_ROUNDING
3593
3594                         BEGIN_LONG_DOUBLE_ROUNDING ();
3595
3596                         if (signbit (arg)) /* arg < 0.0L or negative zero */
3597                           {
3598                             sign = -1;
3599                             arg = -arg;
3600                           }
3601
3602                         if (sign < 0)
3603                           *p++ = '-';
3604                         else if (flags & FLAG_SHOWSIGN)
3605                           *p++ = '+';
3606                         else if (flags & FLAG_SPACE)
3607                           *p++ = ' ';
3608
3609                         if (arg > 0.0L && arg + arg == arg)
3610                           {
3611                             if (dp->conversion >= 'A' && dp->conversion <= 'Z')
3612                               {
3613                                 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
3614                               }
3615                             else
3616                               {
3617                                 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
3618                               }
3619                           }
3620                         else
3621                           {
3622 #  if NEED_PRINTF_LONG_DOUBLE
3623                             pad_ptr = p;
3624
3625                             if (dp->conversion == 'f' || dp->conversion == 'F')
3626                               {
3627                                 char *digits;
3628                                 size_t ndigits;
3629
3630                                 digits =
3631                                   scale10_round_decimal_long_double (arg, precision);
3632                                 if (digits == NULL)
3633                                   {
3634                                     END_LONG_DOUBLE_ROUNDING ();
3635                                     goto out_of_memory;
3636                                   }
3637                                 ndigits = strlen (digits);
3638
3639                                 if (ndigits > precision)
3640                                   do
3641                                     {
3642                                       --ndigits;
3643                                       *p++ = digits[ndigits];
3644                                     }
3645                                   while (ndigits > precision);
3646                                 else
3647                                   *p++ = '0';
3648                                 /* Here ndigits <= precision.  */
3649                                 if ((flags & FLAG_ALT) || precision > 0)
3650                                   {
3651                                     *p++ = decimal_point_char ();
3652                                     for (; precision > ndigits; precision--)
3653                                       *p++ = '0';
3654                                     while (ndigits > 0)
3655                                       {
3656                                         --ndigits;
3657                                         *p++ = digits[ndigits];
3658                                       }
3659                                   }
3660
3661                                 free (digits);
3662                               }
3663                             else if (dp->conversion == 'e' || dp->conversion == 'E')
3664                               {
3665                                 int exponent;
3666
3667                                 if (arg == 0.0L)
3668                                   {
3669                                     exponent = 0;
3670                                     *p++ = '0';
3671                                     if ((flags & FLAG_ALT) || precision > 0)
3672                                       {
3673                                         *p++ = decimal_point_char ();
3674                                         for (; precision > 0; precision--)
3675                                           *p++ = '0';
3676                                       }
3677                                   }
3678                                 else
3679                                   {
3680                                     /* arg > 0.0L.  */
3681                                     int adjusted;
3682                                     char *digits;
3683                                     size_t ndigits;
3684
3685                                     exponent = floorlog10l (arg);
3686                                     adjusted = 0;
3687                                     for (;;)
3688                                       {
3689                                         digits =
3690                                           scale10_round_decimal_long_double (arg,
3691                                                                              (int)precision - exponent);
3692                                         if (digits == NULL)
3693                                           {
3694                                             END_LONG_DOUBLE_ROUNDING ();
3695                                             goto out_of_memory;
3696                                           }
3697                                         ndigits = strlen (digits);
3698
3699                                         if (ndigits == precision + 1)
3700                                           break;
3701                                         if (ndigits < precision
3702                                             || ndigits > precision + 2)
3703                                           /* The exponent was not guessed
3704                                              precisely enough.  */
3705                                           abort ();
3706                                         if (adjusted)
3707                                           /* None of two values of exponent is
3708                                              the right one.  Prevent an endless
3709                                              loop.  */
3710                                           abort ();
3711                                         free (digits);
3712                                         if (ndigits == precision)
3713                                           exponent -= 1;
3714                                         else
3715                                           exponent += 1;
3716                                         adjusted = 1;
3717                                       }
3718                                     /* Here ndigits = precision+1.  */
3719                                     if (is_borderline (digits, precision))
3720                                       {
3721                                         /* Maybe the exponent guess was too high
3722                                            and a smaller exponent can be reached
3723                                            by turning a 10...0 into 9...9x.  */
3724                                         char *digits2 =
3725                                           scale10_round_decimal_long_double (arg,
3726                                                                              (int)precision - exponent + 1);
3727                                         if (digits2 == NULL)
3728                                           {
3729                                             free (digits);
3730                                             END_LONG_DOUBLE_ROUNDING ();
3731                                             goto out_of_memory;
3732                                           }
3733                                         if (strlen (digits2) == precision + 1)
3734                                           {
3735                                             free (digits);
3736                                             digits = digits2;
3737                                             exponent -= 1;
3738                                           }
3739                                         else
3740                                           free (digits2);
3741                                       }
3742                                     /* Here ndigits = precision+1.  */
3743
3744                                     *p++ = digits[--ndigits];
3745                                     if ((flags & FLAG_ALT) || precision > 0)
3746                                       {
3747                                         *p++ = decimal_point_char ();
3748                                         while (ndigits > 0)
3749                                           {
3750                                             --ndigits;
3751                                             *p++ = digits[ndigits];
3752                                           }
3753                                       }
3754
3755                                     free (digits);
3756                                   }
3757
3758                                 *p++ = dp->conversion; /* 'e' or 'E' */
3759 #   if WIDE_CHAR_VERSION
3760                                 {
3761                                   static const wchar_t decimal_format[] =
3762                                     { '%', '+', '.', '2', 'd', '\0' };
3763                                   SNPRINTF (p, 6 + 1, decimal_format, exponent);
3764                                 }
3765                                 while (*p != '\0')
3766                                   p++;
3767 #   else
3768                                 if (sizeof (DCHAR_T) == 1)
3769                                   {
3770                                     sprintf ((char *) p, "%+.2d", exponent);
3771                                     while (*p != '\0')
3772                                       p++;
3773                                   }
3774                                 else
3775                                   {
3776                                     char expbuf[6 + 1];
3777                                     const char *ep;
3778                                     sprintf (expbuf, "%+.2d", exponent);
3779                                     for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3780                                       p++;
3781                                   }
3782 #   endif
3783                               }
3784                             else if (dp->conversion == 'g' || dp->conversion == 'G')
3785                               {
3786                                 if (precision == 0)
3787                                   precision = 1;
3788                                 /* precision >= 1.  */
3789
3790                                 if (arg == 0.0L)
3791                                   /* The exponent is 0, >= -4, < precision.
3792                                      Use fixed-point notation.  */
3793                                   {
3794                                     size_t ndigits = precision;
3795                                     /* Number of trailing zeroes that have to be
3796                                        dropped.  */
3797                                     size_t nzeroes =
3798                                       (flags & FLAG_ALT ? 0 : precision - 1);
3799
3800                                     --ndigits;
3801                                     *p++ = '0';
3802                                     if ((flags & FLAG_ALT) || ndigits > nzeroes)
3803                                       {
3804                                         *p++ = decimal_point_char ();
3805                                         while (ndigits > nzeroes)
3806                                           {
3807                                             --ndigits;
3808                                             *p++ = '0';
3809                                           }
3810                                       }
3811                                   }
3812                                 else
3813                                   {
3814                                     /* arg > 0.0L.  */
3815                                     int exponent;
3816                                     int adjusted;
3817                                     char *digits;
3818                                     size_t ndigits;
3819                                     size_t nzeroes;
3820
3821                                     exponent = floorlog10l (arg);
3822                                     adjusted = 0;
3823                                     for (;;)
3824                                       {
3825                                         digits =
3826                                           scale10_round_decimal_long_double (arg,
3827                                                                              (int)(precision - 1) - exponent);
3828                                         if (digits == NULL)
3829                                           {
3830                                             END_LONG_DOUBLE_ROUNDING ();
3831                                             goto out_of_memory;
3832                                           }
3833                                         ndigits = strlen (digits);
3834
3835                                         if (ndigits == precision)
3836                                           break;
3837                                         if (ndigits < precision - 1
3838                                             || ndigits > precision + 1)
3839                                           /* The exponent was not guessed
3840                                              precisely enough.  */
3841                                           abort ();
3842                                         if (adjusted)
3843                                           /* None of two values of exponent is
3844                                              the right one.  Prevent an endless
3845                                              loop.  */
3846                                           abort ();
3847                                         free (digits);
3848                                         if (ndigits < precision)
3849                                           exponent -= 1;
3850                                         else
3851                                           exponent += 1;
3852                                         adjusted = 1;
3853                                       }
3854                                     /* Here ndigits = precision.  */
3855                                     if (is_borderline (digits, precision - 1))
3856                                       {
3857                                         /* Maybe the exponent guess was too high
3858                                            and a smaller exponent can be reached
3859                                            by turning a 10...0 into 9...9x.  */
3860                                         char *digits2 =
3861                                           scale10_round_decimal_long_double (arg,
3862                                                                              (int)(precision - 1) - exponent + 1);
3863                                         if (digits2 == NULL)
3864                                           {
3865                                             free (digits);
3866                                             END_LONG_DOUBLE_ROUNDING ();
3867                                             goto out_of_memory;
3868                                           }
3869                                         if (strlen (digits2) == precision)
3870                                           {
3871                                             free (digits);
3872                                             digits = digits2;
3873                                             exponent -= 1;
3874                                           }
3875                                         else
3876                                           free (digits2);
3877                                       }
3878                                     /* Here ndigits = precision.  */
3879
3880                                     /* Determine the number of trailing zeroes
3881                                        that have to be dropped.  */
3882                                     nzeroes = 0;
3883                                     if ((flags & FLAG_ALT) == 0)
3884                                       while (nzeroes < ndigits
3885                                              && digits[nzeroes] == '0')
3886                                         nzeroes++;
3887
3888                                     /* The exponent is now determined.  */
3889                                     if (exponent >= -4
3890                                         && exponent < (long)precision)
3891                                       {
3892                                         /* Fixed-point notation:
3893                                            max(exponent,0)+1 digits, then the
3894                                            decimal point, then the remaining
3895                                            digits without trailing zeroes.  */
3896                                         if (exponent >= 0)
3897                                           {
3898                                             size_t count = exponent + 1;
3899                                             /* Note: count <= precision = ndigits.  */
3900                                             for (; count > 0; count--)
3901                                               *p++ = digits[--ndigits];
3902                                             if ((flags & FLAG_ALT) || ndigits > nzeroes)
3903                                               {
3904                                                 *p++ = decimal_point_char ();
3905                                                 while (ndigits > nzeroes)
3906                                                   {
3907                                                     --ndigits;
3908                                                     *p++ = digits[ndigits];
3909                                                   }
3910                                               }
3911                                           }
3912                                         else
3913                                           {
3914                                             size_t count = -exponent - 1;
3915                                             *p++ = '0';
3916                                             *p++ = decimal_point_char ();
3917                                             for (; count > 0; count--)
3918                                               *p++ = '0';
3919                                             while (ndigits > nzeroes)
3920                                               {
3921                                                 --ndigits;
3922                                                 *p++ = digits[ndigits];
3923                                               }
3924                                           }
3925                                       }
3926                                     else
3927                                       {
3928                                         /* Exponential notation.  */
3929                                         *p++ = digits[--ndigits];
3930                                         if ((flags & FLAG_ALT) || ndigits > nzeroes)
3931                                           {
3932                                             *p++ = decimal_point_char ();
3933                                             while (ndigits > nzeroes)
3934                                               {
3935                                                 --ndigits;
3936                                                 *p++ = digits[ndigits];
3937                                               }
3938                                           }
3939                                         *p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */
3940 #   if WIDE_CHAR_VERSION
3941                                         {
3942                                           static const wchar_t decimal_format[] =
3943                                             { '%', '+', '.', '2', 'd', '\0' };
3944                                           SNPRINTF (p, 6 + 1, decimal_format, exponent);
3945                                         }
3946                                         while (*p != '\0')
3947                                           p++;
3948 #   else
3949                                         if (sizeof (DCHAR_T) == 1)
3950                                           {
3951                                             sprintf ((char *) p, "%+.2d", exponent);
3952                                             while (*p != '\0')
3953                                               p++;
3954                                           }
3955                                         else
3956                                           {
3957                                             char expbuf[6 + 1];
3958                                             const char *ep;
3959                                             sprintf (expbuf, "%+.2d", exponent);
3960                                             for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3961                                               p++;
3962                                           }
3963 #   endif
3964                                       }
3965
3966                                     free (digits);
3967                                   }
3968                               }
3969                             else
3970                               abort ();
3971 #  else
3972                             /* arg is finite.  */
3973                             if (!(arg == 0.0L))
3974                               abort ();
3975
3976                             pad_ptr = p;
3977
3978                             if (dp->conversion == 'f' || dp->conversion == 'F')
3979                               {
3980                                 *p++ = '0';
3981                                 if ((flags & FLAG_ALT) || precision > 0)
3982                                   {
3983                                     *p++ = decimal_point_char ();
3984                                     for (; precision > 0; precision--)
3985                                       *p++ = '0';
3986                                   }
3987                               }
3988                             else if (dp->conversion == 'e' || dp->conversion == 'E')
3989                               {
3990                                 *p++ = '0';
3991                                 if ((flags & FLAG_ALT) || precision > 0)
3992                                   {
3993                                     *p++ = decimal_point_char ();
3994                                     for (; precision > 0; precision--)
3995                                       *p++ = '0';
3996                                   }
3997                                 *p++ = dp->conversion; /* 'e' or 'E' */
3998                                 *p++ = '+';
3999                                 *p++ = '0';
4000                                 *p++ = '0';
4001                               }
4002                             else if (dp->conversion == 'g' || dp->conversion == 'G')
4003                               {
4004                                 *p++ = '0';
4005                                 if (flags & FLAG_ALT)
4006                                   {
4007                                     size_t ndigits =
4008                                       (precision > 0 ? precision - 1 : 0);
4009                                     *p++ = decimal_point_char ();
4010                                     for (; ndigits > 0; --ndigits)
4011                                       *p++ = '0';
4012                                   }
4013                               }
4014                             else if (dp->conversion == 'a' || dp->conversion == 'A')
4015                               {
4016                                 *p++ = '0';
4017                                 *p++ = dp->conversion - 'A' + 'X';
4018                                 pad_ptr = p;
4019                                 *p++ = '0';
4020                                 if ((flags & FLAG_ALT) || precision > 0)
4021                                   {
4022                                     *p++ = decimal_point_char ();
4023                                     for (; precision > 0; precision--)
4024                                       *p++ = '0';
4025                                   }
4026                                 *p++ = dp->conversion - 'A' + 'P';
4027                                 *p++ = '+';
4028                                 *p++ = '0';
4029                               }
4030                             else
4031                               abort ();
4032 #  endif
4033                           }
4034
4035                         END_LONG_DOUBLE_ROUNDING ();
4036                       }
4037                   }
4038 #  if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
4039                 else
4040 #  endif
4041 # endif
4042 # if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
4043                   {
4044                     double arg = a.arg[dp->arg_index].a.a_double;
4045
4046                     if (isnand (arg))
4047                       {
4048                         if (dp->conversion >= 'A' && dp->conversion <= 'Z')
4049                           {
4050                             *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
4051                           }
4052                         else
4053                           {
4054                             *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
4055                           }
4056                       }
4057                     else
4058                       {
4059                         int sign = 0;
4060
4061                         if (signbit (arg)) /* arg < 0.0 or negative zero */
4062                           {
4063                             sign = -1;
4064                             arg = -arg;
4065                           }
4066
4067                         if (sign < 0)
4068                           *p++ = '-';
4069                         else if (flags & FLAG_SHOWSIGN)
4070                           *p++ = '+';
4071                         else if (flags & FLAG_SPACE)
4072                           *p++ = ' ';
4073
4074                         if (arg > 0.0 && arg + arg == arg)
4075                           {
4076                             if (dp->conversion >= 'A' && dp->conversion <= 'Z')
4077                               {
4078                                 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
4079                               }
4080                             else
4081                               {
4082                                 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
4083                               }
4084                           }
4085                         else
4086                           {
4087 #  if NEED_PRINTF_DOUBLE
4088                             pad_ptr = p;
4089
4090                             if (dp->conversion == 'f' || dp->conversion == 'F')
4091                               {
4092                                 char *digits;
4093                                 size_t ndigits;
4094
4095                                 digits =
4096                                   scale10_round_decimal_double (arg, precision);
4097                                 if (digits == NULL)
4098                                   goto out_of_memory;
4099                                 ndigits = strlen (digits);
4100
4101                                 if (ndigits > precision)
4102                                   do
4103                                     {
4104                                       --ndigits;
4105                                       *p++ = digits[ndigits];
4106                                     }
4107                                   while (ndigits > precision);
4108                                 else
4109                                   *p++ = '0';
4110                                 /* Here ndigits <= precision.  */
4111                                 if ((flags & FLAG_ALT) || precision > 0)
4112                                   {
4113                                     *p++ = decimal_point_char ();
4114                                     for (; precision > ndigits; precision--)
4115                                       *p++ = '0';
4116                                     while (ndigits > 0)
4117                                       {
4118                                         --ndigits;
4119                                         *p++ = digits[ndigits];
4120                                       }
4121                                   }
4122
4123                                 free (digits);
4124                               }
4125                             else if (dp->conversion == 'e' || dp->conversion == 'E')
4126                               {
4127                                 int exponent;
4128
4129                                 if (arg == 0.0)
4130                                   {
4131                                     exponent = 0;
4132                                     *p++ = '0';
4133                                     if ((flags & FLAG_ALT) || precision > 0)
4134                                       {
4135                                         *p++ = decimal_point_char ();
4136                                         for (; precision > 0; precision--)
4137                                           *p++ = '0';
4138                                       }
4139                                   }
4140                                 else
4141                                   {
4142                                     /* arg > 0.0.  */
4143                                     int adjusted;
4144                                     char *digits;
4145                                     size_t ndigits;
4146
4147                                     exponent = floorlog10 (arg);
4148                                     adjusted = 0;
4149                                     for (;;)
4150                                       {
4151                                         digits =
4152                                           scale10_round_decimal_double (arg,
4153                                                                         (int)precision - exponent);
4154                                         if (digits == NULL)
4155                                           goto out_of_memory;
4156                                         ndigits = strlen (digits);
4157
4158                                         if (ndigits == precision + 1)
4159                                           break;
4160                                         if (ndigits < precision
4161                                             || ndigits > precision + 2)
4162                                           /* The exponent was not guessed
4163                                              precisely enough.  */
4164                                           abort ();
4165                                         if (adjusted)
4166                                           /* None of two values of exponent is
4167                                              the right one.  Prevent an endless
4168                                              loop.  */
4169                                           abort ();
4170                                         free (digits);
4171                                         if (ndigits == precision)
4172                                           exponent -= 1;
4173                                         else
4174                                           exponent += 1;
4175                                         adjusted = 1;
4176                                       }
4177                                     /* Here ndigits = precision+1.  */
4178                                     if (is_borderline (digits, precision))
4179                                       {
4180                                         /* Maybe the exponent guess was too high
4181                                            and a smaller exponent can be reached
4182                                            by turning a 10...0 into 9...9x.  */
4183                                         char *digits2 =
4184                                           scale10_round_decimal_double (arg,
4185                                                                         (int)precision - exponent + 1);
4186                                         if (digits2 == NULL)
4187                                           {
4188                                             free (digits);
4189                                             goto out_of_memory;
4190                                           }
4191                                         if (strlen (digits2) == precision + 1)
4192                                           {
4193                                             free (digits);
4194                                             digits = digits2;
4195                                             exponent -= 1;
4196                                           }
4197                                         else
4198                                           free (digits2);
4199                                       }
4200                                     /* Here ndigits = precision+1.  */
4201
4202                                     *p++ = digits[--ndigits];
4203                                     if ((flags & FLAG_ALT) || precision > 0)
4204                                       {
4205                                         *p++ = decimal_point_char ();
4206                                         while (ndigits > 0)
4207                                           {
4208                                             --ndigits;
4209                                             *p++ = digits[ndigits];
4210                                           }
4211                                       }
4212
4213                                     free (digits);
4214                                   }
4215
4216                                 *p++ = dp->conversion; /* 'e' or 'E' */
4217 #   if WIDE_CHAR_VERSION
4218                                 {
4219                                   static const wchar_t decimal_format[] =
4220                                     /* Produce the same number of exponent digits
4221                                        as the native printf implementation.  */
4222 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4223                                     { '%', '+', '.', '3', 'd', '\0' };
4224 #    else
4225                                     { '%', '+', '.', '2', 'd', '\0' };
4226 #    endif
4227                                   SNPRINTF (p, 6 + 1, decimal_format, exponent);
4228                                 }
4229                                 while (*p != '\0')
4230                                   p++;
4231 #   else
4232                                 {
4233                                   static const char decimal_format[] =
4234                                     /* Produce the same number of exponent digits
4235                                        as the native printf implementation.  */
4236 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4237                                     "%+.3d";
4238 #    else
4239                                     "%+.2d";
4240 #    endif
4241                                   if (sizeof (DCHAR_T) == 1)
4242                                     {
4243                                       sprintf ((char *) p, decimal_format, exponent);
4244                                       while (*p != '\0')
4245                                         p++;
4246                                     }
4247                                   else
4248                                     {
4249                                       char expbuf[6 + 1];
4250                                       const char *ep;
4251                                       sprintf (expbuf, decimal_format, exponent);
4252                                       for (ep = expbuf; (*p = *ep) != '\0'; ep++)
4253                                         p++;
4254                                     }
4255                                 }
4256 #   endif
4257                               }
4258                             else if (dp->conversion == 'g' || dp->conversion == 'G')
4259                               {
4260                                 if (precision == 0)
4261                                   precision = 1;
4262                                 /* precision >= 1.  */
4263
4264                                 if (arg == 0.0)
4265                                   /* The exponent is 0, >= -4, < precision.
4266                                      Use fixed-point notation.  */
4267                                   {
4268                                     size_t ndigits = precision;
4269                                     /* Number of trailing zeroes that have to be
4270                                        dropped.  */
4271                                     size_t nzeroes =
4272                                       (flags & FLAG_ALT ? 0 : precision - 1);
4273
4274                                     --ndigits;
4275                                     *p++ = '0';
4276                                     if ((flags & FLAG_ALT) || ndigits > nzeroes)
4277                                       {
4278                                         *p++ = decimal_point_char ();
4279                                         while (ndigits > nzeroes)
4280                                           {
4281                                             --ndigits;
4282                                             *p++ = '0';
4283                                           }
4284                                       }
4285                                   }
4286                                 else
4287                                   {
4288                                     /* arg > 0.0.  */
4289                                     int exponent;
4290                                     int adjusted;
4291                                     char *digits;
4292                                     size_t ndigits;
4293                                     size_t nzeroes;
4294
4295                                     exponent = floorlog10 (arg);
4296                                     adjusted = 0;
4297                                     for (;;)
4298                                       {
4299                                         digits =
4300                                           scale10_round_decimal_double (arg,
4301                                                                         (int)(precision - 1) - exponent);
4302                                         if (digits == NULL)
4303                                           goto out_of_memory;
4304                                         ndigits = strlen (digits);
4305
4306                                         if (ndigits == precision)
4307                                           break;
4308                                         if (ndigits < precision - 1
4309                                             || ndigits > precision + 1)
4310                                           /* The exponent was not guessed
4311                                              precisely enough.  */
4312                                           abort ();
4313                                         if (adjusted)
4314                                           /* None of two values of exponent is
4315                                              the right one.  Prevent an endless
4316                                              loop.  */
4317                                           abort ();
4318                                         free (digits);
4319                                         if (ndigits < precision)
4320                                           exponent -= 1;
4321                                         else
4322                                           exponent += 1;
4323                                         adjusted = 1;
4324                                       }
4325                                     /* Here ndigits = precision.  */
4326                                     if (is_borderline (digits, precision - 1))
4327                                       {
4328                                         /* Maybe the exponent guess was too high
4329                                            and a smaller exponent can be reached
4330                                            by turning a 10...0 into 9...9x.  */
4331                                         char *digits2 =
4332                                           scale10_round_decimal_double (arg,
4333                                                                         (int)(precision - 1) - exponent + 1);
4334                                         if (digits2 == NULL)
4335                                           {
4336                                             free (digits);
4337                                             goto out_of_memory;
4338                                           }
4339                                         if (strlen (digits2) == precision)
4340                                           {
4341                                             free (digits);
4342                                             digits = digits2;
4343                                             exponent -= 1;
4344                                           }
4345                                         else
4346                                           free (digits2);
4347                                       }
4348                                     /* Here ndigits = precision.  */
4349
4350                                     /* Determine the number of trailing zeroes
4351                                        that have to be dropped.  */
4352                                     nzeroes = 0;
4353                                     if ((flags & FLAG_ALT) == 0)
4354                                       while (nzeroes < ndigits
4355                                              && digits[nzeroes] == '0')
4356                                         nzeroes++;
4357
4358                                     /* The exponent is now determined.  */
4359                                     if (exponent >= -4
4360                                         && exponent < (long)precision)
4361                                       {
4362                                         /* Fixed-point notation:
4363                                            max(exponent,0)+1 digits, then the
4364                                            decimal point, then the remaining
4365                                            digits without trailing zeroes.  */
4366                                         if (exponent >= 0)
4367                                           {
4368                                             size_t count = exponent + 1;
4369                                             /* Note: count <= precision = ndigits.  */
4370                                             for (; count > 0; count--)
4371                                               *p++ = digits[--ndigits];
4372                                             if ((flags & FLAG_ALT) || ndigits > nzeroes)
4373                                               {
4374                                                 *p++ = decimal_point_char ();
4375                                                 while (ndigits > nzeroes)
4376                                                   {
4377                                                     --ndigits;
4378                                                     *p++ = digits[ndigits];
4379                                                   }
4380                                               }
4381                                           }
4382                                         else
4383                                           {
4384                                             size_t count = -exponent - 1;
4385                                             *p++ = '0';
4386                                             *p++ = decimal_point_char ();
4387                                             for (; count > 0; count--)
4388                                               *p++ = '0';
4389                                             while (ndigits > nzeroes)
4390                                               {
4391                                                 --ndigits;
4392                                                 *p++ = digits[ndigits];
4393                                               }
4394                                           }
4395                                       }
4396                                     else
4397                                       {
4398                                         /* Exponential notation.  */
4399                                         *p++ = digits[--ndigits];
4400                                         if ((flags & FLAG_ALT) || ndigits > nzeroes)
4401                                           {
4402                                             *p++ = decimal_point_char ();
4403                                             while (ndigits > nzeroes)
4404                                               {
4405                                                 --ndigits;
4406                                                 *p++ = digits[ndigits];
4407                                               }
4408                                           }
4409                                         *p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */
4410 #   if WIDE_CHAR_VERSION
4411                                         {
4412                                           static const wchar_t decimal_format[] =
4413                                             /* Produce the same number of exponent digits
4414                                                as the native printf implementation.  */
4415 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4416                                             { '%', '+', '.', '3', 'd', '\0' };
4417 #    else
4418                                             { '%', '+', '.', '2', 'd', '\0' };
4419 #    endif
4420                                           SNPRINTF (p, 6 + 1, decimal_format, exponent);
4421                                         }
4422                                         while (*p != '\0')
4423                                           p++;
4424 #   else
4425                                         {
4426                                           static const char decimal_format[] =
4427                                             /* Produce the same number of exponent digits
4428                                                as the native printf implementation.  */
4429 #    if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4430                                             "%+.3d";
4431 #    else
4432                                             "%+.2d";
4433 #    endif
4434                                           if (sizeof (DCHAR_T) == 1)
4435                                             {
4436                                               sprintf ((char *) p, decimal_format, exponent);
4437                                               while (*p != '\0')
4438                                                 p++;
4439                                             }
4440                                           else
4441                                             {
4442                                               char expbuf[6 + 1];
4443                                               const char *ep;
4444                                               sprintf (expbuf, decimal_format, exponent);
4445                                               for (ep = expbuf; (*p = *ep) != '\0'; ep++)
4446                                                 p++;
4447                                             }
4448                                         }
4449 #   endif
4450                                       }
4451
4452                                     free (digits);
4453                                   }
4454                               }
4455                             else
4456                               abort ();
4457 #  else
4458                             /* arg is finite.  */
4459                             if (!(arg == 0.0))
4460                               abort ();
4461
4462                             pad_ptr = p;
4463
4464                             if (dp->conversion == 'f' || dp->conversion == 'F')
4465                               {
4466                                 *p++ = '0';
4467                                 if ((flags & FLAG_ALT) || precision > 0)
4468                                   {
4469                                     *p++ = decimal_point_char ();
4470                                     for (; precision > 0; precision--)
4471                                       *p++ = '0';
4472                                   }
4473                               }
4474                             else if (dp->conversion == 'e' || dp->conversion == 'E')
4475                               {
4476                                 *p++ = '0';
4477                                 if ((flags & FLAG_ALT) || precision > 0)
4478                                   {
4479                                     *p++ = decimal_point_char ();
4480                                     for (; precision > 0; precision--)
4481                                       *p++ = '0';
4482                                   }
4483                                 *p++ = dp->conversion; /* 'e' or 'E' */
4484                                 *p++ = '+';
4485                                 /* Produce the same number of exponent digits as
4486                                    the native printf implementation.  */
4487 #   if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4488                                 *p++ = '0';
4489 #   endif
4490                                 *p++ = '0';
4491                                 *p++ = '0';
4492                               }
4493                             else if (dp->conversion == 'g' || dp->conversion == 'G')
4494                               {
4495                                 *p++ = '0';
4496                                 if (flags & FLAG_ALT)
4497                                   {
4498                                     size_t ndigits =
4499                                       (precision > 0 ? precision - 1 : 0);
4500                                     *p++ = decimal_point_char ();
4501                                     for (; ndigits > 0; --ndigits)
4502                                       *p++ = '0';
4503                                   }
4504                               }
4505                             else
4506                               abort ();
4507 #  endif
4508                           }
4509                       }
4510                   }
4511 # endif
4512
4513                 /* The generated string now extends from tmp to p, with the
4514                    zero padding insertion point being at pad_ptr.  */
4515                 if (has_width && p - tmp < width)
4516                   {
4517                     size_t pad = width - (p - tmp);
4518                     DCHAR_T *end = p + pad;
4519
4520                     if (flags & FLAG_LEFT)
4521                       {
4522                         /* Pad with spaces on the right.  */
4523                         for (; pad > 0; pad--)
4524                           *p++ = ' ';
4525                       }
4526                     else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
4527                       {
4528                         /* Pad with zeroes.  */
4529                         DCHAR_T *q = end;
4530
4531                         while (p > pad_ptr)
4532                           *--q = *--p;
4533                         for (; pad > 0; pad--)
4534                           *p++ = '0';
4535                       }
4536                     else
4537                       {
4538                         /* Pad with spaces on the left.  */
4539                         DCHAR_T *q = end;
4540
4541                         while (p > tmp)
4542                           *--q = *--p;
4543                         for (; pad > 0; pad--)
4544                           *p++ = ' ';
4545                       }
4546
4547                     p = end;
4548                   }
4549
4550                 {
4551                   size_t count = p - tmp;
4552
4553                   if (count >= tmp_length)
4554                     /* tmp_length was incorrectly calculated - fix the
4555                        code above!  */
4556                     abort ();
4557
4558                   /* Make room for the result.  */
4559                   if (count >= allocated - length)
4560                     {
4561                       size_t n = xsum (length, count);
4562
4563                       ENSURE_ALLOCATION (n);
4564                     }
4565
4566                   /* Append the result.  */
4567                   memcpy (result + length, tmp, count * sizeof (DCHAR_T));
4568                   if (tmp != tmpbuf)
4569                     free (tmp);
4570                   length += count;
4571                 }
4572               }
4573 #endif
4574             else
4575               {
4576                 arg_type type = a.arg[dp->arg_index].type;
4577                 int flags = dp->flags;
4578 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
4579                 int has_width;
4580                 size_t width;
4581 #endif
4582 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || NEED_PRINTF_UNBOUNDED_PRECISION
4583                 int has_precision;
4584                 size_t precision;
4585 #endif
4586 #if NEED_PRINTF_UNBOUNDED_PRECISION
4587                 int prec_ourselves;
4588 #else
4589 #               define prec_ourselves 0
4590 #endif
4591 #if NEED_PRINTF_FLAG_LEFTADJUST
4592 #               define pad_ourselves 1
4593 #elif !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
4594                 int pad_ourselves;
4595 #else
4596 #               define pad_ourselves 0
4597 #endif
4598                 TCHAR_T *fbp;
4599                 unsigned int prefix_count;
4600                 int prefixes[2] IF_LINT (= { 0 });
4601 #if !USE_SNPRINTF
4602                 size_t tmp_length;
4603                 TCHAR_T tmpbuf[700];
4604                 TCHAR_T *tmp;
4605 #endif
4606
4607 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
4608                 has_width = 0;
4609                 width = 0;
4610                 if (dp->width_start != dp->width_end)
4611                   {
4612                     if (dp->width_arg_index != ARG_NONE)
4613                       {
4614                         int arg;
4615
4616                         if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
4617                           abort ();
4618                         arg = a.arg[dp->width_arg_index].a.a_int;
4619                         if (arg < 0)
4620                           {
4621                             /* "A negative field width is taken as a '-' flag
4622                                 followed by a positive field width."  */
4623                             flags |= FLAG_LEFT;
4624                             width = (unsigned int) (-arg);
4625                           }
4626                         else
4627                           width = arg;
4628                       }
4629                     else
4630                       {
4631                         const FCHAR_T *digitp = dp->width_start;
4632
4633                         do
4634                           width = xsum (xtimes (width, 10), *digitp++ - '0');
4635                         while (digitp != dp->width_end);
4636                       }
4637                     has_width = 1;
4638                   }
4639 #endif
4640
4641 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || NEED_PRINTF_UNBOUNDED_PRECISION
4642                 has_precision = 0;
4643                 precision = 6;
4644                 if (dp->precision_start != dp->precision_end)
4645                   {
4646                     if (dp->precision_arg_index != ARG_NONE)
4647                       {
4648                         int arg;
4649
4650                         if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
4651                           abort ();
4652                         arg = a.arg[dp->precision_arg_index].a.a_int;
4653                         /* "A negative precision is taken as if the precision
4654                             were omitted."  */
4655                         if (arg >= 0)
4656                           {
4657                             precision = arg;
4658                             has_precision = 1;
4659                           }
4660                       }
4661                     else
4662                       {
4663                         const FCHAR_T *digitp = dp->precision_start + 1;
4664
4665                         precision = 0;
4666                         while (digitp != dp->precision_end)
4667                           precision = xsum (xtimes (precision, 10), *digitp++ - '0');
4668                         has_precision = 1;
4669                       }
4670                   }
4671 #endif
4672
4673                 /* Decide whether to handle the precision ourselves.  */
4674 #if NEED_PRINTF_UNBOUNDED_PRECISION
4675                 switch (dp->conversion)
4676                   {
4677                   case 'd': case 'i': case 'u':
4678                   case 'o':
4679                   case 'x': case 'X': case 'p':
4680                     prec_ourselves = has_precision && (precision > 0);
4681                     break;
4682                   default:
4683                     prec_ourselves = 0;
4684                     break;
4685                   }
4686 #endif
4687
4688                 /* Decide whether to perform the padding ourselves.  */
4689 #if !NEED_PRINTF_FLAG_LEFTADJUST && (!DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION)
4690                 switch (dp->conversion)
4691                   {
4692 # if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO
4693                   /* If we need conversion from TCHAR_T[] to DCHAR_T[], we need
4694                      to perform the padding after this conversion.  Functions
4695                      with unistdio extensions perform the padding based on
4696                      character count rather than element count.  */
4697                   case 'c': case 's':
4698 # endif
4699 # if NEED_PRINTF_FLAG_ZERO
4700                   case 'f': case 'F': case 'e': case 'E': case 'g': case 'G':
4701                   case 'a': case 'A':
4702 # endif
4703                     pad_ourselves = 1;
4704                     break;
4705                   default:
4706                     pad_ourselves = prec_ourselves;
4707                     break;
4708                   }
4709 #endif
4710
4711 #if !USE_SNPRINTF
4712                 /* Allocate a temporary buffer of sufficient size for calling
4713                    sprintf.  */
4714                 tmp_length =
4715                   MAX_ROOM_NEEDED (&a, dp->arg_index, dp->conversion, type,
4716                                    flags, width, has_precision, precision,
4717                                    pad_ourselves);
4718
4719                 if (tmp_length <= sizeof (tmpbuf) / sizeof (TCHAR_T))
4720                   tmp = tmpbuf;
4721                 else
4722                   {
4723                     size_t tmp_memsize = xtimes (tmp_length, sizeof (TCHAR_T));
4724
4725                     if (size_overflow_p (tmp_memsize))
4726                       /* Overflow, would lead to out of memory.  */
4727                       goto out_of_memory;
4728                     tmp = (TCHAR_T *) malloc (tmp_memsize);
4729                     if (tmp == NULL)
4730                       /* Out of memory.  */
4731                       goto out_of_memory;
4732                   }
4733 #endif
4734
4735                 /* Construct the format string for calling snprintf or
4736                    sprintf.  */
4737                 fbp = buf;
4738                 *fbp++ = '%';
4739 #if NEED_PRINTF_FLAG_GROUPING
4740                 /* The underlying implementation doesn't support the ' flag.
4741                    Produce no grouping characters in this case; this is
4742                    acceptable because the grouping is locale dependent.  */
4743 #else
4744                 if (flags & FLAG_GROUP)
4745                   *fbp++ = '\'';
4746 #endif
4747                 if (flags & FLAG_LEFT)
4748                   *fbp++ = '-';
4749                 if (flags & FLAG_SHOWSIGN)
4750                   *fbp++ = '+';
4751                 if (flags & FLAG_SPACE)
4752                   *fbp++ = ' ';
4753                 if (flags & FLAG_ALT)
4754                   *fbp++ = '#';
4755                 if (!pad_ourselves)
4756                   {
4757                     if (flags & FLAG_ZERO)
4758                       *fbp++ = '0';
4759                     if (dp->width_start != dp->width_end)
4760                       {
4761                         size_t n = dp->width_end - dp->width_start;
4762                         /* The width specification is known to consist only
4763                            of standard ASCII characters.  */
4764                         if (sizeof (FCHAR_T) == sizeof (TCHAR_T))
4765                           {
4766                             memcpy (fbp, dp->width_start, n * sizeof (TCHAR_T));
4767                             fbp += n;
4768                           }
4769                         else
4770                           {
4771                             const FCHAR_T *mp = dp->width_start;
4772                             do
4773                               *fbp++ = (unsigned char) *mp++;
4774                             while (--n > 0);
4775                           }
4776                       }
4777                   }
4778                 if (!prec_ourselves)
4779                   {
4780                     if (dp->precision_start != dp->precision_end)
4781                       {
4782                         size_t n = dp->precision_end - dp->precision_start;
4783                         /* The precision specification is known to consist only
4784                            of standard ASCII characters.  */
4785                         if (sizeof (FCHAR_T) == sizeof (TCHAR_T))
4786                           {
4787                             memcpy (fbp, dp->precision_start, n * sizeof (TCHAR_T));
4788                             fbp += n;
4789                           }
4790                         else
4791                           {
4792                             const FCHAR_T *mp = dp->precision_start;
4793                             do
4794                               *fbp++ = (unsigned char) *mp++;
4795                             while (--n > 0);
4796                           }
4797                       }
4798                   }
4799
4800                 switch (type)
4801                   {
4802 #if HAVE_LONG_LONG_INT
4803                   case TYPE_LONGLONGINT:
4804                   case TYPE_ULONGLONGINT:
4805 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4806                     *fbp++ = 'I';
4807                     *fbp++ = '6';
4808                     *fbp++ = '4';
4809                     break;
4810 # else
4811                     *fbp++ = 'l';
4812                     /*FALLTHROUGH*/
4813 # endif
4814 #endif
4815                   case TYPE_LONGINT:
4816                   case TYPE_ULONGINT:
4817 #if HAVE_WINT_T
4818                   case TYPE_WIDE_CHAR:
4819 #endif
4820 #if HAVE_WCHAR_T
4821                   case TYPE_WIDE_STRING:
4822 #endif
4823                     *fbp++ = 'l';
4824                     break;
4825                   case TYPE_LONGDOUBLE:
4826                     *fbp++ = 'L';
4827                     break;
4828                   default:
4829                     break;
4830                   }
4831 #if NEED_PRINTF_DIRECTIVE_F
4832                 if (dp->conversion == 'F')
4833                   *fbp = 'f';
4834                 else
4835 #endif
4836                   *fbp = dp->conversion;
4837 #if USE_SNPRINTF
4838 # if !(__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || ((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__))
4839                 fbp[1] = '%';
4840                 fbp[2] = 'n';
4841                 fbp[3] = '\0';
4842 # else
4843                 /* On glibc2 systems from glibc >= 2.3 - probably also older
4844                    ones - we know that snprintf's returns value conforms to
4845                    ISO C 99: the gl_SNPRINTF_DIRECTIVE_N test passes.
4846                    Therefore we can avoid using %n in this situation.
4847                    On glibc2 systems from 2004-10-18 or newer, the use of %n
4848                    in format strings in writable memory may crash the program
4849                    (if compiled with _FORTIFY_SOURCE=2), so we should avoid it
4850                    in this situation.  */
4851                 /* On native Win32 systems (such as mingw), we can avoid using
4852                    %n because:
4853                      - Although the gl_SNPRINTF_TRUNCATION_C99 test fails,
4854                        snprintf does not write more than the specified number
4855                        of bytes. (snprintf (buf, 3, "%d %d", 4567, 89) writes
4856                        '4', '5', '6' into buf, not '4', '5', '\0'.)
4857                      - Although the gl_SNPRINTF_RETVAL_C99 test fails, snprintf
4858                        allows us to recognize the case of an insufficient
4859                        buffer size: it returns -1 in this case.
4860                    On native Win32 systems (such as mingw) where the OS is
4861                    Windows Vista, the use of %n in format strings by default
4862                    crashes the program. See
4863                      <http://gcc.gnu.org/ml/gcc/2007-06/msg00122.html> and
4864                      <http://msdn2.microsoft.com/en-us/library/ms175782(VS.80).aspx>
4865                    So we should avoid %n in this situation.  */
4866                 fbp[1] = '\0';
4867 # endif
4868 #else
4869                 fbp[1] = '\0';
4870 #endif
4871
4872                 /* Construct the arguments for calling snprintf or sprintf.  */
4873                 prefix_count = 0;
4874                 if (!pad_ourselves && dp->width_arg_index != ARG_NONE)
4875                   {
4876                     if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
4877                       abort ();
4878                     prefixes[prefix_count++] = a.arg[dp->width_arg_index].a.a_int;
4879                   }
4880                 if (!prec_ourselves && dp->precision_arg_index != ARG_NONE)
4881                   {
4882                     if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
4883                       abort ();
4884                     prefixes[prefix_count++] = a.arg[dp->precision_arg_index].a.a_int;
4885                   }
4886
4887 #if USE_SNPRINTF
4888                 /* The SNPRINTF result is appended after result[0..length].
4889                    The latter is an array of DCHAR_T; SNPRINTF appends an
4890                    array of TCHAR_T to it.  This is possible because
4891                    sizeof (TCHAR_T) divides sizeof (DCHAR_T) and
4892                    alignof (TCHAR_T) <= alignof (DCHAR_T).  */
4893 # define TCHARS_PER_DCHAR (sizeof (DCHAR_T) / sizeof (TCHAR_T))
4894                 /* Ensure that maxlen below will be >= 2.  Needed on BeOS,
4895                    where an snprintf() with maxlen==1 acts like sprintf().  */
4896                 ENSURE_ALLOCATION (xsum (length,
4897                                          (2 + TCHARS_PER_DCHAR - 1)
4898                                          / TCHARS_PER_DCHAR));
4899                 /* Prepare checking whether snprintf returns the count
4900                    via %n.  */
4901                 *(TCHAR_T *) (result + length) = '\0';
4902 #endif
4903
4904                 for (;;)
4905                   {
4906                     int count = -1;
4907
4908 #if USE_SNPRINTF
4909                     int retcount = 0;
4910                     size_t maxlen = allocated - length;
4911                     /* SNPRINTF can fail if its second argument is
4912                        > INT_MAX.  */
4913                     if (maxlen > INT_MAX / TCHARS_PER_DCHAR)
4914                       maxlen = INT_MAX / TCHARS_PER_DCHAR;
4915                     maxlen = maxlen * TCHARS_PER_DCHAR;
4916 # define SNPRINTF_BUF(arg) \
4917                     switch (prefix_count)                                   \
4918                       {                                                     \
4919                       case 0:                                               \
4920                         retcount = SNPRINTF ((TCHAR_T *) (result + length), \
4921                                              maxlen, buf,                   \
4922                                              arg, &count);                  \
4923                         break;                                              \
4924                       case 1:                                               \
4925                         retcount = SNPRINTF ((TCHAR_T *) (result + length), \
4926                                              maxlen, buf,                   \
4927                                              prefixes[0], arg, &count);     \
4928                         break;                                              \
4929                       case 2:                                               \
4930                         retcount = SNPRINTF ((TCHAR_T *) (result + length), \
4931                                              maxlen, buf,                   \
4932                                              prefixes[0], prefixes[1], arg, \
4933                                              &count);                       \
4934                         break;                                              \
4935                       default:                                              \
4936                         abort ();                                           \
4937                       }
4938 #else
4939 # define SNPRINTF_BUF(arg) \
4940                     switch (prefix_count)                                   \
4941                       {                                                     \
4942                       case 0:                                               \
4943                         count = sprintf (tmp, buf, arg);                    \
4944                         break;                                              \
4945                       case 1:                                               \
4946                         count = sprintf (tmp, buf, prefixes[0], arg);       \
4947                         break;                                              \
4948                       case 2:                                               \
4949                         count = sprintf (tmp, buf, prefixes[0], prefixes[1],\
4950                                          arg);                              \
4951                         break;                                              \
4952                       default:                                              \
4953                         abort ();                                           \
4954                       }
4955 #endif
4956
4957                     errno = 0;
4958                     switch (type)
4959                       {
4960                       case TYPE_SCHAR:
4961                         {
4962                           int arg = a.arg[dp->arg_index].a.a_schar;
4963                           SNPRINTF_BUF (arg);
4964                         }
4965                         break;
4966                       case TYPE_UCHAR:
4967                         {
4968                           unsigned int arg = a.arg[dp->arg_index].a.a_uchar;
4969                           SNPRINTF_BUF (arg);
4970                         }
4971                         break;
4972                       case TYPE_SHORT:
4973                         {
4974                           int arg = a.arg[dp->arg_index].a.a_short;
4975                           SNPRINTF_BUF (arg);
4976                         }
4977                         break;
4978                       case TYPE_USHORT:
4979                         {
4980                           unsigned int arg = a.arg[dp->arg_index].a.a_ushort;
4981                           SNPRINTF_BUF (arg);
4982                         }
4983                         break;
4984                       case TYPE_INT:
4985                         {
4986                           int arg = a.arg[dp->arg_index].a.a_int;
4987                           SNPRINTF_BUF (arg);
4988                         }
4989                         break;
4990                       case TYPE_UINT:
4991                         {
4992                           unsigned int arg = a.arg[dp->arg_index].a.a_uint;
4993                           SNPRINTF_BUF (arg);
4994                         }
4995                         break;
4996                       case TYPE_LONGINT:
4997                         {
4998                           long int arg = a.arg[dp->arg_index].a.a_longint;
4999                           SNPRINTF_BUF (arg);
5000                         }
5001                         break;
5002                       case TYPE_ULONGINT:
5003                         {
5004                           unsigned long int arg = a.arg[dp->arg_index].a.a_ulongint;
5005                           SNPRINTF_BUF (arg);
5006                         }
5007                         break;
5008 #if HAVE_LONG_LONG_INT
5009                       case TYPE_LONGLONGINT:
5010                         {
5011                           long long int arg = a.arg[dp->arg_index].a.a_longlongint;
5012                           SNPRINTF_BUF (arg);
5013                         }
5014                         break;
5015                       case TYPE_ULONGLONGINT:
5016                         {
5017                           unsigned long long int arg = a.arg[dp->arg_index].a.a_ulonglongint;
5018                           SNPRINTF_BUF (arg);
5019                         }
5020                         break;
5021 #endif
5022                       case TYPE_DOUBLE:
5023                         {
5024                           double arg = a.arg[dp->arg_index].a.a_double;
5025                           SNPRINTF_BUF (arg);
5026                         }
5027                         break;
5028                       case TYPE_LONGDOUBLE:
5029                         {
5030                           long double arg = a.arg[dp->arg_index].a.a_longdouble;
5031                           SNPRINTF_BUF (arg);
5032                         }
5033                         break;
5034                       case TYPE_CHAR:
5035                         {
5036                           int arg = a.arg[dp->arg_index].a.a_char;
5037                           SNPRINTF_BUF (arg);
5038                         }
5039                         break;
5040 #if HAVE_WINT_T
5041                       case TYPE_WIDE_CHAR:
5042                         {
5043                           wint_t arg = a.arg[dp->arg_index].a.a_wide_char;
5044                           SNPRINTF_BUF (arg);
5045                         }
5046                         break;
5047 #endif
5048                       case TYPE_STRING:
5049                         {
5050                           const char *arg = a.arg[dp->arg_index].a.a_string;
5051                           SNPRINTF_BUF (arg);
5052                         }
5053                         break;
5054 #if HAVE_WCHAR_T
5055                       case TYPE_WIDE_STRING:
5056                         {
5057                           const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string;
5058                           SNPRINTF_BUF (arg);
5059                         }
5060                         break;
5061 #endif
5062                       case TYPE_POINTER:
5063                         {
5064                           void *arg = a.arg[dp->arg_index].a.a_pointer;
5065                           SNPRINTF_BUF (arg);
5066                         }
5067                         break;
5068                       default:
5069                         abort ();
5070                       }
5071
5072 #if USE_SNPRINTF
5073                     /* Portability: Not all implementations of snprintf()
5074                        are ISO C 99 compliant.  Determine the number of
5075                        bytes that snprintf() has produced or would have
5076                        produced.  */
5077                     if (count >= 0)
5078                       {
5079                         /* Verify that snprintf() has NUL-terminated its
5080                            result.  */
5081                         if (count < maxlen
5082                             && ((TCHAR_T *) (result + length)) [count] != '\0')
5083                           abort ();
5084                         /* Portability hack.  */
5085                         if (retcount > count)
5086                           count = retcount;
5087                       }
5088                     else
5089                       {
5090                         /* snprintf() doesn't understand the '%n'
5091                            directive.  */
5092                         if (fbp[1] != '\0')
5093                           {
5094                             /* Don't use the '%n' directive; instead, look
5095                                at the snprintf() return value.  */
5096                             fbp[1] = '\0';
5097                             continue;
5098                           }
5099                         else
5100                           {
5101                             /* Look at the snprintf() return value.  */
5102                             if (retcount < 0)
5103                               {
5104 # if !HAVE_SNPRINTF_RETVAL_C99
5105                                 /* HP-UX 10.20 snprintf() is doubly deficient:
5106                                    It doesn't understand the '%n' directive,
5107                                    *and* it returns -1 (rather than the length
5108                                    that would have been required) when the
5109                                    buffer is too small.
5110                                    But a failure at this point can also come
5111                                    from other reasons than a too small buffer,
5112                                    such as an invalid wide string argument to
5113                                    the %ls directive, or possibly an invalid
5114                                    floating-point argument.  */
5115                                 size_t tmp_length =
5116                                   MAX_ROOM_NEEDED (&a, dp->arg_index,
5117                                                    dp->conversion, type, flags,
5118                                                    width, has_precision,
5119                                                    precision, pad_ourselves);
5120
5121                                 if (maxlen < tmp_length)
5122                                   {
5123                                     /* Make more room.  But try to do through
5124                                        this reallocation only once.  */
5125                                     size_t bigger_need =
5126                                       xsum (length,
5127                                             xsum (tmp_length,
5128                                                   TCHARS_PER_DCHAR - 1)
5129                                             / TCHARS_PER_DCHAR);
5130                                     /* And always grow proportionally.
5131                                        (There may be several arguments, each
5132                                        needing a little more room than the
5133                                        previous one.)  */
5134                                     size_t bigger_need2 =
5135                                       xsum (xtimes (allocated, 2), 12);
5136                                     if (bigger_need < bigger_need2)
5137                                       bigger_need = bigger_need2;
5138                                     ENSURE_ALLOCATION (bigger_need);
5139                                     continue;
5140                                   }
5141 # endif
5142                               }
5143                             else
5144                               count = retcount;
5145                           }
5146                       }
5147 #endif
5148
5149                     /* Attempt to handle failure.  */
5150                     if (count < 0)
5151                       {
5152                         /* SNPRINTF or sprintf failed.  Save and use the errno
5153                            that it has set, if any.  */
5154                         int saved_errno = errno;
5155
5156                         if (!(result == resultbuf || result == NULL))
5157                           free (result);
5158                         if (buf_malloced != NULL)
5159                           free (buf_malloced);
5160                         CLEANUP ();
5161                         errno =
5162                           (saved_errno != 0
5163                            ? saved_errno
5164                            : (dp->conversion == 'c' || dp->conversion == 's'
5165                               ? EILSEQ
5166                               : EINVAL));
5167                         return NULL;
5168                       }
5169
5170 #if USE_SNPRINTF
5171                     /* Handle overflow of the allocated buffer.
5172                        If such an overflow occurs, a C99 compliant snprintf()
5173                        returns a count >= maxlen.  However, a non-compliant
5174                        snprintf() function returns only count = maxlen - 1.  To
5175                        cover both cases, test whether count >= maxlen - 1.  */
5176                     if ((unsigned int) count + 1 >= maxlen)
5177                       {
5178                         /* If maxlen already has attained its allowed maximum,
5179                            allocating more memory will not increase maxlen.
5180                            Instead of looping, bail out.  */
5181                         if (maxlen == INT_MAX / TCHARS_PER_DCHAR)
5182                           goto overflow;
5183                         else
5184                           {
5185                             /* Need at least (count + 1) * sizeof (TCHAR_T)
5186                                bytes.  (The +1 is for the trailing NUL.)
5187                                But ask for (count + 2) * sizeof (TCHAR_T)
5188                                bytes, so that in the next round, we likely get
5189                                  maxlen > (unsigned int) count + 1
5190                                and so we don't get here again.
5191                                And allocate proportionally, to avoid looping
5192                                eternally if snprintf() reports a too small
5193                                count.  */
5194                             size_t n =
5195                               xmax (xsum (length,
5196                                           ((unsigned int) count + 2
5197                                            + TCHARS_PER_DCHAR - 1)
5198                                           / TCHARS_PER_DCHAR),
5199                                     xtimes (allocated, 2));
5200
5201                             ENSURE_ALLOCATION (n);
5202                             continue;
5203                           }
5204                       }
5205 #endif
5206
5207 #if NEED_PRINTF_UNBOUNDED_PRECISION
5208                     if (prec_ourselves)
5209                       {
5210                         /* Handle the precision.  */
5211                         TCHAR_T *prec_ptr =
5212 # if USE_SNPRINTF
5213                           (TCHAR_T *) (result + length);
5214 # else
5215                           tmp;
5216 # endif
5217                         size_t prefix_count;
5218                         size_t move;
5219
5220                         prefix_count = 0;
5221                         /* Put the additional zeroes after the sign.  */
5222                         if (count >= 1
5223                             && (*prec_ptr == '-' || *prec_ptr == '+'
5224                                 || *prec_ptr == ' '))
5225                           prefix_count = 1;
5226                         /* Put the additional zeroes after the 0x prefix if
5227                            (flags & FLAG_ALT) || (dp->conversion == 'p').  */
5228                         else if (count >= 2
5229                                  && prec_ptr[0] == '0'
5230                                  && (prec_ptr[1] == 'x' || prec_ptr[1] == 'X'))
5231                           prefix_count = 2;
5232
5233                         move = count - prefix_count;
5234                         if (precision > move)
5235                           {
5236                             /* Insert zeroes.  */
5237                             size_t insert = precision - move;
5238                             TCHAR_T *prec_end;
5239
5240 # if USE_SNPRINTF
5241                             size_t n =
5242                               xsum (length,
5243                                     (count + insert + TCHARS_PER_DCHAR - 1)
5244                                     / TCHARS_PER_DCHAR);
5245                             length += (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR;
5246                             ENSURE_ALLOCATION (n);
5247                             length -= (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR;
5248                             prec_ptr = (TCHAR_T *) (result + length);
5249 # endif
5250
5251                             prec_end = prec_ptr + count;
5252                             prec_ptr += prefix_count;
5253
5254                             while (prec_end > prec_ptr)
5255                               {
5256                                 prec_end--;
5257                                 prec_end[insert] = prec_end[0];
5258                               }
5259
5260                             prec_end += insert;
5261                             do
5262                               *--prec_end = '0';
5263                             while (prec_end > prec_ptr);
5264
5265                             count += insert;
5266                           }
5267                       }
5268 #endif
5269
5270 #if !USE_SNPRINTF
5271                     if (count >= tmp_length)
5272                       /* tmp_length was incorrectly calculated - fix the
5273                          code above!  */
5274                       abort ();
5275 #endif
5276
5277 #if !DCHAR_IS_TCHAR
5278                     /* Convert from TCHAR_T[] to DCHAR_T[].  */
5279                     if (dp->conversion == 'c' || dp->conversion == 's')
5280                       {
5281                         /* type = TYPE_CHAR or TYPE_WIDE_CHAR or TYPE_STRING
5282                            TYPE_WIDE_STRING.
5283                            The result string is not certainly ASCII.  */
5284                         const TCHAR_T *tmpsrc;
5285                         DCHAR_T *tmpdst;
5286                         size_t tmpdst_len;
5287                         /* This code assumes that TCHAR_T is 'char'.  */
5288                         typedef int TCHAR_T_verify
5289                                     [2 * (sizeof (TCHAR_T) == 1) - 1];
5290 # if USE_SNPRINTF
5291                         tmpsrc = (TCHAR_T *) (result + length);
5292 # else
5293                         tmpsrc = tmp;
5294 # endif
5295                         tmpdst =
5296                           DCHAR_CONV_FROM_ENCODING (locale_charset (),
5297                                                     iconveh_question_mark,
5298                                                     tmpsrc, count,
5299                                                     NULL,
5300                                                     NULL, &tmpdst_len);
5301                         if (tmpdst == NULL)
5302                           {
5303                             int saved_errno = errno;
5304                             if (!(result == resultbuf || result == NULL))
5305                               free (result);
5306                             if (buf_malloced != NULL)
5307                               free (buf_malloced);
5308                             CLEANUP ();
5309                             errno = saved_errno;
5310                             return NULL;
5311                           }
5312                         ENSURE_ALLOCATION (xsum (length, tmpdst_len));
5313                         DCHAR_CPY (result + length, tmpdst, tmpdst_len);
5314                         free (tmpdst);
5315                         count = tmpdst_len;
5316                       }
5317                     else
5318                       {
5319                         /* The result string is ASCII.
5320                            Simple 1:1 conversion.  */
5321 # if USE_SNPRINTF
5322                         /* If sizeof (DCHAR_T) == sizeof (TCHAR_T), it's a
5323                            no-op conversion, in-place on the array starting
5324                            at (result + length).  */
5325                         if (sizeof (DCHAR_T) != sizeof (TCHAR_T))
5326 # endif
5327                           {
5328                             const TCHAR_T *tmpsrc;
5329                             DCHAR_T *tmpdst;
5330                             size_t n;
5331
5332 # if USE_SNPRINTF
5333                             if (result == resultbuf)
5334                               {
5335                                 tmpsrc = (TCHAR_T *) (result + length);
5336                                 /* ENSURE_ALLOCATION will not move tmpsrc
5337                                    (because it's part of resultbuf).  */
5338                                 ENSURE_ALLOCATION (xsum (length, count));
5339                               }
5340                             else
5341                               {
5342                                 /* ENSURE_ALLOCATION will move the array
5343                                    (because it uses realloc().  */
5344                                 ENSURE_ALLOCATION (xsum (length, count));
5345                                 tmpsrc = (TCHAR_T *) (result + length);
5346                               }
5347 # else
5348                             tmpsrc = tmp;
5349                             ENSURE_ALLOCATION (xsum (length, count));
5350 # endif
5351                             tmpdst = result + length;
5352                             /* Copy backwards, because of overlapping.  */
5353                             tmpsrc += count;
5354                             tmpdst += count;
5355                             for (n = count; n > 0; n--)
5356                               *--tmpdst = (unsigned char) *--tmpsrc;
5357                           }
5358                       }
5359 #endif
5360
5361 #if DCHAR_IS_TCHAR && !USE_SNPRINTF
5362                     /* Make room for the result.  */
5363                     if (count > allocated - length)
5364                       {
5365                         /* Need at least count elements.  But allocate
5366                            proportionally.  */
5367                         size_t n =
5368                           xmax (xsum (length, count), xtimes (allocated, 2));
5369
5370                         ENSURE_ALLOCATION (n);
5371                       }
5372 #endif
5373
5374                     /* Here count <= allocated - length.  */
5375
5376                     /* Perform padding.  */
5377 #if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
5378                     if (pad_ourselves && has_width)
5379                       {
5380                         size_t w;
5381 # if ENABLE_UNISTDIO
5382                         /* Outside POSIX, it's preferrable to compare the width
5383                            against the number of _characters_ of the converted
5384                            value.  */
5385                         w = DCHAR_MBSNLEN (result + length, count);
5386 # else
5387                         /* The width is compared against the number of _bytes_
5388                            of the converted value, says POSIX.  */
5389                         w = count;
5390 # endif
5391                         if (w < width)
5392                           {
5393                             size_t pad = width - w;
5394
5395                             /* Make room for the result.  */
5396                             if (xsum (count, pad) > allocated - length)
5397                               {
5398                                 /* Need at least count + pad elements.  But
5399                                    allocate proportionally.  */
5400                                 size_t n =
5401                                   xmax (xsum3 (length, count, pad),
5402                                         xtimes (allocated, 2));
5403
5404 # if USE_SNPRINTF
5405                                 length += count;
5406                                 ENSURE_ALLOCATION (n);
5407                                 length -= count;
5408 # else
5409                                 ENSURE_ALLOCATION (n);
5410 # endif
5411                               }
5412                             /* Here count + pad <= allocated - length.  */
5413
5414                             {
5415 # if !DCHAR_IS_TCHAR || USE_SNPRINTF
5416                               DCHAR_T * const rp = result + length;
5417 # else
5418                               DCHAR_T * const rp = tmp;
5419 # endif
5420                               DCHAR_T *p = rp + count;
5421                               DCHAR_T *end = p + pad;
5422                               DCHAR_T *pad_ptr;
5423 # if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO
5424                               if (dp->conversion == 'c'
5425                                   || dp->conversion == 's')
5426                                 /* No zero-padding for string directives.  */
5427                                 pad_ptr = NULL;
5428                               else
5429 # endif
5430                                 {
5431                                   pad_ptr = (*rp == '-' ? rp + 1 : rp);
5432                                   /* No zero-padding of "inf" and "nan".  */
5433                                   if ((*pad_ptr >= 'A' && *pad_ptr <= 'Z')
5434                                       || (*pad_ptr >= 'a' && *pad_ptr <= 'z'))
5435                                     pad_ptr = NULL;
5436                                 }
5437                               /* The generated string now extends from rp to p,
5438                                  with the zero padding insertion point being at
5439                                  pad_ptr.  */
5440
5441                               count = count + pad; /* = end - rp */
5442
5443                               if (flags & FLAG_LEFT)
5444                                 {
5445                                   /* Pad with spaces on the right.  */
5446                                   for (; pad > 0; pad--)
5447                                     *p++ = ' ';
5448                                 }
5449                               else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
5450                                 {
5451                                   /* Pad with zeroes.  */
5452                                   DCHAR_T *q = end;
5453
5454                                   while (p > pad_ptr)
5455                                     *--q = *--p;
5456                                   for (; pad > 0; pad--)
5457                                     *p++ = '0';
5458                                 }
5459                               else
5460                                 {
5461                                   /* Pad with spaces on the left.  */
5462                                   DCHAR_T *q = end;
5463
5464                                   while (p > rp)
5465                                     *--q = *--p;
5466                                   for (; pad > 0; pad--)
5467                                     *p++ = ' ';
5468                                 }
5469                             }
5470                           }
5471                       }
5472 #endif
5473
5474                     /* Here still count <= allocated - length.  */
5475
5476 #if !DCHAR_IS_TCHAR || USE_SNPRINTF
5477                     /* The snprintf() result did fit.  */
5478 #else
5479                     /* Append the sprintf() result.  */
5480                     memcpy (result + length, tmp, count * sizeof (DCHAR_T));
5481 #endif
5482 #if !USE_SNPRINTF
5483                     if (tmp != tmpbuf)
5484                       free (tmp);
5485 #endif
5486
5487 #if NEED_PRINTF_DIRECTIVE_F
5488                     if (dp->conversion == 'F')
5489                       {
5490                         /* Convert the %f result to upper case for %F.  */
5491                         DCHAR_T *rp = result + length;
5492                         size_t rc;
5493                         for (rc = count; rc > 0; rc--, rp++)
5494                           if (*rp >= 'a' && *rp <= 'z')
5495                             *rp = *rp - 'a' + 'A';
5496                       }
5497 #endif
5498
5499                     length += count;
5500                     break;
5501                   }
5502 #undef pad_ourselves
5503 #undef prec_ourselves
5504               }
5505           }
5506       }
5507
5508     /* Add the final NUL.  */
5509     ENSURE_ALLOCATION (xsum (length, 1));
5510     result[length] = '\0';
5511
5512     if (result != resultbuf && length + 1 < allocated)
5513       {
5514         /* Shrink the allocated memory if possible.  */
5515         DCHAR_T *memory;
5516
5517         memory = (DCHAR_T *) realloc (result, (length + 1) * sizeof (DCHAR_T));
5518         if (memory != NULL)
5519           result = memory;
5520       }
5521
5522     if (buf_malloced != NULL)
5523       free (buf_malloced);
5524     CLEANUP ();
5525     *lengthp = length;
5526     /* Note that we can produce a big string of a length > INT_MAX.  POSIX
5527        says that snprintf() fails with errno = EOVERFLOW in this case, but
5528        that's only because snprintf() returns an 'int'.  This function does
5529        not have this limitation.  */
5530     return result;
5531
5532 #if USE_SNPRINTF
5533   overflow:
5534     if (!(result == resultbuf || result == NULL))
5535       free (result);
5536     if (buf_malloced != NULL)
5537       free (buf_malloced);
5538     CLEANUP ();
5539     errno = EOVERFLOW;
5540     return NULL;
5541 #endif
5542
5543   out_of_memory:
5544     if (!(result == resultbuf || result == NULL))
5545       free (result);
5546     if (buf_malloced != NULL)
5547       free (buf_malloced);
5548   out_of_memory_1:
5549     CLEANUP ();
5550     errno = ENOMEM;
5551     return NULL;
5552   }
5553 }
5554
5555 #undef MAX_ROOM_NEEDED
5556 #undef TCHARS_PER_DCHAR
5557 #undef SNPRINTF
5558 #undef USE_SNPRINTF
5559 #undef DCHAR_SET
5560 #undef DCHAR_CPY
5561 #undef PRINTF_PARSE
5562 #undef DIRECTIVES
5563 #undef DIRECTIVE
5564 #undef DCHAR_IS_TCHAR
5565 #undef TCHAR_T
5566 #undef DCHAR_T
5567 #undef FCHAR_T
5568 #undef VASNPRINTF