![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / stand|
Return to prf.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / stand |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 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: * @(#)prf.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "../h/param.h"
10:
11: #include "../vax/mtpr.h"
12: #include "../vax/cons.h"
13:
14: /*
15: * Scaled down version of C Library printf.
16: * Used to print diagnostic information directly on console tty.
17: * Since it is not interrupt driven, all system activities are
18: * suspended. Printf should not be used for chit-chat.
19: *
20: * One additional format: %b is supported to decode error registers.
21: * Usage is:
22: * printf("reg=%b\n", regval, "<base><arg>*");
23: * Where <base> is the output base expressed as a control character,
24: * e.g. \10 gives octal; \20 gives hex. Each arg is a sequence of
25: * characters, the first of which gives the bit number to be inspected
26: * (origin 1), and the next characters (up to a control character, i.e.
27: * a character <= 32), give the name of the register. Thus
28: * printf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
29: * would produce output:
30: * reg=2<BITTWO,BITONE>
31: */
32: /*VARARGS1*/
33: printf(fmt, x1)
34: char *fmt;
35: unsigned x1;
36: {
37:
38: prf(fmt, &x1);
39: }
40:
41: prf(fmt, adx)
42: register char *fmt;
43: register u_int *adx;
44: {
45: register int b, c, i;
46: char *s;
47: int any;
48:
49: loop:
50: while ((c = *fmt++) != '%') {
51: if(c == '\0')
52: return;
53: putchar(c);
54: }
55: again:
56: c = *fmt++;
57: /* THIS CODE IS VAX DEPENDENT IN HANDLING %l? AND %c */
58: switch (c) {
59:
60: case 'l':
61: goto again;
62: case 'x': case 'X':
63: b = 16;
64: goto number;
65: case 'd': case 'D':
66: case 'u': /* what a joke */
67: b = 10;
68: goto number;
69: case 'o': case 'O':
70: b = 8;
71: number:
72: printn((u_long)*adx, b);
73: break;
74: case 'c':
75: b = *adx;
76: for (i = 24; i >= 0; i -= 8)
77: if (c = (b >> i) & 0x7f)
78: putchar(c);
79: break;
80: case 'b':
81: b = *adx++;
82: s = (char *)*adx;
83: printn((u_long)b, *s++);
84: any = 0;
85: if (b) {
86: while (i = *s++) {
87: if (b & (1 << (i-1))) {
88: putchar(any? ',' : '<');
89: any = 1;
90: for (; (c = *s) > 32; s++)
91: putchar(c);
92: } else
93: for (; *s > 32; s++)
94: ;
95: }
96: if (any)
97: putchar('>');
98: }
99: break;
100:
101: case 's':
102: s = (char *)*adx;
103: while (c = *s++)
104: putchar(c);
105: break;
106: }
107: adx++;
108: goto loop;
109: }
110:
111: /*
112: * Printn prints a number n in base b.
113: * We don't use recursion to avoid deep kernel stacks.
114: */
115: printn(n, b)
116: u_long n;
117: {
118: char prbuf[11];
119: register char *cp;
120:
121: if (b == 10 && (int)n < 0) {
122: putchar('-');
123: n = (unsigned)(-(int)n);
124: }
125: cp = prbuf;
126: do {
127: *cp++ = "0123456789abcdef"[n%b];
128: n /= b;
129: } while (n);
130: do
131: putchar(*--cp);
132: while (cp > prbuf);
133: }
134:
135: /*
136: * Print a character on console.
137: */
138: putchar(c)
139: register c;
140: {
141: register s, timo;
142:
143: timo = 30000;
144: /*
145: * Try waiting for the console tty to come ready,
146: * otherwise give up after a reasonable time.
147: */
148: while((mfpr(TXCS)&TXCS_RDY) == 0)
149: if(--timo == 0)
150: break;
151: if(c == 0)
152: return;
153: s = mfpr(TXCS);
154: mtpr(TXCS,0);
155: mtpr(TXDB, c&0xff);
156: if(c == '\n')
157: putchar('\r');
158: putchar(0);
159: mtpr(TXCS, s);
160: }
161:
162: getchar()
163: {
164: register c;
165:
166: while((mfpr(RXCS)&RXCS_DONE) == 0)
167: ;
168: c = mfpr(RXDB)&0177;
169: if (c=='\r')
170: c = '\n';
171: putchar(c);
172: return(c);
173: }
174:
175: gets(buf)
176: char *buf;
177: {
178: register char *lp;
179: register c;
180:
181: lp = buf;
182: for (;;) {
183: c = getchar() & 0177;
184: switch(c) {
185: case '\n':
186: case '\r':
187: c = '\n';
188: *lp++ = '\0';
189: return;
190: case '\b':
191: if (lp > buf) {
192: lp--;
193: putchar(' ');
194: putchar('\b');
195: }
196: continue;
197: case '#':
198: case '\177':
199: lp--;
200: if (lp < buf)
201: lp = buf;
202: continue;
203: case '@':
204: case 'u'&037:
205: lp = buf;
206: putchar('\n');
207: continue;
208: default:
209: *lp++ = c;
210: }
211: }
212: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.