Return to console.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / boot / pc

Annotation of lucent/sys/src/boot/pc/console.c, revision 1.1.1.1

1.1       root        1: #include "u.h"
                      2: #include "lib.h"
                      3: #include "mem.h"
                      4: #include "dat.h"
                      5: #include "fns.h"
                      6: #include "io.h"
                      7: 
                      8: static IOQ consiq;
                      9: static IOQ consoq;
                     10: 
                     11: static void (*consputs)(IOQ*, char*, int) = cgaputs;
                     12: 
                     13: void
                     14: consinit(void)
                     15: {
                     16:        char *p;
                     17:        int baud, port;
                     18: 
                     19:        qinit(&consiq);
                     20: 
                     21:        if((p = getconf("console")) == 0 || strcmp(p, "cga") == 0){
                     22:                consputs = cgaputs;
                     23:                cgainit();
                     24:                kbdinit();
                     25:                return;
                     26:        }
                     27: 
                     28:        qinit(&consoq);
                     29:        consputs = uartputs;
                     30: 
                     31:        port = strtoul(p, 0, 0);
                     32:        baud = 0;
                     33:        if(p = getconf("baud"))
                     34:                baud = strtoul(p, 0, 0);
                     35:        if(baud == 0)
                     36:                baud = 9600;
                     37:        uartspecial(port, kbdchar, conschar, baud);
                     38: }
                     39: 
                     40: void
                     41: kbdchar(int c)
                     42: {
                     43:        c &= 0x7F;
                     44:        if(c == 0x10)
                     45:                panic("^p");
                     46:        consiq.putc(&consiq, c);
                     47: }
                     48: 
                     49: int
                     50: conschar(void)
                     51: {
                     52:        return consoq.getc(&consoq);
                     53: }
                     54: 
                     55: static int
                     56: getline(char *buf, int size, int dotimeout)
                     57: {
                     58:        int c, i=0;
                     59:        ulong start;
                     60:        char echo;
                     61: 
                     62:        for (;;) {
                     63:                start = m->ticks;
                     64:                do{
                     65:                        if(dotimeout && ((m->ticks - start) > 5*HZ))
                     66:                                return -2;
                     67:                        c = consiq.getc(&consiq);
                     68:                }while(c == -1);
                     69:                if(c == '\r')
                     70:                        c = '\n';               /* turn carriage return into newline */
                     71:                if(c == '\177')
                     72:                        c = '\010';             /* turn delete into backspace */
                     73:                if(c == '\025')
                     74:                        echo = '\n';            /* echo ^U as a newline */
                     75:                else
                     76:                        echo = c;
                     77:                (*consputs)(&consoq, &echo, 1);
                     78: 
                     79:                if(c == '\010'){
                     80:                        if(i > 0)
                     81:                                i--; /* bs deletes last character */
                     82:                        continue;
                     83:                }
                     84:                /* a newline ends a line */
                     85:                if (c == '\n')
                     86:                        break;
                     87:                /* ^U wipes out the line */
                     88:                if (c =='\025')
                     89:                        return -1;
                     90:                if(i == size)
                     91:                        return size;
                     92:                buf[i++] = c;
                     93:        }
                     94:        buf[i] = 0;
                     95:        return i;
                     96: }
                     97: 
                     98: int
                     99: getstr(char *prompt, char *buf, int size, char *def, int timeout)
                    100: {
                    101:        int len, isdefault;
                    102: 
                    103:        buf[0] = 0;
                    104:        isdefault = (def && *def);
                    105:        for (;;) {
                    106:                if(isdefault)
                    107:                        print("%s[default==%s]: ", prompt, def);
                    108:                else
                    109:                        print("%s: ", prompt);
                    110:                len = getline(buf, size, timeout);
                    111:                switch(len){
                    112:                case -1:
                    113:                        /* ^U typed */
                    114:                        continue;
                    115:                case -2:
                    116:                        /* timeout, use default */
                    117:                        (*consputs)(&consoq, "\n", 1);
                    118:                        len = 0;
                    119:                        break;
                    120:                default:
                    121:                        break;
                    122:                }
                    123:                if(len >= size){
                    124:                        print("line too long\n");
                    125:                        continue;
                    126:                }
                    127:                break;
                    128:        }
                    129:        if(len == 0 && isdefault)
                    130:                strcpy(buf, def);
                    131:        return 0;
                    132: }
                    133: 
                    134: int
                    135: sprint(char *s, char *fmt, ...)
                    136: {
                    137:        return donprint(s, s+PRINTSIZE, fmt, (&fmt+1)) - s;
                    138: }
                    139: 
                    140: int
                    141: print(char *fmt, ...)
                    142: {
                    143:        char buf[PRINTSIZE];
                    144:        int n;
                    145: 
                    146:        if(consputs == 0)
                    147:                return 0;
                    148:        n = donprint(buf, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
                    149:        (*consputs)(&consoq, buf, n);
                    150:        return n;
                    151: }
                    152: 
                    153: void
                    154: panic(char *fmt, ...)
                    155: {
                    156:        char buf[PRINTSIZE];
                    157:        int n;
                    158: 
                    159:        if(consputs){
                    160:                (*consputs)(&consoq, "panic: ", 7);
                    161:                n = donprint(buf, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
                    162:                (*consputs)(&consoq, buf, n);
                    163:                (*consputs)(&consoq, "\n", 1);
                    164:        }
                    165:        spllo();
                    166:        i8042reset();
                    167:        for(;;)
                    168:                idle();
                    169: }

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