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             (wchar_t)GETARG(wint_t), &mbs);
1007         if (mbseqlen == (size_t)-1) {
1008           fp->_flags |= __SERR;
1009           goto error;
1010         }
1011         size = (int)mbseqlen;
1012       } else {
1013         *buf = (char)(GETARG(int));
1014         size = 1;
1015       }
1016 #else
1017       if (flags & LONGINT)
1018         *buf = (wchar_t)GETARG(wint_t);
1019       else
1020         *buf = (wchar_t)btowc(GETARG(int));
1021       size = 1;
1022 #endif
1023       result = buf;
1024       sign = '\0';
1025       break;
1026     case 'D':
1027       flags |= LONGINT;
1028       /*FALLTHROUGH*/
1029     case 'd':
1030     case 'i':
1031       if (flags & INTMAX_SIZE) {
1032         ujval = SJARG();
1033         if ((intmax_t)ujval < 0) {
1034           ujval = (uintmax_t)(-((intmax_t)ujval));
1035           sign = '-';
1036         }
1037       } else {
1038         ulval = SARG();
1039         if ((long)ulval < 0) {
1040           ulval = (u_long)(-((long)ulval));
1041           sign = '-';
1042         }
1043       }
1044       base = 10;
1045       goto number;
1046 #ifndef NO_FLOATING_POINT
1047 #ifdef WIDE_DOUBLE
1048     case 'a':
1049     case 'A':
1050       if (ch == 'a') {
1051         ox[1] = 'x';
1052         xdigs = xdigs_lower;
1053         expchar = 'p';
1054       } else {
1055         ox[1] = 'X';
1056         xdigs = xdigs_upper;
1057         expchar = 'P';
1058       }
1059       if (flags & LONGDBL) {
1060         fparg.ldbl = GETARG(long double);
1061         dtoaresult =
1062             __hldtoa(fparg.ldbl, xdigs, prec,
1063                 &expt, &signflag, &dtoaend);
1064       } else {
1065         fparg.dbl = GETARG(double);
1066         dtoaresult =
1067             __hdtoa(fparg.dbl, xdigs, prec,
1068                 &expt, &signflag, &dtoaend);
1069       }
1070       if (dtoaresult == NULL)
1071         goto oomem;
1072
1073       if (prec < 0)
1074         prec = dtoaend - dtoaresult;
1075       if (expt == INT_MAX)
1076         ox[1] = '\0';
1077       ndig = dtoaend - dtoaresult;
1078       if (convbuf != NULL)
1079         free(convbuf);
1080 #ifndef NARROW
1081       result = convbuf = __mbsconv(dtoaresult, -1);
1082 #else
1083       /*XXX inefficient*/
1084       result = convbuf = strdup(dtoaresult);
1085 #endif
1086       if (result == NULL)
1087         goto oomem;
1088       __freedtoa(dtoaresult);
1089       goto fp_common;
1090     case 'e':
1091     case 'E':
1092       expchar = ch;
1093       if (prec < 0)
1094         prec = DEFPREC;
1095       goto fp_begin;
1096     case 'f':
1097     case 'F':
1098       expchar = '\0';
1099       goto fp_begin;
1100     case 'g':
1101     case 'G':
1102       expchar = ch - ('g' - 'e');
1103       if (prec == 0)
1104         prec = 1;
1105 fp_begin:
1106       if (prec < 0)
1107         prec = DEFPREC;
1108       if (flags & LONGDBL) {
1109         fparg.ldbl = GETARG(long double);
1110         dtoaresult =
1111             __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec,
1112             &expt, &signflag, &dtoaend);
1113       } else {
1114         fparg.dbl = GETARG(double);
1115         dtoaresult =
1116             __dtoa(fparg.dbl, expchar ? 2 : 3, prec,
1117             &expt, &signflag, &dtoaend);
1118         if (expt == 9999)
1119           expt = INT_MAX;
1120       }
1121       if (dtoaresult == NULL)
1122         goto oomem;
1123       ndig = dtoaend - dtoaresult;
1124       if (convbuf != NULL)
1125         free(convbuf);
1126 #ifndef NARROW
1127       result = convbuf = __mbsconv(dtoaresult, -1);
1128 #else
1129       /*XXX inefficient*/
1130       result = convbuf = strdup(dtoaresult);
1131 #endif
1132       if (result == NULL)
1133         goto oomem;
1134       __freedtoa(dtoaresult);
1135 fp_common:
1136       if (signflag)
1137         sign = '-';
1138       if (expt == INT_MAX) {  /* inf or nan */
1139         if (*result == 'N') {
1140           result = (ch >= 'a') ? STRCONST("nan") :
1141               STRCONST("NAN");
1142           sign = '\0';
1143         } else
1144           result = (ch >= 'a') ? STRCONST("inf") :
1145               STRCONST("INF");
1146         size = 3;
1147         break;
1148       }
1149 #else
1150     //case 'e':
1151     //case 'E':
1152     //case 'f':
1153     //case 'F':
1154     //case 'g':
1155     //case 'G':
1156     //  if (prec == -1) {
1157     //    prec = DEFPREC;
1158     //  } else if ((ch == 'g' || ch == 'G') && prec == 0) {
1159     //    prec = 1;
1160     //  }
1161     case 'e':
1162     case 'E':
1163       expchar = ch;
1164       if (prec < 0)
1165         prec = DEFPREC;
1166       goto fp_begin;
1167     case 'f':
1168     case 'F':
1169       expchar = '\0';
1170       goto fp_begin;
1171     case 'g':
1172     case 'G':
1173       expchar = ch - ('g' - 'e');
1174       if (prec == 0)
1175         prec = 1;
1176 fp_begin:
1177       if (prec < 0)
1178         prec = DEFPREC;
1179
1180       if (flags & LONGDBL) {
1181         _double = (double) GETARG(long double);
1182       } else {
1183         _double = GETARG(double);
1184       }
1185
1186       /* do this before tricky precision changes */
1187       if (isinf(_double)) {
1188         if (_double < 0)
1189           sign = '-';
1190         if (ch == 'E' || ch == 'F' || ch == 'G')
1191           result = STRCONST("INF");
1192         else
1193           result = STRCONST("inf");
1194         size = 3;
1195         break;
1196       }
1197       if (isnan(_double)) {
1198         if (ch == 'E' || ch == 'F' || ch == 'G')
1199           result = STRCONST("NAN");
1200         else
1201           result = STRCONST("nan");
1202         size = 3;
1203         break;
1204       }
1205
1206       flags |= FPT;
1207       dtoaresult = cvt(_double, prec, flags, &softsign, &expt, ch, &ndig);
1208       if (dtoaresult == NULL)
1209         goto oomem;
1210       if (convbuf != NULL)
1211         free(convbuf);
1212 #ifndef NARROW
1213       result = convbuf = __mbsconv(dtoaresult, -1);
1214 #else
1215       /*XXX inefficient*/
1216       result = convbuf = strdup(dtoaresult);
1217 #endif
1218       if (result == NULL)
1219         goto oomem;
1220       __freedtoa(dtoaresult);
1221       if (softsign)
1222         sign = '-';
1223 #endif
1224       flags |= FPT;
1225       if (ch == 'g' || ch == 'G') {
1226         if (expt > -4 && expt <= prec) {
1227           /* Make %[gG] smell like %[fF] */
1228           expchar = '\0';
1229           if (flags & ALT)
1230             prec -= expt;
1231           else
1232             prec = ndig - expt;
1233           if (prec < 0)
1234             prec = 0;
1235         } else {
1236           /*
1237            * Make %[gG] smell like %[eE], but
1238            * trim trailing zeroes if no # flag.
1239            *
1240            * Note: The precision field used with [gG] is the number significant
1241            * digits to print.  When converting to [eE] the digit before the
1242            * decimal must not be included in the precision value.
1243            */
1244           if (!(flags & ALT))
1245             prec = ndig - 1;
1246         }
1247       }
1248       if (expchar) {
1249         dprec = prec; /* In some cases dprec will not be set.  Make sure it is set now */
1250         expsize = exponent(expstr, expt - 1, expchar);
1251         size = expsize + prec + 1; /* Leading digit + exponent string + precision */
1252         if (prec >= 1 || flags & ALT)
1253           ++size; /* Decimal point is added to character count */
1254       } else {
1255         /* space for digits before decimal point */
1256         if (expt > 0)
1257           size = expt;
1258         else  /* "0" */
1259           size = 1;
1260         /* space for decimal pt and following digits */
1261         if (prec || flags & ALT)
1262           size += prec + 1;
1263         if (grouping && expt > 0) {
1264           /* space for thousands' grouping */
1265           nseps = nrepeats = 0;
1266           lead = expt;
1267           while (*grouping != CHAR_MAX) {
1268             if (lead <= *grouping)
1269               break;
1270             lead -= *grouping;
1271             if (*(grouping+1)) {
1272               nseps++;
1273               grouping++;
1274             } else
1275               nrepeats++;
1276           }
1277           size += nseps + nrepeats;
1278         } else
1279           lead = expt;
1280       }
1281       break;
1282 #endif /* !NO_FLOATING_POINT */
1283     case 'n':
1284       /*
1285        * Assignment-like behavior is specified if the
1286        * value overflows or is otherwise unrepresentable.
1287        * C99 says to use `signed char' for %hhn conversions.
1288        */
1289       if (flags & LLONGINT)
1290         *GETARG(long long *) = ret;
1291       else if (flags & SIZET)
1292         *GETARG(ssize_t *) = (ssize_t)ret;
1293       else if (flags & PTRDIFFT)
1294         *GETARG(ptrdiff_t *) = ret;
1295       else if (flags & INTMAXT)
1296         *GETARG(intmax_t *) = ret;
1297       else if (flags & LONGINT)
1298         *GETARG(long *) = ret;
1299       else if (flags & SHORTINT)
1300         *GETARG(short *) = ret;
1301       else if (flags & CHARINT)
1302         *GETARG(signed char *) = ret;
1303       else
1304         *GETARG(int *) = ret;
1305       continue; /* no output */
1306     case 'O':
1307       flags |= LONGINT;
1308       /*FALLTHROUGH*/
1309     case 'o':
1310       if (flags & INTMAX_SIZE)
1311         ujval = UJARG();
1312       else
1313         ulval = UARG();
1314       base = 8;
1315       goto nosign;
1316     case 'p':
1317       /*-
1318        * ``The argument shall be a pointer to void.  The
1319        * value of the pointer is converted to a sequence
1320        * of printable characters, in an implementation-
1321        * defined manner.''
1322        *  -- ANSI X3J11
1323        */
1324       ujval = (uintmax_t) (UINTN) GETARG(void *);
1325       base = 16;
1326       xdigs = xdigs_lower;
1327       flags = flags | INTMAXT;
1328       ox[1] = 'x';
1329       goto nosign;
1330     case 'S':
1331       flags |= LONGINT;
1332       /*FALLTHROUGH*/
1333     case 's':
1334       if (((flags & LONGINT) ? 1:0) != MULTI) {
1335         if ((result = GETARG(CHAR_T *)) == NULL)
1336           result = STRCONST("(null)");
1337       } else {
1338         MCHAR_T *mc;
1339
1340         if (convbuf != NULL)
1341           free(convbuf);
1342         if ((mc = GETARG(MCHAR_T *)) == NULL)
1343           result = STRCONST("(null)");
1344         else {
1345           convbuf = SCONV(mc, prec);
1346           if (convbuf == NULL) {
1347             fp->_flags |= __SERR;
1348             goto error;
1349           }
1350           result = convbuf;
1351         }
1352       }
1353
1354       if (prec >= 0) {
1355         /*
1356          * can't use STRLEN; can only look for the
1357          * NUL in the first `prec' characters, and
1358          * STRLEN() will go further.
1359          */
1360         CHAR_T *p = MEMCHR(result, 0, (size_t)prec);
1361
1362         if (p != NULL) {
1363           size = p - result;
1364           if (size > prec)
1365             size = prec;
1366         } else
1367           size = prec;
1368       } else
1369         size = (int)STRLEN(result);
1370       sign = '\0';
1371       break;
1372     case 'U':
1373       flags |= LONGINT;
1374       /*FALLTHROUGH*/
1375     case 'u':
1376       if (flags & INTMAX_SIZE)
1377         ujval = UJARG();
1378       else
1379         ulval = UARG();
1380       base = 10;
1381       goto nosign;
1382     case 'X':
1383       xdigs = xdigs_upper;
1384       goto hex;
1385     case 'x':
1386       xdigs = xdigs_lower;
1387 hex:
1388       if (flags & INTMAX_SIZE)
1389         ujval = UJARG();
1390       else
1391         ulval = UARG();
1392       base = 16;
1393       /* leading 0x/X only if non-zero */
1394       if (flags & ALT &&
1395           (flags & INTMAX_SIZE ? ujval != 0 : ulval != 0))
1396         ox[1] = ch;
1397
1398       flags &= ~GROUPING;
1399       /* unsigned conversions */
1400 nosign:     sign = '\0';
1401       /*-
1402        * ``... diouXx conversions ... if a precision is
1403        * specified, the 0 flag will be ignored.''
1404        *  -- ANSI X3J11
1405        */
1406 number:     if ((dprec = prec) >= 0)
1407         flags &= ~ZEROPAD;
1408
1409       /*-
1410        * ``The result of converting a zero value with an
1411        * explicit precision of zero is no characters.''
1412        *  -- ANSI X3J11
1413        *
1414        * ``The C Standard is clear enough as is.  The call
1415        * printf("%#.0o", 0) should print 0.''
1416        *  -- Defect Report #151
1417        */
1418       result = cp = buf + BUF;
1419       if (flags & INTMAX_SIZE) {
1420         if (ujval != 0 || prec != 0 ||
1421             (flags & ALT && base == 8))
1422         {
1423           result = __ujtoa(ujval, cp, base,
1424               flags & ALT, xdigs,
1425               flags & GROUPING, thousands_sep,
1426               grouping);
1427         }
1428       } else {
1429         if (ulval != 0 || prec != 0 ||
1430             (flags & ALT && base == 8))
1431           result = __ultoa(ulval, cp, base,
1432               flags & ALT, xdigs,
1433               flags & GROUPING, thousands_sep,
1434               grouping);
1435       }
1436       size = buf + BUF - result;
1437       if (size > BUF) /* should never happen */
1438         abort();
1439       break;
1440     default:  /* "%?" prints ?, unless ? is NUL */
1441       if (ch == '\0')
1442         goto done;
1443       /* pretend it was %c with argument ch */
1444       *buf = ch;
1445       result = buf;
1446       size = 1;
1447       sign = '\0';
1448       break;
1449     }
1450
1451     /*
1452      * All reasonable formats wind up here.  At this point, `result'
1453      * points to a string which (if not flags&LADJUST) should be
1454      * padded out to `width' places.  If flags&ZEROPAD, it should
1455      * first be prefixed by any sign or other prefix; otherwise,
1456      * it should be blank padded before the prefix is emitted.
1457      * After any left-hand padding and prefixing, emit zeroes
1458      * required by a decimal [diouxX] precision, then print the
1459      * string proper, then emit zeroes required by any leftover
1460      * floating precision; finally, if LADJUST, pad with blanks.
1461      *
1462      * Compute actual size, so we know how much to pad.
1463      * size excludes decimal prec; realsz includes it.
1464      */
1465     realsz = dprec > size ? dprec : size;
1466     if (sign)
1467       realsz++;
1468     if (ox[1])
1469       realsz += 2;
1470
1471     prsize = width > realsz ? width : realsz;
1472     if ((unsigned)ret + prsize > INT_MAX) {
1473       ret = END_OF_FILE;
1474       goto error;
1475     }
1476
1477     /* right-adjusting blank padding */
1478     if ((flags & (LADJUST|ZEROPAD)) == 0)
1479       PAD(width - realsz, blanks);
1480
1481     /* prefix */
1482     if (sign)
1483       PRINT(&sign, 1);
1484
1485     if (ox[1]) {  /* ox[1] is either x, X, or \0 */
1486       ox[0] = '0';
1487       PRINT(ox, 2);
1488     }
1489
1490     /* right-adjusting zero padding */
1491     if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
1492       PAD(width - realsz, zeroes);
1493
1494     /* leading zeroes from decimal precision */
1495     PAD(dprec - size, zeroes);
1496
1497     /* the string or number proper */
1498 #ifndef NO_FLOATING_POINT
1499     if ((flags & FPT) == 0) {
1500       PRINT(result, size);
1501     } else {  /* glue together f_p fragments */
1502       if (!expchar) { /* %[fF] or sufficiently short %[gG] */
1503         if (expt <= 0) {
1504           PRINT(zeroes, 1);
1505           if (prec || flags & ALT)
1506             PRINT(decimal_point, 1);
1507           PAD(-expt, zeroes);
1508           /* already handled initial 0's */
1509           prec += expt;
1510         } else {
1511           PRINTANDPAD(result, convbuf + ndig,
1512               lead, zeroes);
1513           result += lead;
1514           if (grouping) {
1515             while (nseps>0 || nrepeats>0) {
1516               if (nrepeats > 0)
1517                 nrepeats--;
1518               else {
1519                 grouping--;
1520                 nseps--;
1521               }
1522               PRINT(&thousands_sep,
1523                   1);
1524               PRINTANDPAD(result,
1525                   convbuf + ndig,
1526                   *grouping, zeroes);
1527               result += *grouping;
1528             }
1529             if (result > convbuf + ndig)
1530               result = convbuf + ndig;
1531           }
1532           if (prec || flags & ALT) {
1533             buf[0] = *decimal_point;
1534             PRINT(buf, 1);
1535           }
1536         }
1537         PRINTANDPAD(result, convbuf + ndig, prec,
1538             zeroes);
1539       } else {  /* %[eE] or sufficiently long %[gG] */
1540         if (prec >= 1 || flags & ALT) {
1541           buf[0] = *result++;
1542           buf[1] = *decimal_point;
1543           PRINT(buf, 2);
1544           PRINT(result, ndig-1);
1545           PAD(prec - ndig, zeroes);
1546         } else  /* XeYYY */
1547           PRINT(result, 1);
1548         PRINT(expstr, expsize);
1549       }
1550     }
1551 #else
1552     PRINT(result, size);
1553 #endif
1554     /* left-adjusting padding (always blank) */
1555     if (flags & LADJUST)
1556       PAD(width - realsz, blanks);
1557
1558     /* finally, adjust ret */
1559     ret += prsize;
1560     FLUSH();
1561   }
1562 done:
1563   FLUSH();
1564 error:
1565   va_end(orgap);
1566   if (convbuf != NULL)
1567     free(convbuf);
1568   if (__sferror(fp))
1569     ret = END_OF_FILE;
1570   if ((argtable != NULL) && (argtable != statargtable))
1571     free (argtable);
1572   return (ret);
1573   /* NOTREACHED */
1574 oomem:
1575   errno = ENOMEM;
1576   ret = END_OF_FILE;
1577   goto error;
1578 }
1579
1580 /*
1581  * Find all arguments when a positional parameter is encountered.  Returns a
1582  * table, indexed by argument number, of pointers to each arguments.  The
1583  * initial argument table should be an array of STATIC_ARG_TBL_SIZE entries.
1584  * It will be replaces with a malloc-ed one if it overflows.
1585  */
1586 static int
1587 __find_arguments(const CHAR_T *fmt0, va_list ap, union arg **argtable)
1588 {
1589   CHAR_T *fmt;    /* format string */
1590   int ch;     /* character from fmt */
1591   int n, n2;    /* handy integer (short term usage) */
1592   CHAR_T *cp;   /* handy char pointer (short term usage) */
1593   int flags;    /* flags as above */
1594   enum typeid *typetable; /* table of types */
1595   enum typeid stattypetable [STATIC_ARG_TBL_SIZE];
1596   int tablesize;    /* current size of type table */
1597   int tablemax;   /* largest used index in table */
1598   int nextarg;    /* 1-based argument index */
1599
1600   /*
1601    * Add an argument type to the table, expanding if necessary.
1602    */
1603 #define ADDTYPE(type) \
1604   do { \
1605     if (nextarg >= tablesize) \
1606       if (__grow_type_table(nextarg, &typetable, \
1607           &tablesize) == -1) \
1608         return -1; \
1609     if (nextarg > tablemax) \
1610       tablemax = nextarg; \
1611     typetable[nextarg++] = type; \
1612   } while (/*CONSTCOND*/0)
1613
1614 #define ADDSARG() \
1615   do { \
1616     if (flags & INTMAXT)  \
1617       ADDTYPE(T_INTMAXT); \
1618     else if (flags & SIZET)  \
1619       ADDTYPE(T_SIZET); \
1620     else if (flags & PTRDIFFT) \
1621       ADDTYPE(T_PTRDIFFT); \
1622     else if (flags & LLONGINT) \
1623       ADDTYPE(T_LLONG); \
1624     else if (flags & LONGINT) \
1625       ADDTYPE(T_LONG); \
1626     else \
1627       ADDTYPE(T_INT); \
1628   } while (/*CONSTCOND*/0)
1629
1630 #define ADDUARG() \
1631   do { \
1632     if (flags & INTMAXT)  \
1633       ADDTYPE(T_UINTMAXT); \
1634     else if (flags & SIZET)  \
1635       ADDTYPE(T_SIZET); \
1636     else if (flags & PTRDIFFT) \
1637       ADDTYPE(T_PTRDIFFT); \
1638     else if (flags & LLONGINT) \
1639       ADDTYPE(T_U_LLONG); \
1640     else if (flags & LONGINT) \
1641       ADDTYPE(T_U_LONG); \
1642     else \
1643       ADDTYPE(T_U_INT); \
1644   } while (/*CONSTCOND*/0)
1645   /*
1646    * Add * arguments to the type array.
1647    */
1648 #define ADDASTER() \
1649   n2 = 0; \
1650   cp = fmt; \
1651   while (is_digit(*cp)) { \
1652     n2 = 10 * n2 + to_digit(*cp); \
1653     cp++; \
1654   } \
1655   if (*cp == '$') { \
1656     int hold = nextarg; \
1657     nextarg = n2; \
1658     ADDTYPE(T_INT); \
1659     nextarg = hold; \
1660     fmt = ++cp; \
1661   } else { \
1662     ADDTYPE(T_INT); \
1663   }
1664   fmt = (CHAR_T *)__UNCONST(fmt0);
1665   typetable = stattypetable;
1666   tablesize = STATIC_ARG_TBL_SIZE;
1667   tablemax = 0;
1668   nextarg = 1;
1669   for (n = 0; n < STATIC_ARG_TBL_SIZE; n++)
1670     typetable[n] = T_UNUSED;
1671
1672   /*
1673    * Scan the format for conversions (`%' character).
1674    */
1675   for (;;) {
1676     for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
1677       /* void */;
1678     if (ch == '\0')
1679       goto done;
1680     fmt++;    /* skip over '%' */
1681
1682     flags = 0;
1683
1684 rflag:    ch = *fmt++;
1685 reswitch: switch (ch) {
1686     case ' ':
1687     case '#':
1688       goto rflag;
1689     case '*':
1690       ADDASTER ();
1691       goto rflag;
1692     case '-':
1693     case '+':
1694     case '\'':
1695       goto rflag;
1696     case '.':
1697       if ((ch = *fmt++) == '*') {
1698         ADDASTER ();
1699         goto rflag;
1700       }
1701       while (is_digit(ch)) {
1702         ch = *fmt++;
1703       }
1704       goto reswitch;
1705     case '0':
1706       goto rflag;
1707     case '1': case '2': case '3': case '4':
1708     case '5': case '6': case '7': case '8': case '9':
1709       n = 0;
1710       do {
1711         n = 10 * n + to_digit(ch);
1712         ch = *fmt++;
1713       } while (is_digit(ch));
1714       if (ch == '$') {
1715         nextarg = n;
1716         goto rflag;
1717       }
1718       goto reswitch;
1719 #ifndef NO_FLOATING_POINT
1720     case 'L':
1721       flags |= LONGDBL;
1722       goto rflag;
1723 #endif
1724     case 'h':
1725       if (flags & SHORTINT) {
1726         flags &= ~SHORTINT;
1727         flags |= CHARINT;
1728       } else
1729         flags |= SHORTINT;
1730       goto rflag;
1731     case 'j':
1732       flags |= INTMAXT;
1733       goto rflag;
1734     case 'l':
1735       if (flags & LONGINT) {
1736         flags &= ~LONGINT;
1737         flags |= LLONGINT;
1738       } else
1739         flags |= LONGINT;
1740       goto rflag;
1741     case 'q':
1742       flags |= LLONGINT;  /* not necessarily */
1743       goto rflag;
1744     case 't':
1745       flags |= PTRDIFFT;
1746       goto rflag;
1747     case 'z':
1748       flags |= SIZET;
1749       goto rflag;
1750     case 'C':
1751       flags |= LONGINT;
1752       /*FALLTHROUGH*/
1753     case 'c':
1754       if (flags & LONGINT)
1755         ADDTYPE(T_WINT);
1756       else
1757         ADDTYPE(T_INT);
1758       break;
1759     case 'D':
1760       flags |= LONGINT;
1761       /*FALLTHROUGH*/
1762     case 'd':
1763     case 'i':
1764       ADDSARG();
1765       break;
1766 #ifndef NO_FLOATING_POINT
1767     case 'a':
1768     case 'A':
1769     case 'e':
1770     case 'E':
1771     case 'f':
1772     case 'g':
1773     case 'G':
1774       if (flags & LONGDBL)
1775         ADDTYPE(T_LONG_DOUBLE);
1776       else
1777         ADDTYPE(T_DOUBLE);
1778       break;
1779 #endif /* !NO_FLOATING_POINT */
1780     case 'n':
1781       if (flags & INTMAXT)
1782         ADDTYPE(TP_INTMAXT);
1783       else if (flags & PTRDIFFT)
1784         ADDTYPE(TP_PTRDIFFT);
1785       else if (flags & SIZET)
1786         ADDTYPE(TP_SIZET);
1787       else if (flags & LLONGINT)
1788         ADDTYPE(TP_LLONG);
1789       else if (flags & LONGINT)
1790         ADDTYPE(TP_LONG);
1791       else if (flags & SHORTINT)
1792         ADDTYPE(TP_SHORT);
1793       else if (flags & CHARINT)
1794         ADDTYPE(TP_SCHAR);
1795       else
1796         ADDTYPE(TP_INT);
1797       continue; /* no output */
1798     case 'O':
1799       flags |= LONGINT;
1800       /*FALLTHROUGH*/
1801     case 'o':
1802       ADDUARG();
1803       break;
1804     case 'p':
1805       ADDTYPE(TP_VOID);
1806       break;
1807     case 'S':
1808       flags |= LONGINT;
1809       /*FALLTHROUGH*/
1810     case 's':
1811       if (flags & LONGINT)
1812         ADDTYPE(TP_WCHAR);
1813       else
1814         ADDTYPE(TP_CHAR);
1815       break;
1816     case 'U':
1817       flags |= LONGINT;
1818       /*FALLTHROUGH*/
1819     case 'u':
1820     case 'X':
1821     case 'x':
1822       ADDUARG();
1823       break;
1824     default:  /* "%?" prints ?, unless ? is NUL */
1825       if (ch == '\0')
1826         goto done;
1827       break;
1828     }
1829   }
1830 done:
1831   /*
1832    * Build the argument table.
1833    */
1834   if (tablemax >= STATIC_ARG_TBL_SIZE) {
1835     *argtable = (union arg *)
1836         malloc (sizeof (union arg) * (tablemax + 1));
1837     if (*argtable == NULL)
1838       return -1;
1839   }
1840
1841   (*argtable) [0].intarg = 0;
1842   for (n = 1; n <= tablemax; n++) {
1843     switch (typetable [n]) {
1844         case T_UNUSED: /* whoops! */
1845       (*argtable) [n].intarg = va_arg (ap, int);
1846       break;
1847         case TP_SCHAR:
1848       (*argtable) [n].pschararg = va_arg (ap, signed char *);
1849       break;
1850         case TP_SHORT:
1851       (*argtable) [n].pshortarg = va_arg (ap, short *);
1852       break;
1853         case T_INT:
1854       (*argtable) [n].intarg = va_arg (ap, int);
1855       break;
1856         case T_U_INT:
1857       (*argtable) [n].uintarg = va_arg (ap, unsigned int);
1858       break;
1859         case TP_INT:
1860       (*argtable) [n].pintarg = va_arg (ap, int *);
1861       break;
1862         case T_LONG:
1863       (*argtable) [n].longarg = va_arg (ap, long);
1864       break;
1865         case T_U_LONG:
1866       (*argtable) [n].ulongarg = va_arg (ap, unsigned long);
1867       break;
1868         case TP_LONG:
1869       (*argtable) [n].plongarg = va_arg (ap, long *);
1870       break;
1871         case T_LLONG:
1872       (*argtable) [n].longlongarg = va_arg (ap, long long);
1873       break;
1874         case T_U_LLONG:
1875       (*argtable) [n].ulonglongarg = va_arg (ap, unsigned long long);
1876       break;
1877         case TP_LLONG:
1878       (*argtable) [n].plonglongarg = va_arg (ap, long long *);
1879       break;
1880         case T_PTRDIFFT:
1881       (*argtable) [n].ptrdiffarg = va_arg (ap, ptrdiff_t);
1882       break;
1883         case TP_PTRDIFFT:
1884       (*argtable) [n].pptrdiffarg = va_arg (ap, ptrdiff_t *);
1885       break;
1886         case T_SIZET:
1887       (*argtable) [n].sizearg = va_arg (ap, size_t);
1888       break;
1889         case TP_SIZET:
1890       (*argtable) [n].psizearg = va_arg (ap, size_t *);
1891       break;
1892         case T_INTMAXT:
1893       (*argtable) [n].intmaxarg = va_arg (ap, intmax_t);
1894       break;
1895         case T_UINTMAXT:
1896       (*argtable) [n].uintmaxarg = va_arg (ap, uintmax_t);
1897       break;
1898         case TP_INTMAXT:
1899       (*argtable) [n].pintmaxarg = va_arg (ap, intmax_t *);
1900       break;
1901         case T_DOUBLE:
1902 #ifndef NO_FLOATING_POINT
1903       (*argtable) [n].doublearg = va_arg (ap, double);
1904 #endif
1905       break;
1906         case T_LONG_DOUBLE:
1907 #ifndef NO_FLOATING_POINT
1908       (*argtable) [n].longdoublearg = va_arg (ap, long double);
1909 #endif
1910       break;
1911         case TP_CHAR:
1912       (*argtable) [n].pchararg = va_arg (ap, char *);
1913       break;
1914         case TP_VOID:
1915       (*argtable) [n].pvoidarg = va_arg (ap, void *);
1916       break;
1917         case T_WINT:
1918       (*argtable) [n].wintarg = va_arg (ap, wint_t);
1919       break;
1920         case TP_WCHAR:
1921       (*argtable) [n].pwchararg = va_arg (ap, wchar_t *);
1922       break;
1923     }
1924   }
1925
1926   if ((typetable != NULL) && (typetable != stattypetable))
1927     free (typetable);
1928   return 0;
1929 }
1930
1931 /*
1932  * Increase the size of the type table.
1933  */
1934 static int
1935 __grow_type_table (int nextarg, enum typeid **typetable, int *tablesize)
1936 {
1937   enum typeid *const oldtable = *typetable;
1938   const int oldsize = *tablesize;
1939   enum typeid *newtable;
1940   int n, newsize = oldsize * 2;
1941
1942   if (newsize < nextarg + 1)
1943     newsize = nextarg + 1;
1944   if (oldsize == STATIC_ARG_TBL_SIZE) {
1945     if ((newtable = malloc(newsize * sizeof(enum typeid))) == NULL)
1946       return -1;
1947     memcpy(newtable, oldtable, oldsize * sizeof(enum typeid));
1948   } else {
1949     newtable = realloc(oldtable, newsize * sizeof(enum typeid));
1950     if (newtable == NULL) {
1951       free(oldtable);
1952       return -1;
1953     }
1954   }
1955   for (n = oldsize; n < newsize; n++)
1956     newtable[n] = T_UNUSED;
1957
1958   *typetable = newtable;
1959   *tablesize = newsize;
1960   return 0;
1961 }
1962
1963
1964 #ifndef NO_FLOATING_POINT
1965 #ifndef WIDE_DOUBLE
1966 static char *
1967 cvt(double value, int ndigits, int flags, char *sign, int *decpt, int ch,
1968     int *length)
1969 {
1970   int mode, dsgn;
1971   char *digits, *bp, *rve;
1972
1973   _DIAGASSERT(decpt != NULL);
1974   _DIAGASSERT(length != NULL);
1975   _DIAGASSERT(sign != NULL);
1976
1977   if (ch == 'f') {
1978     mode = 3;   /* ndigits after the decimal point */
1979   } else {
1980     /* To obtain ndigits after the decimal point for the 'e'
1981      * and 'E' formats, round to ndigits + 1 significant
1982      * figures.
1983      */
1984     if (ch == 'e' || ch == 'E') {
1985       ndigits++;
1986     }
1987     mode = 2;   /* ndigits significant digits */
1988   }
1989
1990   digits = __dtoa(value, mode, ndigits, decpt, &dsgn, &rve);
1991   if (digits == NULL)
1992     return NULL;
1993   if (dsgn) {
1994     value = -value;
1995     *sign = '-';
1996   } else
1997     *sign = '\000';
1998   if ((ch != 'g' && ch != 'G') || flags & ALT) {  /* Print trailing zeros */
1999     bp = digits + ndigits;
2000     if (ch == 'f') {
2001       if (*digits == '0' && value)
2002         *decpt = -ndigits + 1;
2003       bp += *decpt;
2004     }
2005     while (rve < bp)
2006       *rve++ = '0';
2007   }
2008   *length = rve - digits;
2009   return digits;
2010 }
2011 #endif
2012
2013 static int
2014 exponent(CHAR_T *p0, int expo, int fmtch)
2015 {
2016   CHAR_T *p, *t;
2017   CHAR_T expbuf[MAXEXPDIG];
2018
2019   p = p0;
2020   *p++ = fmtch;
2021   if (expo < 0) {
2022     expo = -expo;
2023     *p++ = '-';
2024   }
2025   else
2026     *p++ = '+';
2027   t = expbuf + MAXEXPDIG;
2028   if (expo > 9) {
2029     do {
2030       *--t = to_char(expo % 10);
2031     } while ((expo /= 10) > 9);
2032     *--t = to_char(expo);
2033     for (; t < expbuf + MAXEXPDIG; *p++ = *t++);
2034   }
2035   else {
2036     /*
2037      * Exponents for decimal floating point conversions
2038      * (%[eEgG]) must be at least two characters long,
2039      * whereas exponents for hexadecimal conversions can
2040      * be only one character long.
2041      */
2042     if (fmtch == 'e' || fmtch == 'E')
2043       *p++ = '0';
2044     *p++ = to_char(expo);
2045   }
2046   return (p - p0);
2047 }
2048 #endif /* !NO_FLOATING_POINT */