Return to kdb_input.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / kdb

Annotation of 43BSDReno/sys/kdb/kdb_input.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 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:  *     @(#)kdb_input.c 7.5 (Berkeley) 5/3/90
                      7:  */
                      8: 
                      9: #include "../kdb/defs.h"
                     10: 
                     11: char   line[LINSIZ];
                     12: char   *kdblp;
                     13: char   kdbpeekc,kdblastc = EOR;
                     14: 
                     15: /* input routines */
                     16: 
                     17: kdbeol(c)
                     18:        char c;
                     19: {
                     20:        return (c==EOR || c==';');
                     21: }
                     22: 
                     23: kdbrdc()
                     24: {
                     25:        do
                     26:                (void) kdbreadchar();
                     27:        while (kdblastc==SP || kdblastc==TB);
                     28:        return (kdblastc);
                     29: }
                     30: 
                     31: kdbreadchar()
                     32: {
                     33:        static char *erase = "\b \b";
                     34: 
                     35:        if (kdblp==0) {
                     36:                kdblp=line;
                     37:                do {
                     38:                        (void) kdbreadc(kdblp);
                     39:                        if (kdbmkfault)
                     40:                                kdberror((char *)0);
                     41:                        switch (*kdblp) {
                     42:                        case CTRL('h'): case 0177:
                     43:                                if (kdblp > line)
                     44:                                        kdbwrite(erase, 3), kdblp--;
                     45:                                break;
                     46:                        case CTRL('u'):
                     47:                                while (kdblp > line) 
                     48:                                        kdbwrite(erase, 3), kdblp--;
                     49:                                break;
                     50:                        case CTRL('r'):
                     51:                                kdbwrite("^R\n", 3);
                     52:                                if (kdblp > line)
                     53:                                        kdbwrite(line, kdblp-line);
                     54:                                break;
                     55:                        case CTRL('w'):
                     56:                                if (kdblp <= line)
                     57:                                        break;
                     58:                                do {
                     59:                                        if (!isspace(*kdblp))
                     60:                                                goto erasenb;
                     61:                                        kdbwrite(erase, 3);
                     62:                                } while (--kdblp > line);
                     63:                                break;
                     64:                        erasenb:
                     65:                                do
                     66:                                        kdbwrite(erase, 3);
                     67:                                while (--kdblp > line && !isspace(*kdblp));
                     68:                                break;
                     69:                        default:
                     70:                                kdbecho(*kdblp++);
                     71:                                break;
                     72:                        }
                     73:                } while (kdblp == line || kdblp[-1] != EOR);
                     74:                *kdblp=0; kdblp=line;
                     75:        }
                     76:        if (kdblastc = kdbpeekc)
                     77:                kdbpeekc=0;
                     78:        else  if (kdblastc = *kdblp)
                     79:                kdblp++;
                     80:        return (kdblastc);
                     81: }
                     82: 
                     83: static
                     84: kdbecho(c)
                     85:        char c;
                     86: {
                     87:        char buf[2];
                     88: 
                     89:        if (c==0177 || (c<SP && c != TB && c != EOR)) {
                     90:                buf[0] = '^';
                     91:                buf[1] = c ^ 0100;
                     92:                kdbwrite(buf, 2);
                     93:        } else
                     94:                kdbwrite(&c, 1);
                     95: }
                     96: 
                     97: kdbnextchar()
                     98: {
                     99: 
                    100:        if (kdbeol(kdbrdc())) {
                    101:                kdblp--;
                    102:                return (0);
                    103:        }
                    104:        return (kdblastc);
                    105: }
                    106: 
                    107: kdbquotchar()
                    108: {
                    109: 
                    110:        if (kdbreadchar()=='\\')
                    111:                return (kdbreadchar());
                    112:        if (kdblastc=='\'')
                    113:                return (0);
                    114:        return (kdblastc);
                    115: }
                    116: 
                    117: kdbgetformat(deformat)
                    118:        char *deformat;
                    119: {
                    120:        register char *fptr;
                    121:        register int quote;
                    122: 
                    123:        fptr=deformat; quote=0;
                    124:        while ((quote ? kdbreadchar()!=EOR : !kdbeol(kdbreadchar())))
                    125:                if ((*fptr++ = kdblastc)=='"')
                    126:                        quote = ~quote;
                    127:        kdblp--;
                    128:        if (fptr!=deformat)
                    129:                *fptr++ = '\0';
                    130: }

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