Return to docomm.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / sdb

Annotation of 3BSD/cmd/sdb/docomm.c, revision 1.1

1.1     ! root        1: #include <signal.h>
        !             2: #include "head.h"
        !             3: #include <a.out.h>
        !             4: 
        !             5: struct user u;
        !             6: L_INT  cntval;
        !             7: INT    signo;
        !             8: INT    adrflg;
        !             9: INT    pid;
        !            10: ADDR   userpc;
        !            11: char   *s;
        !            12: enum   {NOCOM, PRCOM, DSCOM} lastcom;
        !            13: 
        !            14: docommand() {
        !            15:        register char   *p;
        !            16:        register int    i;
        !            17:        register ADDR   addr, bkaddr;
        !            18:        struct proct    *procp;
        !            19:        
        !            20:        cntval = 1;
        !            21:        adrflg = 0;
        !            22:        errflg = 0;
        !            23: 
        !            24:        if (scallf) {
        !            25:                doscall();
        !            26:                setcur(1);
        !            27:                lastcom = NOCOM;
        !            28:                return;
        !            29:        }
        !            30:        
        !            31:        if (reflag) {  /* search for regular expression */
        !            32:                dore();
        !            33:                lastcom = PRCOM;
        !            34:                return;
        !            35:        }
        !            36:        
        !            37:        if (cmd == '\0') {
        !            38:                if (integ != 0 && var[0] != '\0') {
        !            39:                        error("Invalid command (1)");
        !            40:                        return;
        !            41:                }
        !            42:                if (integ != 0) { /* print line number */
        !            43:                        ffind(integ);
        !            44:                        fprint();
        !            45:                        lastcom = PRCOM;
        !            46:                        return;
        !            47:                }
        !            48:                if (var[0] != 0) {
        !            49:                        printf("Unexpected null command\n");
        !            50:                        return;
        !            51:                }
        !            52:        }
        !            53:                
        !            54:        switch (cmd) {
        !            55:        
        !            56:        case 'Y':
        !            57:                debug = !debug;
        !            58:                break;
        !            59: 
        !            60:        case 'V':
        !            61:                version();
        !            62:                break;
        !            63: 
        !            64:        case 'a':
        !            65:                if (integ) {
        !            66:                        cpstr(args, "l\n");
        !            67:                } else if (proc[0]) {
        !            68:                        cpall(args, "T\n");
        !            69:                } else {
        !            70:                        error("Bad arguments");
        !            71:                        break;
        !            72:                }
        !            73:                goto setbrk;
        !            74:                break;  
        !            75: 
        !            76:        case 'l':
        !            77:                setcur(1);
        !            78:                lastcom = NOCOM;
        !            79:                break;
        !            80:                
        !            81:        case 'T':
        !            82:                prfrx(1);
        !            83:                lastcom = NOCOM;
        !            84:                break;
        !            85:                
        !            86:        case 't':
        !            87:                prframe();
        !            88:                lastcom = NOCOM;
        !            89:                break;
        !            90:                
        !            91:        case 'e':
        !            92:                p = args;
        !            93:                if (*p == '\0') {
        !            94:                        printf("%.8s() in \"%s\"\n",
        !            95:                                curproc()->pname, curfile);
        !            96:                        break;
        !            97:                }
        !            98: 
        !            99:                while (*p != '\0')
        !           100:                        if (*p++ == '.') goto l1;
        !           101:                /* argument is procedure name */
        !           102:                procp = findproc(args);
        !           103:                if ((procp->pname[0] != '\0') && (procp->sfptr != badfile)) {
        !           104:                        finit(adrtofilep(procp->paddr)->sfilename);
        !           105:                        ffind(procp->lineno);
        !           106:                }
        !           107:                else printf("Can't find %s\n", args);
        !           108:                printf("%.8s() in \"%s\"\n", curproc()->pname, curfile);
        !           109:                lastcom = NOCOM;
        !           110:                break;
        !           111:                
        !           112:        l1:     /* argument is filename */
        !           113:                finit(args);
        !           114:                printf("\"%s\"\n", curfile);
        !           115:                lastcom = NOCOM;
        !           116:                break;
        !           117:                
        !           118:        case 'p':
        !           119:                if (integ) ffind(integ);
        !           120:                fprint();
        !           121:                lastcom = PRCOM;
        !           122:                break;
        !           123:                
        !           124:        case 'q':
        !           125:                exit(0);
        !           126:                
        !           127:        case 'w':
        !           128:                if (integ) ffind(integ);
        !           129:                i = fline;
        !           130:                fback(WINDOW/2);
        !           131:                fprintn(WINDOW);
        !           132:                ffind(i);
        !           133:                lastcom = PRCOM;
        !           134:                break;
        !           135:                
        !           136:        case 'X':
        !           137:                prdebug();
        !           138:                break;
        !           139: 
        !           140:        case 'z':
        !           141:                if (integ) ffind(integ);
        !           142:                fprintn(WINDOW);
        !           143:                lastcom = PRCOM;
        !           144:                break;
        !           145: 
        !           146:        case '-':
        !           147:                fback(integ ? integ : 1);
        !           148:                fpargs();
        !           149:                lastcom = PRCOM;
        !           150:                break;
        !           151: 
        !           152:        case '+':
        !           153:                fforward(integ ? integ : 1);
        !           154:                fpargs();
        !           155:                lastcom = PRCOM;
        !           156:                break;
        !           157: 
        !           158:        case '\n':
        !           159:                switch (lastcom) {
        !           160:                case PRCOM:
        !           161:                        fforward(1);
        !           162:                        fprint();
        !           163:                        break;
        !           164:                case DSCOM:
        !           165:                        oaddr += oincr ? oincr : typetosize(otype, WORDSIZE);
        !           166:                        printf("0x%x/ ", oaddr);
        !           167:                        dispf((ADDR) oaddr, odesc,
        !           168:                            oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0);
        !           169:                        break;
        !           170:                }
        !           171:                break;
        !           172: 
        !           173:        case '\004':
        !           174:                fforward(1);
        !           175:                printf("\b");
        !           176:                fprintn(WINDOW);
        !           177:                lastcom = PRCOM;
        !           178:                break;
        !           179: 
        !           180:        case 'r':
        !           181:                if (args[0] == '\0') getargs();
        !           182:        case 'R':
        !           183:                signo = 0;
        !           184:                cpstr(oldargs, args);
        !           185:                if (debug) error("calling dopcs");
        !           186:                if (integ) cntval = integ;
        !           187:                if (!executing) {
        !           188:                        executing = TRUE;
        !           189:                        if (integ) cntval = integ;
        !           190:                        dopcs('r');
        !           191:                        executing = FALSE;
        !           192:                }
        !           193:                if (debug) error("exiting dopcs");
        !           194:                bkaddr = -1;
        !           195:                goto f1;
        !           196: 
        !           197:        case 'c':
        !           198:                signo = 0;
        !           199:        case 'C':
        !           200:                if (proc[0] != '\0' || integ != 0) {
        !           201:                        dot = getaddr(proc, integ);
        !           202:                        if (dot == -1) {
        !           203:                                error("Cannot set temporary breakpoint");
        !           204:                                break;
        !           205:                        }
        !           206:                        dopcs('b');
        !           207:                        bkaddr = dot;
        !           208:                } else
        !           209:                        bkaddr = -1;
        !           210:                integ = atoi(args);
        !           211: 
        !           212: f1:            if (debug) error("calling dopcs");
        !           213:                if (integ) cntval = integ;
        !           214:                dopcs('c');
        !           215:                if (debug) error("exiting dopcs");
        !           216:                if (bkaddr != -1) {
        !           217:                        ADDR dotsave;
        !           218:                        dotsave = dot;
        !           219:                        dot = bkaddr;
        !           220:                        dopcs('d');
        !           221:                        dot = dotsave;
        !           222:                }
        !           223:                if (!signo) printf("Breakpoint");
        !           224:                printf(" at\n");
        !           225:                setcur(1);
        !           226:                lastcom = NOCOM;
        !           227:                break;
        !           228:                
        !           229:        case 'S':
        !           230:        case 's':
        !           231:                signo = 0;
        !           232:                integ = atoi(args);
        !           233:                singstep(integ ? integ : 1, cmd);
        !           234:                if (signo) printf("\n");
        !           235:                setcur(1);
        !           236:                lastcom = NOCOM;
        !           237:                break;
        !           238:                
        !           239:        case 'g':
        !           240:                if (pid == 0  ||  signo) {
        !           241:                        error("Not stopped at breakpoint");
        !           242:                }
        !           243:                dot = getaddr(proc, integ);
        !           244:                if (dot == -1) {
        !           245:                        error("Bad address");
        !           246:                        break;
        !           247:                }
        !           248:                adrflg = 1;
        !           249:                integ = atoi(args);
        !           250:                if (integ) cntval = integ;
        !           251:                dopcs('c');
        !           252:                if (!signo) printf("Breakpoint");
        !           253:                printf(" at\n");
        !           254:                setcur(1);
        !           255:                lastcom = NOCOM;
        !           256:                break;
        !           257: 
        !           258:        case 'k':
        !           259:                if (scallx) {
        !           260:                        userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs;
        !           261:                        *(ADDR *)(((ADDR)&u)+FP) = fps;
        !           262:                        *(ADDR *)(((ADDR)&u)+AP) = aps;
        !           263:                        if (bkpts)
        !           264:                                bkpts->flag = flagss;
        !           265:                        scallx = 0;
        !           266:                        error("Procedure killed");
        !           267:                        longjmp(env, 0);
        !           268:                } else {
        !           269:                        dopcs('k');
        !           270:                        printf("\n");
        !           271:                        lastcom = NOCOM;
        !           272:                        break;
        !           273:                }
        !           274: 
        !           275:        case 'B':
        !           276:                prbkpt();
        !           277:                break;
        !           278: 
        !           279:        case 'b':
        !           280:        setbrk:
        !           281:                if (proc[0] == '\0' && integ == 0) {
        !           282:                        integ = fline;
        !           283:                }
        !           284:                dot = getaddr(proc,integ);
        !           285:                if (dot == -1 || dot == 0) {
        !           286:                        error("Cannot set breakpoint");
        !           287:                        break;
        !           288:                }
        !           289:                dopcs('b');
        !           290:                s = " b\n";
        !           291:                s[1] = cmd;
        !           292:                printbkpt(s, adrtoprocp(dot)->pname,
        !           293:                        adrtolineno(dot));
        !           294:                break;
        !           295:                
        !           296:        case 'd':
        !           297:                if (proc[0] == '\0' && integ == 0) {
        !           298:                        idbkpt();
        !           299:                        break;
        !           300:                }
        !           301:                dot = getaddr(proc,integ);
        !           302:                if (dot == -1) {
        !           303:                        error("Non existent breakpoint");
        !           304:                        break;
        !           305:                }
        !           306:                dopcs('d');
        !           307:                break;
        !           308:                
        !           309:        case 'D':
        !           310:                dabkpt();
        !           311:                error("All breakpoints deleted");
        !           312:                break;
        !           313: 
        !           314:        case 'm':
        !           315:                addr = varaddr(proc[0] ? proc : curproc()->pname, var);
        !           316:                printf("stopped with value %d\n", monex(addr, 'd'));
        !           317:                setcur(1);
        !           318:                lastcom = NOCOM;
        !           319:                break;
        !           320:                
        !           321:        case '/':
        !           322:                if (var[0] == '.' && var[1] == '\0') {
        !           323:                        if (integ == 0) integ = oaddr;
        !           324:                        dispf((ADDR) integ, args[0] ? args : odesc,
        !           325:                            oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0);
        !           326:                        oaddr = integ;
        !           327:                } else
        !           328:                if (integ && (var[0] == '\0')) {
        !           329:                        dispf((ADDR) integ, args, N_GSYM, 0, 0, 0);
        !           330:                        oaddr = integ;
        !           331:                        cpstr(odesc, args);
        !           332:                        oclass = N_GSYM;
        !           333:                        otype = 0;
        !           334:                } else
        !           335:                        dispvar(proc, var, args);
        !           336:                lastcom = DSCOM;
        !           337:                break;
        !           338:                
        !           339:        case '=':
        !           340:                if (var[0] == '\0') {
        !           341:                        if (proc[0]) {
        !           342:                                addr = getaddr(proc, integ);
        !           343:                                if (addr == -1) {
        !           344:                                        error("Unknown address");
        !           345:                                        break;
        !           346:                                }
        !           347:                        }
        !           348:                        else
        !           349:                                addr = integ;
        !           350:                        dispf(addr, args[0] ? args : "x", 0, -1, 0, 0);
        !           351:                } else 
        !           352:                        findvar(proc, var, args[0] ? args : "x", 2);
        !           353:                break;
        !           354: 
        !           355:        case '!':
        !           356:                if (var[0] == '\0')
        !           357:                        addr = getaddr(proc, integ);
        !           358:                else
        !           359:                        addr = varaddr(proc, var);
        !           360:                if (addr == -1) 
        !           361:                        error("Unknown variable");
        !           362:                else {
        !           363:                        if (number(args[0]) || eqany(args[0], ".-")) {
        !           364:                                char *p;
        !           365:                                double atof();
        !           366:                                union {
        !           367:                                        struct{
        !           368:                                                int w1, w2;
        !           369:                                        };
        !           370:                                        struct {
        !           371:                                                double d;
        !           372:                                        };
        !           373:                                } dbl;
        !           374: 
        !           375:                                p = (args[0] == '-') ? args+1 : args;
        !           376:                                for (; *p != '.' && *p != 'e'; p++) {
        !           377:                                        if (!number(*p)) goto l2;
        !           378:                                }
        !           379:                                dbl.d = atof(args);
        !           380:                                putval(addr, 'd', dbl.w1);
        !           381:                                if (typetodesc(sl_type,0)[0] == 'g')
        !           382:                                        putval(addr+WORDSIZE, 'd', dbl.w2);
        !           383:                                break;
        !           384:                        }
        !           385: l2:                    if (sl_class == N_RSYM && addr < 16)
        !           386:                                putreg(addr,typetodesc(sl_type,subflag)[0],
        !           387:                                                argvalue(args));
        !           388:                        else
        !           389:                                putval(addr,typetodesc(sl_type,subflag)[0],
        !           390:                                                argvalue(args));
        !           391:                }
        !           392:                lastcom = NOCOM;
        !           393:                break;
        !           394: 
        !           395:        case '"':
        !           396:                printf(args);
        !           397:                break;
        !           398:        }
        !           399: }
        !           400: 
        !           401: fpargs() {
        !           402:        register int i;
        !           403:        
        !           404:        switch(args[0]) {
        !           405:        case 'p':
        !           406:        case '\0':
        !           407:                fprint();
        !           408:                break;
        !           409: case 'w':
        !           410:                i = fline;
        !           411:                fback(WINDOW/2);
        !           412:                fprintn(WINDOW);
        !           413:                ffind(i);
        !           414:                break;
        !           415:        case 'z':
        !           416:                fprintn(WINDOW);
        !           417:                break;
        !           418:        }
        !           419: }

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