![[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 [Apple XNU] / XNU / osfmk / kern|
Return to printf.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25:
26: /*
27: * Mach Operating System
28: * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
29: * All Rights Reserved.
30: *
31: * Permission to use, copy, modify and distribute this software and its
32: * documentation is hereby granted, provided that both the copyright
33: * notice and this permission notice appear in all copies of the
34: * software, derivative works or modified versions, and any portions
35: * thereof, and that both notices appear in supporting documentation.
36: *
37: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
38: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
39: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
40: *
41: * Carnegie Mellon requests users of this software to return to
42: *
43: * Software Distribution Coordinator or [email protected]
44: * School of Computer Science
45: * Carnegie Mellon University
46: * Pittsburgh PA 15213-3890
47: *
48: * any improvements or extensions that they make and grant Carnegie Mellon
49: * the rights to redistribute these changes.
50: */
51:
52: /*
53: * Common code for printf et al.
54: *
55: * The calling routine typically takes a variable number of arguments,
56: * and passes the address of the first one. This implementation
57: * assumes a straightforward, stack implementation, aligned to the
58: * machine's wordsize. Increasing addresses are assumed to point to
59: * successive arguments (left-to-right), as is the case for a machine
60: * with a downward-growing stack with arguments pushed right-to-left.
61: *
62: * To write, for example, fprintf() using this routine, the code
63: *
64: * fprintf(fd, format, args)
65: * FILE *fd;
66: * char *format;
67: * {
68: * _doprnt(format, &args, fd);
69: * }
70: *
71: * would suffice. (This example does not handle the fprintf's "return
72: * value" correctly, but who looks at the return value of fprintf
73: * anyway?)
74: *
75: * This version implements the following printf features:
76: *
77: * %d decimal conversion
78: * %u unsigned conversion
79: * %x hexadecimal conversion
80: * %X hexadecimal conversion with capital letters
81: * %o octal conversion
82: * %c character
83: * %s string
84: * %m.n field width, precision
85: * %-m.n left adjustment
86: * %0m.n zero-padding
87: * %*.* width and precision taken from arguments
88: *
89: * This version does not implement %f, %e, or %g. It accepts, but
90: * ignores, an `l' as in %ld, %lo, %lx, and %lu, and therefore will not
91: * work correctly on machines for which sizeof(long) != sizeof(int).
92: * It does not even parse %D, %O, or %U; you should be using %ld, %o and
93: * %lu if you mean long conversion.
94: *
95: * As mentioned, this version does not return any reasonable value.
96: *
97: * Permission is granted to use, modify, or propagate this code as
98: * long as this notice is incorporated.
99: *
100: * Steve Summit 3/25/87
101: */
102:
103: /*
104: * Added formats for decoding device registers:
105: *
106: * printf("reg = %b", regval, "<base><arg>*")
107: *
108: * where <base> is the output base expressed as a control character:
109: * i.e. '\10' gives octal, '\20' gives hex. Each <arg> is a sequence of
110: * characters, the first of which gives the bit number to be inspected
111: * (origin 1), and the rest (up to a control character (<= 32)) give the
112: * name of the register. Thus
113: * printf("reg = %b\n", 3, "\10\2BITTWO\1BITONE")
114: * would produce
115: * reg = 3<BITTWO,BITONE>
116: *
117: * If the second character in <arg> is also a control character, it
118: * indicates the last bit of a bit field. In this case, printf will extract
119: * bits <1> to <2> and print it. Characters following the second control
120: * character are printed before the bit field.
121: * printf("reg = %b\n", 0xb, "\10\4\3FIELD1=\2BITTWO\1BITONE")
122: * would produce
123: * reg = b<FIELD1=2,BITONE>
124: *
125: * The %B format is like %b but the bits are numbered from the most
126: * significant (the bit weighted 31), which is called 1, to the least
127: * significant, called 32.
128: */
129: /*
130: * Added for general use:
131: * # prefix for alternate format:
132: * 0x (0X) for hex
133: * leading 0 for octal
134: * + print '+' if positive
135: * blank print ' ' if positive
136: *
137: * z signed hexadecimal
138: * r signed, 'radix'
139: * n unsigned, 'radix'
140: *
141: * D,U,O,Z same as corresponding lower-case versions
142: * (compatibility)
143: */
144:
145: #include <platforms.h>
146: #include <mach/boolean.h>
147: #include <cpus.h>
148: #include <kern/cpu_number.h>
149: #include <kern/lock.h>
150: #include <kern/thread.h>
151: #include <kern/sched_prim.h>
152: #include <kern/misc_protos.h>
153: #include <stdarg.h>
154: #include <string.h>
155: #include <mach_assert.h>
156: #ifdef MACH_BSD
157: #include <sys/msgbuf.h>
158: #endif
159:
160: #ifdef __ppc__
161: #include <ppc/Firmware.h>
162: #endif
163:
164: /*
165: * Forward declarations
166: */
167: void printnum(
168: register unsigned int u,
169: register int base,
170: void (*putc)(char));
171:
172:
173: #define isdigit(d) ((d) >= '0' && (d) <= '9')
174: #define Ctod(c) ((c) - '0')
175:
176: #define MAXBUF (sizeof(long int) * 8) /* enough for binary */
177:
178: void
179: printnum(
180: register unsigned int u, /* number to print */
181: register int base,
182: void (*putc)(char))
183: {
184: char buf[MAXBUF]; /* build number here */
185: register char * p = &buf[MAXBUF-1];
186: static char digs[] = "0123456789abcdef";
187:
188: do {
189: *p-- = digs[u % base];
190: u /= base;
191: } while (u != 0);
192:
193: while (++p != &buf[MAXBUF])
194: (*putc)(*p);
195:
196: }
197:
198: boolean_t _doprnt_truncates = FALSE;
199:
200: void
201: _doprnt(
202: register const char *fmt,
203: va_list *argp,
204: /* character output routine */
205: void (*putc)(char),
206: int radix) /* default radix - for '%r' */
207: {
208: int length;
209: int prec;
210: boolean_t ladjust;
211: char padc;
212: long n;
213: unsigned long u;
214: int plus_sign;
215: int sign_char;
216: boolean_t altfmt, truncate;
217: int base;
218: register char c;
219: int capitals;
220:
221: while ((c = *fmt) != '\0') {
222: if (c != '%') {
223: (*putc)(c);
224: fmt++;
225: continue;
226: }
227:
228: fmt++;
229:
230: length = 0;
231: prec = -1;
232: ladjust = FALSE;
233: padc = ' ';
234: plus_sign = 0;
235: sign_char = 0;
236: altfmt = FALSE;
237:
238: while (TRUE) {
239: c = *fmt;
240: if (c == '#') {
241: altfmt = TRUE;
242: }
243: else if (c == '-') {
244: ladjust = TRUE;
245: }
246: else if (c == '+') {
247: plus_sign = '+';
248: }
249: else if (c == ' ') {
250: if (plus_sign == 0)
251: plus_sign = ' ';
252: }
253: else
254: break;
255: fmt++;
256: }
257:
258: if (c == '0') {
259: padc = '0';
260: c = *++fmt;
261: }
262:
263: if (isdigit(c)) {
264: while(isdigit(c)) {
265: length = 10 * length + Ctod(c);
266: c = *++fmt;
267: }
268: }
269: else if (c == '*') {
270: length = va_arg(*argp, int);
271: c = *++fmt;
272: if (length < 0) {
273: ladjust = !ladjust;
274: length = -length;
275: }
276: }
277:
278: if (c == '.') {
279: c = *++fmt;
280: if (isdigit(c)) {
281: prec = 0;
282: while(isdigit(c)) {
283: prec = 10 * prec + Ctod(c);
284: c = *++fmt;
285: }
286: }
287: else if (c == '*') {
288: prec = va_arg(*argp, int);
289: c = *++fmt;
290: }
291: }
292:
293: if (c == 'l')
294: c = *++fmt; /* need it if sizeof(int) < sizeof(long) */
295:
296: truncate = FALSE;
297: capitals=0; /* Assume lower case printing */
298:
299: switch(c) {
300: case 'b':
301: case 'B':
302: {
303: register char *p;
304: boolean_t any;
305: register int i;
306:
307: u = va_arg(*argp, unsigned long);
308: p = va_arg(*argp, char *);
309: base = *p++;
310: printnum(u, base, putc);
311:
312: if (u == 0)
313: break;
314:
315: any = FALSE;
316: while ((i = *p++) != '\0') {
317: if (*fmt == 'B')
318: i = 33 - i;
319: if (*p <= 32) {
320: /*
321: * Bit field
322: */
323: register int j;
324: if (any)
325: (*putc)(',');
326: else {
327: (*putc)('<');
328: any = TRUE;
329: }
330: j = *p++;
331: if (*fmt == 'B')
332: j = 32 - j;
333: for (; (c = *p) > 32; p++)
334: (*putc)(c);
335: printnum((unsigned)( (u>>(j-1)) & ((2<<(i-j))-1)),
336: base, putc);
337: }
338: else if (u & (1<<(i-1))) {
339: if (any)
340: (*putc)(',');
341: else {
342: (*putc)('<');
343: any = TRUE;
344: }
345: for (; (c = *p) > 32; p++)
346: (*putc)(c);
347: }
348: else {
349: for (; *p > 32; p++)
350: continue;
351: }
352: }
353: if (any)
354: (*putc)('>');
355: break;
356: }
357:
358: case 'c':
359: c = va_arg(*argp, int);
360: (*putc)(c);
361: break;
362:
363: case 's':
364: {
365: register char *p;
366: register char *p2;
367:
368: if (prec == -1)
369: prec = 0x7fffffff; /* MAXINT */
370:
371: p = va_arg(*argp, char *);
372:
373: if (p == (char *)0)
374: p = "";
375:
376: if (length > 0 && !ladjust) {
377: n = 0;
378: p2 = p;
379:
380: for (; *p != '\0' && n < prec; p++)
381: n++;
382:
383: p = p2;
384:
385: while (n < length) {
386: (*putc)(' ');
387: n++;
388: }
389: }
390:
391: n = 0;
392:
393: while (*p != '\0') {
394: if (++n > prec || (length > 0 && n > length))
395: break;
396:
397: (*putc)(*p++);
398: }
399:
400: if (n < length && ladjust) {
401: while (n < length) {
402: (*putc)(' ');
403: n++;
404: }
405: }
406:
407: break;
408: }
409:
410: case 'o':
411: truncate = _doprnt_truncates;
412: case 'O':
413: base = 8;
414: goto print_unsigned;
415:
416: case 'd':
417: truncate = _doprnt_truncates;
418: case 'D':
419: base = 10;
420: goto print_signed;
421:
422: case 'u':
423: truncate = _doprnt_truncates;
424: case 'U':
425: base = 10;
426: goto print_unsigned;
427:
428: case 'x':
429: truncate = _doprnt_truncates;
430: base = 16;
431: goto print_unsigned;
432:
433: case 'X':
434: base = 16;
435: capitals=16; /* Print in upper case */
436: goto print_unsigned;
437:
438: case 'z':
439: truncate = _doprnt_truncates;
440: base = 16;
441: goto print_signed;
442:
443: case 'Z':
444: base = 16;
445: capitals=16; /* Print in upper case */
446: goto print_signed;
447:
448: case 'r':
449: truncate = _doprnt_truncates;
450: case 'R':
451: base = radix;
452: goto print_signed;
453:
454: case 'n':
455: truncate = _doprnt_truncates;
456: case 'N':
457: base = radix;
458: goto print_unsigned;
459:
460: print_signed:
461: n = va_arg(*argp, long);
462: if (n >= 0) {
463: u = n;
464: sign_char = plus_sign;
465: }
466: else {
467: u = -n;
468: sign_char = '-';
469: }
470: goto print_num;
471:
472: print_unsigned:
473: u = va_arg(*argp, unsigned long);
474: goto print_num;
475:
476: print_num:
477: {
478: char buf[MAXBUF]; /* build number here */
479: register char * p = &buf[MAXBUF-1];
480: static char digits[] = "0123456789abcdef0123456789ABCDEF";
481: char *prefix = 0;
482:
483: if (truncate) u = (long)((int)(u));
484:
485: if (u != 0 && altfmt) {
486: if (base == 8)
487: prefix = "0";
488: else if (base == 16)
489: prefix = "0x";
490: }
491:
492: do {
493: /* Print in the correct case */
494: *p-- = digits[(u % base)+capitals];
495: u /= base;
496: } while (u != 0);
497:
498: length -= (&buf[MAXBUF-1] - p);
499: if (sign_char)
500: length--;
501: if (prefix)
502: length -= strlen((const char *) prefix);
503:
504: if (padc == ' ' && !ladjust) {
505: /* blank padding goes before prefix */
506: while (--length >= 0)
507: (*putc)(' ');
508: }
509: if (sign_char)
510: (*putc)(sign_char);
511: if (prefix)
512: while (*prefix)
513: (*putc)(*prefix++);
514: if (padc == '0') {
515: /* zero padding goes after sign and prefix */
516: while (--length >= 0)
517: (*putc)('0');
518: }
519: while (++p != &buf[MAXBUF])
520: (*putc)(*p);
521:
522: if (ladjust) {
523: while (--length >= 0)
524: (*putc)(' ');
525: }
526: break;
527: }
528:
529: case '\0':
530: fmt--;
531: break;
532:
533: default:
534: (*putc)(c);
535: }
536: fmt++;
537: }
538: }
539:
540: #if MP_PRINTF
541: boolean_t new_printf_cpu_number = FALSE;
542: #endif /* MP_PRINTF */
543:
544:
545: decl_simple_lock_data(,printf_lock)
546:
547: void
548: printf_init(void)
549: {
550: /*
551: * Lock is only really needed after the first thread is created.
552: */
553: simple_lock_init(&printf_lock, ETAP_MISC_PRINTF);
554: }
555:
556: /* derived from boot_gets */
557: void
558: safe_gets(
559: char *str,
560: int maxlen)
561: {
562: register char *lp;
563: register int c;
564: char *strmax = str + maxlen - 1; /* allow space for trailing 0 */
565:
566: lp = str;
567: for (;;) {
568: c = cngetc();
569: switch (c) {
570: case '\n':
571: case '\r':
572: printf("\n");
573: *lp++ = 0;
574: return;
575:
576: case '\b':
577: case '#':
578: case '\177':
579: if (lp > str) {
580: printf("\b \b");
581: lp--;
582: }
583: continue;
584:
585: case '@':
586: case 'u'&037:
587: lp = str;
588: printf("\n\r");
589: continue;
590:
591: default:
592: if (c >= ' ' && c < '\177') {
593: if (lp < strmax) {
594: *lp++ = c;
595: printf("%c", c);
596: }
597: else {
598: printf("%c", '\007'); /* beep */
599: }
600: }
601: }
602: }
603: }
604:
605: void
606: conslog_putc(
607: char c)
608: {
609: extern unsigned int debug_mode, disableDebugOuput, disableConsoleOutput;
610:
611: if ((debug_mode && !disableDebugOuput) || !disableConsoleOutput)
612: cnputc(c);
613:
614: #ifdef MACH_BSD
615: log_putc(c);
616: #endif
617: }
618:
619: void
620: printf(const char *fmt, ...)
621: {
622: va_list listp;
623:
624: disable_preemption();
625: va_start(listp, fmt);
626: _doprnt(fmt, &listp, conslog_putc, 16);
627: va_end(listp);
628: enable_preemption();
629: }
630:
631: static char *copybyte_str;
632:
633: static void
634: copybyte(
635: char byte)
636: {
637: *copybyte_str++ = byte;
638: *copybyte_str = '\0';
639: }
640:
641: int
642: sprintf(char *buf, const char *fmt, ...)
643: {
644: va_list listp;
645: va_start(listp, fmt);
646: copybyte_str = buf;
647: _doprnt(fmt, &listp, copybyte, 16);
648: va_end(listp);
649: return strlen(buf);
650: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.