git.gag.com Git - debian/amanda/blob - gnulib/vasnprintf.c

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