Return to trace3.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / db

Annotation of coherent/d/bin/db/trace3.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * A debugger.
        !             3:  * Display.
        !             4:  */
        !             5: #include <stdio.h>
        !             6: #include <ctype.h>
        !             7: #include "trace.h"
        !             8: 
        !             9: /*
        !            10:  * Execute a command string.
        !            11:  */
        !            12: execute(cp)
        !            13: char *cp;
        !            14: {
        !            15:        register INP *ip;
        !            16: 
        !            17:        while ((ip=inpp) != NULL) {
        !            18:                inpp = ip->i_next;
        !            19:                nfree(ip);
        !            20:        }
        !            21:        modsize = sizeof(int);
        !            22:        sincmod = SNULL;
        !            23:        dot = getpc();
        !            24:        lastc = '\0';
        !            25:        addstrp(cp);
        !            26:        request();
        !            27:        testint();
        !            28: }
        !            29: 
        !            30: /*
        !            31:  * Parse requests and execute them.
        !            32:  */
        !            33: request()
        !            34: {
        !            35:        register int c;
        !            36:        register char *cp;
        !            37:        register unsigned segn;
        !            38:        register long l;
        !            39:        register long d;
        !            40:        VAL val[VALSIZE];
        !            41: 
        !            42:        while ((c=getn()) != EOF) {
        !            43:                if (c == '!') {
        !            44:                        syscall();
        !            45:                        continue;
        !            46:                }
        !            47:                if (c == '?') {
        !            48:                        if ((c=getn()) != '\n') {
        !            49:                                printe("Syntax error");
        !            50:                                goto next;
        !            51:                        }
        !            52:                        if (errrstr == NULL)
        !            53:                                printx("No error\n");
        !            54:                        else
        !            55:                                printx("%s\n", errrstr);
        !            56:                        continue;
        !            57:                }
        !            58:                ungetn(c);
        !            59:                if (explist(val) == 0)
        !            60:                        goto next;
        !            61:                switch (c=getn()) {
        !            62:                case ':':
        !            63:                        sincmod = SNULL;
        !            64:                        if (command(val) == 0)
        !            65:                                return;
        !            66:                        continue;
        !            67:                case '\n':
        !            68:                        if (nvalue(&val[0]) && sincmod!=SNULL) {
        !            69:                                if (excflag == 0) {
        !            70:                                        sincmod = SNULL;
        !            71:                                        printe("Cannot single step");
        !            72:                                        continue;
        !            73:                                }
        !            74:                                sinmode = sincmod;
        !            75:                                sindecr = rvalue(&val[1], (long)1);
        !            76:                                return;
        !            77:                        }
        !            78:                case '=':
        !            79:                        ungetn(c);
        !            80:                case '?':
        !            81:                        sincmod = SNULL;
        !            82:                        segn = vsegno(&val[0], cseg);
        !            83:                        if ((c=getn()) == '=') {
        !            84:                                l = lvalue(&val[0], (long)dot);
        !            85:                                if ((c=getn()) == '\n') {
        !            86:                                        putaddnum( l);
        !            87:                                        printx("\n");
        !            88:                                        continue;
        !            89:                                }
        !            90:                                ungetn(c);
        !            91:                                if (setdata(segn, l) == 0)
        !            92:                                        break;
        !            93:                                continue;
        !            94:                        }
        !            95:                        if (c != '\n') {
        !            96:                                cp = &segform[segn][0];
        !            97:                                while (c != '\n') {
        !            98:                                        *cp++ = c;
        !            99:                                        c = getn();
        !           100:                                }
        !           101:                                *cp++ = '\0';
        !           102:                        }
        !           103:                        d = dot;
        !           104:                        l = lad;
        !           105:                        dot = lvalue(&val[0], (long)lad);
        !           106:                        dispfmt(segn, segform[segn],
        !           107:                                (int)rvalue(&val[1], (long)1));
        !           108:                        if (segn != 2)
        !           109:                                cseg = segn;
        !           110:                        else {
        !           111:                                dot = d;
        !           112:                                lad = l;
        !           113:                        }
        !           114:                        continue;
        !           115:                default:
        !           116:                        sincmod = SNULL;
        !           117:                        printe("Syntax error");
        !           118:                        break;
        !           119:                }
        !           120:        next:
        !           121:                while ((c=getn()) != '\n')
        !           122:                        ;
        !           123:        }
        !           124: }
        !           125: 
        !           126: /*
        !           127:  * Change the value of a location.
        !           128:  */
        !           129: setdata(segn, a)
        !           130: long a;
        !           131: {
        !           132:        register char *cp;
        !           133:        register int n;
        !           134:        register int c;
        !           135:        char b[1];
        !           136:        char l3[3];
        !           137:        int i[1];
        !           138:        long l[1];
        !           139:        VAL val[VALSIZE];
        !           140: 
        !           141:        if (explist(val) == 0)
        !           142:                return (0);
        !           143:        if ((c=getn()) != '\n')
        !           144:                return (0);
        !           145:        for (n=0; n<VALSIZE; n++, a+=modsize) {
        !           146:                if (nvalue(&val[n]))
        !           147:                        continue;
        !           148:                l[0] = rvalue(&val[n], (long)0);
        !           149:                switch (modsize) {
        !           150:                case (sizeof(char)):
        !           151:                        b[0] = l[0];
        !           152:                        cp = b;
        !           153:                        break;
        !           154:                case (sizeof(int)):
        !           155:                        i[0] = l[0];
        !           156:                        cp = i;
        !           157:                        break;
        !           158:                case (sizeof(l3)):
        !           159:                        ltol3(l3, l, 1);
        !           160:                        cp = l3;
        !           161:                        break;
        !           162:                case (sizeof(long)):
        !           163:                        cp = l;
        !           164:                        break;
        !           165:                default:
        !           166:                        printe("Bad change type");
        !           167:                        return (1);
        !           168:                }
        !           169:                add = a;
        !           170:                if (putb(segn, cp, modsize) == 0) {
        !           171:                        printe("Cannot change value");
        !           172:                        return (1);
        !           173:                }
        !           174:        }
        !           175:        if (segn == 2)
        !           176:                setregs();
        !           177:        return (1);
        !           178: }
        !           179: 
        !           180: /*
        !           181:  * Send a command to the shell.
        !           182:  */
        !           183: syscall()
        !           184: {
        !           185:        register int c;
        !           186:        register char *cp;
        !           187: 
        !           188:        cp = miscbuf;
        !           189:        while ((c=getn()) != '\n')
        !           190:                *cp++ = c;
        !           191:        *cp++ = '\0';
        !           192:        system(miscbuf);
        !           193:        testint();
        !           194:        printf("!\n");
        !           195: }
        !           196: 
        !           197: /*
        !           198:  * Print out data according to a format string.  `n' is the number
        !           199:  * of times this is done.
        !           200:  */
        !           201: 
        !           202: static int     addfmt = 32767;
        !           203: 
        !           204: dispfmt(s, fs, n)
        !           205: char *fs;
        !           206: {
        !           207:        register char *sp1;
        !           208:        register char *sp2;
        !           209:        register int c;
        !           210:        register int r;
        !           211:        register int t1;
        !           212:        register int t2;
        !           213:        register char *sp3;
        !           214:        register char *fp;
        !           215:        register long nad;
        !           216:        register long pad;
        !           217:        register long uad;
        !           218: 
        !           219:        r = 1;
        !           220:        t2 = '\0';
        !           221:        add = dot;
        !           222:        nad = dot;
        !           223:        pad = dot;
        !           224:        uad = dot;
        !           225:        sp1 = miscbuf;
        !           226:        sp3 = &sp1[DISSIZE];
        !           227:        while (n--) {
        !           228:                fp = fs;
        !           229:                for (;;) {
        !           230:                        c = *fp++;
        !           231:                        if (isascii(c) && isdigit(c)) {
        !           232:                                r = 0;
        !           233:                                do {
        !           234:                                        r = r*10 + c-'0';
        !           235:                                        c = *fp++;
        !           236:                                } while (isascii(c) && isdigit(c));
        !           237:                                --fp;
        !           238:                                continue;
        !           239:                        }
        !           240:                        switch (c) {
        !           241:                        case '^':
        !           242:                                add = uad;
        !           243:                                continue;
        !           244:                        case '+':
        !           245:                                add += r;
        !           246:                                r = 1;
        !           247:                                continue;
        !           248:                        case '-':
        !           249:                                add -= r;
        !           250:                                r = 1;
        !           251:                                continue;
        !           252:                        case 'n':
        !           253:                                *sp1 = '\0';
        !           254:                                flushb((long)nad);
        !           255:                                sp1 = miscbuf;
        !           256:                                nad = add;
        !           257:                                continue;
        !           258:                        case 'd':
        !           259:                        case 'o':
        !           260:                        case 'u':
        !           261:                        case 'x':
        !           262:                                t2 = c;
        !           263:                                continue;
        !           264:                        case 'a':
        !           265:                                addfmt = 32767;
        !           266:                                continue;
        !           267:                        case 'A':
        !           268:                                addfmt = -1;
        !           269:                                continue;
        !           270:                        default:
        !           271:                                t1 = c;
        !           272:                                if (t1=='\0' && t2=='\0')
        !           273:                                        break;
        !           274:                                if (t1 == '\0')
        !           275:                                        t1 = 'w';
        !           276:                                if (t2 == '\0')
        !           277:                                        t2 = DDCHR;
        !           278:                                uad = add;
        !           279:                                while (r--) {
        !           280:                                        if (testint())
        !           281:                                                return (1);
        !           282:                                        *sp1++ = ' ';
        !           283:                                        pad = add;
        !           284:                                        sp2 = conform(sp1, s, t1, t2, getb);
        !           285:                                        if (sp2 == NULL) {
        !           286:                                                *--sp1 = '\0';
        !           287:                                                if (sp1 != miscbuf)
        !           288:                                                        flushb((long)nad);
        !           289:                                                printe("Addressing error");
        !           290:                                                return (0);
        !           291:                                        }
        !           292:                                        if (sp2 <= sp3)
        !           293:                                                sp1 = sp2;
        !           294:                                        else {
        !           295:                                                *--sp1 = '\0';
        !           296:                                                flushb((long)nad);
        !           297:                                                *sp2 = '\0';
        !           298:                                                *sp1 = ' ';
        !           299:                                                sp2 = sp1;
        !           300:                                                sp1 = miscbuf;
        !           301:                                                while (*sp2)
        !           302:                                                        *sp1++ = *sp2++;
        !           303:                                                nad = pad;
        !           304:                                        }
        !           305:                                        if (c == 'i') {
        !           306:                                                *sp1++ = '\0';
        !           307:                                                flushb((long)nad);
        !           308:                                                sp1 = miscbuf;
        !           309:                                                nad = add;
        !           310:                                        }
        !           311:                                }
        !           312:                                r = 1;
        !           313:                                t2 = '\0';
        !           314:                                if (c != '\0')
        !           315:                                        continue;
        !           316:                        }
        !           317:                        break;
        !           318:                }
        !           319:                lad = add;
        !           320:        }
        !           321:        if (sp1 != miscbuf) {
        !           322:                *sp1 = '\0';
        !           323:                flushb((long)nad);
        !           324:        }
        !           325:        return (1);
        !           326: }
        !           327: 
        !           328: /*
        !           329:  * Flush the output buffer.  The given address `a' is printed before the
        !           330:  * contents of the buffer and dot is set to it.
        !           331:  */
        !           332: flushb(a)
        !           333: register long a;
        !           334: {
        !           335:        char    buf[40];
        !           336: 
        !           337:        dot = a;
        !           338:        if( fflag)
        !           339:                printx( "%lx", a);
        !           340:        else {
        !           341:                conaddr( buf, -1, a, addfmt);
        !           342:                printx( "%s", buf);
        !           343:        }
        !           344:        printx("\t%s\n", miscbuf);
        !           345: }
        !           346: 
        !           347: /*
        !           348:  * Given a format character `f' and a function `func', print out
        !           349:  * data according to the given format.  The function `get' is
        !           350:  * called to read characters.
        !           351:  */
        !           352: char *
        !           353: conform(sp, s, t1, t2, get)
        !           354: register char *sp;
        !           355: int (*get)();
        !           356: {
        !           357:        register char *lp;
        !           358:        unsigned char c[1];
        !           359:        unsigned char v[3];
        !           360:        unsigned short h[1];
        !           361:        char *p[1];
        !           362:        int i[1];
        !           363:        long l[1];
        !           364: #ifndef        NFP
        !           365:        float f[1];
        !           366:        double d[1];
        !           367: #endif
        !           368: 
        !           369:        switch (t1) {
        !           370:        case 'b':
        !           371:                if ((*get)(s, c, sizeof(c)) == 0)
        !           372:                        return (NULL);
        !           373:                modsize = sizeof(c);
        !           374: 
        !           375:                /*
        !           376:                 * There should be a better way to do this.
        !           377:                 */
        !           378:                if (t2 != 'd')
        !           379:                        i[0] = c[0];
        !           380:                else {
        !           381:                        char x[1];
        !           382: 
        !           383:                        x[0] = c[0];
        !           384:                        i[0] = x[0];
        !           385:                }
        !           386:                sprintf(sp, getform(t1, t2), i[0]);
        !           387:                break;
        !           388:        case 'c':
        !           389:                if ((*get)(s, c, sizeof(c)) == 0)
        !           390:                        return (NULL);
        !           391:                modsize = sizeof(c);
        !           392:                sp = conescs(sp, c[0]);
        !           393:                return (sp);
        !           394:        case 'C':
        !           395:                if ((*get)(s, c, sizeof(c)) == 0)
        !           396:                        return (NULL);
        !           397:                modsize = sizeof(c);
        !           398:                *sp++ = (c[0]>=040&&c[0]<0177) ? c[0] : '.';
        !           399:                return (sp);
        !           400: #ifndef        NFP
        !           401:        case 'f':
        !           402:                if ((*get)(s, (char *)f, sizeof(f)) == 0)
        !           403:                        return (NULL);
        !           404:                modsize = sizeof(f);
        !           405:                sprintf(sp, getform(t1, t2), f[0]);
        !           406:                break;
        !           407:        case 'F':
        !           408:                if ((*get)(s, (char *)d, sizeof(d)) == 0)
        !           409:                        return (NULL);
        !           410:                modsize = sizeof(d);
        !           411:                sprintf(sp, getform(t1, t2), d[0]);
        !           412:                break;
        !           413: #endif
        !           414:        case 'h':
        !           415:                if ((*get)(s, h, sizeof(h)) == 0)
        !           416:                        return (NULL);
        !           417:                modsize = sizeof(h);
        !           418: 
        !           419:                /*
        !           420:                 * Oh well.
        !           421:                 */
        !           422:                if (t2 != 'd')
        !           423:                        i[0] = h[0];
        !           424:                else {
        !           425:                        short x[1];
        !           426: 
        !           427:                        x[0] = h[0];
        !           428:                        i[0] = x[0];
        !           429:                }
        !           430:                sprintf(sp, getform(t1, t2), i[0]);
        !           431:                break;
        !           432:        case 'i':
        !           433:                sp = coninst(sp, s);
        !           434:                modsize = INLEN;
        !           435:                return (sp);
        !           436:        case 'l':
        !           437:                if ((*get)(s, (char *)l, sizeof(l)) == 0)
        !           438:                        return (NULL);
        !           439:                modsize = sizeof(l);
        !           440:                sprintf(sp, getform(t1, t2), l[0]);
        !           441:                break;
        !           442:        case 'p':
        !           443:                if ((*get)(s, (char *)p, sizeof(p)) == 0)
        !           444:                        return (NULL);
        !           445:                modsize = sizeof(p);
        !           446:                sp = conaddr(sp, -1, (long)p[0], I);
        !           447:                return (sp);
        !           448:        case 's':
        !           449:        case 'S':
        !           450:                lp = &sp[DISSIZE];
        !           451:                c[0] = '\0';
        !           452:                for (;;) {
        !           453:                        if ((*get)(s, c, sizeof(c)) == 0)
        !           454:                                return (NULL);
        !           455:                        if (c[0] == '\0')
        !           456:                                break;
        !           457:                        if (t1 == 's')
        !           458:                                sp = conescs(sp, c[0]);
        !           459:                        else
        !           460:                                *sp++ = c[0];
        !           461:                        if (sp > lp)
        !           462:                                return (NULL);
        !           463:                }
        !           464:                modsize = sizeof(i);
        !           465:                return (sp);
        !           466:        case 'v':
        !           467:                if ((*get)(s, (char *)v, sizeof(v)) == 0)
        !           468:                        return (NULL);
        !           469:                modsize = sizeof(v);
        !           470:                l3tol(l, v, 1);
        !           471:                sprintf(sp, getform(t1, t2), l[0]);
        !           472:                break;
        !           473:        case 'w':
        !           474:                if ((*get)(s, (char *)i, sizeof(i)) == 0)
        !           475:                        return (NULL);
        !           476:                modsize = sizeof(i);
        !           477:                sprintf(sp, getform(t1, t2), i[0]);
        !           478:                break;
        !           479:        case 'Y':
        !           480:                sp = gettime(sp, cseg, get);
        !           481:                modsize = sizeof(i);
        !           482:                return (sp);
        !           483:        default:
        !           484:                return (NULL);
        !           485:        }
        !           486:        while (*sp)
        !           487:                sp++;
        !           488:        return (sp);
        !           489: }
        !           490: 
        !           491: /*
        !           492:  * If the given character is unprintable, convert it into
        !           493:  * an escape sequence.
        !           494:  */
        !           495: char *
        !           496: conescs(sp, c)
        !           497: register char *sp;
        !           498: register int c;
        !           499: {
        !           500:        *sp++ = '\\';
        !           501:        switch (c) {
        !           502:        case '\0':
        !           503:                *sp++ = '0';
        !           504:                break;
        !           505:        case '\b':
        !           506:                *sp++ = 'b';
        !           507:                break;
        !           508:        case '\n':
        !           509:                *sp++ = 'n';
        !           510:                break;
        !           511:        case '\f':
        !           512:                *sp++ = 'f';
        !           513:                break;
        !           514:        case '\r':
        !           515:                *sp++ = 'r';
        !           516:                break;
        !           517:        case '\\':
        !           518:                *sp++ = '\\';
        !           519:                break;
        !           520:        default:
        !           521:                if (c<040 || c>=0177) {
        !           522:                        sprintf(sp, "%03o", c);
        !           523:                        while (*sp)
        !           524:                                sp++;
        !           525:                        break;
        !           526:                }
        !           527:                sp[-1] = c;
        !           528:        }
        !           529:        return (sp);
        !           530: }
        !           531: 
        !           532: /*
        !           533:  * Get the current time.
        !           534:  */
        !           535: char *
        !           536: gettime(sp, s, get)
        !           537: register char *sp;
        !           538: int (*get)();
        !           539: {
        !           540:        long l;
        !           541:        register int n;
        !           542:        register char *cp;
        !           543: 
        !           544:        if ((*get)(s, (char *) &l, sizeof(l)) == 0)
        !           545:                return (NULL);
        !           546:        cp = ctime(&l);
        !           547:        n = 24;
        !           548:        do {
        !           549:                *sp++ = *cp++;
        !           550:        } while (--n);
        !           551:        return (sp);
        !           552: }

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