![[BACK]](/icons/back.gif){kind=icon}
Return to printf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / lib / libsa|
Return to printf.c CVS log | Up to [local] / sys / lib / libsa |
1.1 nbrk 1: /* $OpenBSD: printf.c,v 1.24 2006/09/18 21:11:50 mpf Exp $ */
2: /* $NetBSD: printf.c,v 1.10 1996/11/30 04:19:21 gwr Exp $ */
3:
4: /*-
5: * Copyright (c) 1993
6: * The Regents of the University of California. All rights reserved.
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: * @(#)printf.c 8.1 (Berkeley) 6/11/93
33: */
34:
35: /*
36: * Scaled down version of printf(3).
37: *
38: * One additional format:
39: *
40: * The format %b is supported to decode error registers.
41: * Its usage is:
42: *
43: * printf("reg=%b\n", regval, "<base><arg>*");
44: *
45: * where <base> is the output base expressed as a control character, e.g.
46: * \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
47: * the first of which gives the bit number to be inspected (origin 1), and
48: * the next characters (up to a control character, i.e. a character <= 32),
49: * give the name of the register. Thus:
50: *
51: * printf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
52: *
53: * would produce output:
54: *
55: * reg=3<BITTWO,BITONE>
56: */
57:
58: #include <sys/cdefs.h>
59: #include <sys/types.h>
60: #include <sys/stdarg.h>
61:
62: #include "stand.h"
63:
64: void kprintn(void (*)(int), u_long, int);
65: #ifdef LIBSA_LONGLONG_PRINTF
66: void kprintn64(void (*)(int), u_int64_t, int);
67: #endif
68: void kdoprnt(void (*)(int), const char *, va_list);
69:
70: const char hexdig[] = "0123456789abcdef";
71:
72: void
73: printf(const char *fmt, ...)
74: {
75: va_list ap;
76:
77: va_start(ap, fmt);
78: kdoprnt(putchar, fmt, ap);
79: va_end(ap);
80: }
81:
82: void
83: vprintf(const char *fmt, va_list ap)
84: {
85: kdoprnt(putchar, fmt, ap);
86: }
87:
88: void
89: kdoprnt(void (*put)(int), const char *fmt, va_list ap)
90: {
91: #ifdef LIBSA_LONGLONG_PRINTF
92: u_int64_t ull;
93: #endif
94: unsigned long ul;
95: int ch, lflag;
96: char *p;
97:
98: for (;;) {
99: while ((ch = *fmt++) != '%') {
100: if (ch == '\0')
101: return;
102: put(ch);
103: }
104: lflag = 0;
105: reswitch: switch (ch = *fmt++) {
106: case 'l':
107: lflag++;
108: goto reswitch;
109: #ifndef STRIPPED
110: case 'b':
111: {
112: int set, n;
113:
114: ul = va_arg(ap, int);
115: p = va_arg(ap, char *);
116: kprintn(put, ul, *p++);
117:
118: if (!ul)
119: break;
120:
121: for (set = 0; (n = *p++);) {
122: if (ul & (1 << (n - 1))) {
123: put(set ? ',' : '<');
124: for (; (n = *p) > ' '; ++p)
125: put(n);
126: set = 1;
127: } else
128: for (; *p > ' '; ++p)
129: ;
130: }
131: if (set)
132: put('>');
133: }
134: break;
135: #endif
136: case 'c':
137: ch = va_arg(ap, int);
138: put(ch & 0x7f);
139: break;
140: case 's':
141: p = va_arg(ap, char *);
142: while ((ch = *p++))
143: put(ch);
144: break;
145: case 'd':
146: #ifdef LIBSA_LONGLONG_PRINTF
147: if (lflag > 1) {
148: ull = va_arg(ap, int64_t);
149: if ((int64_t)ull < 0) {
150: put('-');
151: ull = -(int64_t)ull;
152: }
153: kprintn64(put, ull, 10);
154: break;
155: }
156: #endif
157: ul = lflag ?
158: va_arg(ap, long) : va_arg(ap, int);
159: if ((long)ul < 0) {
160: put('-');
161: ul = -(long)ul;
162: }
163: kprintn(put, ul, 10);
164: break;
165: case 'o':
166: #ifdef LIBSA_LONGLONG_PRINTF
167: if (lflag > 1) {
168: ull = va_arg(ap, u_int64_t);
169: kprintn64(put, ull, 8);
170: break;
171: }
172: #endif
173: ul = lflag ?
174: va_arg(ap, u_long) : va_arg(ap, u_int);
175: kprintn(put, ul, 8);
176: break;
177: case 'u':
178: #ifdef LIBSA_LONGLONG_PRINTF
179: if (lflag > 1) {
180: ull = va_arg(ap, u_int64_t);
181: kprintn64(put, ull, 10);
182: break;
183: }
184: #endif
185: ul = lflag ?
186: va_arg(ap, u_long) : va_arg(ap, u_int);
187: kprintn(put, ul, 10);
188: break;
189: case 'p':
190: put('0');
191: put('x');
192: lflag += sizeof(void *)==sizeof(u_long)? 1 : 0;
193: case 'x':
194: #ifdef LIBSA_LONGLONG_PRINTF
195: if (lflag > 1) {
196: ull = va_arg(ap, u_int64_t);
197: kprintn64(put, ull, 16);
198: break;
199: }
200: #else
201: if (lflag > 1) {
202: /* hold an int64_t in base 16 */
203: char *p, buf[(sizeof(u_int64_t) * NBBY / 4) + 1];
204: u_int64_t ull;
205:
206: ull = va_arg(ap, u_int64_t);
207: p = buf;
208: do {
209: *p++ = hexdig[ull & 15];
210: } while (ull >>= 4);
211: do {
212: put(*--p);
213: } while (p > buf);
214: break;
215: }
216: #endif
217: ul = lflag ?
218: va_arg(ap, u_long) : va_arg(ap, u_int);
219: kprintn(put, ul, 16);
220: break;
221: default:
222: put('%');
223: #ifdef LIBSA_LONGLONG_PRINTF
224: while (--lflag)
225: #else
226: if (lflag)
227: #endif
228: put('l');
229: put(ch);
230: }
231: }
232: va_end(ap);
233: }
234:
235: void
236: kprintn(void (*put)(int), unsigned long ul, int base)
237: {
238: /* hold a long in base 8 */
239: char *p, buf[(sizeof(long) * NBBY / 3) + 1];
240:
241: p = buf;
242: do {
243: *p++ = hexdig[ul % base];
244: } while (ul /= base);
245: do {
246: put(*--p);
247: } while (p > buf);
248: }
249:
250: #ifdef LIBSA_LONGLONG_PRINTF
251: void
252: kprintn64(void (*put)(int), u_int64_t ull, int base)
253: {
254: /* hold an int64_t in base 8 */
255: char *p, buf[(sizeof(u_int64_t) * NBBY / 3) + 1];
256:
257: p = buf;
258: do {
259: *p++ = hexdig[ull % base];
260: } while (ull /= base);
261: do {
262: put(*--p);
263: } while (p > buf);
264: }
265: #endif
266:
267: int donottwiddle = 0;
268:
269: void
270: twiddle(void)
271: {
272: static int pos;
273:
274: if (!donottwiddle) {
275: putchar("|/-\\"[pos++ & 3]);
276: putchar('\b');
277: }
278: }