![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subr_prf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to subr_prf.c CVS log | Up to [Apple XNU] / XNU / bsd / 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: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
23: /*-
24: * Copyright (c) 1986, 1988, 1991, 1993
25: * The Regents of the University of California. All rights reserved.
26: * (c) UNIX System Laboratories, Inc.
27: * All or some portions of this file are derived from material licensed
28: * to the University of California by American Telephone and Telegraph
29: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
30: * the permission of UNIX System Laboratories, Inc.
31: *
32: * Redistribution and use in source and binary forms, with or without
33: * modification, are permitted provided that the following conditions
34: * are met:
35: * 1. Redistributions of source code must retain the above copyright
36: * notice, this list of conditions and the following disclaimer.
37: * 2. Redistributions in binary form must reproduce the above copyright
38: * notice, this list of conditions and the following disclaimer in the
39: * documentation and/or other materials provided with the distribution.
40: * 3. All advertising materials mentioning features or use of this software
41: * must display the following acknowledgement:
42: * This product includes software developed by the University of
43: * California, Berkeley and its contributors.
44: * 4. Neither the name of the University nor the names of its contributors
45: * may be used to endorse or promote products derived from this software
46: * without specific prior written permission.
47: *
48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58: * SUCH DAMAGE.
59: *
60: * @(#)subr_prf.c 8.4 (Berkeley) 5/4/95
61: */
62: /* HISTORY
63: * 22-Sep-1997 Umesh Vaishampayan ([email protected])
64: * Cleaned up m68k crud. Fixed vlog() to do logpri() for ppc, too.
65: *
66: * 17-July-97 Umesh Vaishampayan ([email protected])
67: * Eliminated multiple definition of constty which is defined
68: * in bsd/dev/XXX/cons.c
69: *
70: * 26-MAR-1997 Umesh Vaishampayan ([email protected]
71: * Fixed tharshing format in many functions. Cleanup.
72: *
73: * 17-Jun-1995 Mac Gillon (mgillon) at NeXT
74: * Purged old history
75: * New version based on 4.4 and NS3.3
76: */
77:
78: #include <sys/param.h>
79: #include <sys/systm.h>
80: #include <sys/buf.h>
81: #include <sys/conf.h>
82: #include <sys/reboot.h>
83: #include <sys/msgbuf.h>
84: #include <sys/proc.h>
85: #include <sys/ioctl.h>
86: #include <sys/tty.h>
87: #include <sys/file.h>
88: #include <sys/tprintf.h>
89: #include <sys/syslog.h>
90: #include <stdarg.h>
91: #include <sys/malloc.h>
92: #include <sys/lock.h>
93: #include <kern/parallel.h>
94: #import <sys/subr_prf.h>
95:
96: #include <kern/cpu_number.h> /* for cpu_number() */
97: #include <machine/spl.h>
98: #include <libkern/libkern.h>
99:
100: struct snprintf_arg {
101: char *str;
102: size_t remain;
103: };
104:
105:
106: /*
107: * In case console is off,
108: * panicstr contains argument to last
109: * call to panic.
110: */
111: extern const char *panicstr;
112:
113: extern cnputc(); /* standard console putc */
114: int (*v_putc)() = cnputc; /* routine to putc on virtual console */
115:
116: extern struct tty cons; /* standard console tty */
117: extern struct tty *constty; /* pointer to console "window" tty */
118:
119: /*
120: * Record cpu that panic'd and lock around panic data
121: */
122:
123: static void puts(const char *s, int flags, struct tty *ttyp);
124: static void printn(u_long n, int b, int flags, struct tty *ttyp, int zf, int fld_size);
125:
126: /* MP printf stuff */
127: decl_simple_lock_data(,printf_lock)
128: #if NCPUS > 1
129: boolean_t new_printf_cpu_number; /* do we need to output who we are */
130: #endif
131:
132: extern void logwakeup();
133: extern void halt_cpu();
134: #if NeXT
135: extern void mini_mon();
136: #endif /* NeXT */
137: extern boot();
138: int putchar();
139:
140: static void
141: snprintf_func(int ch, void *arg);
142:
143:
144:
145: /*
146: * Uprintf prints to the controlling terminal for the current process.
147: * It may block if the tty queue is overfull. No message is printed if
148: * the queue does not clear in a reasonable time.
149: */
150: void
151: uprintf(const char *fmt, ...)
152: {
153: register struct proc *p = current_proc();
154: va_list ap;
155:
156: unix_master(); /* sessions, sigh */
157: if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) {
158: va_start(ap, fmt);
159: prf(fmt, ap, TOTTY, (struct tty *)p->p_session->s_ttyvp);
160: va_end(ap);
161: }
162: unix_release();
163: }
164:
165: tpr_t
166: tprintf_open(p)
167: register struct proc *p;
168: {
169: unix_master(); /* sessions, sigh */
170: if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) {
171: SESSHOLD(p->p_session);
172: unix_release();
173: return ((tpr_t) p->p_session);
174: }
175: unix_release();
176: return ((tpr_t) NULL);
177: }
178:
179: void
180: tprintf_close(sess)
181: tpr_t sess;
182: {
183: unix_master(); /* sessions, sigh */
184: if (sess)
185: SESSRELE((struct session *) sess);
186: unix_release();
187: }
188:
189: /*
190: * tprintf prints on the controlling terminal associated
191: * with the given session.
192: */
193: void
194: tprintf(tpr_t tpr, const char *fmt, ...)
195: {
196: register struct session *sess = (struct session *)tpr;
197: struct tty *tp = NULL;
198: int flags = TOLOG;
199: va_list ap;
200:
201: logpri(LOG_INFO);
202: unix_master(); /* sessions, sigh */
203: if (sess && sess->s_ttyvp && ttycheckoutq(sess->s_ttyp, 0)) {
204: flags |= TOTTY;
205: tp = sess->s_ttyp;
206: }
207: if (tp != NULL) {
208: va_start(ap, fmt);
209: prf(fmt, ap, TOTTY, tp);
210: va_end(ap);
211: }
212: unix_release();
213: logwakeup();
214: }
215:
216: /*
217: * Ttyprintf displays a message on a tty; it should be used only by
218: * the tty driver, or anything that knows the underlying tty will not
219: * be revoke(2)'d away. Other callers should use tprintf.
220: */
221: void
222: ttyprintf(struct tty *tp, const char *fmt, ...)
223: {
224: va_list ap;
225:
226: if (tp != NULL) {
227: va_start(ap, fmt);
228: prf(fmt, ap, TOTTY, tp);
229: va_end(ap);
230: }
231: }
232:
233: extern int log_open;
234:
235:
236: void
237: logpri(level)
238: int level;
239: {
240:
241: putchar('<', TOLOG, (struct tty *)0);
242: printn((u_long)level, 10, TOLOG, (struct tty *)0, 0, 0);
243: putchar('>', TOLOG, (struct tty *)0);
244: }
245:
246: void
247: addlog(const char *fmt, ...)
248: {
249: register s = splhigh();
250: va_list ap;
251:
252: va_start(ap, fmt);
253: prf(fmt, ap, TOLOG, (struct tty *)0);
254: splx(s);
255: if (!log_open)
256: prf(fmt, ap, TOCONS, (struct tty *)0);
257: va_end(ap);
258: logwakeup();
259: }
260: void _printf(int flags, struct tty *ttyp, const char *format, ...)
261: {
262: va_list ap;
263:
264: va_start(ap, format);
265: prf(format, ap, flags, ttyp);
266: va_end(ap);
267: }
268:
269: int prf(const char *fmt, va_list ap, int flags, struct tty *ttyp)
270: {
271: register int b, c, i;
272: char *s;
273: int any;
274: int zf = 0, fld_size;
275:
276: #if NCPUS > 1
277: int cpun = cpu_number();
278:
279: if(ttyp == 0) {
280: simple_lock(&printf_lock);
281: } else
282: TTY_LOCK(ttyp);
283:
284: if (cpun != master_cpu)
285: new_printf_cpu_number = TRUE;
286:
287: if (new_printf_cpu_number) {
288: putchar('{', flags, ttyp);
289: printn((u_long)cpun, 10, flags, ttyp, 0, 0);
290: putchar('}', flags, ttyp);
291: }
292: #endif /* NCPUS > 1 */
293: loop:
294: while ((c = *fmt++) != '%') {
295: if (c == '\0') {
296: #if NCPUS > 1
297: if(ttyp == 0) {
298: simple_unlock(&printf_lock);
299: } else
300: TTY_UNLOCK(ttyp);
301: #endif
302: return 0;
303: }
304: putchar(c, flags, ttyp);
305: }
306: again:
307: zf = 0;
308: fld_size = 0;
309: c = *fmt++;
310: if (c == '0')
311: zf = '0';
312: fld_size = 0;
313: for (;c <= '9' && c >= '0'; c = *fmt++)
314: fld_size = fld_size * 10 + c - '0';
315:
316: /* THIS CODE IS VAX DEPENDENT IN HANDLING %l? AND %c */
317: switch (c) {
318:
319: case 'l':
320: goto again;
321: case 'x': case 'X':
322: b = 16;
323: goto number;
324: case 'd': case 'D':
325: case 'u': /* what a joke */
326: b = 10;
327: goto number;
328: case 'o': case 'O':
329: b = 8;
330: number:
331: printn(va_arg(ap, unsigned), b, flags, ttyp, zf, fld_size);
332: break;
333: case 'c':
334: b = va_arg(ap, unsigned);
335: #if BYTE_ORDER == LITTLE_ENDIAN
336: for (i = 24; i >= 0; i -= 8)
337: if (c = (b >> i) & 0x7f)
338: putchar(c, flags, ttyp);
339: #endif
340: #if BYTE_ORDER == BIG_ENDIAN
341: if ((c = (b & 0x7f)))
342: putchar(c, flags, ttyp);
343: #endif
344: break;
345: case 'b':
346: b = va_arg(ap, unsigned);
347: s = va_arg(ap, char *);
348: printn((u_long)b, *s++, flags, ttyp, 0, 0);
349: any = 0;
350: if (b) {
351: while ((i = *s++)) {
352: if (*s <= 32) {
353: register int j;
354:
355: if (any++)
356: putchar(',', flags, ttyp);
357: j = *s++ ;
358: for (; (c = *s) > 32 ; s++)
359: putchar(c, flags, ttyp);
360: printn( (u_long)( (b >> (j-1)) &
361: ( (2 << (i-j)) -1)),
362: 8, flags, ttyp, 0, 0);
363: } else if (b & (1 << (i-1))) {
364: putchar(any? ',' : '<', flags, ttyp);
365: any = 1;
366: for (; (c = *s) > 32; s++)
367: putchar(c, flags, ttyp);
368: } else
369: for (; *s > 32; s++)
370: ;
371: }
372: putchar('>', flags, ttyp);
373: }
374: break;
375:
376: case 's':
377: s = va_arg(ap, char *);
378: #ifdef DEBUG
379: if (fld_size) {
380: while (fld_size-- > 0)
381: putchar((c = *s++)? c : '_', flags, ttyp);
382: } else {
383: while ((c = *s++))
384: putchar(c, flags, ttyp);
385: }
386: #else
387: while (c = *s++)
388: putchar(c, flags, ttyp);
389: #endif
390: break;
391:
392: case '%':
393: putchar('%', flags, ttyp);
394: goto loop;
395: case 'C':
396: b = va_arg(ap, unsigned);
397: #if BYTE_ORDER == LITTLE_ENDIAN
398: for (i = 24; i >= 0; i -= 8)
399: if (c = (b >> i) & 0x7f)
400: putchar(c, flags, ttyp);
401: #endif
402: #if BYTE_ORDER == BIG_ENDIAN
403: if ((c = (b & 0x7f)))
404: putchar(c, flags, ttyp);
405: #endif
406:
407: case 'r':
408: case 'R':
409: b = va_arg(ap, unsigned);
410: s = va_arg(ap, char *);
411: if (c == 'R') {
412: puts("0x", flags, ttyp);
413: printn((u_long)b, 16, flags, ttyp, 0, 0);
414: }
415: any = 0;
416: if (c == 'r' || b) {
417: register struct reg_desc *rd;
418: register struct reg_values *rv;
419: unsigned field;
420:
421: putchar('<', flags, ttyp);
422: for (rd = (struct reg_desc *)s; rd->rd_mask; rd++) {
423: field = b & rd->rd_mask;
424: field = (rd->rd_shift > 0)
425: ? field << rd->rd_shift
426: : field >> -rd->rd_shift;
427: if (any &&
428: (rd->rd_format || rd->rd_values
429: || (rd->rd_name && field)
430: )
431: )
432: putchar(',', flags, ttyp);
433: if (rd->rd_name) {
434: if (rd->rd_format || rd->rd_values
435: || field) {
436: puts(rd->rd_name, flags, ttyp);
437: any = 1;
438: }
439: if (rd->rd_format || rd->rd_values) {
440: putchar('=', flags, ttyp);
441: any = 1;
442: }
443: }
444: if (rd->rd_format) {
445: _printf(flags, ttyp, rd->rd_format,
446: field);
447: any = 1;
448: if (rd->rd_values)
449: putchar(':', flags, ttyp);
450: }
451: if (rd->rd_values) {
452: any = 1;
453: for (rv = rd->rd_values;
454: rv->rv_name;
455: rv++) {
456: if (field == rv->rv_value) {
457: puts(rv->rv_name, flags,
458: ttyp);
459: break;
460: }
461: }
462: if (rv->rv_name == NULL)
463: puts("???", flags, ttyp);
464: }
465: }
466: putchar('>', flags, ttyp);
467: }
468: break;
469:
470: case 'n':
471: case 'N':
472: {
473: register struct reg_values *rv;
474:
475: b = va_arg(ap, unsigned);
476: s = va_arg(ap,char *);
477: for (rv = (struct reg_values *)s; rv->rv_name; rv++) {
478: if (b == rv->rv_value) {
479: puts(rv->rv_name, flags, ttyp);
480: break;
481: }
482: }
483: if (rv->rv_name == NULL)
484: puts("???", flags, ttyp);
485: if (c == 'N' || rv->rv_name == NULL) {
486: putchar(':', flags, ttyp);
487: printn((u_long)b, 10, flags, ttyp, 0, 0);
488: }
489: }
490: break;
491: }
492: goto loop;
493: }
494:
495: static void puts(const char *s, int flags, struct tty *ttyp)
496: {
497: register char c;
498:
499: while ((c = *s++))
500: putchar(c, flags, ttyp);
501: }
502:
503: /*
504: * Printn prints a number n in base b.
505: * We don't use recursion to avoid deep kernel stacks.
506: */
507: static void printn(u_long n, int b, int flags, struct tty *ttyp, int zf, int fld_size)
508: {
509: char prbuf[11];
510: register char *cp;
511:
512: if (b == 10 && (int)n < 0) {
513: putchar('-', flags, ttyp);
514: n = (unsigned)(-(int)n);
515: }
516: cp = prbuf;
517: do {
518: *cp++ = "0123456789abcdef"[n%b];
519: n /= b;
520: } while (n);
521: if (fld_size) {
522: for (fld_size -= cp - prbuf; fld_size > 0; fld_size--)
523: if (zf)
524: putchar('0', flags, ttyp);
525: else
526: putchar(' ', flags, ttyp);
527: }
528: do
529: putchar(*--cp, flags, ttyp);
530: while (cp > prbuf);
531: }
532:
533:
534:
535: /*
536: * Warn that a system table is full.
537: */
538: void tablefull(const char *tab)
539: {
540: log(LOG_ERR, "%s: table is full\n", tab);
541: }
542:
543: /*
544: * Print a character on console or users terminal.
545: * If destination is console then the last MSGBUFS characters
546: * are saved in msgbuf for inspection later.
547: */
548: /*ARGSUSED*/
549: int
550: putchar(c, flags, tp)
551: register int c;
552: struct tty *tp;
553: {
554: register struct msgbuf *mbp;
555: char **sp = (char**) tp;
556:
557: if (panicstr)
558: constty = 0;
559: if ((flags & TOCONS) && tp == NULL && constty) {
560: tp = constty;
561: flags |= TOTTY;
562: }
563: if ((flags & TOTTY) && tp && tputchar(c, tp) < 0 &&
564: (flags & TOCONS) && tp == constty)
565: constty = 0;
566: if ((flags & TOLOG) && c != '\0' && c != '\r' && c != 0177)
567: log_putc(c);
568: if ((flags & TOCONS) && constty == 0 && c != '\0')
569: (*v_putc)(c);
570: if (flags & TOSTR) {
571: **sp = c;
572: (*sp)++;
573: }
574: return 0;
575: }
576:
577:
578:
579: /*
580: * Scaled down version of vsprintf(3).
581: */
582: int
583: vsprintf(char *buf, const char *cfmt, va_list ap)
584: {
585: int retval;
586:
587: retval = kvprintf(cfmt, NULL, (void *)buf, 10, ap);
588: buf[retval] = '\0';
589: return retval;
590: }
591:
592: /*
593: * Scaled down version of snprintf(3).
594: */
595: int
596: snprintf(char *str, size_t size, const char *format, ...)
597: {
598: int retval;
599: va_list ap;
600:
601: va_start(ap, format);
602: retval = vsnprintf(str, size, format, ap);
603: va_end(ap);
604: return(retval);
605: }
606:
607: /*
608: * Scaled down version of vsnprintf(3).
609: */
610: int
611: vsnprintf(char *str, size_t size, const char *format, va_list ap)
612: {
613: struct snprintf_arg info;
614: int retval;
615:
616: info.str = str;
617: info.remain = size;
618: retval = kvprintf(format, snprintf_func, &info, 10, ap);
619: if (info.remain >= 1)
620: *info.str++ = '\0';
621: return retval;
622: }
623:
624: static void
625: snprintf_func(int ch, void *arg)
626: {
627: struct snprintf_arg *const info = arg;
628:
629: if (info->remain >= 2) {
630: *info->str++ = ch;
631: info->remain--;
632: }
633: }
634:
635: /*
636: * Put a number (base <= 16) in a buffer in reverse order; return an
637: * optional length and a pointer to the NULL terminated (preceded?)
638: * buffer.
639: */
640: static char *
641: ksprintn(ul, base, lenp)
642: register u_long ul;
643: register int base, *lenp;
644: { /* A long in base 8, plus NULL. */
645: static char buf[sizeof(long) * NBBY / 3 + 2];
646: register char *p;
647:
648: p = buf;
649: do {
650: *++p = hex2ascii(ul % base);
651: } while (ul /= base);
652: if (lenp)
653: *lenp = p - buf;
654: return (p);
655: }
656:
657: /*
658: * Scaled down version of printf(3).
659: *
660: * Two additional formats:
661: *
662: * The format %b is supported to decode error registers.
663: * Its usage is:
664: *
665: * printf("reg=%b\n", regval, "<base><arg>*");
666: *
667: * where <base> is the output base expressed as a control character, e.g.
668: * \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
669: * the first of which gives the bit number to be inspected (origin 1), and
670: * the next characters (up to a control character, i.e. a character <= 32),
671: * give the name of the register. Thus:
672: *
673: * kvprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
674: *
675: * would produce output:
676: *
677: * reg=3<BITTWO,BITONE>
678: *
679: * XXX: %D -- Hexdump, takes pointer and separator string:
680: * ("%6D", ptr, ":") -> XX:XX:XX:XX:XX:XX
681: * ("%*D", len, ptr, " " -> XX XX XX XX ...
682: */
683: int
684: kvprintf(char const *fmt, void (*func)(int, void*), void *arg, int radix, va_list ap)
685: {
686: #define PCHAR(c) {int cc=(c); if (func) (*func)(cc,arg); else *d++ = cc; retval++; }
687: char *p, *q, *d;
688: u_char *up;
689: int ch, n;
690: u_long ul;
691: int base, lflag, tmp, width, ladjust, sharpflag, neg, sign, dot;
692: int dwidth;
693: char padc;
694: int retval = 0;
695:
696: if (!func)
697: d = (char *) arg;
698: else
699: d = NULL;
700:
701: if (fmt == NULL)
702: fmt = "(fmt null)\n";
703:
704: if (radix < 2 || radix > 36)
705: radix = 10;
706:
707: for (;;) {
708: padc = ' ';
709: width = 0;
710: while ((ch = (u_char)*fmt++) != '%') {
711: if (ch == '\0')
712: return retval;
713: PCHAR(ch);
714: }
715: lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
716: sign = 0; dot = 0; dwidth = 0;
717: reswitch: switch (ch = (u_char)*fmt++) {
718: case '.':
719: dot = 1;
720: goto reswitch;
721: case '#':
722: sharpflag = 1;
723: goto reswitch;
724: case '+':
725: sign = 1;
726: goto reswitch;
727: case '-':
728: ladjust = 1;
729: goto reswitch;
730: case '%':
731: PCHAR(ch);
732: break;
733: case '*':
734: if (!dot) {
735: width = va_arg(ap, int);
736: if (width < 0) {
737: ladjust = !ladjust;
738: width = -width;
739: }
740: } else {
741: dwidth = va_arg(ap, int);
742: }
743: goto reswitch;
744: case '0':
745: if (!dot) {
746: padc = '0';
747: goto reswitch;
748: }
749: case '1': case '2': case '3': case '4':
750: case '5': case '6': case '7': case '8': case '9':
751: for (n = 0;; ++fmt) {
752: n = n * 10 + ch - '0';
753: ch = *fmt;
754: if (ch < '0' || ch > '9')
755: break;
756: }
757: if (dot)
758: dwidth = n;
759: else
760: width = n;
761: goto reswitch;
762: case 'b':
763: ul = va_arg(ap, int);
764: p = va_arg(ap, char *);
765: for (q = ksprintn(ul, *p++, NULL); *q;)
766: PCHAR(*q--);
767:
768: if (!ul)
769: break;
770:
771: for (tmp = 0; *p;) {
772: n = *p++;
773: if (ul & (1 << (n - 1))) {
774: PCHAR(tmp ? ',' : '<');
775: for (; (n = *p) > ' '; ++p)
776: PCHAR(n);
777: tmp = 1;
778: } else
779: for (; *p > ' '; ++p)
780: continue;
781: }
782: if (tmp)
783: PCHAR('>');
784: break;
785: case 'c':
786: PCHAR(va_arg(ap, int));
787: break;
788: case 'D':
789: up = va_arg(ap, u_char *);
790: p = va_arg(ap, char *);
791: if (!width)
792: width = 16;
793: while(width--) {
794: PCHAR(hex2ascii(*up >> 4));
795: PCHAR(hex2ascii(*up & 0x0f));
796: up++;
797: if (width)
798: for (q=p;*q;q++)
799: PCHAR(*q);
800: }
801: break;
802: case 'd':
803: ul = lflag ? va_arg(ap, long) : va_arg(ap, int);
804: sign = 1;
805: base = 10;
806: goto number;
807: case 'l':
808: lflag = 1;
809: goto reswitch;
810: case 'o':
811: ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
812: base = 8;
813: goto nosign;
814: case 'p':
815: ul = (uintptr_t)va_arg(ap, void *);
816: base = 16;
817: sharpflag = (width == 0);
818: goto nosign;
819: case 'n':
820: case 'r':
821: ul = lflag ? va_arg(ap, u_long) :
822: sign ? (u_long)va_arg(ap, int) : va_arg(ap, u_int);
823: base = radix;
824: goto number;
825: case 's':
826: p = va_arg(ap, char *);
827: if (p == NULL)
828: p = "(null)";
829: if (!dot)
830: n = strlen (p);
831: else
832: for (n = 0; n < dwidth && p[n]; n++)
833: continue;
834:
835: width -= n;
836:
837: if (!ladjust && width > 0)
838: while (width--)
839: PCHAR(padc);
840: while (n--)
841: PCHAR(*p++);
842: if (ladjust && width > 0)
843: while (width--)
844: PCHAR(padc);
845: break;
846: case 'u':
847: ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
848: base = 10;
849: goto nosign;
850: case 'x':
851: ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
852: base = 16;
853: goto nosign;
854: case 'z':
855: ul = lflag ? va_arg(ap, u_long) :
856: sign ? (u_long)va_arg(ap, int) : va_arg(ap, u_int);
857: base = 16;
858: goto number;
859: nosign: sign = 0;
860: number: if (sign && (long)ul < 0L) {
861: neg = 1;
862: ul = -(long)ul;
863: }
864: p = ksprintn(ul, base, &tmp);
865: if (sharpflag && ul != 0) {
866: if (base == 8)
867: tmp++;
868: else if (base == 16)
869: tmp += 2;
870: }
871: if (neg)
872: tmp++;
873:
874: if (!ladjust && width && (width -= tmp) > 0)
875: while (width--)
876: PCHAR(padc);
877: if (neg)
878: PCHAR('-');
879: if (sharpflag && ul != 0) {
880: if (base == 8) {
881: PCHAR('0');
882: } else if (base == 16) {
883: PCHAR('0');
884: PCHAR('x');
885: }
886: }
887:
888: while (*p)
889: PCHAR(*p--);
890:
891: if (ladjust && width && (width -= tmp) > 0)
892: while (width--)
893: PCHAR(padc);
894:
895: break;
896: default:
897: PCHAR('%');
898: if (lflag)
899: PCHAR('l');
900: PCHAR(ch);
901: break;
902: }
903: }
904: #undef PCHAR
905: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.