![[BACK]](/icons/back.gif){kind=icon}
Return to vfprintf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / usr / lib / libc / stdio|
Return to vfprintf.c CVS log | Up to [local] / prex-old / usr / lib / libc / stdio |
1.1 nbrk 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: * Actual printf innards.
35: *
36: * This code is large and complicated...
37: */
38:
39: #include <sys/types.h>
40:
41: #include <limits.h>
42: #include <stdio.h>
43: #include <stdlib.h>
44: #include <string.h>
45: #include <stdarg.h>
46:
47: #include "local.h"
48: #include "fvwrite.h"
49:
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
55: __sprint(FILE *fp, struct __suio *uio)
56: {
57: int err;
58:
59: if (uio->uio_resid == 0) {
60: uio->uio_iovcnt = 0;
61: return (0);
62: }
63: err = __sfvwrite(fp, uio);
64: uio->uio_resid = 0;
65: uio->uio_iovcnt = 0;
66: return (err);
67: }
68:
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
75: __sbprintf(FILE *fp, const char *fmt, va_list ap)
76: {
77: int ret;
78: FILE fake;
79: unsigned char buf[BUFSIZ];
80:
81: /* copy the important variables */
82: fake._flags = fp->_flags & ~__SNBF;
83: fake._file = fp->_file;
84:
85: /* set up the buffer */
86: fake._bf._base = fake._p = buf;
87: fake._bf._size = fake._w = sizeof(buf);
88:
89: /* do the work, then copy any error status */
90: ret = vfprintf(&fake, fmt, ap);
91: if (ret >= 0 && fflush(&fake))
92: ret = EOF;
93: if (fake._flags & __SERR)
94: fp->_flags |= __SERR;
95: return (ret);
96: }
97:
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')
104:
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 *
112: __ultoa(u_long val, char *endp, int base, int octzero, char *xdigs)
113: {
114: char *cp = endp;
115: long sval;
116:
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);
135: sval = val / 10;
136: } else
137: sval = val;
138: do {
139: *--cp = to_char(sval % 10);
140: sval /= 10;
141: } while (sval != 0);
142: break;
143:
144: case 8:
145: do {
146: *--cp = to_char(val & 7);
147: val >>= 3;
148: } while (val);
149: if (octzero && *cp != '0')
150: *--cp = '0';
151: break;
152:
153: case 16:
154: do {
155: *--cp = xdigs[val & 15];
156: val >>= 4;
157: } while (val);
158: break;
159:
160: default: /* oops */
161: abort();
162: }
163: return (cp);
164: }
165:
166:
167: #define BUF 32
168:
169:
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
181: vfprintf(fp, fmt0, ap)
182: FILE *fp;
183: const char *fmt0;
184: 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) */
196: 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 */
208:
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'};
219:
220: /*
221: * BEWARE, these `goto error' on error, and PAD uses `n'.
222: */
223: #define PRINT(ptr, len) { \
224: iovp->iov_base = (ptr); \
225: iovp->iov_len = (len); \
226: uio.uio_resid += (len); \
227: iovp++; \
228: if (++uio.uio_iovcnt >= NIOV) { \
229: if (__sprint(fp, &uio)) \
230: goto error; \
231: iovp = iov; \
232: } \
233: }
234: #define PAD(howmany, with) { \
235: if ((n = (howmany)) > 0) { \
236: while (n > PADSIZE) { \
237: PRINT(with, PADSIZE); \
238: n -= PADSIZE; \
239: } \
240: PRINT(with, n); \
241: } \
242: }
243: #define FLUSH() { \
244: if (uio.uio_resid && __sprint(fp, &uio)) \
245: goto error; \
246: uio.uio_iovcnt = 0; \
247: iovp = iov; \
248: }
249:
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) : \
256: 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) : \
260: flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \
261: (u_long)va_arg(ap, u_int))
262:
263: /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */
264: if (cantwrite(fp))
265: return (EOF);
266:
267: /* optimise fprintf(stderr) (and other unbuffered Unix files) */
268: if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
269: fp->_file >= 0)
270: return (__sbprintf(fp, fmt0, ap));
271:
272: fmt = (char *)fmt0;
273: uio.uio_iov = iovp = iov;
274: uio.uio_resid = 0;
275: uio.uio_iovcnt = 0;
276: ret = 0;
277:
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) {
285: PRINT(cp, n);
286: ret += n;
287: }
288: if (ch == '\0')
289: goto done;
290: fmt++; /* skip over '%' */
291:
292: flags = 0;
293: dprec = 0;
294: width = 0;
295: prec = -1;
296: sign = '\0';
297:
298: rflag: ch = *fmt++;
299: 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)
307: sign = ' ';
308: goto rflag;
309: case '#':
310: 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;
321: width = -width;
322: /* FALLTHROUGH */
323: case '-':
324: flags |= LADJUST;
325: goto rflag;
326: case '+':
327: sign = '+';
328: goto rflag;
329: case '.':
330: if ((ch = *fmt++) == '*') {
331: n = va_arg(ap, int);
332: prec = n < 0 ? -1 : n;
333: goto rflag;
334: }
335: n = 0;
336: while (is_digit(ch)) {
337: n = 10 * n + to_digit(ch);
338: ch = *fmt++;
339: }
340: 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: */
348: 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':
352: n = 0;
353: do {
354: n = 10 * n + to_digit(ch);
355: ch = *fmt++;
356: } while (is_digit(ch));
357: width = n;
358: goto reswitch;
359: case 'h':
360: flags |= SHORTINT;
361: goto rflag;
362: case 'l':
363: flags |= LONGINT;
364: goto rflag;
365: case 'c':
366: *(cp = buf) = va_arg(ap, int);
367: size = 1;
368: sign = '\0';
369: break;
370: case 'D':
371: flags |= LONGINT;
372: /*FALLTHROUGH*/
373: case 'd':
374: case 'i':
375: ulval = SARG();
376: if ((long)ulval < 0) {
377: ulval = -ulval;
378: sign = '-';
379: }
380: 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':
391: flags |= LONGINT;
392: /*FALLTHROUGH*/
393: case 'o':
394: ulval = UARG();
395: 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: */
405: ulval = (u_long)va_arg(ap, void *);
406: base = 16;
407: xdigs = "0123456789abcdef";
408: flags |= HEXPREFIX;
409: ch = 'x';
410: goto nosign;
411: case 's':
412: if ((cp = va_arg(ap, char *)) == NULL)
413: 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);
421:
422: if (p != NULL) {
423: size = p - cp;
424: if (size > prec)
425: size = prec;
426: } else
427: size = prec;
428: } else
429: size = strlen(cp);
430: sign = '\0';
431: break;
432: case 'U':
433: flags |= LONGINT;
434: /*FALLTHROUGH*/
435: case 'u':
436: ulval = UARG();
437: base = 10;
438: goto nosign;
439: case 'X':
440: xdigs = "0123456789ABCDEF";
441: goto hex;
442: case 'x':
443: xdigs = "0123456789abcdef";
444: hex:
445: ulval = UARG();
446: base = 16;
447: /* leading 0x/X only if non-zero */
448: if (flags & ALT && ulval != 0)
449: flags |= HEXPREFIX;
450:
451: /* unsigned conversions */
452: nosign: sign = '\0';
453: /*
454: * ``... diouXx conversions ... if a precision is
455: * specified, the 0 flag will be ignored.''
456: * -- ANSI X3J11
457: */
458: number: if ((dprec = prec) >= 0)
459: flags &= ~ZEROPAD;
460:
461: /*
462: * ``The result of converting a zero value with an
463: * explicit precision of zero is no characters.''
464: * -- ANSI X3J11
465: */
466: cp = buf + BUF;
467: if (ulval != 0 || prec != 0)
468: cp = __ultoa(ulval, cp, base,
469: flags & ALT, xdigs);
470: 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 */
476: cp = buf;
477: *cp = ch;
478: size = 1;
479: sign = '\0';
480: break;
481: }
482:
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: */
497: fieldsz = size;
498: if (sign)
499: fieldsz++;
500: else if (flags & HEXPREFIX)
501: fieldsz += 2;
502: realsz = dprec > fieldsz ? dprec : fieldsz;
503:
504: /* right-adjusting blank padding */
505: if ((flags & (LADJUST|ZEROPAD)) == 0)
506: PAD(width - realsz, blanks);
507:
508: /* prefix */
509: if (sign) {
510: PRINT(&sign, 1);
511: } else if (flags & HEXPREFIX) {
512: ox[0] = '0';
513: ox[1] = ch;
514: PRINT(ox, 2);
515: }
516:
517: /* right-adjusting zero padding */
518: if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
519: PAD(width - realsz, zeroes);
520:
521: /* leading zeroes from decimal precision */
522: PAD(dprec - fieldsz, zeroes);
523:
524: /* the string or number proper */
525: PRINT(cp, size);
526:
527: /* left-adjusting padding (always blank) */
528: if (flags & LADJUST)
529: PAD(width - realsz, blanks);
530:
531: /* finally, adjust ret */
532: ret += width > realsz ? width : realsz;
533:
534: FLUSH(); /* copy out the I/O vectors */
535: }
536: done:
537: FLUSH();
538: error:
539: return (__sferror(fp) ? EOF : ret);
540: /* NOTREACHED */
541: }