missing/vsnprintf.c

   1 /*-
   2  * Copyright (c) 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Chris Torek.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * IMPORTANT NOTE:
  35  * --------------
  36  * From ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change
  37  * paragraph 3 above is now null and void.
  38  */
  39
  40 /* SNPRINTF.C
  41  * fjc 7-31-97 Modified by Mib Software to be a standalone snprintf.c module.
  42  *      http://www.mibsoftware.com
  43  * Mib Software does not warrant this software any differently than the
  44  * University of California, Berkeley as described above.  All warranties
  45  * are disclaimed.  Use this software at your own risk.
  46  *
  47  *      All code referencing FILE * functions was eliminated, since it could
  48  *      never be called.  All header files and necessary files are collapsed
  49  *      into one file, internal functions are declared static.  This should
  50  *      allow inclusion into libraries with less chance of namespace collisions.
  51  *
  52  *      snprintf should be the only externally visible item.
  53  *
  54  *      As of 7-31-97 FLOATING_POINT is NOT provided.  The code is somewhat
  55  *        non-portable, so it is disabled.
  56  */
  57
  58 /* Define FLOATING_POINT to get floating point. */
  59 /*
  60 #define FLOATING_POINT
  61 */
  62
  63 #include <sys/types.h>
  64 #define u_long unsigned long
  65 #define u_short unsigned short
  66 #define u_int unsigned int
  67
  68 #if !defined(HAVE_STDARG_PROTOTYPES)
  69 #if defined(__STDC__)
  70 #define HAVE_STDARG_PROTOTYPES 1
  71 #endif
  72 #endif
  73
  74 #undef __P
  75 #if defined(HAVE_STDARG_PROTOTYPES)
  76 # include <stdarg.h>
  77 # if !defined(__P)
  78 #  define __P(x) x
  79 # endif
  80 #else
  81 # define __P(x) ()
  82 # if !defined(const)
  83 #  define const
  84 # endif
  85 # include <varargs.h>
  86 #endif
  87 #ifndef _BSD_VA_LIST_
  88 #define _BSD_VA_LIST_ va_list
  89 #endif
  90
  91 #ifdef __STDC__
  92 # include <limits.h>
  93 #else
  94 # ifndef LONG_MAX
  95 #  ifdef HAVE_LIMITS_H
  96 #   include <limits.h>
  97 #  else
  98     /* assuming 32bit(2's compliment) long */
  99 #   define LONG_MAX 2147483647
 100 #  endif
 101 # endif
 102 #endif
 103
 104 #if defined(__hpux) && !defined(__GNUC__) && !defined(__STDC__)
 105 #define const
 106 #endif
 107
 108 #if defined(sgi)
 109 #undef __const
 110 #define __const
 111 #endif /* People who don't like const sys_error */
 112
 113 #include <stddef.h>
 114 #if defined(__hpux) && !defined(__GNUC__) || defined(__DECC)
 115 #include <string.h>
 116 #endif
 117
 118 #if !defined(__CYGWIN32__) && defined(__hpux) && !defined(__GNUC__)
 119 #include <stdlib.h>
 120 #endif
 121
 122 #ifndef NULL
 123 #define NULL    0
 124 #endif
 125
 126 /*
 127  * NB: to fit things in six character monocase externals, the stdio
 128  * code uses the prefix `__s' for stdio objects, typically followed
 129  * by a three-character attempt at a mnemonic.
 130  */
 131
 132 /* stdio buffers */
 133 struct __sbuf {
 134         unsigned char *_base;
 135         size_t  _size;
 136 };
 137
 138
 139 /*
 140  * stdio state variables.
 141  *
 142  * The following always hold:
 143  *
 144  *      if (_flags&(__SLBF|__SWR)) == (__SLBF|__SWR),
 145  *              _lbfsize is -_bf._size, else _lbfsize is 0
 146  *      if _flags&__SRD, _w is 0
 147  *      if _flags&__SWR, _r is 0
 148  *
 149  * This ensures that the getc and putc macros (or inline functions) never
 150  * try to write or read from a file that is in `read' or `write' mode.
 151  * (Moreover, they can, and do, automatically switch from read mode to
 152  * write mode, and back, on "r+" and "w+" files.)
 153  *
 154  * _lbfsize is used only to make the inline line-buffered output stream
 155  * code as compact as possible.
 156  *
 157  * _ub, _up, and _ur are used when ungetc() pushes back more characters
 158  * than fit in the current _bf, or when ungetc() pushes back a character
 159  * that does not match the previous one in _bf.  When this happens,
 160  * _ub._base becomes non-nil (i.e., a stream has ungetc() data iff
 161  * _ub._base!=NULL) and _up and _ur save the current values of _p and _r.
 162  *
 163  * NB: see WARNING above before changing the layout of this structure!
 164  */
 165 typedef struct __sFILE {
 166         unsigned char *_p;      /* current position in (some) buffer */
 167 #if 0
 168         size_t  _r;             /* read space left for getc() */
 169 #endif
 170         size_t  _w;             /* write space left for putc() */
 171         short   _flags;         /* flags, below; this FILE is free if 0 */
 172         short   _file;          /* fileno, if Unix descriptor, else -1 */
 173         struct  __sbuf _bf;     /* the buffer (at least 1 byte, if !NULL) */
 174         size_t  _lbfsize;       /* 0 or -_bf._size, for inline putc */
 175         int     (*vwrite)(/* struct __sFILE*, struct __suio * */);
 176 } FILE;
 177
 178
 179 #define __SLBF  0x0001          /* line buffered */
 180 #define __SNBF  0x0002          /* unbuffered */
 181 #define __SRD   0x0004          /* OK to read */
 182 #define __SWR   0x0008          /* OK to write */
 183         /* RD and WR are never simultaneously asserted */
 184 #define __SRW   0x0010          /* open for reading & writing */
 185 #define __SEOF  0x0020          /* found EOF */
 186 #define __SERR  0x0040          /* found error */
 187 #define __SMBF  0x0080          /* _buf is from malloc */
 188 #define __SAPP  0x0100          /* fdopen()ed in append mode */
 189 #define __SSTR  0x0200          /* this is an sprintf/snprintf string */
 190 #define __SOPT  0x0400          /* do fseek() optimisation */
 191 #define __SNPT  0x0800          /* do not do fseek() optimisation */
 192 #define __SOFF  0x1000          /* set iff _offset is in fact correct */
 193 #define __SMOD  0x2000          /* true => fgetln modified _p text */
 194
 195
 196 #define EOF     (-1)
 197
 198
 199 #define __sfeof(p)      (((p)->_flags & __SEOF) != 0)
 200 #define __sferror(p)    (((p)->_flags & __SERR) != 0)
 201 #define __sclearerr(p)  ((void)((p)->_flags &= ~(__SERR|__SEOF)))
 202 #define __sfileno(p)    ((p)->_file)
 203
 204 #undef feof
 205 #undef ferror
 206 #undef clearerr
 207 #define feof(p)         __sfeof(p)
 208 #define ferror(p)       __sferror(p)
 209 #define clearerr(p)     __sclearerr(p)
 210
 211 #ifndef _ANSI_SOURCE
 212 #define fileno(p)       __sfileno(p)
 213 #endif
 214
 215
 216 /*
 217  * I/O descriptors for __sfvwrite().
 218  */
 219 struct __siov {
 220         const void *iov_base;
 221         size_t  iov_len;
 222 };
 223 struct __suio {
 224         struct  __siov *uio_iov;
 225         int     uio_iovcnt;
 226         int     uio_resid;
 227 };
 228
 229 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_SNPRINTF)
 230 /*
 231  * Write some memory regions.  Return zero on success, EOF on error.
 232  *
 233  * This routine is large and unsightly, but most of the ugliness due
 234  * to the three different kinds of output buffering is handled here.
 235  */
 236 static int BSD__sfvwrite(fp, uio)
 237         register FILE *fp;
 238         register struct __suio *uio;
 239 {
 240         register size_t len;
 241         register char *p;
 242         register struct __siov *iov;
 243         register int w;
 244
 245         if ((len = uio->uio_resid) == 0)
 246                 return (0);
 247 #ifndef __hpux
 248 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 249 #endif
 250 #define COPY(n)   (void)memcpy((void *)fp->_p, (void *)p, (size_t)(n))
 251
 252         iov = uio->uio_iov;
 253         p = iov->iov_base;
 254         len = iov->iov_len;
 255         iov++;
 256 #define GETIOV(extra_work) \
 257         while (len == 0) { \
 258                 extra_work; \
 259                 p = iov->iov_base; \
 260                 len = iov->iov_len; \
 261                 iov++; \
 262         }
 263         if (fp->_flags & __SNBF) {
 264         /* fjc 7-31-97 Will never happen.  We are working with
 265                                            strings only
 266         */
 267         } else if ((fp->_flags & __SLBF) == 0) {
 268         /*
 269                  * Fully buffered: fill partially full buffer, if any,
 270                  * and then flush.  If there is no partial buffer, write
 271                  * one _bf._size byte chunk directly (without copying).
 272                  *
 273                  * String output is a special case: write as many bytes
 274                  * as fit, but pretend we wrote everything.  This makes
 275                  * snprintf() return the number of bytes needed, rather
 276                  * than the number used, and avoids its write function
 277                  * (so that the write function can be invalid).
 278                  */
 279                 do {
 280                         GETIOV(;);
 281                         w = fp->_w;
 282                         if (fp->_flags & __SSTR) {
 283                                 if (len < w)
 284                                         w = len;
 285                                 COPY(w);        /* copy MIN(fp->_w,len), */
 286                                 fp->_w -= w;
 287                                 fp->_p += w;
 288                                 w = len;        /* but pretend copied all */
 289                         } else {
 290                                 /* fjc 7-31-97 Will never happen.  We are working with
 291                                                                    strings only
 292                                 */
 293                         }
 294                         p += w;
 295                         len -= w;
 296                 } while ((uio->uio_resid -= w) != 0);
 297         } else {
 298                 /* fjc 7-31-97 Will never happen.  We are working with
 299                                                    strings only
 300                 */
 301         }
 302         return (0);
 303 }
 304 #endif
 305
 306 /*
 307  * Actual printf innards.
 308  *
 309  * This code is large and complicated...
 310  */
 311
 312 /*
 313  * Flush out all the vectors defined by the given uio,
 314  * then reset it so that it can be reused.
 315  */
 316 static int
 317 BSD__sprint(FILE *fp, register struct __suio *uio)
 318 {
 319         register int err;
 320
 321         if (uio->uio_resid == 0) {
 322                 uio->uio_iovcnt = 0;
 323                 return (0);
 324         }
 325         err = (*fp->vwrite)(fp, uio);
 326         uio->uio_resid = 0;
 327         uio->uio_iovcnt = 0;
 328         return (err);
 329 }
 330
 331
 332 /*
 333  * Helper function for `fprintf to unbuffered unix file': creates a
 334  * temporary buffer.  We only work on write-only files; this avoids
 335  * worries about ungetc buffers and so forth.
 336  */
 337 static int
 338 BSD__sbprintf(register FILE *fp, const char *fmt, va_list ap)
 339 {
 340 /* We don't support files. */
 341         return 0;
 342 }
 343
 344
 345 /*
 346  * Macros for converting digits to letters and vice versa
 347  */
 348 #define to_digit(c)     ((c) - '0')
 349 #define is_digit(c)     ((unsigned)to_digit(c) <= 9)
 350 #define to_char(n)      ((n) + '0')
 351
 352 #ifdef _HAVE_SANE_QUAD_
 353 /*
 354  * Convert an unsigned long long to ASCII for printf purposes, returning
 355  * a pointer to the first character of the string representation.
 356  * Octal numbers can be forced to have a leading zero; hex numbers
 357  * use the given digits.
 358  */
 359 static char *
 360 BSD__uqtoa(register u_quad_t val, char *endp, int base, int octzero, const char *xdigs)
 361 {
 362         register char *cp = endp;
 363         register long sval;
 364
 365         /*
 366          * Handle the three cases separately, in the hope of getting
 367          * better/faster code.
 368          */
 369         switch (base) {
 370         case 10:
 371                 if (val < 10) { /* many numbers are 1 digit */
 372                         *--cp = to_char(val);
 373                         return (cp);
 374                 }
 375                 /*
 376                  * On many machines, unsigned arithmetic is harder than
 377                  * signed arithmetic, so we do at most one unsigned mod and
 378                  * divide; this is sufficient to reduce the range of
 379                  * the incoming value to where signed arithmetic works.
 380                  */
 381                 if (val > LLONG_MAX) {
 382                         *--cp = to_char(val % 10);
 383                         sval = val / 10;
 384                 } else
 385                         sval = val;
 386                 do {
 387                         *--cp = to_char(sval % 10);
 388                         sval /= 10;
 389                 } while (sval != 0);
 390                 break;
 391
 392         case 8:
 393                 do {
 394                         *--cp = to_char(val & 7);
 395                         val >>= 3;
 396                 } while (val);
 397                 if (octzero && *cp != '0')
 398                         *--cp = '0';
 399                 break;
 400
 401         case 16:
 402                 do {
 403                         *--cp = xdigs[val & 15];
 404                         val >>= 4;
 405                 } while (val);
 406                 break;
 407
 408         default:                        /* oops */
 409                 /*
 410                 abort();
 411                 */
 412                 break;  /* fjc 7-31-97.  Don't reference abort() here */
 413         }
 414         return (cp);
 415 }
 416 #endif /* _HAVE_SANE_QUAD_ */
 417
 418 /*
 419  * Convert an unsigned long to ASCII for printf purposes, returning
 420  * a pointer to the first character of the string representation.
 421  * Octal numbers can be forced to have a leading zero; hex numbers
 422  * use the given digits.
 423  */
 424 static char *
 425 BSD__ultoa(register u_long val, char *endp, int base, int octzero, const char *xdigs)
 426 {
 427         register char *cp = endp;
 428         register long sval;
 429
 430         /*
 431          * Handle the three cases separately, in the hope of getting
 432          * better/faster code.
 433          */
 434         switch (base) {
 435         case 10:
 436                 if (val < 10) { /* many numbers are 1 digit */
 437                         *--cp = to_char(val);
 438                         return (cp);
 439                 }
 440                 /*
 441                  * On many machines, unsigned arithmetic is harder than
 442                  * signed arithmetic, so we do at most one unsigned mod and
 443                  * divide; this is sufficient to reduce the range of
 444                  * the incoming value to where signed arithmetic works.
 445                  */
 446                 if (val > LONG_MAX) {
 447                         *--cp = to_char(val % 10);
 448                         sval = val / 10;
 449                 } else
 450                         sval = val;
 451                 do {
 452                         *--cp = to_char(sval % 10);
 453                         sval /= 10;
 454                 } while (sval != 0);
 455                 break;
 456
 457         case 8:
 458                 do {
 459                         *--cp = to_char(val & 7);
 460                         val >>= 3;
 461                 } while (val);
 462                 if (octzero && *cp != '0')
 463                         *--cp = '0';
 464                 break;
 465
 466         case 16:
 467                 do {
 468                         *--cp = xdigs[val & 15];
 469                         val >>= 4;
 470                 } while (val);
 471                 break;
 472
 473         default:                        /* oops */
 474                 /*
 475                 abort();
 476                 */
 477                 break;  /* fjc 7-31-97.  Don't reference abort() here */
 478         }
 479         return (cp);
 480 }
 481
 482 #ifdef FLOATING_POINT
 483 #include <math.h>
 484 /* #include "floatio.h" */
 485
 486 #ifndef MAXEXP
 487 # define MAXEXP 1024
 488 #endif
 489
 490 #ifndef MAXFRACT
 491 # define MAXFRACT 64
 492 #endif
 493
 494 #define BUF             (MAXEXP+MAXFRACT+1)     /* + decimal point */
 495 #define DEFPREC         6
 496
 497 static char *cvt __P((double, int, int, char *, int *, int, int *));
 498 static int exponent __P((char *, int, int));
 499
 500 #else /* no FLOATING_POINT */
 501
 502 #define BUF             68
 503
 504 #endif /* FLOATING_POINT */
 505
 506
 507 /*
 508  * Flags used during conversion.
 509  */
 510 #define ALT             0x001           /* alternate form */
 511 #define HEXPREFIX       0x002           /* add 0x or 0X prefix */
 512 #define LADJUST         0x004           /* left adjustment */
 513 #define LONGDBL         0x008           /* long double; unimplemented */
 514 #define LONGINT         0x010           /* long integer */
 515
 516 #ifdef _HAVE_SANE_QUAD_
 517 #define QUADINT         0x020           /* quad integer */
 518 #endif /* _HAVE_SANE_QUAD_ */
 519
 520 #define SHORTINT        0x040           /* short integer */
 521 #define ZEROPAD         0x080           /* zero (as opposed to blank) pad */
 522 #define FPT             0x100           /* Floating point number */
 523 static int
 524 BSD_vfprintf(FILE *fp, const char *fmt0, va_list ap)
 525 {
 526         register const char *fmt; /* format string */
 527         register int ch;        /* character from fmt */
 528         register int n;         /* handy integer (short term usage) */
 529         register const char *cp;/* handy char pointer (short term usage) */
 530         register struct __siov *iovp;/* for PRINT macro */
 531         register int flags;     /* flags as above */
 532         int ret;                /* return value accumulator */
 533         int width;              /* width from format (%8d), or 0 */
 534         int prec;               /* precision from format (%.3d), or -1 */
 535         char sign;              /* sign prefix (' ', '+', '-', or \0) */
 536 #ifdef FLOATING_POINT
 537         char softsign;          /* temporary negative sign for floats */
 538         double _double;         /* double precision arguments %[eEfgG] */
 539         int expt;               /* integer value of exponent */
 540         int expsize;            /* character count for expstr */
 541         int ndig;               /* actual number of digits returned by cvt */
 542         char expstr[7];         /* buffer for exponent string */
 543 #endif
 544         u_long  ulval;          /* integer arguments %[diouxX] */
 545 #ifdef _HAVE_SANE_QUAD_
 546         u_quad_t uqval;         /* %q integers */
 547 #endif /* _HAVE_SANE_QUAD_ */
 548         int base;               /* base for [diouxX] conversion */
 549         int dprec;              /* a copy of prec if [diouxX], 0 otherwise */
 550         int fieldsz;            /* field size expanded by sign, etc */
 551         int realsz;             /* field size expanded by dprec */
 552         int size;               /* size of converted field or string */
 553         const char *xdigs = 0;  /* digits for [xX] conversion */
 554 #define NIOV 8
 555         struct __suio uio;      /* output information: summary */
 556         struct __siov iov[NIOV];/* ... and individual io vectors */
 557         char buf[BUF];          /* space for %c, %[diouxX], %[eEfgG] */
 558         char ox[2];             /* space for 0x hex-prefix */
 559         char *const ebuf = buf + sizeof(buf);
 560
 561         /*
 562          * Choose PADSIZE to trade efficiency vs. size.  If larger printf
 563          * fields occur frequently, increase PADSIZE and make the initializers
 564          * below longer.
 565          */
 566 #define PADSIZE 16              /* pad chunk size */
 567         static const char blanks[PADSIZE] =
 568          {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
 569         static const char zeroes[PADSIZE] =
 570          {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
 571
 572         /*
 573          * BEWARE, these `goto error' on error, and PAD uses `n'.
 574          */
 575 #define PRINT(ptr, len) { \
 576         iovp->iov_base = (ptr); \
 577         iovp->iov_len = (len); \
 578         uio.uio_resid += (len); \
 579         iovp++; \
 580         if (++uio.uio_iovcnt >= NIOV) { \
 581                 if (BSD__sprint(fp, &uio)) \
 582                         goto error; \
 583                 iovp = iov; \
 584         } \
 585 }
 586 #define PAD(howmany, with) { \
 587         if ((n = (howmany)) > 0) { \
 588                 while (n > PADSIZE) { \
 589                         PRINT(with, PADSIZE); \
 590                         n -= PADSIZE; \
 591                 } \
 592                 PRINT(with, n); \
 593         } \
 594 }
 595 #define FLUSH() { \
 596         if (uio.uio_resid && BSD__sprint(fp, &uio)) \
 597                 goto error; \
 598         uio.uio_iovcnt = 0; \
 599         iovp = iov; \
 600 }
 601
 602         /*
 603          * To extend shorts properly, we need both signed and unsigned
 604          * argument extraction methods.
 605          */
 606 #define SARG() \
 607         (flags&LONGINT ? va_arg(ap, long) : \
 608             flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
 609             (long)va_arg(ap, int))
 610 #define UARG() \
 611         (flags&LONGINT ? va_arg(ap, u_long) : \
 612             flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \
 613             (u_long)va_arg(ap, u_int))
 614
 615         /* optimise fprintf(stderr) (and other unbuffered Unix files) */
 616         if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
 617             fp->_file >= 0)
 618                 return (BSD__sbprintf(fp, fmt0, ap));
 619
 620         fmt = fmt0;
 621         uio.uio_iov = iovp = iov;
 622         uio.uio_resid = 0;
 623         uio.uio_iovcnt = 0;
 624         ret = 0;
 625         xdigs = 0;
 626
 627         /*
 628          * Scan the format for conversions (`%' character).
 629          */
 630         for (;;) {
 631                 for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
 632                         /* void */;
 633                 if ((n = fmt - cp) != 0) {
 634                         PRINT(cp, n);
 635                         ret += n;
 636                 }
 637                 if (ch == '\0')
 638                         goto done;
 639                 fmt++;          /* skip over '%' */
 640
 641                 flags = 0;
 642                 dprec = 0;
 643                 width = 0;
 644                 prec = -1;
 645                 sign = '\0';
 646
 647 rflag:          ch = *fmt++;
 648 reswitch:       switch (ch) {
 649                 case ' ':
 650                         /*
 651                          * ``If the space and + flags both appear, the space
 652                          * flag will be ignored.''
 653                          *      -- ANSI X3J11
 654                          */
 655                         if (!sign)
 656                                 sign = ' ';
 657                         goto rflag;
 658                 case '#':
 659                         flags |= ALT;
 660                         goto rflag;
 661                 case '*':
 662                         /*
 663                          * ``A negative field width argument is taken as a
 664                          * - flag followed by a positive field width.''
 665                          *      -- ANSI X3J11
 666                          * They don't exclude field widths read from args.
 667                          */
 668                         if ((width = va_arg(ap, int)) >= 0)
 669                                 goto rflag;
 670                         width = -width;
 671                         /* FALLTHROUGH */
 672                 case '-':
 673                         flags |= LADJUST;
 674                         goto rflag;
 675                 case '+':
 676                         sign = '+';
 677                         goto rflag;
 678                 case '.':
 679                         if ((ch = *fmt++) == '*') {
 680                                 n = va_arg(ap, int);
 681                                 prec = n < 0 ? -1 : n;
 682                                 goto rflag;
 683                         }
 684                         n = 0;
 685                         while (is_digit(ch)) {
 686                                 n = 10 * n + to_digit(ch);
 687                                 ch = *fmt++;
 688                         }
 689                         prec = n < 0 ? -1 : n;
 690                         goto reswitch;
 691                 case '0':
 692                         /*
 693                          * ``Note that 0 is taken as a flag, not as the
 694                          * beginning of a field width.''
 695                          *      -- ANSI X3J11
 696                          */
 697                         flags |= ZEROPAD;
 698                         goto rflag;
 699                 case '1': case '2': case '3': case '4':
 700                 case '5': case '6': case '7': case '8': case '9':
 701                         n = 0;
 702                         do {
 703                                 n = 10 * n + to_digit(ch);
 704                                 ch = *fmt++;
 705                         } while (is_digit(ch));
 706                         width = n;
 707                         goto reswitch;
 708 #ifdef FLOATING_POINT
 709                 case 'L':
 710                         flags |= LONGDBL;
 711                         goto rflag;
 712 #endif
 713                 case 'h':
 714                         flags |= SHORTINT;
 715                         goto rflag;
 716                 case 'l':
 717                         flags |= LONGINT;
 718                         goto rflag;
 719 #ifdef _HAVE_SANE_QUAD_
 720                 case 'q':
 721                         flags |= QUADINT;
 722                         goto rflag;
 723 #endif /* _HAVE_SANE_QUAD_ */
 724                 case 'c':
 725                         cp = buf;
 726                         *buf = (char)va_arg(ap, int);
 727                         size = 1;
 728                         sign = '\0';
 729                         break;
 730                 case 'D':
 731                         flags |= LONGINT;
 732                         /*FALLTHROUGH*/
 733                 case 'd':
 734                 case 'i':
 735 #ifdef _HAVE_SANE_QUAD_
 736                         if (flags & QUADINT) {
 737                                 uqval = va_arg(ap, quad_t);
 738                                 if ((quad_t)uqval < 0) {
 739                                         uqval = -uqval;
 740                                         sign = '-';
 741                                 }
 742                         } else
 743 #endif /* _HAVE_SANE_QUAD_ */
 744                         {
 745                                 ulval = SARG();
 746                                 if ((long)ulval < 0) {
 747                                         ulval = -ulval;
 748                                         sign = '-';
 749                                 }
 750                         }
 751                         base = 10;
 752                         goto number;
 753 #ifdef FLOATING_POINT
 754                 case 'e':               /* anomalous precision */
 755                 case 'E':
 756                         prec = (prec == -1) ?
 757                                 DEFPREC + 1 : prec + 1;
 758                         /* FALLTHROUGH */
 759                         goto fp_begin;
 760                 case 'f':               /* always print trailing zeroes */
 761                         if (prec != 0)
 762                                 flags |= ALT;
 763                 case 'g':
 764                 case 'G':
 765                         if (prec == -1)
 766                                 prec = DEFPREC;
 767 fp_begin:               _double = va_arg(ap, double);
 768                         /* do this before tricky precision changes */
 769                         if (isinf(_double)) {
 770                                 if (_double < 0)
 771                                         sign = '-';
 772                                 cp = "Inf";
 773                                 size = 3;
 774                                 break;
 775                         }
 776                         if (isnan(_double)) {
 777                                 cp = "NaN";
 778                                 size = 3;
 779                                 break;
 780                         }
 781                         flags |= FPT;
 782                         cp = cvt(_double, prec, flags, &softsign,
 783                                 &expt, ch, &ndig);
 784                         if (ch == 'g' || ch == 'G') {
 785                                 if (expt <= -4 || expt > prec)
 786                                         ch = (ch == 'g') ? 'e' : 'E';
 787                                 else
 788                                         ch = 'g';
 789                         }
 790                         if (ch <= 'e') {        /* 'e' or 'E' fmt */
 791                                 --expt;
 792                                 expsize = exponent(expstr, expt, ch);
 793                                 size = expsize + ndig;
 794                                 if (ndig > 1 || flags & ALT)
 795                                         ++size;
 796                         } else if (ch == 'f') {         /* f fmt */
 797                                 if (expt > 0) {
 798                                         size = expt;
 799                                         if (prec || flags & ALT)
 800                                                 size += prec + 1;
 801                                 } else  /* "0.X" */
 802                                         size = prec + 2;
 803                         } else if (expt >= ndig) {      /* fixed g fmt */
 804                                 size = expt;
 805                                 if (flags & ALT)
 806                                         ++size;
 807                         } else
 808                                 size = ndig + (expt > 0 ?
 809                                         1 : 2 - expt);
 810
 811                         if (softsign)
 812                                 sign = '-';
 813                         break;
 814 #endif /* FLOATING_POINT */
 815                 case 'n':
 816 #ifdef _HAVE_SANE_QUAD_
 817                         if (flags & QUADINT)
 818                                 *va_arg(ap, quad_t *) = ret;
 819                         else if (flags & LONGINT)
 820 #else /* _HAVE_SANE_QUAD_ */
 821                         if (flags & LONGINT)
 822 #endif /* _HAVE_SANE_QUAD_ */
 823                                 *va_arg(ap, long *) = ret;
 824                         else if (flags & SHORTINT)
 825                                 *va_arg(ap, short *) = ret;
 826                         else
 827                                 *va_arg(ap, int *) = ret;
 828                         continue;       /* no output */
 829                 case 'O':
 830                         flags |= LONGINT;
 831                         /*FALLTHROUGH*/
 832                 case 'o':
 833 #ifdef _HAVE_SANE_QUAD_
 834                         if (flags & QUADINT)
 835                                 uqval = va_arg(ap, u_quad_t);
 836                         else
 837 #endif /* _HAVE_SANE_QUAD_ */
 838                                 ulval = UARG();
 839                         base = 8;
 840                         goto nosign;
 841                 case 'p':
 842                         /*
 843                          * ``The argument shall be a pointer to void.  The
 844                          * value of the pointer is converted to a sequence
 845                          * of printable characters, in an implementation-
 846                          * defined manner.''
 847                          *      -- ANSI X3J11
 848                          */
 849                         prec = sizeof(void*)*CHAR_BIT/4;
 850 #ifdef _HAVE_LLP64_
 851                         uqval = (u_long)va_arg(ap, void *);
 852                         flags = (flags) | QUADINT | HEXPREFIX;
 853 #else
 854                         ulval = (u_long)va_arg(ap, void *);
 855 #ifdef _HAVE_SANE_QUAD_
 856                         flags = (flags & ~QUADINT) | HEXPREFIX;
 857 #else /* _HAVE_SANE_QUAD_ */
 858                         flags = (flags) | HEXPREFIX;
 859 #endif /* _HAVE_SANE_QUAD_ */
 860 #endif
 861                         base = 16;
 862                         xdigs = "0123456789abcdef";
 863                         ch = 'x';
 864                         goto nosign;
 865                 case 's':
 866                         if ((cp = va_arg(ap, char *)) == NULL)
 867                                 cp = "(null)";
 868                         if (prec >= 0) {
 869                                 /*
 870                                  * can't use strlen; can only look for the
 871                                  * NUL in the first `prec' characters, and
 872                                  * strlen() will go further.
 873                                  */
 874                                 const char *p = (char *)memchr(cp, 0, prec);
 875
 876                                 if (p != NULL) {
 877                                         size = p - cp;
 878                                         if (size > prec)
 879                                                 size = prec;
 880                                 } else
 881                                         size = prec;
 882                         } else
 883                                 size = strlen(cp);
 884                         sign = '\0';
 885                         break;
 886                 case 'U':
 887                         flags |= LONGINT;
 888                         /*FALLTHROUGH*/
 889                 case 'u':
 890 #ifdef _HAVE_SANE_QUAD_
 891                         if (flags & QUADINT)
 892                                 uqval = va_arg(ap, u_quad_t);
 893                         else
 894 #endif /* _HAVE_SANE_QUAD_ */
 895                                 ulval = UARG();
 896                         base = 10;
 897                         goto nosign;
 898                 case 'X':
 899                         xdigs = "0123456789ABCDEF";
 900                         goto hex;
 901                 case 'x':
 902                         xdigs = "0123456789abcdef";
 903 hex:
 904 #ifdef _HAVE_SANE_QUAD_
 905                         if (flags & QUADINT)
 906                                 uqval = va_arg(ap, u_quad_t);
 907                         else
 908 #endif /* _HAVE_SANE_QUAD_ */
 909                                 ulval = UARG();
 910                         base = 16;
 911                         /* leading 0x/X only if non-zero */
 912                         if (flags & ALT &&
 913 #ifdef _HAVE_SANE_QUAD_
 914                             (flags & QUADINT ? uqval != 0 : ulval != 0)
 915 #else /* _HAVE_SANE_QUAD_ */
 916                             ulval != 0
 917 #endif /* _HAVE_SANE_QUAD_ */
 918                             )
 919                                 flags |= HEXPREFIX;
 920
 921                         /* unsigned conversions */
 922 nosign:                 sign = '\0';
 923                         /*
 924                          * ``... diouXx conversions ... if a precision is
 925                          * specified, the 0 flag will be ignored.''
 926                          *      -- ANSI X3J11
 927                          */
 928 number:                 if ((dprec = prec) >= 0)
 929                                 flags &= ~ZEROPAD;
 930
 931                         /*
 932                          * ``The result of converting a zero value with an
 933                          * explicit precision of zero is no characters.''
 934                          *      -- ANSI X3J11
 935                          */
 936 #ifdef _HAVE_SANE_QUAD_
 937                         if (flags & QUADINT) {
 938                                 if (uqval != 0 || prec != 0)
 939                                         cp = BSD__uqtoa(uqval, ebuf, base,
 940                                             flags & ALT, xdigs);
 941                         } else
 942 #else /* _HAVE_SANE_QUAD_ */
 943 #endif /* _HAVE_SANE_QUAD_ */
 944                         {
 945                                 if (ulval != 0 || prec != 0)
 946                                         cp = BSD__ultoa(ulval, ebuf, base,
 947                                             flags & ALT, xdigs);
 948                         }
 949                         size = ebuf - cp;
 950                         break;
 951                 default:        /* "%?" prints ?, unless ? is NUL */
 952                         if (ch == '\0')
 953                                 goto done;
 954                         /* pretend it was %c with argument ch */
 955                         cp = buf;
 956                         *buf = ch;
 957                         size = 1;
 958                         sign = '\0';
 959                         break;
 960                 }
 961
 962                 /*
 963                  * All reasonable formats wind up here.  At this point, `cp'
 964                  * points to a string which (if not flags&LADJUST) should be
 965                  * padded out to `width' places.  If flags&ZEROPAD, it should
 966                  * first be prefixed by any sign or other prefix; otherwise,
 967                  * it should be blank padded before the prefix is emitted.
 968                  * After any left-hand padding and prefixing, emit zeroes
 969                  * required by a decimal [diouxX] precision, then print the
 970                  * string proper, then emit zeroes required by any leftover
 971                  * floating precision; finally, if LADJUST, pad with blanks.
 972                  *
 973                  * Compute actual size, so we know how much to pad.
 974                  * fieldsz excludes decimal prec; realsz includes it.
 975                  */
 976                 fieldsz = size;
 977                 if (sign)
 978                         fieldsz++;
 979                 else if (flags & HEXPREFIX)
 980                         fieldsz += 2;
 981                 realsz = dprec > fieldsz ? dprec : fieldsz;
 982
 983                 /* right-adjusting blank padding */
 984                 if ((flags & (LADJUST|ZEROPAD)) == 0)
 985                         PAD(width - realsz, blanks);
 986
 987                 /* prefix */
 988                 if (sign) {
 989                         PRINT(&sign, 1);
 990                 } else if (flags & HEXPREFIX) {
 991                         ox[0] = '0';
 992                         ox[1] = ch;
 993                         PRINT(ox, 2);
 994                 }
 995
 996                 /* right-adjusting zero padding */
 997                 if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
 998                         PAD(width - realsz, zeroes);
 999
1000                 /* leading zeroes from decimal precision */
1001                 PAD(dprec - fieldsz, zeroes);
1002
1003                 /* the string or number proper */
1004 #ifdef FLOATING_POINT
1005                 if ((flags & FPT) == 0) {
1006                         PRINT(cp, size);
1007                 } else {        /* glue together f_p fragments */
1008                         if (ch >= 'f') {        /* 'f' or 'g' */
1009                                 if (_double == 0) {
1010                                 /* kludge for __dtoa irregularity */
1011                                         if (prec == 0 ||
1012                                             (flags & ALT) == 0) {
1013                                                 PRINT("0", 1);
1014                                         } else {
1015                                                 PRINT("0.", 2);
1016                                                 PAD(ndig - 1, zeroes);
1017                                         }
1018                                 } else if (expt <= 0) {
1019                                         PRINT("0.", 2);
1020                                         PAD(-expt, zeroes);
1021                                         PRINT(cp, ndig);
1022                                 } else if (expt >= ndig) {
1023                                         PRINT(cp, ndig);
1024                                         PAD(expt - ndig, zeroes);
1025                                         if (flags & ALT)
1026                                                 PRINT(".", 1);
1027                                 } else {
1028                                         PRINT(cp, expt);
1029                                         cp += expt;
1030                                         PRINT(".", 1);
1031                                         PRINT(cp, ndig-expt);
1032                                 }
1033                         } else {        /* 'e' or 'E' */
1034                                 if (ndig > 1 || flags & ALT) {
1035                                         ox[0] = *cp++;
1036                                         ox[1] = '.';
1037                                         PRINT(ox, 2);
1038                                         if (_double || flags & ALT == 0) {
1039                                                 PRINT(cp, ndig-1);
1040                                         } else  /* 0.[0..] */
1041                                                 /* __dtoa irregularity */
1042                                                 PAD(ndig - 1, zeroes);
1043                                 } else  /* XeYYY */
1044                                         PRINT(cp, 1);
1045                                 PRINT(expstr, expsize);
1046                         }
1047                 }
1048 #else
1049                 PRINT(cp, size);
1050 #endif
1051                 /* left-adjusting padding (always blank) */
1052                 if (flags & LADJUST)
1053                         PAD(width - realsz, blanks);
1054
1055                 /* finally, adjust ret */
1056                 ret += width > realsz ? width : realsz;
1057
1058                 FLUSH();        /* copy out the I/O vectors */
1059         }
1060 done:
1061         FLUSH();
1062 error:
1063         return (__sferror(fp) ? EOF : ret);
1064         /* NOTREACHED */
1065 }
1066
1067 #ifdef FLOATING_POINT
1068
1069 extern char *BSD__dtoa __P((double, int, int, int *, int *, char **));
1070
1071 static char *
1072 cvt(value, ndigits, flags, sign, decpt, ch, length)
1073         double value;
1074         int ndigits, flags, *decpt, ch, *length;
1075         char *sign;
1076 {
1077         int mode, dsgn;
1078         char *digits, *bp, *rve;
1079
1080         if (ch == 'f')
1081                 mode = 3;
1082         else {
1083                 mode = 2;
1084         }
1085         if (value < 0) {
1086                 value = -value;
1087                 *sign = '-';
1088         } else if (value == 0.0 && 1.0/value < 0) {
1089             *sign = '-';
1090         } else {
1091             *sign = '\000';
1092         }
1093         digits = BSD__dtoa(value, mode, ndigits, decpt, &dsgn, &rve);
1094         if (flags & ALT) {      /* Print trailing zeros */
1095                 bp = digits + ndigits;
1096                 if (ch == 'f') {
1097                         if (*digits == '0' && value)
1098                                 *decpt = -ndigits + 1;
1099                         bp += *decpt;
1100                 }
1101                 if (value == 0) /* kludge for __dtoa irregularity */
1102                         rve = bp;
1103                 while (rve < bp)
1104                         *rve++ = '0';
1105         }
1106         *length = rve - digits;
1107         return (digits);
1108 }
1109
1110 static int
1111 exponent(p0, exp, fmtch)
1112         char *p0;
1113         int exp, fmtch;
1114 {
1115         register char *p, *t;
1116         char expbuf[MAXEXP];
1117
1118         p = p0;
1119         *p++ = fmtch;
1120         if (exp < 0) {
1121                 exp = -exp;
1122                 *p++ = '-';
1123         }
1124         else
1125                 *p++ = '+';
1126         t = expbuf + MAXEXP;
1127         if (exp > 9) {
1128                 do {
1129                         *--t = to_char(exp % 10);
1130                 } while ((exp /= 10) > 9);
1131                 *--t = to_char(exp);
1132                 for (; t < expbuf + MAXEXP; *p++ = *t++);
1133         }
1134         else {
1135                 *p++ = '0';
1136                 *p++ = to_char(exp);
1137         }
1138         return (p - p0);
1139 }
1140 #endif /* FLOATING_POINT */
1141
1142 #ifndef HAVE_VSNPRINTF
1143 int
1144 vsnprintf(str, n, fmt, ap)
1145         char *str;
1146         size_t n;
1147         const char *fmt;
1148         _BSD_VA_LIST_ ap;
1149 {
1150         int ret;
1151         FILE f;
1152
1153         if ((int)n < 1)
1154                 return (EOF);
1155         f._flags = __SWR | __SSTR;
1156         f._bf._base = f._p = (unsigned char *)str;
1157         f._bf._size = f._w = n - 1;
1158         f.vwrite = BSD__sfvwrite;
1159         ret = BSD_vfprintf(&f, fmt, ap);
1160         *f._p = 0;
1161         return (ret);
1162 }
1163 #endif
1164
1165 #if defined(LIBC_SCCS) && !defined(lint)
1166 static char sccsid[] = "@(#)snprintf.c  8.1 (Berkeley) 6/4/93";
1167 #endif /* LIBC_SCCS and not lint */
1168
1169 #ifndef HAVE_SNPRINTF
1170 int
1171 #if defined(HAVE_STDARG_PROTOTYPES)
1172 snprintf(char *str, size_t n, char const *fmt, ...)
1173 #else
1174 snprintf(str, n, fmt, va_alist)
1175 char *str, *fmt;
1176 size_t n;
1177 va_dcl
1178 #endif
1179 {
1180         int ret;
1181         va_list ap;
1182         FILE f;
1183
1184         if ((int)n < 1)
1185                 return (EOF);
1186
1187 #if defined(HAVE_STDARG_PROTOTYPES)
1188         va_start(ap, fmt);
1189 #else
1190         va_start(ap);
1191 #endif
1192         f._flags = __SWR | __SSTR;
1193         f._bf._base = f._p = (unsigned char *)str;
1194         f._bf._size = f._w = n - 1;
1195         f.vwrite = BSD__sfvwrite;
1196         ret = BSD_vfprintf(&f, fmt, ap);
1197         *f._p = 0;
1198         va_end(ap);
1199         return (ret);
1200 }
1201 #endif