Return to pcs.c CVS log

Up to [Research Unix] / researchv8dc / cmd / adb

Annotation of researchv8dc/cmd/adb/pcs.c, revision 1.1.1.1

1.1       root        1: #
                      2: /*
                      3:  *
                      4:  *     UNIX debugger
                      5:  *
                      6:  */
                      7: 
                      8: #include "defs.h"
                      9: 
                     10: MSG    NOBKPT;
                     11: MSG    SZBKPT;
                     12: MSG    EXBKPT;
                     13: MSG    NOPCS;
                     14: MSG    BADMOD;
                     15: 
                     16: /* breakpoints */
                     17: BKPT *bkpthead;
                     18: 
                     19: char   lastc;
                     20: 
                     21: /* sub process control */
                     22: 
                     23: subpcs(modif)
                     24: {
                     25:        register int    check;
                     26:        int     keepsig,runmode;
                     27:        register BKPT *bk;
                     28:        char *comptr;
                     29:        char *malloc();
                     30:        WORD defval();
                     31: 
                     32:        keepsig=0;
                     33:        loopcnt=cntval;
                     34:        switch (modif) {
                     35: 
                     36:                /* delete breakpoint */
                     37:        case 'd': 
                     38:        case 'D':
                     39:                if ((bk=scanbkpt(dot)) == NULL)
                     40:                        error(NOBKPT);
                     41:                bk->flag=BKPTCLR;
                     42:                return;
                     43: 
                     44:                /* set breakpoint */
                     45:        case 'b': 
                     46:        case 'B':
                     47:                if (bk=scanbkpt(dot))
                     48:                        bk->flag=BKPTCLR;
                     49:                for (bk=bkpthead; bk; bk=bk->nxtbkpt)
                     50:                        if (bk->flag == BKPTCLR)
                     51:                                break;
                     52:                if (bk==0) {
                     53:                        bk = (BKPT *)malloc(sizeof(*bk));
                     54:                        if (bk == NULL)
                     55:                                error(SZBKPT);
                     56:                        bk->nxtbkpt=bkpthead;
                     57:                        bkpthead=bk;
                     58:                }
                     59:                bk->loc = dot;
                     60:                bk->initcnt = bk->count = cntval;
                     61:                bk->flag = BKPTSET;
                     62:                check=MAXCOM-1;
                     63:                comptr=bk->comm;
                     64:                rdc();
                     65:                reread();
                     66:                do {
                     67:                        *comptr++ = readchar();
                     68:                } while (check-- && lastc!=EOR);
                     69:                *comptr=0;
                     70:                reread();
                     71:                if (check)
                     72:                        return;
                     73:                error(EXBKPT);
                     74: 
                     75:                /* exit */
                     76:        case 'k' :
                     77:        case 'K':
                     78:                if (pid == 0)
                     79:                        error(NOPCS);
                     80:                printf("%d: killed", pid);
                     81:                endpcs();
                     82:                return;
                     83: 
                     84:                /* run program */
                     85:        case 'r': 
                     86:        case 'R':
                     87:                endpcs();
                     88:                setup();
                     89:                runmode=CONTIN;
                     90:                break;
                     91: 
                     92:                /* single step */
                     93:        case 's': 
                     94:        case 'S':
                     95:                if (pid == 0) {
                     96:                        setup();
                     97:                        loopcnt--;
                     98:                }
                     99:                else {
                    100:                        runmode=SINGLE;
                    101:                        keepsig=defval((WORD)signo);
                    102:                }
                    103:                break;
                    104: 
                    105:                /* continue with optional signal */
                    106:        case 'c': 
                    107:        case 'C': 
                    108:        case 0:
                    109:                if (pid==0)
                    110:                        error(NOPCS);
                    111:                runmode=CONTIN;
                    112:                keepsig=defval((WORD)signo);
                    113:                break;
                    114: 
                    115:        case 'g':       /* grab the current process */
                    116:                if (adrflg && adrval == 0) {
                    117:                        if (pid == 0)
                    118:                                error(NOPCS);
                    119:                        ungrab();
                    120:                }
                    121:                else {
                    122:                        grab();
                    123:                        printf("stopped at%16t");
                    124:                        delbp();
                    125:                        printpc();
                    126:                }
                    127:                return;
                    128: 
                    129:        default:
                    130:                error(BADMOD);
                    131:        }
                    132: 
                    133:        if (loopcnt>0 && runpcs(runmode,keepsig))
                    134:                printf("breakpoint%16t");
                    135:        else
                    136:                printf("stopped at%16t");
                    137:        delbp();
                    138:        printpc();
                    139: }

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