StdLib/LibC/Stdio/vfwprintf.c

   1 /** @file
   2     Implementation of internals for printf and wprintf.
   3
   4     Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
   5     This program and the accompanying materials are licensed and made available
   6     under the terms and conditions of the BSD License that accompanies this
   7     distribution.  The full text of the license may be found at
   8     http://opensource.org/licenses/bsd-license.
   9
  10     THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11     WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13     Copyright (c) 1990, 1993
  14     The Regents of the University of California.  All rights reserved.
  15
  16     This code is derived from software contributed to Berkeley by
  17     Chris Torek.
  18
  19     Redistribution and use in source and binary forms, with or without
  20     modification, are permitted provided that the following conditions
  21     are met:
  22       - Redistributions of source code must retain the above copyright
  23         notice, this list of conditions and the following disclaimer.
  24       - Redistributions in binary form must reproduce the above copyright
  25         notice, this list of conditions and the following disclaimer in the
  26         documentation and/or other materials provided with the distribution.
  27       - Neither the name of the University nor the names of its contributors
  28         may be used to endorse or promote products derived from this software
  29         without specific prior written permission.
  30
  31     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  32     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34     ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  35     LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  36     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  37     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  38     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  39     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  40     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41     POSSIBILITY OF SUCH DAMAGE.
  42
  43     NetBSD: vfwprintf.c,v 1.9.2.1.4.1 2008/04/08 21:10:55 jdc Exp
  44     vfprintf.c  8.1 (Berkeley) 6/4/93
  45 **/
  46 #include  <LibConfig.h>
  47
  48 #include "namespace.h"
  49 #include <sys/types.h>
  50
  51 #include <assert.h>
  52 #include <ctype.h>
  53 #include <limits.h>
  54 #include <locale.h>
  55 #include <stdarg.h>
  56 #include <stddef.h>
  57 #include <stdint.h>
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <string.h>
  61 #include <errno.h>
  62 #include <wchar.h>
  63 #include <wctype.h>
  64
  65 #include "reentrant.h"
  66 #include "local.h"
  67 #include "extern.h"
  68 #include "fvwrite.h"
  69
  70 #ifdef  _MSC_VER
  71   // Keep compiler quiet about conversions from larger to smaller types.
  72   #pragma warning ( disable : 4244 )
  73 #endif
  74
  75 #ifndef NARROW
  76 #define MCHAR_T   char
  77 #define CHAR_T    wchar_t
  78 #define STRLEN(a) wcslen(a)
  79 #define MEMCHR(a, b, c) wmemchr(a, b, c)
  80 #define SCONV(a, b) __mbsconv(a, b)
  81 #define STRCONST(a) L ## a
  82 #define WDECL(a, b) a ## w ## b
  83 #define END_OF_FILE WEOF
  84 #define MULTI   0
  85 #else
  86 #define MCHAR_T   wchar_t
  87 #define CHAR_T    char
  88 #define STRLEN(a) strlen(a)
  89 #define MEMCHR(a, b, c) memchr(a, b, c)
  90 #define SCONV(a, b) __wcsconv(a, b)
  91 #define STRCONST(a) a
  92 #define WDECL(a, b) a ## b
  93 #define END_OF_FILE EOF
  94 #define MULTI   1
  95 #endif
  96
  97 union arg {
  98   int                 intarg;
  99   u_int               uintarg;
 100   long                longarg;
 101   unsigned long       ulongarg;
 102   long long           longlongarg;
 103   unsigned long long  ulonglongarg;
 104   ptrdiff_t           ptrdiffarg;
 105   size_t              sizearg;
 106   intmax_t            intmaxarg;
 107   uintmax_t           uintmaxarg;
 108   void               *pvoidarg;
 109   char               *pchararg;
 110   signed char        *pschararg;
 111   short              *pshortarg;
 112   int                *pintarg;
 113   long               *plongarg;
 114   long long          *plonglongarg;
 115   ptrdiff_t          *pptrdiffarg;
 116   size_t             *psizearg;
 117   intmax_t           *pintmaxarg;
 118 #ifndef NO_FLOATING_POINT
 119   double              doublearg;
 120   long double         longdoublearg;
 121 #endif
 122   wint_t              wintarg;
 123   wchar_t            *pwchararg;
 124 };
 125
 126 /*
 127  * Type ids for argument type table.
 128  */
 129 enum typeid {
 130   T_UNUSED,   TP_SHORT,     T_INT,          T_U_INT,  TP_INT,
 131   T_LONG,     T_U_LONG,     TP_LONG,        T_LLONG,  T_U_LLONG,
 132   TP_LLONG,   T_PTRDIFFT,   TP_PTRDIFFT,    T_SIZET,  TP_SIZET,
 133   T_INTMAXT,  T_UINTMAXT,   TP_INTMAXT,     TP_VOID,  TP_CHAR,
 134   TP_SCHAR,   T_DOUBLE,     T_LONG_DOUBLE,  T_WINT,   TP_WCHAR
 135 };
 136
 137 static int      __sbprintf(FILE *, const CHAR_T *, va_list);
 138 static CHAR_T  *__ujtoa(uintmax_t, CHAR_T *, int, int, const char *, int,
 139                         char, const char *);
 140 static CHAR_T  *__ultoa(u_long, CHAR_T *, int, int, const char *, int,
 141                         char, const char *);
 142 #ifndef NARROW
 143 static CHAR_T  *__mbsconv(char *, int);
 144 static wint_t   __xfputwc(CHAR_T, FILE *);
 145 #else
 146 static char    *__wcsconv(wchar_t *, int);
 147 static int      __sprint(FILE *, struct __suio *);
 148 #endif
 149 static int      __find_arguments(const CHAR_T *, va_list, union arg **);
 150 static int      __grow_type_table(int, enum typeid **, int *);
 151
 152 /*
 153  * Helper function for `fprintf to unbuffered unix file': creates a
 154  * temporary buffer.  We only work on write-only files; this avoids
 155  * worries about ungetc buffers and so forth.
 156  */
 157 static int
 158 __sbprintf(FILE *fp, const CHAR_T *fmt, va_list ap)
 159 {
 160   int ret;
 161   FILE fake;
 162   struct __sfileext fakeext;
 163   unsigned char buf[BUFSIZ];
 164
 165   _DIAGASSERT(fp != NULL);
 166   _DIAGASSERT(fmt != NULL);
 167   if(fp == NULL) {
 168     errno = EINVAL;
 169     return (EOF);
 170   }
 171
 172   _FILEEXT_SETUP(&fake, &fakeext);
 173
 174   /* copy the important variables */
 175   fake._flags   = fp->_flags & ~__SNBF;
 176   fake._file    = fp->_file;
 177   fake._cookie  = fp->_cookie;
 178   fake._write   = fp->_write;
 179
 180   /* set up the buffer */
 181   fake._bf._base  = fake._p = buf;
 182   fake._bf._size  = fake._w = sizeof(buf);
 183   fake._lbfsize   = 0;  /* not actually used, but Just In Case */
 184
 185   /* do the work, then copy any error status */
 186   ret = WDECL(__vf,printf_unlocked)(&fake, fmt, ap);
 187   if (ret >= 0 && fflush(&fake))
 188     ret = END_OF_FILE;
 189   if (fake._flags & __SERR)
 190     fp->_flags |= __SERR;
 191   return (ret);
 192 }
 193
 194 #ifndef NARROW
 195 /*
 196  * Like __fputwc, but handles fake string (__SSTR) files properly.
 197  * File must already be locked.
 198  */
 199 static wint_t
 200 __xfputwc(wchar_t wc, FILE *fp)
 201 {
 202   static const mbstate_t initial = { 0 };
 203   mbstate_t mbs;
 204   char buf[MB_LEN_MAX];
 205   struct __suio uio;
 206   struct __siov iov;
 207   size_t len;
 208
 209   if ((fp->_flags & __SSTR) == 0)
 210     return (__fputwc_unlock(wc, fp));
 211
 212   mbs = initial;
 213   if ((len = wcrtomb(buf, wc, &mbs)) == (size_t)-1) {
 214     fp->_flags |= __SERR;
 215     return (END_OF_FILE);
 216   }
 217   uio.uio_iov     = &iov;
 218   uio.uio_resid   = (int)len;
 219   uio.uio_iovcnt  = 1;
 220   iov.iov_base    = buf;
 221   iov.iov_len     = len;
 222   return (__sfvwrite(fp, &uio) != EOF ? (wint_t)wc : END_OF_FILE);
 223 }
 224 #else
 225 /*
 226  * Flush out all the vectors defined by the given uio,
 227  * then reset it so that it can be reused.
 228  */
 229 static int
 230 __sprint(FILE *fp, struct __suio *uio)
 231 {
 232   int err;
 233
 234   _DIAGASSERT(fp != NULL);
 235   _DIAGASSERT(uio != NULL);
 236   if(fp == NULL) {
 237     errno = EINVAL;
 238     return (EOF);
 239   }
 240
 241   if (uio->uio_resid == 0) {
 242     uio->uio_iovcnt = 0;
 243     return (0);
 244   }
 245   err = __sfvwrite(fp, uio);
 246   uio->uio_resid = 0;
 247   uio->uio_iovcnt = 0;
 248   return (err);
 249 }
 250 #endif
 251
 252 /*
 253  * Macros for converting digits to letters and vice versa
 254  */
 255 #define to_digit(c) ((c) - '0')
 256 #define is_digit(c) ((unsigned)to_digit(c) <= 9)
 257 #define to_char(n)  (CHAR_T)((n) + '0')
 258
 259 /*
 260  * Convert an unsigned long to ASCII for printf purposes, returning
 261  * a pointer to the first character of the string representation.
 262  * Octal numbers can be forced to have a leading zero; hex numbers
 263  * use the given digits.
 264  */
 265 static CHAR_T *
 266 __ultoa(u_long val, CHAR_T *endp, int base, int octzero, const char *xdigs,
 267         int needgrp, char thousep, const char *grp)
 268 {
 269   CHAR_T *cp = endp;
 270   LONGN sval;
 271   int ndig;
 272
 273   /*
 274    * Handle the three cases separately, in the hope of getting
 275    * better/faster code.
 276    */
 277   switch (base) {
 278   case 10:
 279     if (val < 10) { /* many numbers are 1 digit */
 280       *--cp = to_char(val);
 281       return (cp);
 282     }
 283     ndig = 0;
 284     /*
 285      * On many machines, unsigned arithmetic is harder than
 286      * signed arithmetic, so we do at most one unsigned mod and
 287      * divide; this is sufficient to reduce the range of
 288      * the incoming value to where signed arithmetic works.
 289      */
 290     if (val > LONG_MAX) {
 291       *--cp = to_char(val % 10);
 292       ndig++;
 293       sval = (LONGN)(val / 10);
 294     } else
 295       sval = (LONGN)val;
 296     do {
 297       *--cp = to_char(sval % 10);
 298       ndig++;
 299       /*
 300        * If (*grp == CHAR_MAX) then no more grouping
 301        * should be performed.
 302        */
 303       if (needgrp && ndig == *grp && *grp != CHAR_MAX
 304           && sval > 9) {
 305         *--cp = thousep;
 306         ndig = 0;
 307         /*
 308          * If (*(grp+1) == '\0') then we have to
 309          * use *grp character (last grouping rule)
 310          * for all next cases
 311          */
 312         if (*(grp+1) != '\0')
 313           grp++;
 314       }
 315       sval /= 10;
 316     } while (sval != 0);
 317     break;
 318
 319   case 8:
 320     do {
 321       *--cp = to_char(val & 7);
 322       val >>= 3;
 323     } while (val);
 324     if (octzero && *cp != '0')
 325       *--cp = '0';
 326     break;
 327
 328   case 16:
 329     do {
 330       *--cp = xdigs[(size_t)val & 15];
 331       val >>= 4;
 332     } while (val);
 333     break;
 334
 335   default:      /* oops */
 336     abort();
 337   }
 338   return (cp);
 339 }
 340
 341 /* Identical to __ultoa, but for intmax_t. */
 342 static CHAR_T *
 343 __ujtoa(uintmax_t val, CHAR_T *endp, int base, int octzero,
 344         const char *xdigs, int needgrp, char thousep, const char *grp)
 345 {
 346   CHAR_T *cp = endp;
 347   intmax_t sval;
 348   int ndig;
 349
 350   /* quick test for small values; __ultoa is typically much faster */
 351   /* (perhaps instead we should run until small, then call __ultoa?) */
 352   if (val <= ULONG_MAX)
 353     return (__ultoa((u_long)val, endp, base, octzero, xdigs,
 354         needgrp, thousep, grp));
 355   switch (base) {
 356   case 10:
 357     if (val < 10) {
 358       *--cp = to_char(val % 10);
 359       return (cp);
 360     }
 361     ndig = 0;
 362     if (val > INTMAX_MAX) {
 363       *--cp = to_char(val % 10);
 364       ndig++;
 365       sval = val / 10;
 366     } else
 367       sval = val;
 368     do {
 369       *--cp = to_char(sval % 10);
 370       ndig++;
 371       /*
 372        * If (*grp == CHAR_MAX) then no more grouping
 373        * should be performed.
 374        */
 375       if (needgrp && *grp != CHAR_MAX && ndig == *grp
 376           && sval > 9) {
 377         *--cp = thousep;
 378         ndig = 0;
 379         /*
 380          * If (*(grp+1) == '\0') then we have to
 381          * use *grp character (last grouping rule)
 382          * for all next cases
 383          */
 384         if (*(grp+1) != '\0')
 385           grp++;
 386       }
 387       sval /= 10;
 388     } while (sval != 0);
 389     break;
 390
 391   case 8:
 392     do {
 393       *--cp = to_char(val & 7);
 394       val >>= 3;
 395     } while (val);
 396     if (octzero && *cp != '0')
 397       *--cp = '0';
 398     break;
 399
 400   case 16:
 401     do {
 402       *--cp = xdigs[(size_t)val & 15];
 403       val >>= 4;
 404     } while (val);
 405     break;
 406
 407   default:
 408     abort();
 409   }
 410   return (cp);
 411 }
 412
 413 #ifndef NARROW
 414 /*
 415  * Convert a multibyte character string argument for the %s format to a wide
 416  * string representation. ``prec'' specifies the maximum number of bytes
 417  * to output. If ``prec'' is greater than or equal to zero, we can't assume
 418  * that the multibyte char. string ends in a null character.
 419  */
 420 static wchar_t *
 421 __mbsconv(char *mbsarg, int prec)
 422 {
 423   static const mbstate_t initial = { 0 };
 424   mbstate_t mbs;
 425   wchar_t *convbuf, *wcp;
 426   const char *p;
 427   size_t insize, nchars, nconv;
 428
 429   if (mbsarg == NULL)
 430     return (NULL);
 431
 432   /*
 433    * Supplied argument is a multibyte string; convert it to wide
 434    * characters first.
 435    */
 436   if (prec >= 0) {
 437     /*
 438      * String is not guaranteed to be NUL-terminated. Find the
 439      * number of characters to print.
 440      */
 441     p = mbsarg;
 442     insize = nchars = nconv = 0;
 443     mbs = initial;
 444     while (nchars != (size_t)prec) {
 445       nconv = mbrlen(p, MB_CUR_MAX, &mbs);
 446       if (nconv == 0 || nconv == (size_t)-1 ||
 447           nconv == (size_t)-2)
 448         break;
 449       p += nconv;
 450       nchars++;
 451       insize += nconv;
 452     }
 453     if (nconv == (size_t)-1 || nconv == (size_t)-2)
 454       return (NULL);
 455   } else
 456     insize = strlen(mbsarg);
 457
 458   /*
 459    * Allocate buffer for the result and perform the conversion,
 460    * converting at most `size' bytes of the input multibyte string to
 461    * wide characters for printing.
 462    */
 463   convbuf = malloc((insize + 1) * sizeof(*convbuf));
 464   if (convbuf == NULL)
 465     return (NULL);
 466   wcp = convbuf;
 467   p = mbsarg;
 468   mbs = initial;
 469   nconv = 0;
 470   while (insize != 0) {
 471     nconv = mbrtowc(wcp, p, insize, &mbs);
 472     if (nconv == 0 || nconv == (size_t)-1 || nconv == (size_t)-2)
 473       break;
 474     wcp++;
 475     p += nconv;
 476     insize -= nconv;
 477   }
 478   if (nconv == (size_t)-1 || nconv == (size_t)-2) {
 479     free(convbuf);
 480     return (NULL);
 481   }
 482   *wcp = L'\0';
 483
 484   return (convbuf);
 485 }
 486 #else
 487 /*
 488  * Convert a wide character string argument for the %ls format to a multibyte
 489  * string representation. If not -1, prec specifies the maximum number of
 490  * bytes to output, and also means that we can't assume that the wide char.
 491  * string ends is null-terminated.
 492  */
 493 static char *
 494 __wcsconv(wchar_t *wcsarg, int prec)
 495 {
 496   static const mbstate_t initial = { 0 };
 497   mbstate_t mbs;
 498   char buf[MB_LEN_MAX];
 499   wchar_t *p;
 500   char *convbuf;
 501   size_t clen, nbytes;
 502
 503   /* Allocate space for the maximum number of bytes we could output. */
 504   if (prec < 0) {
 505     p = wcsarg;
 506     mbs = initial;
 507     nbytes = wcsrtombs(NULL, (const wchar_t **)&p, 0, &mbs);
 508     if (nbytes == (size_t)-1)
 509       return (NULL);
 510   } else {
 511     /*
 512      * Optimisation: if the output precision is small enough,
 513      * just allocate enough memory for the maximum instead of
 514      * scanning the string.
 515      */
 516     if (prec < 128)
 517       nbytes = prec;
 518     else {
 519       nbytes = 0;
 520       p = wcsarg;
 521       mbs = initial;
 522       for (;;) {
 523         clen = wcrtomb(buf, *p++, &mbs);
 524         if (clen == 0 || clen == (size_t)-1 ||
 525             nbytes + clen > (size_t)prec)
 526           break;
 527         nbytes += clen;
 528       }
 529     }
 530   }
 531   if ((convbuf = malloc(nbytes + 1)) == NULL)
 532     return (NULL);
 533
 534   /* Fill the output buffer. */
 535   p = wcsarg;
 536   mbs = initial;
 537   if ((nbytes = wcsrtombs(convbuf, (const wchar_t **)&p,
 538       nbytes, &mbs)) == (size_t)-1) {
 539     free(convbuf);
 540     return (NULL);
 541   }
 542   convbuf[nbytes] = '\0';
 543   return (convbuf);
 544 }
 545 #endif
 546
 547 /*
 548  * MT-safe version
 549  */
 550 int
 551 WDECL(vf,printf)(FILE * __restrict fp, const CHAR_T * __restrict fmt0, va_list ap)
 552 {
 553   int ret;
 554
 555   if(fp == NULL) {
 556     errno = EINVAL;
 557     return (EOF);
 558   }
 559   FLOCKFILE(fp);
 560   ret = WDECL(__vf,printf_unlocked)(fp, fmt0, ap);
 561   FUNLOCKFILE(fp);
 562   return (ret);
 563 }
 564
 565 #ifndef NO_FLOATING_POINT
 566
 567 #include <float.h>
 568 #include <math.h>
 569 #include "floatio.h"
 570
 571 #define DEFPREC   6
 572
 573 static int exponent(CHAR_T *, int, int);
 574 #ifndef WIDE_DOUBLE
 575 static char *cvt(double, int, int, char *, int *, int, int *);
 576 #endif
 577
 578 #endif /* !NO_FLOATING_POINT */
 579
 580 /*
 581  * The size of the buffer we use as scratch space for integer
 582  * conversions, among other things.  Technically, we would need the
 583  * most space for base 10 conversions with thousands' grouping
 584  * characters between each pair of digits.  100 bytes is a
 585  * conservative overestimate even for a 128-bit uintmax_t.
 586  */
 587 #define BUF 100
 588
 589 #define STATIC_ARG_TBL_SIZE 8           /* Size of static argument table. */
 590
 591 /*
 592  * Flags used during conversion.
 593  */
 594 #define ALT       0x001   /* alternate form */
 595 #define LADJUST   0x004   /* left adjustment */
 596 #define LONGDBL   0x008   /* long double */
 597 #define LONGINT   0x010   /* long integer */
 598 #define LLONGINT  0x020   /* long long integer */
 599 #define SHORTINT  0x040   /* short integer */
 600 #define ZEROPAD   0x080   /* zero (as opposed to blank) pad */
 601 #define FPT       0x100   /* Floating point number */
 602 #define GROUPING  0x200   /* use grouping ("'" flag) */
 603           /* C99 additional size modifiers: */
 604 #define SIZET     0x400   /* size_t */
 605 #define PTRDIFFT  0x800   /* ptrdiff_t */
 606 #define INTMAXT   0x1000    /* intmax_t */
 607 #define CHARINT   0x2000    /* print char using int format */
 608
 609 /*
 610  * Non-MT-safe version
 611  */
 612 int
 613 WDECL(__vf,printf_unlocked)(FILE *fp, const CHAR_T *fmt0, va_list ap)
 614 {
 615   CHAR_T *fmt;    /* format string */
 616   int ch;     /* character from fmt */
 617   int n, n2;    /* handy integer (short term usage) */
 618   CHAR_T *cp;   /* handy char pointer (short term usage) */
 619   int flags;    /* flags as above */
 620   int ret;    /* return value accumulator (number of items converted)*/
 621   int width;    /* width from format (%8d), or 0 */
 622   int prec;   /* precision from format; <0 for N/A */
 623   CHAR_T sign;    /* sign prefix (' ', '+', '-', or \0) */
 624   char thousands_sep; /* locale specific thousands separator */
 625   const char *grouping; /* locale specific numeric grouping rules */
 626 #ifndef NO_FLOATING_POINT
 627   /*
 628    * We can decompose the printed representation of floating
 629    * point numbers into several parts, some of which may be empty:
 630    *
 631    * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ
 632    *    A       B     ---C---      D       E   F
 633    *
 634    * A: 'sign' holds this value if present; '\0' otherwise
 635    * B: ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal
 636    * C: cp points to the string MMMNNN.  Leading and trailing
 637    *  zeros are not in the string and must be added.
 638    * D: expchar holds this character; '\0' if no exponent, e.g. %f
 639    * F: at least two digits for decimal, at least one digit for hex
 640    */
 641   char *decimal_point;  /* locale specific decimal point */
 642 #ifdef WIDE_DOUBLE
 643   int signflag;   /* true if float is negative */
 644   union {     /* floating point arguments %[aAeEfFgG] */
 645     double dbl;
 646     long double ldbl;
 647   } fparg;
 648   char *dtoaend;    /* pointer to end of converted digits */
 649 #else
 650   double _double;   /* double precision arguments %[eEfgG] */
 651   char softsign;    /* temporary negative sign for floats */
 652 #endif
 653   char *dtoaresult; /* buffer allocated by dtoa */
 654   int expt = 0;   /* integer value of exponent */
 655   char expchar;   /* exponent character: [eEpP\0] */
 656   int expsize;    /* character count for expstr */
 657   int lead;   /* sig figs before decimal or group sep */
 658   int ndig;   /* actual number of digits returned by dtoa */
 659   CHAR_T expstr[MAXEXPDIG+2]; /* buffer for exponent string: e+ZZZ */
 660   int nseps;    /* number of group separators with ' */
 661   int nrepeats;   /* number of repeats of the last group */
 662 #endif
 663   u_long  ulval;    /* integer arguments %[diouxX] */
 664   uintmax_t ujval;  /* %j, %ll, %q, %t, %z integers */
 665   int base;   /* base for [diouxX] conversion */
 666   int dprec;    /* a copy of prec if [diouxX], 0 otherwise */
 667   int realsz;   /* field size expanded by dprec, sign, etc */
 668   int size;   /* size of converted field or string */
 669   int prsize;             /* max size of printed field */
 670   const char *xdigs;  /* digits for %[xX] conversion */
 671 #ifdef NARROW
 672 #define NIOV 8
 673   struct __siov *iovp;  /* for PRINT macro */
 674   struct __suio uio;  /* output information: summary */
 675   struct __siov iov[NIOV];/* ... and individual io vectors */
 676 #else
 677   int n3;
 678 #endif
 679   CHAR_T buf[BUF];  /* buffer with space for digits of uintmax_t */
 680   CHAR_T ox[2];   /* space for 0x hex-prefix */
 681   union arg *argtable;  /* args, built due to positional arg */
 682   union arg statargtable [STATIC_ARG_TBL_SIZE];
 683   int nextarg;    /* 1-based argument index */
 684   va_list orgap;    /* original argument pointer */
 685   CHAR_T *convbuf;  /* multibyte to wide conversion result */
 686
 687   /*
 688    * Choose PADSIZE to trade efficiency vs. size.  If larger printf
 689    * fields occur frequently, increase PADSIZE and make the initialisers
 690    * below longer.
 691    */
 692 #define PADSIZE 16    /* pad chunk size */
 693   static CHAR_T blanks[PADSIZE] =
 694    {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
 695   static CHAR_T zeroes[PADSIZE] =
 696    {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
 697
 698   static const char xdigs_lower[17] = "0123456789abcdef";
 699   static const char xdigs_upper[17] = "0123456789ABCDEF";
 700
 701   /*
 702    * BEWARE, these `goto error' on error, PRINT uses `n2' and
 703    * PAD uses `n'.
 704    */
 705 #ifndef NARROW
 706 #define PRINT(ptr, len) do {      \
 707   for (n3 = 0; n3 < (len); n3++)    \
 708     __xfputwc((ptr)[n3], fp); \
 709 } while (/*CONSTCOND*/0)
 710 #define FLUSH()
 711 #else
 712 #define PRINT(ptr, len) do { \
 713   iovp->iov_base = __UNCONST(ptr); \
 714   iovp->iov_len = (len); \
 715   uio.uio_resid += (len); \
 716   iovp++; \
 717   if (++uio.uio_iovcnt >= NIOV) { \
 718     if (__sprint(fp, &uio)) \
 719       goto error; \
 720     iovp = iov; \
 721   } \
 722 } while (/*CONSTCOND*/0)
 723 #define FLUSH() do { \
 724   if (uio.uio_resid && __sprint(fp, &uio)) \
 725     goto error; \
 726   uio.uio_iovcnt = 0; \
 727   iovp = iov; \
 728 } while (/*CONSTCOND*/0)
 729 #endif /* NARROW */
 730
 731 #define PAD(howmany, with)  do {    \
 732   if ((n = (howmany)) > 0) {    \
 733     while (n > PADSIZE) {   \
 734       PRINT(with, PADSIZE); \
 735       n -= PADSIZE;   \
 736     }       \
 737     PRINT(with, n);     \
 738   }         \
 739 } while (/*CONSTCOND*/0)
 740 #define PRINTANDPAD(p, ep, len, with) do {  \
 741   n2 = (ep) - (p);            \
 742   if (n2 > (len))       \
 743     n2 = (len);     \
 744   if (n2 > 0)       \
 745     PRINT((p), n2);     \
 746   PAD((len) - (n2 > 0 ? n2 : 0), (with)); \
 747 } while(/*CONSTCOND*/0)
 748
 749   /*
 750    * Get the argument indexed by nextarg.   If the argument table is
 751    * built, use it to get the argument.  If its not, get the next
 752    * argument (and arguments must be gotten sequentially).
 753    */
 754 #define GETARG(type) \
 755   ((/*CONSTCOND*/argtable != NULL) ? *((type*)(void*)(&argtable[nextarg++])) : \
 756       (nextarg++, va_arg(ap, type)))
 757
 758   /*
 759    * To extend shorts properly, we need both signed and unsigned
 760    * argument extraction methods.
 761    */
 762 #define SARG() \
 763   ((long)(flags&LONGINT ? GETARG(long) : \
 764       flags&SHORTINT ? (short)GETARG(int) : \
 765       flags&CHARINT ? (signed char)GETARG(int) : \
 766       GETARG(int)))
 767
 768 #define UARG() \
 769   ((u_long)(flags&LONGINT ? GETARG(u_long) : \
 770       flags&SHORTINT ? (u_long)(u_short)GETARG(int) : \
 771       flags&CHARINT ? (u_long)(u_char)GETARG(int) : \
 772       (u_long)GETARG(u_int)))
 773
 774 #define INTMAX_SIZE (INTMAXT|SIZET|PTRDIFFT|LLONGINT)
 775
 776 #define SJARG() \
 777   (flags&INTMAXT ? GETARG(intmax_t) : \
 778       flags&SIZET ? (intmax_t)GETARG(size_t) : \
 779       flags&PTRDIFFT ? (intmax_t)GETARG(ptrdiff_t) : \
 780       (intmax_t)GETARG(long long))
 781
 782 #define UJARG() \
 783   (flags&INTMAXT ? GETARG(uintmax_t) : \
 784       flags&SIZET ? (uintmax_t)GETARG(size_t) : \
 785       flags&PTRDIFFT ? (uintmax_t)GETARG(ptrdiff_t) : \
 786       (uintmax_t)GETARG(unsigned long long))
 787
 788   /*
 789    * Get * arguments, including the form *nn$.  Preserve the nextarg
 790    * that the argument can be gotten once the type is determined.
 791    */
 792 #define GETASTER(val) \
 793   n2 = 0; \
 794   cp = fmt; \
 795   while (is_digit(*cp)) { \
 796     n2 = 10 * n2 + to_digit(*cp); \
 797     cp++; \
 798   } \
 799   if (*cp == '$') { \
 800     int hold = nextarg; \
 801     if (argtable == NULL) { \
 802       argtable = statargtable; \
 803       if (__find_arguments(fmt0, orgap, &argtable) == -1) \
 804         goto oomem; \
 805     } \
 806     nextarg = n2; \
 807     val = GETARG (int); \
 808     nextarg = hold; \
 809     fmt = ++cp; \
 810   } else { \
 811     val = GETARG (int); \
 812   }
 813
 814   _DIAGASSERT(fp != NULL);
 815   _DIAGASSERT(fmt0 != NULL);
 816   if(fp == NULL) {
 817     errno = EINVAL;
 818     return (EOF);
 819   }
 820
 821   _SET_ORIENTATION(fp, -1);
 822
 823   ndig = -1;  /* XXX gcc */
 824
 825   thousands_sep = '\0';
 826   grouping = NULL;
 827 #ifndef NO_FLOATING_POINT
 828   decimal_point = localeconv()->decimal_point;
 829   expsize = 0;    /* XXXGCC -Wuninitialized [sh3,m68000] */
 830 #endif
 831   convbuf = NULL;
 832   /* sorry, f{w,}printf(read_only_file, L"") returns {W,}EOF, not 0 */
 833   if (cantwrite(fp)) {
 834     errno = EBADF;
 835     return (END_OF_FILE);
 836   }
 837
 838   /* optimise fprintf(stderr) (and other unbuffered Unix files) */
 839   if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
 840       fp->_file >= 0)
 841     return (__sbprintf(fp, fmt0, ap));
 842
 843   fmt = (CHAR_T *)__UNCONST(fmt0);
 844   argtable = NULL;
 845   nextarg = 1;
 846   va_copy(orgap, ap);
 847 #ifdef NARROW
 848   uio.uio_iov = iovp = iov;
 849   uio.uio_resid = 0;
 850   uio.uio_iovcnt = 0;
 851 #endif
 852   ret = 0;
 853
 854   /*
 855    * Scan the format for conversions (`%' character).
 856    */
 857   for (;;)
 858   {
 859     const CHAR_T *result;
 860
 861     for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
 862       continue;
 863     if ((n = (int)(fmt - cp)) != 0) {
 864       if ((unsigned)ret + n > INT_MAX) {
 865         ret = END_OF_FILE;
 866         goto error;
 867       }
 868       PRINT(cp, n);
 869       ret += n;
 870     }
 871     if (ch == '\0')
 872       goto done;
 873     fmt++;    /* skip over '%' */
 874
 875     flags = 0;
 876     dprec = 0;
 877     width = 0;
 878     prec = -1;
 879     sign = '\0';
 880     ox[1] = '\0';
 881     expchar = '\0';
 882     lead = 0;
 883     nseps = nrepeats = 0;
 884     ulval = 0;
 885     ujval = 0;
 886     xdigs = NULL;
 887
 888 rflag:    ch = *fmt++;
 889 reswitch: switch (ch) {
 890     case ' ':
 891       /*-
 892        * ``If the space and + flags both appear, the space
 893        * flag will be ignored.''
 894        *  -- ANSI X3J11
 895        */
 896       if (!sign)
 897         sign = ' ';
 898       goto rflag;
 899     case '#':
 900       flags |= ALT;
 901       goto rflag;
 902     case '*':
 903       /*-
 904        * ``A negative field width argument is taken as a
 905        * - flag followed by a positive field width.''
 906        *  -- ANSI X3J11
 907        * They don't exclude field widths read from args.
 908        */
 909       GETASTER (width);
 910       if (width >= 0)
 911         goto rflag;
 912       width = -width;
 913       /* FALLTHROUGH */
 914     case '-':
 915       flags |= LADJUST;
 916       goto rflag;
 917     case '+':
 918       sign = '+';
 919       goto rflag;
 920     case '\'':
 921       flags |= GROUPING;
 922       thousands_sep = *(localeconv()->thousands_sep);
 923       grouping = localeconv()->grouping;
 924       goto rflag;
 925     case '.':
 926       if ((ch = *fmt++) == '*') {
 927         GETASTER (prec);
 928         goto rflag;
 929       }
 930       prec = 0;
 931       while (is_digit(ch)) {
 932         prec = 10 * prec + to_digit(ch);
 933         ch = *fmt++;
 934       }
 935       goto reswitch;
 936     case '0':
 937       /*-
 938        * ``Note that 0 is taken as a flag, not as the
 939        * beginning of a field width.''
 940        *  -- ANSI X3J11
 941        */
 942       flags |= ZEROPAD;
 943       goto rflag;
 944     case '1': case '2': case '3': case '4':
 945     case '5': case '6': case '7': case '8': case '9':
 946       n = 0;
 947       do {
 948         n = 10 * n + to_digit(ch);
 949         ch = *fmt++;
 950       } while (is_digit(ch));
 951       if (ch == '$') {
 952         nextarg = n;
 953         if (argtable == NULL) {
 954           argtable = statargtable;
 955           if (__find_arguments(fmt0, orgap,
 956               &argtable) == -1)
 957             goto oomem;
 958         }
 959         goto rflag;
 960       }
 961       width = n;
 962       goto reswitch;
 963 #ifndef NO_FLOATING_POINT
 964     case 'L':
 965       flags |= LONGDBL;
 966       goto rflag;
 967 #endif
 968     case 'h':
 969       if (flags & SHORTINT) {
 970         flags &= ~SHORTINT;
 971         flags |= CHARINT;
 972       } else
 973         flags |= SHORTINT;
 974       goto rflag;
 975     case 'j':
 976       flags |= INTMAXT;
 977       goto rflag;
 978     case 'l':
 979       if (flags & LONGINT) {
 980         flags &= ~LONGINT;
 981         flags |= LLONGINT;
 982       } else
 983         flags |= LONGINT;
 984       goto rflag;
 985     case 'q':
 986       flags |= LLONGINT;  /* not necessarily */
 987       goto rflag;
 988     case 't':
 989       flags |= PTRDIFFT;
 990       goto rflag;
 991     case 'z':
 992       flags |= SIZET;
 993       goto rflag;
 994     case 'C':
 995       flags |= LONGINT;
 996       /*FALLTHROUGH*/
 997     case 'c':
 998 #ifdef NARROW
 999       if (flags & LONGINT) {
1000         static const mbstate_t initial = { 0 };
1001         mbstate_t mbs;
1002         size_t mbseqlen;
1003
1004         mbs = initial;
1005         mbseqlen = wcrtomb(buf,
1006             /* The compiler "knows" that wint_t may be smaller than an int so
1007                it warns about it when used as the type argument to va_arg().
1008                Since any type of parameter smaller than an int is promoted to an int on a
1009                function call, we must call GETARG with type int instead of wint_t.
1010             */
1011             (wchar_t)GETARG(int), &mbs);
1012         if (mbseqlen == (size_t)-1) {
1013           fp->_flags |= __SERR;
1014           goto error;
1015         }
1016         size = (int)mbseqlen;
1017       } else {
1018         *buf = (char)(GETARG(int));
1019         size = 1;
1020       }
1021 #else
1022       if (flags & LONGINT)
1023         *buf = (wchar_t)GETARG(int);
1024       else
1025         *buf = (wchar_t)btowc(GETARG(int));
1026       size = 1;
1027 #endif
1028       result = buf;
1029       sign = '\0';
1030       break;
1031     case 'D':
1032       flags |= LONGINT;
1033       /*FALLTHROUGH*/
1034     case 'd':
1035     case 'i':
1036       if (flags & INTMAX_SIZE) {
1037         ujval = SJARG();
1038         if ((intmax_t)ujval < 0) {
1039           ujval = (uintmax_t)(-((intmax_t)ujval));
1040           sign = '-';
1041         }
1042       } else {
1043         ulval = SARG();
1044         if ((long)ulval < 0) {
1045           ulval = (u_long)(-((long)ulval));
1046           sign = '-';
1047         }
1048       }
1049       base = 10;
1050       goto number;
1051 #ifndef NO_FLOATING_POINT
1052 #ifdef WIDE_DOUBLE
1053     case 'a':
1054     case 'A':
1055       if (ch == 'a') {
1056         ox[1] = 'x';
1057         xdigs = xdigs_lower;
1058         expchar = 'p';
1059       } else {
1060         ox[1] = 'X';
1061         xdigs = xdigs_upper;
1062         expchar = 'P';
1063       }
1064       if (flags & LONGDBL) {
1065         fparg.ldbl = GETARG(long double);
1066         dtoaresult =
1067             __hldtoa(fparg.ldbl, xdigs, prec,
1068                 &expt, &signflag, &dtoaend);
1069       } else {
1070         fparg.dbl = GETARG(double);
1071         dtoaresult =
1072             __hdtoa(fparg.dbl, xdigs, prec,
1073                 &expt, &signflag, &dtoaend);
1074       }
1075       if (dtoaresult == NULL)
1076         goto oomem;
1077
1078       if (prec < 0)
1079         prec = dtoaend - dtoaresult;
1080       if (expt == INT_MAX)
1081         ox[1] = '\0';
1082       ndig = dtoaend - dtoaresult;
1083       if (convbuf != NULL)
1084         free(convbuf);
1085 #ifndef NARROW
1086       result = convbuf = __mbsconv(dtoaresult, -1);
1087 #else
1088       /*XXX inefficient*/
1089       result = convbuf = strdup(dtoaresult);
1090 #endif
1091       if (result == NULL)
1092         goto oomem;
1093       __freedtoa(dtoaresult);
1094       goto fp_common;
1095     case 'e':
1096     case 'E':
1097       expchar = ch;
1098       if (prec < 0)
1099         prec = DEFPREC;
1100       goto fp_begin;
1101     case 'f':
1102     case 'F':
1103       expchar = '\0';
1104       goto fp_begin;
1105     case 'g':
1106     case 'G':
1107       expchar = ch - ('g' - 'e');
1108       if (prec == 0)
1109         prec = 1;
1110 fp_begin:
1111       if (prec < 0)
1112         prec = DEFPREC;
1113       if (flags & LONGDBL) {
1114         fparg.ldbl = GETARG(long double);
1115         dtoaresult =
1116             __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec,
1117             &expt, &signflag, &dtoaend);
1118       } else {
1119         fparg.dbl = GETARG(double);
1120         dtoaresult =
1121             __dtoa(fparg.dbl, expchar ? 2 : 3, prec,
1122             &expt, &signflag, &dtoaend);
1123         if (expt == 9999)
1124           expt = INT_MAX;
1125       }
1126       if (dtoaresult == NULL)
1127         goto oomem;
1128       ndig = dtoaend - dtoaresult;
1129       if (convbuf != NULL)
1130         free(convbuf);
1131 #ifndef NARROW
1132       result = convbuf = __mbsconv(dtoaresult, -1);
1133 #else
1134       /*XXX inefficient*/
1135       result = convbuf = strdup(dtoaresult);
1136 #endif
1137       if (result == NULL)
1138         goto oomem;
1139       __freedtoa(dtoaresult);
1140 fp_common:
1141       if (signflag)
1142         sign = '-';
1143       if (expt == INT_MAX) {  /* inf or nan */
1144         if (*result == 'N') {
1145           result = (ch >= 'a') ? STRCONST("nan") :
1146               STRCONST("NAN");
1147           sign = '\0';
1148         } else
1149           result = (ch >= 'a') ? STRCONST("inf") :
1150               STRCONST("INF");
1151         size = 3;
1152         break;
1153       }
1154 #else
1155     //case 'e':
1156     //case 'E':
1157     //case 'f':
1158     //case 'F':
1159     //case 'g':
1160     //case 'G':
1161     //  if (prec == -1) {
1162     //    prec = DEFPREC;
1163     //  } else if ((ch == 'g' || ch == 'G') && prec == 0) {
1164     //    prec = 1;
1165     //  }
1166     case 'e':
1167     case 'E':
1168       expchar = ch;
1169       if (prec < 0)
1170         prec = DEFPREC;
1171       goto fp_begin;
1172     case 'f':
1173     case 'F':
1174       expchar = '\0';
1175       goto fp_begin;
1176     case 'g':
1177     case 'G':
1178       expchar = ch - ('g' - 'e');
1179       if (prec == 0)
1180         prec = 1;
1181 fp_begin:
1182       if (prec < 0)
1183         prec = DEFPREC;
1184
1185       if (flags & LONGDBL) {
1186         _double = (double) GETARG(long double);
1187       } else {
1188         _double = GETARG(double);
1189       }
1190
1191       /* do this before tricky precision changes */
1192       if (isinf(_double)) {
1193         if (_double < 0)
1194           sign = '-';
1195         if (ch == 'E' || ch == 'F' || ch == 'G')
1196           result = STRCONST("INF");
1197         else
1198           result = STRCONST("inf");
1199         size = 3;
1200         break;
1201       }
1202       if (isnan(_double)) {
1203         if (ch == 'E' || ch == 'F' || ch == 'G')
1204           result = STRCONST("NAN");
1205         else
1206           result = STRCONST("nan");
1207         size = 3;
1208         break;
1209       }
1210
1211       flags |= FPT;
1212       dtoaresult = cvt(_double, prec, flags, &softsign, &expt, ch, &ndig);
1213       if (dtoaresult == NULL)
1214         goto oomem;
1215       if (convbuf != NULL)
1216         free(convbuf);
1217 #ifndef NARROW
1218       result = convbuf = __mbsconv(dtoaresult, -1);
1219 #else
1220       /*XXX inefficient*/
1221       result = convbuf = strdup(dtoaresult);
1222 #endif
1223       if (result == NULL)
1224         goto oomem;
1225       __freedtoa(dtoaresult);
1226       if (softsign)
1227         sign = '-';
1228 #endif
1229       flags |= FPT;
1230       if (ch == 'g' || ch == 'G') {
1231         if (expt > -4 && expt <= prec) {
1232           /* Make %[gG] smell like %[fF] */
1233           expchar = '\0';
1234           if (flags & ALT)
1235             prec -= expt;
1236           else
1237             prec = ndig - expt;
1238           if (prec < 0)
1239             prec = 0;
1240         } else {
1241           /*
1242            * Make %[gG] smell like %[eE], but
1243            * trim trailing zeroes if no # flag.
1244            *
1245            * Note: The precision field used with [gG] is the number significant
1246            * digits to print.  When converting to [eE] the digit before the
1247            * decimal must not be included in the precision value.
1248            */
1249           if (!(flags & ALT))
1250             prec = ndig - 1;
1251         }
1252       }
1253       if (expchar) {
1254         dprec = prec; /* In some cases dprec will not be set.  Make sure it is set now */
1255         expsize = exponent(expstr, expt - 1, expchar);
1256         size = expsize + prec + 1; /* Leading digit + exponent string + precision */
1257         if (prec >= 1 || flags & ALT)
1258           ++size; /* Decimal point is added to character count */
1259       } else {
1260         /* space for digits before decimal point */
1261         if (expt > 0)
1262           size = expt;
1263         else  /* "0" */
1264           size = 1;
1265         /* space for decimal pt and following digits */
1266         if (prec || flags & ALT)
1267           size += prec + 1;
1268         if (grouping && expt > 0) {
1269           /* space for thousands' grouping */
1270           nseps = nrepeats = 0;
1271           lead = expt;
1272           while (*grouping != CHAR_MAX) {
1273             if (lead <= *grouping)
1274               break;
1275             lead -= *grouping;
1276             if (*(grouping+1)) {
1277               nseps++;
1278               grouping++;
1279             } else
1280               nrepeats++;
1281           }
1282           size += nseps + nrepeats;
1283         } else
1284           lead = expt;
1285       }
1286       break;
1287 #endif /* !NO_FLOATING_POINT */
1288     case 'n':
1289       /*
1290        * Assignment-like behavior is specified if the
1291        * value overflows or is otherwise unrepresentable.
1292        * C99 says to use `signed char' for %hhn conversions.
1293        */
1294       if (flags & LLONGINT)
1295         *GETARG(long long *) = ret;
1296       else if (flags & SIZET)
1297         *GETARG(ssize_t *) = (ssize_t)ret;
1298       else if (flags & PTRDIFFT)
1299         *GETARG(ptrdiff_t *) = ret;
1300       else if (flags & INTMAXT)
1301         *GETARG(intmax_t *) = ret;
1302       else if (flags & LONGINT)
1303         *GETARG(long *) = ret;
1304       else if (flags & SHORTINT)
1305         *GETARG(short *) = ret;
1306       else if (flags & CHARINT)
1307         *GETARG(signed char *) = ret;
1308       else
1309         *GETARG(int *) = ret;
1310       continue; /* no output */
1311     case 'O':
1312       flags |= LONGINT;
1313       /*FALLTHROUGH*/
1314     case 'o':
1315       if (flags & INTMAX_SIZE)
1316         ujval = UJARG();
1317       else
1318         ulval = UARG();
1319       base = 8;
1320       goto nosign;
1321     case 'p':
1322       /*-
1323        * ``The argument shall be a pointer to void.  The
1324        * value of the pointer is converted to a sequence
1325        * of printable characters, in an implementation-
1326        * defined manner.''
1327        *  -- ANSI X3J11
1328        */
1329       ujval = (uintmax_t) (UINTN) GETARG(void *);
1330       base = 16;
1331       xdigs = xdigs_lower;
1332       flags = flags | INTMAXT;
1333       ox[1] = 'x';
1334       goto nosign;
1335     case 'S':
1336       flags |= LONGINT;
1337       /*FALLTHROUGH*/
1338     case 's':
1339       if (((flags & LONGINT) ? 1:0) != MULTI) {
1340         if ((result = GETARG(CHAR_T *)) == NULL)
1341           result = STRCONST("(null)");
1342       } else {
1343         MCHAR_T *mc;
1344
1345         if (convbuf != NULL)
1346           free(convbuf);
1347         if ((mc = GETARG(MCHAR_T *)) == NULL)
1348           result = STRCONST("(null)");
1349         else {
1350           convbuf = SCONV(mc, prec);
1351           if (convbuf == NULL) {
1352             fp->_flags |= __SERR;
1353             goto error;
1354           }
1355           result = convbuf;
1356         }
1357       }
1358
1359       if (prec >= 0) {
1360         /*
1361          * can't use STRLEN; can only look for the
1362          * NUL in the first `prec' characters, and
1363          * STRLEN() will go further.
1364          */
1365         CHAR_T *p = MEMCHR(result, 0, (size_t)prec);
1366
1367         if (p != NULL) {
1368           size = p - result;
1369           if (size > prec)
1370             size = prec;
1371         } else
1372           size = prec;
1373       } else
1374         size = (int)STRLEN(result);
1375       sign = '\0';
1376       break;
1377     case 'U':
1378       flags |= LONGINT;
1379       /*FALLTHROUGH*/
1380     case 'u':
1381       if (flags & INTMAX_SIZE)
1382         ujval = UJARG();
1383       else
1384         ulval = UARG();
1385       base = 10;
1386       goto nosign;
1387     case 'X':
1388       xdigs = xdigs_upper;
1389       goto hex;
1390     case 'x':
1391       xdigs = xdigs_lower;
1392 hex:
1393       if (flags & INTMAX_SIZE)
1394         ujval = UJARG();
1395       else
1396         ulval = UARG();
1397       base = 16;
1398       /* leading 0x/X only if non-zero */
1399       if (flags & ALT &&
1400           (flags & INTMAX_SIZE ? ujval != 0 : ulval != 0))
1401         ox[1] = ch;
1402
1403       flags &= ~GROUPING;
1404       /* unsigned conversions */
1405 nosign:     sign = '\0';
1406       /*-
1407        * ``... diouXx conversions ... if a precision is
1408        * specified, the 0 flag will be ignored.''
1409        *  -- ANSI X3J11
1410        */
1411 number:     if ((dprec = prec) >= 0)
1412         flags &= ~ZEROPAD;
1413
1414       /*-
1415        * ``The result of converting a zero value with an
1416        * explicit precision of zero is no characters.''
1417        *  -- ANSI X3J11
1418        *
1419        * ``The C Standard is clear enough as is.  The call
1420        * printf("%#.0o", 0) should print 0.''
1421        *  -- Defect Report #151
1422        */
1423       result = cp = buf + BUF;
1424       if (flags & INTMAX_SIZE) {
1425         if (ujval != 0 || prec != 0 ||
1426             (flags & ALT && base == 8))
1427         {
1428           result = __ujtoa(ujval, cp, base,
1429               flags & ALT, xdigs,
1430               flags & GROUPING, thousands_sep,
1431               grouping);
1432         }
1433       } else {
1434         if (ulval != 0 || prec != 0 ||
1435             (flags & ALT && base == 8))
1436           result = __ultoa(ulval, cp, base,
1437               flags & ALT, xdigs,
1438               flags & GROUPING, thousands_sep,
1439               grouping);
1440       }
1441       size = buf + BUF - result;
1442       if (size > BUF) /* should never happen */
1443         abort();
1444       break;
1445     default:  /* "%?" prints ?, unless ? is NUL */
1446       if (ch == '\0')
1447         goto done;
1448       /* pretend it was %c with argument ch */
1449       *buf = ch;
1450       result = buf;
1451       size = 1;
1452       sign = '\0';
1453       break;
1454     }
1455
1456     /*
1457      * All reasonable formats wind up here.  At this point, `result'
1458      * points to a string which (if not flags&LADJUST) should be
1459      * padded out to `width' places.  If flags&ZEROPAD, it should
1460      * first be prefixed by any sign or other prefix; otherwise,
1461      * it should be blank padded before the prefix is emitted.
1462      * After any left-hand padding and prefixing, emit zeroes
1463      * required by a decimal [diouxX] precision, then print the
1464      * string proper, then emit zeroes required by any leftover
1465      * floating precision; finally, if LADJUST, pad with blanks.
1466      *
1467      * Compute actual size, so we know how much to pad.
1468      * size excludes decimal prec; realsz includes it.
1469      */
1470     realsz = dprec > size ? dprec : size;
1471     if (sign)
1472       realsz++;
1473     if (ox[1])
1474       realsz += 2;
1475
1476     prsize = width > realsz ? width : realsz;
1477     if ((unsigned)ret + prsize > INT_MAX) {
1478       ret = END_OF_FILE;
1479       goto error;
1480     }
1481
1482     /* right-adjusting blank padding */
1483     if ((flags & (LADJUST|ZEROPAD)) == 0)
1484       PAD(width - realsz, blanks);
1485
1486     /* prefix */
1487     if (sign)
1488       PRINT(&sign, 1);
1489
1490     if (ox[1]) {  /* ox[1] is either x, X, or \0 */
1491       ox[0] = '0';
1492       PRINT(ox, 2);
1493     }
1494
1495     /* right-adjusting zero padding */
1496     if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
1497       PAD(width - realsz, zeroes);
1498
1499     /* leading zeroes from decimal precision */
1500     PAD(dprec - size, zeroes);
1501
1502     /* the string or number proper */
1503 #ifndef NO_FLOATING_POINT
1504     if ((flags & FPT) == 0) {
1505       PRINT(result, size);
1506     } else {  /* glue together f_p fragments */
1507       if (!expchar) { /* %[fF] or sufficiently short %[gG] */
1508         if (expt <= 0) {
1509           PRINT(zeroes, 1);
1510           if (prec || flags & ALT)
1511             PRINT(decimal_point, 1);
1512           PAD(-expt, zeroes);
1513           /* already handled initial 0's */
1514           prec += expt;
1515         } else {
1516           PRINTANDPAD(result, convbuf + ndig,
1517               lead, zeroes);
1518           result += lead;
1519           if (grouping) {
1520             while (nseps>0 || nrepeats>0) {
1521               if (nrepeats > 0)
1522                 nrepeats--;
1523               else {
1524                 grouping--;
1525                 nseps--;
1526               }
1527               PRINT(&thousands_sep,
1528                   1);
1529               PRINTANDPAD(result,
1530                   convbuf + ndig,
1531                   *grouping, zeroes);
1532               result += *grouping;
1533             }
1534             if (result > convbuf + ndig)
1535               result = convbuf + ndig;
1536           }
1537           if (prec || flags & ALT) {
1538             buf[0] = *decimal_point;
1539             PRINT(buf, 1);
1540           }
1541         }
1542         PRINTANDPAD(result, convbuf + ndig, prec,
1543             zeroes);
1544       } else {  /* %[eE] or sufficiently long %[gG] */
1545         if (prec >= 1 || flags & ALT) {
1546           buf[0] = *result++;
1547           buf[1] = *decimal_point;
1548           PRINT(buf, 2);
1549           PRINT(result, ndig-1);
1550           PAD(prec - ndig, zeroes);
1551         } else  /* XeYYY */
1552           PRINT(result, 1);
1553         PRINT(expstr, expsize);
1554       }
1555     }
1556 #else
1557     PRINT(result, size);
1558 #endif
1559     /* left-adjusting padding (always blank) */
1560     if (flags & LADJUST)
1561       PAD(width - realsz, blanks);
1562
1563     /* finally, adjust ret */
1564     ret += prsize;
1565     FLUSH();
1566   }
1567 done:
1568   FLUSH();
1569 error:
1570   va_end(orgap);
1571   if (convbuf != NULL)
1572     free(convbuf);
1573   if (__sferror(fp))
1574     ret = END_OF_FILE;
1575   if ((argtable != NULL) && (argtable != statargtable))
1576     free (argtable);
1577   return (ret);
1578   /* NOTREACHED */
1579 oomem:
1580   errno = ENOMEM;
1581   ret = END_OF_FILE;
1582   goto error;
1583 }
1584
1585 /*
1586  * Find all arguments when a positional parameter is encountered.  Returns a
1587  * table, indexed by argument number, of pointers to each arguments.  The
1588  * initial argument table should be an array of STATIC_ARG_TBL_SIZE entries.
1589  * It will be replaces with a malloc-ed one if it overflows.
1590  */
1591 static int
1592 __find_arguments(const CHAR_T *fmt0, va_list ap, union arg **argtable)
1593 {
1594   CHAR_T *fmt;    /* format string */
1595   int ch;     /* character from fmt */
1596   int n, n2;    /* handy integer (short term usage) */
1597   CHAR_T *cp;   /* handy char pointer (short term usage) */
1598   int flags;    /* flags as above */
1599   enum typeid *typetable; /* table of types */
1600   enum typeid stattypetable [STATIC_ARG_TBL_SIZE];
1601   int tablesize;    /* current size of type table */
1602   int tablemax;   /* largest used index in table */
1603   int nextarg;    /* 1-based argument index */
1604
1605   /*
1606    * Add an argument type to the table, expanding if necessary.
1607    */
1608 #define ADDTYPE(type) \
1609   do { \
1610     if (nextarg >= tablesize) \
1611       if (__grow_type_table(nextarg, &typetable, \
1612           &tablesize) == -1) \
1613         return -1; \
1614     if (nextarg > tablemax) \
1615       tablemax = nextarg; \
1616     typetable[nextarg++] = type; \
1617   } while (/*CONSTCOND*/0)
1618
1619 #define ADDSARG() \
1620   do { \
1621     if (flags & INTMAXT)  \
1622       ADDTYPE(T_INTMAXT); \
1623     else if (flags & SIZET)  \
1624       ADDTYPE(T_SIZET); \
1625     else if (flags & PTRDIFFT) \
1626       ADDTYPE(T_PTRDIFFT); \
1627     else if (flags & LLONGINT) \
1628       ADDTYPE(T_LLONG); \
1629     else if (flags & LONGINT) \
1630       ADDTYPE(T_LONG); \
1631     else \
1632       ADDTYPE(T_INT); \
1633   } while (/*CONSTCOND*/0)
1634
1635 #define ADDUARG() \
1636   do { \
1637     if (flags & INTMAXT)  \
1638       ADDTYPE(T_UINTMAXT); \
1639     else if (flags & SIZET)  \
1640       ADDTYPE(T_SIZET); \
1641     else if (flags & PTRDIFFT) \
1642       ADDTYPE(T_PTRDIFFT); \
1643     else if (flags & LLONGINT) \
1644       ADDTYPE(T_U_LLONG); \
1645     else if (flags & LONGINT) \
1646       ADDTYPE(T_U_LONG); \
1647     else \
1648       ADDTYPE(T_U_INT); \
1649   } while (/*CONSTCOND*/0)
1650   /*
1651    * Add * arguments to the type array.
1652    */
1653 #define ADDASTER() \
1654   n2 = 0; \
1655   cp = fmt; \
1656   while (is_digit(*cp)) { \
1657     n2 = 10 * n2 + to_digit(*cp); \
1658     cp++; \
1659   } \
1660   if (*cp == '$') { \
1661     int hold = nextarg; \
1662     nextarg = n2; \
1663     ADDTYPE(T_INT); \
1664     nextarg = hold; \
1665     fmt = ++cp; \
1666   } else { \
1667     ADDTYPE(T_INT); \
1668   }
1669   fmt = (CHAR_T *)__UNCONST(fmt0);
1670   typetable = stattypetable;
1671   tablesize = STATIC_ARG_TBL_SIZE;
1672   tablemax = 0;
1673   nextarg = 1;
1674   for (n = 0; n < STATIC_ARG_TBL_SIZE; n++)
1675     typetable[n] = T_UNUSED;
1676
1677   /*
1678    * Scan the format for conversions (`%' character).
1679    */
1680   for (;;) {
1681     for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
1682       /* void */;
1683     if (ch == '\0')
1684       goto done;
1685     fmt++;    /* skip over '%' */
1686
1687     flags = 0;
1688
1689 rflag:    ch = *fmt++;
1690 reswitch: switch (ch) {
1691     case ' ':
1692     case '#':
1693       goto rflag;
1694     case '*':
1695       ADDASTER ();
1696       goto rflag;
1697     case '-':
1698     case '+':
1699     case '\'':
1700       goto rflag;
1701     case '.':
1702       if ((ch = *fmt++) == '*') {
1703         ADDASTER ();
1704         goto rflag;
1705       }
1706       while (is_digit(ch)) {
1707         ch = *fmt++;
1708       }
1709       goto reswitch;
1710     case '0':
1711       goto rflag;
1712     case '1': case '2': case '3': case '4':
1713     case '5': case '6': case '7': case '8': case '9':
1714       n = 0;
1715       do {
1716         n = 10 * n + to_digit(ch);
1717         ch = *fmt++;
1718       } while (is_digit(ch));
1719       if (ch == '$') {
1720         nextarg = n;
1721         goto rflag;
1722       }
1723       goto reswitch;
1724 #ifndef NO_FLOATING_POINT
1725     case 'L':
1726       flags |= LONGDBL;
1727       goto rflag;
1728 #endif
1729     case 'h':
1730       if (flags & SHORTINT) {
1731         flags &= ~SHORTINT;
1732         flags |= CHARINT;
1733       } else
1734         flags |= SHORTINT;
1735       goto rflag;
1736     case 'j':
1737       flags |= INTMAXT;
1738       goto rflag;
1739     case 'l':
1740       if (flags & LONGINT) {
1741         flags &= ~LONGINT;
1742         flags |= LLONGINT;
1743       } else
1744         flags |= LONGINT;
1745       goto rflag;
1746     case 'q':
1747       flags |= LLONGINT;  /* not necessarily */
1748       goto rflag;
1749     case 't':
1750       flags |= PTRDIFFT;
1751       goto rflag;
1752     case 'z':
1753       flags |= SIZET;
1754       goto rflag;
1755     case 'C':
1756       flags |= LONGINT;
1757       /*FALLTHROUGH*/
1758     case 'c':
1759       if (flags & LONGINT)
1760         ADDTYPE(T_WINT);
1761       else
1762         ADDTYPE(T_INT);
1763       break;
1764     case 'D':
1765       flags |= LONGINT;
1766       /*FALLTHROUGH*/
1767     case 'd':
1768     case 'i':
1769       ADDSARG();
1770       break;
1771 #ifndef NO_FLOATING_POINT
1772     case 'a':
1773     case 'A':
1774     case 'e':
1775     case 'E':
1776     case 'f':
1777     case 'g':
1778     case 'G':
1779       if (flags & LONGDBL)
1780         ADDTYPE(T_LONG_DOUBLE);
1781       else
1782         ADDTYPE(T_DOUBLE);
1783       break;
1784 #endif /* !NO_FLOATING_POINT */
1785     case 'n':
1786       if (flags & INTMAXT)
1787         ADDTYPE(TP_INTMAXT);
1788       else if (flags & PTRDIFFT)
1789         ADDTYPE(TP_PTRDIFFT);
1790       else if (flags & SIZET)
1791         ADDTYPE(TP_SIZET);
1792       else if (flags & LLONGINT)
1793         ADDTYPE(TP_LLONG);
1794       else if (flags & LONGINT)
1795         ADDTYPE(TP_LONG);
1796       else if (flags & SHORTINT)
1797         ADDTYPE(TP_SHORT);
1798       else if (flags & CHARINT)
1799         ADDTYPE(TP_SCHAR);
1800       else
1801         ADDTYPE(TP_INT);
1802       continue; /* no output */
1803     case 'O':
1804       flags |= LONGINT;
1805       /*FALLTHROUGH*/
1806     case 'o':
1807       ADDUARG();
1808       break;
1809     case 'p':
1810       ADDTYPE(TP_VOID);
1811       break;
1812     case 'S':
1813       flags |= LONGINT;
1814       /*FALLTHROUGH*/
1815     case 's':
1816       if (flags & LONGINT)
1817         ADDTYPE(TP_WCHAR);
1818       else
1819         ADDTYPE(TP_CHAR);
1820       break;
1821     case 'U':
1822       flags |= LONGINT;
1823       /*FALLTHROUGH*/
1824     case 'u':
1825     case 'X':
1826     case 'x':
1827       ADDUARG();
1828       break;
1829     default:  /* "%?" prints ?, unless ? is NUL */
1830       if (ch == '\0')
1831         goto done;
1832       break;
1833     }
1834   }
1835 done:
1836   /*
1837    * Build the argument table.
1838    */
1839   if (tablemax >= STATIC_ARG_TBL_SIZE) {
1840     *argtable = (union arg *)
1841         malloc (sizeof (union arg) * (tablemax + 1));
1842     if (*argtable == NULL)
1843       return -1;
1844   }
1845
1846   (*argtable) [0].intarg = 0;
1847   for (n = 1; n <= tablemax; n++) {
1848     switch (typetable [n]) {
1849         case T_UNUSED: /* whoops! */
1850       (*argtable) [n].intarg = va_arg (ap, int);
1851       break;
1852         case TP_SCHAR:
1853       (*argtable) [n].pschararg = va_arg (ap, signed char *);
1854       break;
1855         case TP_SHORT:
1856       (*argtable) [n].pshortarg = va_arg (ap, short *);
1857       break;
1858         case T_INT:
1859       (*argtable) [n].intarg = va_arg (ap, int);
1860       break;
1861         case T_U_INT:
1862       (*argtable) [n].uintarg = va_arg (ap, unsigned int);
1863       break;
1864         case TP_INT:
1865       (*argtable) [n].pintarg = va_arg (ap, int *);
1866       break;
1867         case T_LONG:
1868       (*argtable) [n].longarg = va_arg (ap, long);
1869       break;
1870         case T_U_LONG:
1871       (*argtable) [n].ulongarg = va_arg (ap, unsigned long);
1872       break;
1873         case TP_LONG:
1874       (*argtable) [n].plongarg = va_arg (ap, long *);
1875       break;
1876         case T_LLONG:
1877       (*argtable) [n].longlongarg = va_arg (ap, long long);
1878       break;
1879         case T_U_LLONG:
1880       (*argtable) [n].ulonglongarg = va_arg (ap, unsigned long long);
1881       break;
1882         case TP_LLONG:
1883       (*argtable) [n].plonglongarg = va_arg (ap, long long *);
1884       break;
1885         case T_PTRDIFFT:
1886       (*argtable) [n].ptrdiffarg = va_arg (ap, ptrdiff_t);
1887       break;
1888         case TP_PTRDIFFT:
1889       (*argtable) [n].pptrdiffarg = va_arg (ap, ptrdiff_t *);
1890       break;
1891         case T_SIZET:
1892       (*argtable) [n].sizearg = va_arg (ap, size_t);
1893       break;
1894         case TP_SIZET:
1895       (*argtable) [n].psizearg = va_arg (ap, size_t *);
1896       break;
1897         case T_INTMAXT:
1898       (*argtable) [n].intmaxarg = va_arg (ap, intmax_t);
1899       break;
1900         case T_UINTMAXT:
1901       (*argtable) [n].uintmaxarg = va_arg (ap, uintmax_t);
1902       break;
1903         case TP_INTMAXT:
1904       (*argtable) [n].pintmaxarg = va_arg (ap, intmax_t *);
1905       break;
1906         case T_DOUBLE:
1907 #ifndef NO_FLOATING_POINT
1908       (*argtable) [n].doublearg = va_arg (ap, double);
1909 #endif
1910       break;
1911         case T_LONG_DOUBLE:
1912 #ifndef NO_FLOATING_POINT
1913       (*argtable) [n].longdoublearg = va_arg (ap, long double);
1914 #endif
1915       break;
1916         case TP_CHAR:
1917       (*argtable) [n].pchararg = va_arg (ap, char *);
1918       break;
1919         case TP_VOID:
1920       (*argtable) [n].pvoidarg = va_arg (ap, void *);
1921       break;
1922         case T_WINT:
1923       (*argtable) [n].wintarg = va_arg (ap, int);
1924       break;
1925         case TP_WCHAR:
1926       (*argtable) [n].pwchararg = va_arg (ap, wchar_t *);
1927       break;
1928     }
1929   }
1930
1931   if ((typetable != NULL) && (typetable != stattypetable))
1932     free (typetable);
1933   return 0;
1934 }
1935
1936 /*
1937  * Increase the size of the type table.
1938  */
1939 static int
1940 __grow_type_table (int nextarg, enum typeid **typetable, int *tablesize)
1941 {
1942   enum typeid *const oldtable = *typetable;
1943   const int oldsize = *tablesize;
1944   enum typeid *newtable;
1945   int n, newsize = oldsize * 2;
1946
1947   if (newsize < nextarg + 1)
1948     newsize = nextarg + 1;
1949   if (oldsize == STATIC_ARG_TBL_SIZE) {
1950     if ((newtable = malloc(newsize * sizeof(enum typeid))) == NULL)
1951       return -1;
1952     memcpy(newtable, oldtable, oldsize * sizeof(enum typeid));
1953   } else {
1954     newtable = realloc(oldtable, newsize * sizeof(enum typeid));
1955     if (newtable == NULL) {
1956       free(oldtable);
1957       return -1;
1958     }
1959   }
1960   for (n = oldsize; n < newsize; n++)
1961     newtable[n] = T_UNUSED;
1962
1963   *typetable = newtable;
1964   *tablesize = newsize;
1965   return 0;
1966 }
1967
1968
1969 #ifndef NO_FLOATING_POINT
1970 #ifndef WIDE_DOUBLE
1971 static char *
1972 cvt(double value, int ndigits, int flags, char *sign, int *decpt, int ch,
1973     int *length)
1974 {
1975   int mode, dsgn;
1976   char *digits, *bp, *rve;
1977
1978   _DIAGASSERT(decpt != NULL);
1979   _DIAGASSERT(length != NULL);
1980   _DIAGASSERT(sign != NULL);
1981
1982   if (ch == 'f') {
1983     mode = 3;   /* ndigits after the decimal point */
1984   } else {
1985     /* To obtain ndigits after the decimal point for the 'e'
1986      * and 'E' formats, round to ndigits + 1 significant
1987      * figures.
1988      */
1989     if (ch == 'e' || ch == 'E') {
1990       ndigits++;
1991     }
1992     mode = 2;   /* ndigits significant digits */
1993   }
1994
1995   digits = __dtoa(value, mode, ndigits, decpt, &dsgn, &rve);
1996   if (digits == NULL)
1997     return NULL;
1998   if (dsgn) {
1999     value = -value;
2000     *sign = '-';
2001   } else
2002     *sign = '\000';
2003   if ((ch != 'g' && ch != 'G') || flags & ALT) {  /* Print trailing zeros */
2004     bp = digits + ndigits;
2005     if (ch == 'f') {
2006       if (*digits == '0' && value)
2007         *decpt = -ndigits + 1;
2008       bp += *decpt;
2009     }
2010     while (rve < bp)
2011       *rve++ = '0';
2012   }
2013   *length = rve - digits;
2014   return digits;
2015 }
2016 #endif
2017
2018 static int
2019 exponent(CHAR_T *p0, int expo, int fmtch)
2020 {
2021   CHAR_T *p, *t;
2022   CHAR_T expbuf[MAXEXPDIG];
2023
2024   p = p0;
2025   *p++ = fmtch;
2026   if (expo < 0) {
2027     expo = -expo;
2028     *p++ = '-';
2029   }
2030   else
2031     *p++ = '+';
2032   t = expbuf + MAXEXPDIG;
2033   if (expo > 9) {
2034     do {
2035       *--t = to_char(expo % 10);
2036     } while ((expo /= 10) > 9);
2037     *--t = to_char(expo);
2038     for (; t < expbuf + MAXEXPDIG; *p++ = *t++);
2039   }
2040   else {
2041     /*
2042      * Exponents for decimal floating point conversions
2043      * (%[eEgG]) must be at least two characters long,
2044      * whereas exponents for hexadecimal conversions can
2045      * be only one character long.
2046      */
2047     if (fmtch == 'e' || fmtch == 'E')
2048       *p++ = '0';
2049     *p++ = to_char(expo);
2050   }
2051   return (p - p0);
2052 }
2053 #endif /* !NO_FLOATING_POINT */