![[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] / funnyos / libkern|
Return to printf.c CVS log | Up to [local] / funnyos / libkern |
1.1 ! init 1: /* $Id: printf.c,v 1.1.1.1 2007/10/12 08:40:38 init Exp $ */
! 2: /* $OpenBSD: printf.c,v 1.24 2006/09/18 21:11:50 mpf Exp $ */
! 3: /* $NetBSD: printf.c,v 1.10 1996/11/30 04:19:21 gwr Exp $ */
! 4:
! 5: /*-
! 6: * Copyright (c) 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. Neither the name of the University nor the names of its contributors
! 18: * may be used to endorse or promote products derived from this software
! 19: * without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 31: * SUCH DAMAGE.
! 32: *
! 33: * @(#)printf.c 8.1 (Berkeley) 6/11/93
! 34: */
! 35:
! 36: /*
! 37: * Scaled down version of printf(3).
! 38: *
! 39: * One additional format:
! 40: *
! 41: * The format %b is supported to decode error registers.
! 42: * Its usage is:
! 43: *
! 44: * printf("reg=%b\n", regval, "<base><arg>*");
! 45: *
! 46: * where <base> is the output base expressed as a control character, e.g.
! 47: * \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
! 48: * the first of which gives the bit number to be inspected (origin 1), and
! 49: * the next characters (up to a control character, i.e. a character <= 32),
! 50: * give the name of the register. Thus:
! 51: *
! 52: * printf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
! 53: *
! 54: * would produce output:
! 55: *
! 56: * reg=3<BITTWO,BITONE>
! 57: */
! 58:
! 59: #include <sys/types.h>
! 60: #include <sys/stdarg.h>
! 61: #include <libkern/printf.h>
! 62:
! 63:
! 64: void kdoprnt(void (*)(char), const char *, va_list);
! 65: void kprintn(void (*put)(char), unsigned long ul, int base);
! 66:
! 67: const char hexdig[] = "0123456789abcdef";
! 68:
! 69: /*
! 70: * putchar function; usually gets xxx_early_putc at startup and then gets fcons_putc after fcons attachment.
! 71: */
! 72: void (*putchar)(char);
! 73:
! 74:
! 75: void
! 76: kpanic(const char *fmt, ...)
! 77: {
! 78: /*
! 79: * System panic. Just disables interrupts, kills sheduler, prints alarm message and spins off forever.
! 80: */
! 81: va_list ap;
! 82:
! 83: /* XXX disable intrs & sched */
! 84:
! 85: putchar('\n');
! 86: putchar('S');
! 87: putchar('Y');
! 88: putchar('S');
! 89: putchar('T');
! 90: putchar('E');
! 91: putchar('M');
! 92: putchar(' ');
! 93: putchar('P');
! 94: putchar('A');
! 95: putchar('N');
! 96: putchar('I');
! 97: putchar('C');
! 98: putchar(' ');
! 99: putchar(':');
! 100: putchar(' ');
! 101:
! 102: va_start(ap, fmt);
! 103: kdoprnt(putchar, fmt, ap);
! 104: va_end(ap);
! 105:
! 106: while(1)
! 107: ;
! 108: /* NOTREACHED */
! 109: }
! 110:
! 111:
! 112: void
! 113: printf(const char *fmt, ...)
! 114: {
! 115: va_list ap;
! 116:
! 117: va_start(ap, fmt);
! 118: kdoprnt(putchar, fmt, ap);
! 119: va_end(ap);
! 120: }
! 121:
! 122: void
! 123: kdoprnt(void (*put)(char), const char *fmt, va_list ap)
! 124: {
! 125: #ifdef LIBSA_LONGLONG_PRINTF
! 126: u_int64_t ull;
! 127: #endif
! 128: unsigned long ul;
! 129: int ch, lflag;
! 130: char *p;
! 131:
! 132: for (;;) {
! 133: while ((ch = *fmt++) != '%') {
! 134: if (ch == '\0')
! 135: return;
! 136: put(ch);
! 137: }
! 138: lflag = 0;
! 139: reswitch: switch (ch = *fmt++) {
! 140: case 'l':
! 141: lflag++;
! 142: goto reswitch;
! 143: #ifndef STRIPPED
! 144: case 'b':
! 145: {
! 146: int set, n;
! 147:
! 148: ul = va_arg(ap, int);
! 149: p = va_arg(ap, char *);
! 150: kprintn(put, ul, *p++);
! 151:
! 152: if (!ul)
! 153: break;
! 154:
! 155: for (set = 0; (n = *p++);) {
! 156: if (ul & (1 << (n - 1))) {
! 157: put(set ? ',' : '<');
! 158: for (; (n = *p) > ' '; ++p)
! 159: put(n);
! 160: set = 1;
! 161: } else
! 162: for (; *p > ' '; ++p)
! 163: ;
! 164: }
! 165: if (set)
! 166: put('>');
! 167: }
! 168: break;
! 169: #endif
! 170: case 'c':
! 171: ch = va_arg(ap, int);
! 172: put(ch & 0x7f);
! 173: break;
! 174: case 's':
! 175: p = va_arg(ap, char *);
! 176: while ((ch = *p++))
! 177: put(ch);
! 178: break;
! 179: case 'd':
! 180: #ifdef LIBSA_LONGLONG_PRINTF
! 181: if (lflag > 1) {
! 182: ull = va_arg(ap, int64_t);
! 183: if ((int64_t)ull < 0) {
! 184: put('-');
! 185: ull = -(int64_t)ull;
! 186: }
! 187: kprintn64(put, ull, 10);
! 188: break;
! 189: }
! 190: #endif
! 191: ul = lflag ?
! 192: va_arg(ap, long) : va_arg(ap, int);
! 193: if ((long)ul < 0) {
! 194: put('-');
! 195: ul = -(long)ul;
! 196: }
! 197: kprintn(put, ul, 10);
! 198: break;
! 199: case 'o':
! 200: #ifdef LIBSA_LONGLONG_PRINTF
! 201: if (lflag > 1) {
! 202: ull = va_arg(ap, u_int64_t);
! 203: kprintn64(put, ull, 8);
! 204: break;
! 205: }
! 206: #endif
! 207: ul = lflag ?
! 208: va_arg(ap, u_long) : va_arg(ap, u_int);
! 209: kprintn(put, ul, 8);
! 210: break;
! 211: case 'u':
! 212: #ifdef LIBSA_LONGLONG_PRINTF
! 213: if (lflag > 1) {
! 214: ull = va_arg(ap, u_int64_t);
! 215: kprintn64(put, ull, 10);
! 216: break;
! 217: }
! 218: #endif
! 219: ul = lflag ?
! 220: va_arg(ap, u_long) : va_arg(ap, u_int);
! 221: kprintn(put, ul, 10);
! 222: break;
! 223: case 'p':
! 224: put('0');
! 225: put('x');
! 226: lflag += sizeof(void *)==sizeof(u_long)? 1 : 0;
! 227: case 'x':
! 228: #ifdef LIBSA_LONGLONG_PRINTF
! 229: if (lflag > 1) {
! 230: ull = va_arg(ap, u_int64_t);
! 231: kprintn64(put, ull, 16);
! 232: break;
! 233: }
! 234: #else
! 235: if (lflag > 1) {
! 236: /* hold an int64_t in base 16 */
! 237: char *p, buf[(sizeof(u_int64_t) * 8 / 4) + 1];
! 238: u_int64_t ull;
! 239:
! 240: ull = va_arg(ap, u_int64_t);
! 241: p = buf;
! 242: do {
! 243: *p++ = hexdig[ull & 15];
! 244: } while (ull >>= 4);
! 245: do {
! 246: put(*--p);
! 247: } while (p > buf);
! 248: break;
! 249: }
! 250: #endif
! 251: ul = lflag ?
! 252: va_arg(ap, u_long) : va_arg(ap, u_int);
! 253: kprintn(put, ul, 16);
! 254: break;
! 255: default:
! 256: put('%');
! 257: #ifdef LIBSA_LONGLONG_PRINTF
! 258: while (--lflag)
! 259: #else
! 260: if (lflag)
! 261: #endif
! 262: put('l');
! 263: put(ch);
! 264: }
! 265: }
! 266: va_end(ap);
! 267: }
! 268:
! 269:
! 270: void
! 271: kprintn(void (*put)(char), unsigned long ul, int base)
! 272: {
! 273: /* hold a long in base 8 */
! 274: char *p, buf[(sizeof(long) * 8 / 3) + 1];
! 275:
! 276: p = buf;
! 277: do {
! 278: *p++ = hexdig[ul % base];
! 279: } while (ul /= base);
! 280: do {
! 281: put(*--p);
! 282: } while (p > buf);
! 283: }
! 284: