Return to prf.c CVS log

Up to [Research Unix] / researchv9 / sys / boot / stand

Annotation of researchv9/sys/boot/stand/prf.c, revision 1.1.1.2

1.1.1.2 ! root        1: /*     prf.c   4.3     81/05/05        */
1.1       root        2: 
                      3: #include <sys/types.h>
                      4: #include <machine/sunromvec.h>
                      5: 
                      6: /*
                      7:  * Scaled down version of C Library printf.
                      8:  * Used to print diagnostic information directly on console tty.
                      9:  * Since it is not interrupt driven, all system activities are
                     10:  * suspended.  Printf should not be used for chit-chat.
                     11:  *
                     12:  * One additional format: %b is supported to decode error registers.
                     13:  * Usage is:
                     14:  *     printf("reg=%b\n", regval, "<base><arg>*");
                     15:  * Where <base> is the output base expressed as a control character,
                     16:  * e.g. \10 gives octal; \20 gives hex.  Each arg is a sequence of
                     17:  * characters, the first of which gives the bit number to be inspected
                     18:  * (origin 1), and the next characters (up to a control character, i.e.
                     19:  * a character <= 32), give the name of the register.  Thus
                     20:  *     printf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
                     21:  * would produce output:
                     22:  *     reg=2<BITTWO,BITONE>
                     23:  */
                     24: /*VARARGS1*/
                     25: printf(fmt, x1)
                     26:        char *fmt;
                     27:        unsigned x1;
                     28: {
                     29: 
                     30:        prf(fmt, &x1);
                     31: }
                     32: 
                     33: prf(fmt, adx)
                     34:        register char *fmt;
                     35:        register u_int *adx;
                     36: {
                     37:        register int b, c, i;
1.1.1.2 ! root       38:        char *s;
        !            39:        int any;
1.1       root       40: 
                     41: loop:
                     42:        while ((c = *fmt++) != '%') {
                     43:                if(c == '\0')
                     44:                        return;
                     45:                putchar(c);
                     46:        }
                     47: again:
                     48:        c = *fmt++;
1.1.1.2 ! root       49:        /* THIS CODE IS VAX DEPENDENT IN HANDLING %l? AND %c */
1.1       root       50:        switch (c) {
                     51: 
                     52:        case 'l':
                     53:                goto again;
                     54:        case 'x': case 'X':
                     55:                b = 16;
                     56:                goto number;
                     57:        case 'd': case 'D':
                     58:        case 'u':               /* what a joke */
                     59:                b = 10;
                     60:                goto number;
                     61:        case 'o': case 'O':
                     62:                b = 8;
                     63: number:
                     64:                printn((u_long)*adx, b);
                     65:                break;
                     66:        case 'c':
                     67:                b = *adx;
1.1.1.2 ! root       68:                for (i = 24; i >= 0; i -= 8)
        !            69:                        if (c = (b >> i) & 0x7f)
        !            70:                                putchar(c);
1.1       root       71:                break;
                     72:        case 'b':
                     73:                b = *adx++;
                     74:                s = (char *)*adx;
                     75:                printn((u_long)b, *s++);
                     76:                any = 0;
                     77:                if (b) {
                     78:                        putchar('<');
                     79:                        while (i = *s++) {
                     80:                                if (b & (1 << (i-1))) {
                     81:                                        if (any)
                     82:                                                putchar(',');
                     83:                                        any = 1;
                     84:                                        for (; (c = *s) > 32; s++)
                     85:                                                putchar(c);
                     86:                                } else
                     87:                                        for (; *s > 32; s++)
                     88:                                                ;
                     89:                        }
                     90:                        putchar('>');
                     91:                }
                     92:                break;
                     93: 
                     94:        case 's':
                     95:                s = (char *)*adx;
                     96:                while (c = *s++)
                     97:                        putchar(c);
                     98:                break;
                     99:        }
                    100:        adx++;
                    101:        goto loop;
                    102: }
                    103: 
                    104: /*
                    105:  * Printn prints a number n in base b.
                    106:  * We don't use recursion to avoid deep kernel stacks.
                    107:  */
                    108: printn(n, b)
1.1.1.2 ! root      109:        u_long n;
1.1       root      110: {
                    111:        char prbuf[11];
                    112:        register char *cp;
                    113: 
                    114:        if (b == 10 && (int)n < 0) {
                    115:                putchar('-');
                    116:                n = (unsigned)(-(int)n);
                    117:        }
                    118:        cp = prbuf;
                    119:        do {
                    120:                *cp++ = "0123456789abcdef"[n%b];
                    121:                n /= b;
                    122:        } while (n);
                    123:        do
                    124:                putchar(*--cp);
                    125:        while (cp > prbuf);
                    126: }
                    127: 
                    128: /*
                    129:  * Print a character on console.
                    130:  */
                    131: putchar(c)
                    132:        int c;
                    133: {
                    134: 
                    135:        (*romp->v_putchar)(c);
                    136: }
1.1.1.2 ! root      137: 
        !           138: getchar()
        !           139: {
        !           140:        register c;
        !           141: 
        !           142:        while ((c = (*romp->v_mayget)()) == -1)
        !           143:                ;
        !           144:        if (c == '\r')
        !           145:                c = '\n';
        !           146:        if (c == 0177 || c == '\b') {
        !           147:                putchar('\b');
        !           148:                putchar(' ');
        !           149:                c = '\b';
        !           150:        }
        !           151:        putchar(c);
        !           152:        return (c);
        !           153: }
        !           154: 
        !           155: gets(buf)
        !           156:        char *buf;
        !           157: {
        !           158:        register char *lp;
        !           159:        register c;
        !           160: 
        !           161:        lp = buf;
        !           162:        for (;;) {
        !           163:                c = getchar() & 0177;
        !           164:        store:
        !           165:                switch(c) {
        !           166:                case '\n':
        !           167:                case '\r':
        !           168:                        c = '\n';
        !           169:                        *lp++ = '\0';
        !           170:                        return;
        !           171:                case '\b':
        !           172:                case '#':
        !           173:                        lp--;
        !           174:                        if (lp < buf)
        !           175:                                lp = buf;
        !           176:                        continue;
        !           177:                case '@':
        !           178:                case 'u'&037:
        !           179:                        lp = buf;
        !           180:                        putchar('\n');
        !           181:                        continue;
        !           182:                default:
        !           183:                        *lp++ = c;
        !           184:                }
        !           185:        }
        !           186: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.