![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / ex|
Return to printf.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / ex |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)printf.c 7.3 (Berkeley) 6/7/85";
9: #endif not lint
10:
11: /* The pwb version this is based on */
12: static char *printf_id = "@(#) printf.c:2.2 6/5/79";
13: #include "varargs.h"
14: /*
15: * This version of printf is compatible with the Version 7 C
16: * printf. The differences are only minor except that this
17: * printf assumes it is to print through putchar. Version 7
18: * printf is more general (and is much larger) and includes
19: * provisions for floating point.
20: */
21:
22:
23: #define MAXOCT 11 /* Maximum octal digits in a long */
24: #define MAXINT 32767 /* largest normal length positive integer */
25: #define BIG 1000000000 /* largest power of 10 less than an unsigned long */
26: #define MAXDIGS 10 /* number of digits in BIG */
27:
28: static int width, sign, fill;
29:
30: char *_p_dconv();
31:
32: printf(va_alist)
33: va_dcl
34: {
35: va_list ap;
36: register char *fmt;
37: char fcode;
38: int prec;
39: int length,mask1,nbits,n;
40: long int mask2, num;
41: register char *bptr;
42: char *ptr;
43: char buf[134];
44:
45: va_start(ap);
46: fmt = va_arg(ap,char *);
47: for (;;) {
48: /* process format string first */
49: while ((fcode = *fmt++)!='%') {
50: /* ordinary (non-%) character */
51: if (fcode=='\0')
52: return;
53: putchar(fcode);
54: }
55: /* length modifier: -1 for h, 1 for l, 0 for none */
56: length = 0;
57: /* check for a leading - sign */
58: sign = 0;
59: if (*fmt == '-') {
60: sign++;
61: fmt++;
62: }
63: /* a '0' may follow the - sign */
64: /* this is the requested fill character */
65: fill = 1;
66: if (*fmt == '0') {
67: fill--;
68: fmt++;
69: }
70:
71: /* Now comes a digit string which may be a '*' */
72: if (*fmt == '*') {
73: width = va_arg(ap, int);
74: if (width < 0) {
75: width = -width;
76: sign = !sign;
77: }
78: fmt++;
79: }
80: else {
81: width = 0;
82: while (*fmt>='0' && *fmt<='9')
83: width = width * 10 + (*fmt++ - '0');
84: }
85:
86: /* maybe a decimal point followed by more digits (or '*') */
87: if (*fmt=='.') {
88: if (*++fmt == '*') {
89: prec = va_arg(ap, int);
90: fmt++;
91: }
92: else {
93: prec = 0;
94: while (*fmt>='0' && *fmt<='9')
95: prec = prec * 10 + (*fmt++ - '0');
96: }
97: }
98: else
99: prec = -1;
100:
101: /*
102: * At this point, "sign" is nonzero if there was
103: * a sign, "fill" is 0 if there was a leading
104: * zero and 1 otherwise, "width" and "prec"
105: * contain numbers corresponding to the digit
106: * strings before and after the decimal point,
107: * respectively, and "fmt" addresses the next
108: * character after the whole mess. If there was
109: * no decimal point, "prec" will be -1.
110: */
111: switch (*fmt) {
112: case 'L':
113: case 'l':
114: length = 2;
115: /* no break!! */
116: case 'h':
117: case 'H':
118: length--;
119: fmt++;
120: break;
121: }
122:
123: /*
124: * At exit from the following switch, we will
125: * emit the characters starting at "bptr" and
126: * ending at "ptr"-1, unless fcode is '\0'.
127: */
128: switch (fcode = *fmt++) {
129: /* process characters and strings first */
130: case 'c':
131: buf[0] = va_arg(ap, int);
132: ptr = bptr = &buf[0];
133: if (buf[0] != '\0')
134: ptr++;
135: break;
136: case 's':
137: bptr = va_arg(ap,char *);
138: if (bptr==0)
139: bptr = "(null pointer)";
140: if (prec < 0)
141: prec = MAXINT;
142: for (n=0; *bptr++ && n < prec; n++) ;
143: ptr = --bptr;
144: bptr -= n;
145: break;
146: case 'O':
147: length = 1;
148: fcode = 'o';
149: /* no break */
150: case 'o':
151: case 'X':
152: case 'x':
153: if (length > 0)
154: num = va_arg(ap,long);
155: else
156: num = (unsigned)va_arg(ap,int);
157: if (fcode=='o') {
158: mask1 = 0x7;
159: mask2 = 0x1fffffffL;
160: nbits = 3;
161: }
162: else {
163: mask1 = 0xf;
164: mask2 = 0x0fffffffL;
165: nbits = 4;
166: }
167: n = (num!=0);
168: bptr = buf + MAXOCT + 3;
169: /* shift and mask for speed */
170: do
171: if (((int) num & mask1) < 10)
172: *--bptr = ((int) num & mask1) + 060;
173: else
174: *--bptr = ((int) num & mask1) + 0127;
175: while (num = (num >> nbits) & mask2);
176:
177: if (fcode=='o') {
178: if (n)
179: *--bptr = '0';
180: }
181: else
182: if (!sign && fill <= 0) {
183: putchar('0');
184: putchar(fcode);
185: width -= 2;
186: }
187: else {
188: *--bptr = fcode;
189: *--bptr = '0';
190: }
191: ptr = buf + MAXOCT + 3;
192: break;
193: case 'D':
194: case 'U':
195: case 'I':
196: length = 1;
197: fcode = fcode + 'a' - 'A';
198: /* no break */
199: case 'd':
200: case 'i':
201: case 'u':
202: if (length > 0)
203: num = va_arg(ap,long);
204: else {
205: n = va_arg(ap,int);
206: if (fcode=='u')
207: num = (unsigned) n;
208: else
209: num = (long) n;
210: }
211: if (n = (fcode != 'u' && num < 0))
212: num = -num;
213: /* now convert to digits */
214: bptr = _p_dconv(num, buf);
215: if (n)
216: *--bptr = '-';
217: if (fill == 0)
218: fill = -1;
219: ptr = buf + MAXDIGS + 1;
220: break;
221: default:
222: /* not a control character,
223: * print it.
224: */
225: ptr = bptr = &fcode;
226: ptr++;
227: break;
228: }
229: if (fcode != '\0')
230: _p_emit(bptr,ptr);
231: }
232: va_end(ap);
233: }
234:
235: /* _p_dconv converts the unsigned long integer "value" to
236: * printable decimal and places it in "buffer", right-justified.
237: * The value returned is the address of the first non-zero character,
238: * or the address of the last character if all are zero.
239: * The result is NOT null terminated, and is MAXDIGS characters long,
240: * starting at buffer[1] (to allow for insertion of a sign).
241: *
242: * This program assumes it is running on 2's complement machine
243: * with reasonable overflow treatment.
244: */
245: char *
246: _p_dconv(value, buffer)
247: long value;
248: char *buffer;
249: {
250: register char *bp;
251: register int svalue;
252: int n;
253: long lval;
254:
255: bp = buffer;
256:
257: /* zero is a special case */
258: if (value == 0) {
259: bp += MAXDIGS;
260: *bp = '0';
261: return(bp);
262: }
263:
264: /* develop the leading digit of the value in "n" */
265: n = 0;
266: while (value < 0) {
267: value -= BIG; /* will eventually underflow */
268: n++;
269: }
270: while ((lval = value - BIG) >= 0) {
271: value = lval;
272: n++;
273: }
274:
275: /* stash it in buffer[1] to allow for a sign */
276: bp[1] = n + '0';
277: /*
278: * Now develop the rest of the digits. Since speed counts here,
279: * we do it in two loops. The first gets "value" down until it
280: * is no larger than MAXINT. The second one uses integer divides
281: * rather than long divides to speed it up.
282: */
283: bp += MAXDIGS + 1;
284: while (value > MAXINT) {
285: *--bp = (int)(value % 10) + '0';
286: value /= 10;
287: }
288:
289: /* cannot lose precision */
290: svalue = value;
291: while (svalue > 0) {
292: *--bp = (svalue % 10) + '0';
293: svalue /= 10;
294: }
295:
296: /* fill in intermediate zeroes if needed */
297: if (buffer[1] != '0') {
298: while (bp > buffer + 2)
299: *--bp = '0';
300: --bp;
301: }
302: return(bp);
303: }
304:
305: /*
306: * This program sends string "s" to putchar. The character after
307: * the end of "s" is given by "send". This allows the size of the
308: * field to be computed; it is stored in "alen". "width" contains the
309: * user specified length. If width<alen, the width will be taken to
310: * be alen. "sign" is zero if the string is to be right-justified
311: * in the field, nonzero if it is to be left-justified. "fill" is
312: * 0 if the string is to be padded with '0', positive if it is to be
313: * padded with ' ', and negative if an initial '-' should appear before
314: * any padding in right-justification (to avoid printing "-3" as
315: * "000-3" where "-0003" was intended).
316: */
317: _p_emit(s, send)
318: register char *s;
319: char *send;
320: {
321: char cfill;
322: register int alen;
323: int npad;
324:
325: alen = send - s;
326: if (alen > width)
327: width = alen;
328: cfill = fill>0? ' ': '0';
329:
330: /* we may want to print a leading '-' before anything */
331: if (*s == '-' && fill < 0) {
332: putchar(*s++);
333: alen--;
334: width--;
335: }
336: npad = width - alen;
337:
338: /* emit any leading pad characters */
339: if (!sign)
340: while (--npad >= 0)
341: putchar(cfill);
342:
343: /* emit the string itself */
344: while (--alen >= 0)
345: putchar(*s++);
346:
347: /* emit trailing pad characters */
348: if (sign)
349: while (--npad >= 0)
350: putchar(cfill);
351: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.