Return to kdb_pcs.c CVS log

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

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

1.1       root        1: /*
                      2:  * Copyright (c) 1986, 1989 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_pcs.c   7.4 (Berkeley) 5/3/90
                      7:  */
                      8: 
                      9: #include "../kdb/defs.h"
                     10: 
                     11: char   *kdbNOBKPT;
                     12: char   *kdbSZBKPT;
                     13: char   *kdbEXBKPT;
                     14: char   *kdbBADMOD;
                     15: 
                     16: /* breakpoints */
                     17: BKPTR  kdbbkpthead;
                     18: 
                     19: char   *kdblp;
                     20: char   kdblastc;
                     21: extern char *kdbmalloc();
                     22: long   kdbloopcnt;
                     23: 
                     24: /* sub process control */
                     25: 
                     26: kdbsubpcs(modif)
                     27: {
                     28:        register check, runmode;
                     29:        register BKPTR bkptr;
                     30:        register char *comptr;
                     31: 
                     32:        kdbloopcnt=kdbcntval;
                     33:        switch (modif) {
                     34: 
                     35:                /* delete breakpoint */
                     36:        case 'd': case 'D':
                     37:                if (bkptr=kdbscanbkpt((ADDR)kdbdot)) {
                     38:                        bkptr->flag=0;
                     39:                        return;
                     40:                }
                     41:                kdberror(kdbNOBKPT);
                     42: 
                     43:                /* set breakpoint */
                     44:        case 'b': case 'B':
                     45:                if (bkptr=kdbscanbkpt((ADDR)kdbdot))
                     46:                        bkptr->flag=0;
                     47:                for (bkptr=kdbbkpthead; bkptr; bkptr=bkptr->nxtbkpt)
                     48:                        if (bkptr->flag == 0)
                     49:                                break;
                     50:                if (bkptr==0) {
                     51:                        bkptr=(BKPTR)kdbmalloc(sizeof *bkptr);
                     52:                        if (bkptr == (BKPTR)-1)
                     53:                                kdberror(kdbSZBKPT);
                     54:                        bkptr->nxtbkpt=kdbbkpthead;
                     55:                        kdbbkpthead=bkptr;
                     56:                }
                     57:                bkptr->loc = kdbdot;
                     58:                bkptr->initcnt = bkptr->count = kdbcntval;
                     59:                bkptr->flag = BKPTSET;
                     60:                check=MAXCOM-1; comptr=bkptr->comm; (void) kdbrdc(); kdblp--;
                     61:                do
                     62:                        *comptr++ = kdbreadchar();
                     63:                while (check-- && kdblastc!=EOR);
                     64:                *comptr=0; kdblp--;
                     65:                if (check)
                     66:                        return;
                     67:                kdberror(kdbEXBKPT);
                     68: 
                     69:                /* single step */
                     70:        case 's': case 'S':
                     71:                runmode=SINGLE;
                     72:                break;
                     73: 
                     74:                /* continue */
                     75:        case 'c': case 'C':
                     76:                runmode=CONTIN;
                     77:                break;
                     78: 
                     79:                /* kill */
                     80:        case 'k': case 'K':
                     81:                reset(PANIC);
                     82:                /* NOTREACHED */
                     83: 
                     84:        default:
                     85:                kdberror(kdbBADMOD);
                     86:        }
                     87:        if (kdbloopcnt>0)
                     88:                kdbrunpcs(runmode, 0);
                     89: }

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