Prex Home / Browse Source - Prex Version: 0.9.0

root/usr/lib/libc/stdio/vfprintf.c

DEFINITIONS

1. __sprint
2. __sbprintf
3. __ultoa
4. vfprintf

   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  */
  33 /*
  34  * Actual printf innards.
  35  *
  36  * This code is large and complicated...
  37  */
  39 #include <sys/types.h>
  41 #include <limits.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <stdarg.h>
  47 #include "local.h"
  48 #include "fvwrite.h"
  50 /*
  51  * Flush out all the vectors defined by the given uio,
  52  * then reset it so that it can be reused.
  53  */
  54 static int
__sprint(FILE *fp, struct __suio *uio)
  56 {
  57         int error;
  59         if (uio->uio_resid == 0) {
uio->uio_iovcnt = 0;
  61                 return (0);
  62         }
error = __sfvwrite(fp, uio);
uio->uio_resid = 0;
uio->uio_iovcnt = 0;
  66         return (error);
  67 }
  69 /*
  70  * Helper function for `fprintf to unbuffered unix file': creates a
  71  * temporary buffer.  We only work on write-only files; this avoids
  72  * worries about ungetc buffers and so forth.
  73  */
  74 static int
__sbprintf(FILE *fp, const char *fmt, va_list ap)
  76 {
  77         int ret;
FILE fake;
  79         unsigned char buf[BUFSIZ];
  81         /* copy the important variables */
fake._flags = fp->_flags & ~__SNBF;
fake._file = fp->_file;
  85         /* set up the buffer */
fake._bf._base = fake._p = buf;
fake._bf._size = fake._w = sizeof(buf);
  89         /* do the work, then copy any error status */
ret = vfprintf(&fake, fmt, ap);
  91         if (ret >= 0 && fflush(&fake))
ret = EOF;
  93         if (fake._flags & __SERR)
fp->_flags |= __SERR;
  95         return (ret);
  96 }
  98 /*
  99  * Macros for converting digits to letters and vice versa
 100  */
 101 #define to_digit(c)     ((c) - '0')
 102 #define is_digit(c)     ((unsigned)to_digit(c) <= 9)
 103 #define to_char(n)      ((n) + '0')
 105 /*
 106  * Convert an unsigned long to ASCII for printf purposes, returning
 107  * a pointer to the first character of the string representation.
 108  * Octal numbers can be forced to have a leading zero; hex numbers
 109  * use the given digits.
 110  */
 111 static char *
__ultoa(u_long val, char *endp, int base, int octzero, char *xdigs)
 113 {
 114         char *cp = endp;
 115         long sval;
 117         /*
 118          * Handle the three cases separately, in the hope of getting
 119          * better/faster code.
 120          */
 121         switch (base) {
 122         case 10:
 123                 if (val < 10) { /* many numbers are 1 digit */
 124                         *--cp = to_char(val);
 125                         return (cp);
 126                 }
 127                 /*
 128                  * On many machines, unsigned arithmetic is harder than
 129                  * signed arithmetic, so we do at most one unsigned mod and
 130                  * divide; this is sufficient to reduce the range of
 131                  * the incoming value to where signed arithmetic works.
 132                  */
 133                 if (val > LONG_MAX) {
 134                         *--cp = to_char(val % 10);
sval = val / 10;
 136                 } else
sval = val;
 138                 do {
 139                         *--cp = to_char(sval % 10);
sval /= 10;
 141                 } while (sval != 0);
 142                 break;
 144         case 8:
 145                 do {
 146                         *--cp = to_char(val & 7);
val >>= 3;
 148                 } while (val);
 149                 if (octzero && *cp != '0')
 150                         *--cp = '0';
 151                 break;
 153         case 16:
 154                 do {
 155                         *--cp = xdigs[val & 15];
val >>= 4;
 157                 } while (val);
 158                 break;
 160         default:                        /* oops */
exit(1);
 162         }
 163         return (cp);
 164 }
 167 #define BUF             32
 170 /*
 171  * Flags used during conversion.
 172  */
 173 #define ALT             0x001           /* alternate form */
 174 #define HEXPREFIX       0x002           /* add 0x or 0X prefix */
 175 #define LADJUST         0x004           /* left adjustment */
 176 #define LONGDBL         0x008           /* long double; unimplemented */
 177 #define LONGINT         0x010           /* long integer */
 178 #define SHORTINT        0x040           /* short integer */
 179 #define ZEROPAD         0x080           /* zero (as opposed to blank) pad */
 180 int
vfprintf(fp, fmt0, ap)
FILE *fp;
 183         const char *fmt0;
va_list ap;
 185 {
 186         char *fmt;              /* format string */
 187         int ch;                 /* character from fmt */
 188         int n;                  /* handy integer (short term usage) */
 189         char *cp;               /* handy char pointer (short term usage) */
 190         struct __siov *iovp;    /* for PRINT macro */
 191         int flags;              /* flags as above */
 192         int ret;                /* return value accumulator */
 193         int width;              /* width from format (%8d), or 0 */
 194         int prec;               /* precision from format (%.3d), or -1 */
 195         char sign;              /* sign prefix (' ', '+', '-', or \0) */
u_long  ulval;          /* integer arguments %[diouxX] */
 197         int base;               /* base for [diouxX] conversion */
 198         int dprec;              /* a copy of prec if [diouxX], 0 otherwise */
 199         int fieldsz;            /* field size expanded by sign, etc */
 200         int realsz;             /* field size expanded by dprec */
 201         int size;               /* size of converted field or string */
 202         char *xdigs = NULL;     /* digits for [xX] conversion */
 203 #define NIOV 8
 204         struct __suio uio;      /* output information: summary */
 205         struct __siov iov[NIOV];/* ... and individual io vectors */
 206         char buf[BUF];          /* space for %c, %[diouxX], %[eEfgG] */
 207         char ox[2];             /* space for 0x hex-prefix */
 209         /*
 210          * Choose PADSIZE to trade efficiency vs. size.  If larger printf
 211          * fields occur frequently, increase PADSIZE and make the initialisers
 212          * below longer.
 213          */
 214 #define PADSIZE 16              /* pad chunk size */
 215         static char blanks[PADSIZE] =
 216          {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
 217         static char zeroes[PADSIZE] =
 218          {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
 220         /*
 221          * BEWARE, these `goto error' on error, and PAD uses `n'.
 222          */
 223 #define PRINT(ptr, len) { \
iovp->iov_base = (ptr); \
iovp->iov_len = (len); \
uio.uio_resid += (len); \
iovp++; \
 228         if (++uio.uio_iovcnt >= NIOV) { \
 229                 if (__sprint(fp, &uio)) \
 230                         goto error; \
iovp = iov; \
 232         } \
 233 }
 234 #define PAD(howmany, with) { \
 235         if ((n = (howmany)) > 0) { \
 236                 while (n > PADSIZE) { \
PRINT(with, PADSIZE); \
n -= PADSIZE; \
 239                 } \
PRINT(with, n); \
 241         } \
 242 }
 243 #define FLUSH() { \
 244         if (uio.uio_resid && __sprint(fp, &uio)) \
 245                 goto error; \
uio.uio_iovcnt = 0; \
iovp = iov; \
 248 }
 250         /*
 251          * To extend shorts properly, we need both signed and unsigned
 252          * argument extraction methods.
 253          */
 254 #define SARG() \
 255         (flags&LONGINT ? va_arg(ap, long) : \
flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
 257             (long)va_arg(ap, int))
 258 #define UARG() \
 259         (flags&LONGINT ? va_arg(ap, u_long) : \
flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \
 261             (u_long)va_arg(ap, u_int))
 263         /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */
 264         if (cantwrite(fp))
 265                 return (EOF);
 267         /* optimise fprintf(stderr) (and other unbuffered Unix files) */
 268         if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
fp->_file >= 0)
 270                 return (__sbprintf(fp, fmt0, ap));
fmt = (char *)fmt0;
uio.uio_iov = iovp = iov;
uio.uio_resid = 0;
uio.uio_iovcnt = 0;
ret = 0;
 278         /*
 279          * Scan the format for conversions (`%' character).
 280          */
 281         for (;;) {
 282                 for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
 283                         /* void */;
 284                 if ((n = fmt - cp) != 0) {
PRINT(cp, n);
ret += n;
 287                 }
 288                 if (ch == '\0')
 289                         goto done;
fmt++;          /* skip over '%' */
flags = 0;
dprec = 0;
width = 0;
prec = -1;
sign = '\0';
rflag:          ch = *fmt++;
reswitch:       switch (ch) {
 300                 case ' ':
 301                         /*
 302                          * ``If the space and + flags both appear, the space
 303                          * flag will be ignored.''
 304                          *      -- ANSI X3J11
 305                          */
 306                         if (!sign)
sign = ' ';
 308                         goto rflag;
 309                 case '#':
flags |= ALT;
 311                         goto rflag;
 312                 case '*':
 313                         /*
 314                          * ``A negative field width argument is taken as a
 315                          * - flag followed by a positive field width.''
 316                          *      -- ANSI X3J11
 317                          * They don't exclude field widths read from args.
 318                          */
 319                         if ((width = va_arg(ap, int)) >= 0)
 320                                 goto rflag;
width = -width;
 322                         /* FALLTHROUGH */
 323                 case '-':
flags |= LADJUST;
 325                         goto rflag;
 326                 case '+':
sign = '+';
 328                         goto rflag;
 329                 case '.':
 330                         if ((ch = *fmt++) == '*') {
n = va_arg(ap, int);
prec = n < 0 ? -1 : n;
 333                                 goto rflag;
 334                         }
n = 0;
 336                         while (is_digit(ch)) {
n = 10 * n + to_digit(ch);
ch = *fmt++;
 339                         }
prec = n < 0 ? -1 : n;
 341                         goto reswitch;
 342                 case '0':
 343                         /*
 344                          * ``Note that 0 is taken as a flag, not as the
 345                          * beginning of a field width.''
 346                          *      -- ANSI X3J11
 347                          */
flags |= ZEROPAD;
 349                         goto rflag;
 350                 case '1': case '2': case '3': case '4':
 351                 case '5': case '6': case '7': case '8': case '9':
n = 0;
 353                         do {
n = 10 * n + to_digit(ch);
ch = *fmt++;
 356                         } while (is_digit(ch));
width = n;
 358                         goto reswitch;
 359                 case 'h':
flags |= SHORTINT;
 361                         goto rflag;
 362                 case 'l':
flags |= LONGINT;
 364                         goto rflag;
 365                 case 'c':
 366                         *(cp = buf) = va_arg(ap, int);
size = 1;
sign = '\0';
 369                         break;
 370                 case 'D':
flags |= LONGINT;
 372                         /*FALLTHROUGH*/
 373                 case 'd':
 374                 case 'i':
ulval = SARG();
 376                         if ((long)ulval < 0) {
ulval = -ulval;
sign = '-';
 379                         }
base = 10;
 381                         goto number;
 382                 case 'n':
 383                         if (flags & LONGINT)
 384                                 *va_arg(ap, long *) = ret;
 385                         else if (flags & SHORTINT)
 386                                 *va_arg(ap, short *) = ret;
 387                         else
 388                                 *va_arg(ap, int *) = ret;
 389                         continue;       /* no output */
 390                 case 'O':
flags |= LONGINT;
 392                         /*FALLTHROUGH*/
 393                 case 'o':
ulval = UARG();
base = 8;
 396                         goto nosign;
 397                 case 'p':
 398                         /*
 399                          * ``The argument shall be a pointer to void.  The
 400                          * value of the pointer is converted to a sequence
 401                          * of printable characters, in an implementation-
 402                          * defined manner.''
 403                          *      -- ANSI X3J11
 404                          */
ulval = (u_long)va_arg(ap, void *);
base = 16;
xdigs = "0123456789abcdef";
flags |= HEXPREFIX;
ch = 'x';
 410                         goto nosign;
 411                 case 's':
 412                         if ((cp = va_arg(ap, char *)) == NULL)
cp = "(null)";
 414                         if (prec >= 0) {
 415                                 /*
 416                                  * can't use strlen; can only look for the
 417                                  * NUL in the first `prec' characters, and
 418                                  * strlen() will go further.
 419                                  */
 420                                 char *p = memchr(cp, 0, prec);
 422                                 if (p != NULL) {
size = p - cp;
 424                                         if (size > prec)
size = prec;
 426                                 } else
size = prec;
 428                         } else
size = strlen(cp);
sign = '\0';
 431                         break;
 432                 case 'U':
flags |= LONGINT;
 434                         /*FALLTHROUGH*/
 435                 case 'u':
ulval = UARG();
base = 10;
 438                         goto nosign;
 439                 case 'X':
xdigs = "0123456789ABCDEF";
 441                         goto hex;
 442                 case 'x':
xdigs = "0123456789abcdef";
hex:
ulval = UARG();
base = 16;
 447                         /* leading 0x/X only if non-zero */
 448                         if (flags & ALT && ulval != 0)
flags |= HEXPREFIX;
 451                         /* unsigned conversions */
nosign:                 sign = '\0';
 453                         /*
 454                          * ``... diouXx conversions ... if a precision is
 455                          * specified, the 0 flag will be ignored.''
 456                          *      -- ANSI X3J11
 457                          */
number:                 if ((dprec = prec) >= 0)
flags &= ~ZEROPAD;
 461                         /*
 462                          * ``The result of converting a zero value with an
 463                          * explicit precision of zero is no characters.''
 464                          *      -- ANSI X3J11
 465                          */
cp = buf + BUF;
 467                         if (ulval != 0 || prec != 0)
cp = __ultoa(ulval, cp, base,
flags & ALT, xdigs);
size = buf + BUF - cp;
 471                         break;
 472                 default:        /* "%?" prints ?, unless ? is NUL */
 473                         if (ch == '\0')
 474                                 goto done;
 475                         /* pretend it was %c with argument ch */
cp = buf;
 477                         *cp = ch;
size = 1;
sign = '\0';
 480                         break;
 481                 }
 483                 /*
 484                  * All reasonable formats wind up here.  At this point, `cp'
 485                  * points to a string which (if not flags&LADJUST) should be
 486                  * padded out to `width' places.  If flags&ZEROPAD, it should
 487                  * first be prefixed by any sign or other prefix; otherwise,
 488                  * it should be blank padded before the prefix is emitted.
 489                  * After any left-hand padding and prefixing, emit zeroes
 490                  * required by a decimal [diouxX] precision, then print the
 491                  * string proper, then emit zeroes required by any leftover
 492                  * floating precision; finally, if LADJUST, pad with blanks.
 493                  *
 494                  * Compute actual size, so we know how much to pad.
 495                  * fieldsz excludes decimal prec; realsz includes it.
 496                  */
fieldsz = size;
 498                 if (sign)
fieldsz++;
 500                 else if (flags & HEXPREFIX)
fieldsz += 2;
realsz = dprec > fieldsz ? dprec : fieldsz;
 504                 /* right-adjusting blank padding */
 505                 if ((flags & (LADJUST|ZEROPAD)) == 0)
PAD(width - realsz, blanks);
 508                 /* prefix */
 509                 if (sign) {
PRINT(&sign, 1);
 511                 } else if (flags & HEXPREFIX) {
ox[0] = '0';
ox[1] = ch;
PRINT(ox, 2);
 515                 }
 517                 /* right-adjusting zero padding */
 518                 if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
PAD(width - realsz, zeroes);
 521                 /* leading zeroes from decimal precision */
PAD(dprec - fieldsz, zeroes);
 524                 /* the string or number proper */
PRINT(cp, size);
 527                 /* left-adjusting padding (always blank) */
 528                 if (flags & LADJUST)
PAD(width - realsz, blanks);
 531                 /* finally, adjust ret */
ret += width > realsz ? width : realsz;
FLUSH();        /* copy out the I/O vectors */
 535         }
done:
FLUSH();
error:
 539         return (__sferror(fp) ? EOF : ret);
 540         /* NOTREACHED */
 541 }