Return to prvar.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / old / sdb

Annotation of 43BSDTahoe/old/sdb/prvar.c, revision 1.1

1.1     ! root        1: static char sccsid[] = "@(#)prvar.c 4.3 8/17/82";
        !             2: #include "head.h"
        !             3: #include <a.out.h>
        !             4: #include <stab.h>
        !             5: #include "cdefs.h"
        !             6: struct user u;
        !             7: BKPTR  bkpthead;
        !             8: STRING errflg;
        !             9: 
        !            10: /* 
        !            11:  *  outvar():
        !            12:  * Prints named variable, recursing once for each structure member or
        !            13:  *  subscript.
        !            14:  * proc:var: variable name
        !            15:  * fmt: print format
        !            16:  * metaflag: set iff var contains metacharacters * or ?
        !            17:  * addr: partial address of variable, initally 0
        !            18:  * class: type class of variable
        !            19:  * subflag: number of levels of subscript indirection
        !            20:  * prnamep: pointer to end of partially formed print name of variable
        !            21:  * comblk: name of common block containing variable, if any
        !            22:  * prvar: as in findvar
        !            23:  *
        !            24:  * Here and elsewhere we assume that -1 is an invalid address, and
        !            25:  *     its is used to indicate error.
        !            26:  */
        !            27: outvar(proc, var, fmt, metaflag, addr, class, subflag, prnamep,
        !            28:                comblk, prvar)
        !            29: ADDR addr; char *proc, *var, *fmt, *prnamep, *comblk; u_char class; {
        !            30:        char *p, *q, *r, *oldpr;
        !            31:        register int match;
        !            32:        long soffset, goffset;
        !            33:        register ADDR newaddr = -1, arrowaddr;
        !            34:        register enum {INIT, ARROW, DOT} typeflag;
        !            35: 
        !            36:        switch (var[0]) {
        !            37:        case '\0':
        !            38:                if (prvar == 0) return(addr);
        !            39:                if (metaflag) {
        !            40:                        if (comblk[0] && !(eqstr(comblk, "*")))
        !            41: #ifndef FLEXNAMES
        !            42:                                printf("%.8s:%.8s", comblk, prname);
        !            43: #else
        !            44:                                printf("%s:%s", comblk, prname);
        !            45: #endif
        !            46:                        else if (proc[0])
        !            47: #ifndef FLEXNAMES
        !            48:                                printf("%.8s:%.8s", proc, prname);
        !            49: #else
        !            50:                                printf("%s:%s", proc, prname);
        !            51: #endif
        !            52:                        else
        !            53:                                printf("%s", prname);
        !            54:                }
        !            55:                printit(metaflag, prvar, addr, fmt, class, sl_type,
        !            56:                        sl_size, subflag, DSP);
        !            57:                return(addr);
        !            58: 
        !            59:        case '[':
        !            60:                *prnamep++ = *var++;
        !            61:                p = var;
        !            62:                for (;;) {
        !            63:                        *prnamep++ = *var;
        !            64:                        if (*var == '\0' || *var == ']') break;
        !            65:                        var++;
        !            66:                }
        !            67:                newaddr = getindir(class, addr, sl_type);
        !            68:                newaddr += typetosize(sl_type, sl_size) * readint(&p);
        !            69:                return(outvar(proc, var+1, fmt, metaflag, newaddr, N_GSYM,
        !            70:                        subflag+1, prnamep, comblk, prvar));
        !            71:                
        !            72:        case '-':
        !            73:        case '>':
        !            74:                typeflag = ARROW;
        !            75:                while (eqany(*var, "->"))
        !            76:                        *prnamep++ = *var++;
        !            77:                subflag++;
        !            78:                arrowaddr = getindir(class, addr, sl_type);
        !            79:                if (errflg) {
        !            80:                        printf("%s\n", errflg);
        !            81:                        errflg = 0;
        !            82:                        return(0);
        !            83:                }
        !            84:                class = N_GSYM;
        !            85:                if (var[0] == '\0') {
        !            86:                        p = var;
        !            87:                        newaddr = arrowaddr;
        !            88:                        goto recurse;
        !            89:                }
        !            90:                break;
        !            91: 
        !            92:        case '.':
        !            93:                typeflag = DOT;
        !            94:                if (class == N_RSYM) {
        !            95:                        error("Not with a register variable");
        !            96:                        return(0);
        !            97:                }
        !            98:                *prnamep++ = *var++;
        !            99:                subflag = 0;
        !           100:                break;
        !           101: 
        !           102:        default:
        !           103:                typeflag = INIT;
        !           104:                break;
        !           105:        }
        !           106: 
        !           107:        if (typeflag == INIT) {
        !           108:                soffset = proc[0] ? adrtostoffset(callpc-1) : -1;
        !           109:                goffset = proc[0] ? -1 : findfile(curfile)->stf_offset;
        !           110:        } else {
        !           111:                soffset = proc[0] ? adrtostoffset(callpc-1) : -1;
        !           112:                goffset = findfile(curfile)->stf_offset;
        !           113:        }
        !           114: 
        !           115:        p = var;
        !           116:        oldpr = prnamep;
        !           117:        while (!eqany(*p, "->.[") && *p != '\0')
        !           118:                *prnamep++ = *p++;
        !           119:        *prnamep = '\0';
        !           120: 
        !           121:        match = 0;
        !           122:        slookinit(); 
        !           123: 
        !           124:        for (;;) {
        !           125:                if (soffset != -1)
        !           126:                        if ((soffset = slooknext(var, soffset, typeflag!=INIT,
        !           127:                                comblk)) != -1)
        !           128:                                goto found;
        !           129:                if (goffset != -1)
        !           130:                        if ((goffset = globallookup(var, goffset, 
        !           131:                                typeflag!=INIT)) != -1)
        !           132:                                goto found;
        !           133:                return(newaddr);
        !           134: 
        !           135:        found:
        !           136:                r = sl_name;
        !           137:                q = oldpr;
        !           138:                while (*r) *q++ = *r++;
        !           139:                *q ='\0';
        !           140: 
        !           141:                switch(typeflag) {
        !           142:                case INIT:
        !           143:                        class = sl_class & STABMASK;
        !           144:                        if (!varclass(class) || class == N_SSYM)
        !           145:                                goto l;
        !           146:                        newaddr = (class == N_LSYM) ? -sl_addr : sl_addr;
        !           147:                        newaddr = formaddr(class, newaddr);
        !           148:                        break;
        !           149: 
        !           150:                case ARROW:
        !           151:                        class = sl_class & STABMASK;
        !           152:                        if (!varclass(class) || class != N_SSYM)
        !           153:                                goto l;
        !           154:                        newaddr = arrowaddr + sl_addr;
        !           155:                        break;
        !           156: 
        !           157:                case DOT:
        !           158:                        class = sl_class & STABMASK;
        !           159:                        if (!varclass(class) || class != N_SSYM)
        !           160:                                goto l;
        !           161:                        newaddr = addr + sl_addr;
        !           162:                        break;
        !           163:                }
        !           164: 
        !           165:        recurse:
        !           166:                newaddr = outvar(proc, p, fmt, metaflag, newaddr, 
        !           167:                        class, subflag, prnamep, comblk, prvar);
        !           168:                
        !           169:                if (!metaflag)
        !           170:                        return(newaddr);
        !           171: l:;    }
        !           172: }
        !           173: 
        !           174: /* Output external variables.  Arguments as in outvar() */
        !           175: extoutvar(var, fmt, metaflag, prvar)
        !           176: char *var, *fmt; {
        !           177:        long offset;
        !           178:        ADDR addr = -1;
        !           179: 
        !           180:        offset = extstart;
        !           181:        sl_addr = -1;
        !           182: 
        !           183:        for (;;) {
        !           184:                offset = extlookup(var, offset);
        !           185:                addr = sl_addr;
        !           186:                if (offset == -1)
        !           187:                        return(addr);
        !           188:                if (metaflag) 
        !           189: #ifndef FLEXNAMES
        !           190:                        printf("%.7s", sl_name);
        !           191: #else
        !           192:                        printf("%s", sl_name);
        !           193: #endif
        !           194:                printit(metaflag, prvar, addr, fmt[0] ? fmt : "d", 
        !           195:                        N_GSYM, 0, 0, 0, DSP);
        !           196:                if (!metaflag)
        !           197:                        return(addr);
        !           198:        }
        !           199: }
        !           200: 
        !           201: prdebug() {
        !           202:        register struct proct *procp;
        !           203:        register struct filet *filep;
        !           204:        
        !           205:        printf("dot=%d\n", dot);
        !           206:        printf("extstart = %d\n", extstart);
        !           207:        printf("firstdata = %d\n", firstdata);
        !           208:        for(filep=files;filep->sfilename[0];filep++)
        !           209:                printf("%s offs %d @ %d flag %d addr 0x%x\n", filep->sfilename, filep->stf_offset, filep, filep->lineflag, filep->faddr);
        !           210:        for(procp=procs;procp->pname[0];procp++) {
        !           211: #ifndef FLEXNAMES
        !           212:                printf("%s addr 0x%x; offs %d; sfptr %d; line %d",
        !           213: #else
        !           214:                printf("%8.8s addr 0x%x; offs %d; sfptr %d; line %d",
        !           215: #endif
        !           216:                        procp->pname, procp->paddr, procp->st_offset,
        !           217:                        procp->sfptr, procp->lineno);
        !           218:                if (procp->entrypt) printf(" entrypoint");
        !           219:                printf("\n");
        !           220:        }
        !           221: }
        !           222: 
        !           223: /*
        !           224:  * display addr in data space using format desc or class s
        !           225:  *  type == 1 => use addr for value to print
        !           226:  */
        !           227: dispf(addr, desc, class, type, size, subflag, space)
        !           228: u_char class;
        !           229: char *desc; short type; ADDR addr; {
        !           230:        dispx(addr, desc, class, type, size, subflag, DSP);
        !           231:        printf("\n");
        !           232: }
        !           233: 
        !           234: /* display addr in instruction space using format desc or class s */
        !           235: /*  returns -1 if bad address */
        !           236: dispi(addr, desc, class, type, size, subflag, space)
        !           237: u_char class;
        !           238: char *desc; short type; ADDR addr; {
        !           239:        register i;
        !           240:        i = dispx(addr, desc, class, type, size, subflag, ISP);
        !           241:        printf("\n");
        !           242:        return(i);
        !           243: }
        !           244: 
        !           245: char   pd[3];
        !           246: dispx(addr, desc, class, type, size, subflag, space)
        !           247: u_char class;
        !           248: char *desc; short type; ADDR addr; {
        !           249:        int i, sflag;
        !           250:        char *p;
        !           251:        char dlen, dfmt;
        !           252:        long value;
        !           253:        union {
        !           254:                char c[WORDSIZE]; 
        !           255:                int w;
        !           256:                float f;
        !           257:        } word;
        !           258:        union {
        !           259:                struct{
        !           260:                        int w1, w2;
        !           261:                } ww;
        !           262:                double d;
        !           263:        } dbl;
        !           264: 
        !           265:        class &= STABMASK;
        !           266:        if (desc[0]  == '\0') desc = typetodesc(type, subflag);
        !           267:        cpstr(odesc, desc);
        !           268:        otype = type;
        !           269:        oclass = class;
        !           270:        oaddr = addr;
        !           271:        oincr = 0;
        !           272:        if (debug) printf("dispx(addr=%d,desc=%s,class=%d,type=%d,size=%d,subflg=%d,space=%d)\n",
        !           273:                addr, desc, class, type, size, subflag, space);
        !           274:        pd[0] = '%';
        !           275:        pd[1] = dfmt = 'd';
        !           276:        dlen = '\0';
        !           277:        for (p = desc; *p; p++) {
        !           278:                if (*p>= '0' && *p<'9') {
        !           279:                        size = readint(&p);
        !           280:                        p--;
        !           281:                } else switch (*p) {
        !           282:                        case 'l':
        !           283:                        case 'h':
        !           284:                        case 'b':
        !           285:                                dlen = *p;
        !           286:                                break;
        !           287: 
        !           288:                        case 'a':
        !           289:                        case 'c':
        !           290:                        case 'd':
        !           291:                        case 'f':
        !           292:                        case 'g':
        !           293:                        case 'i':
        !           294:                        case 'I':
        !           295:                        case 'o':
        !           296:                        case 'p':
        !           297:                        case 's':
        !           298:                        case 'u':
        !           299:                        case 'x':
        !           300:                                pd[1] = dfmt = *p;
        !           301:                                break;
        !           302: 
        !           303:                        default:
        !           304:                                printf("Illegal descriptor: %c\n", *p);
        !           305:                                return(1);
        !           306:                }
        !           307:        }
        !           308: 
        !           309:        if (type == -1)
        !           310:                value = addr;
        !           311:        else if (class == N_RSYM && addr < 16) {
        !           312:                /* MACHINE DEPENDENT */
        !           313:                if ((addr > 0 && addr < 6) || addr > 11) {
        !           314:                        printf("Bad register var %d\n", addr);
        !           315:                        return(-1);
        !           316:                }
        !           317:                value = *(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*addr);
        !           318:        }
        !           319:        else {
        !           320:                value = getval(addr, dfmt == 'g' ? 'd' : dfmt, space);
        !           321:        }
        !           322: 
        !           323:        if (errflg) {
        !           324:                printf("%s", errflg);
        !           325:                errflg = 0;
        !           326:                return(-1);
        !           327:        }
        !           328: 
        !           329:        switch (dfmt) {
        !           330:        default:
        !           331:                switch (dfmt) {
        !           332:                case 'u':
        !           333:                case 'x':
        !           334:                case 'o':
        !           335:                        switch (dlen) {
        !           336:                        case 'h':
        !           337:                                value = (unsigned short) value;
        !           338:                                oincr = 2;
        !           339:                                break;
        !           340:                        case 'b':
        !           341:                                value = (unsigned char) value;
        !           342:                                oincr = 1;
        !           343:                                break;
        !           344:                        case 'l':
        !           345:                                value = (unsigned long) value;
        !           346:                                oincr = 4;
        !           347:                                break;
        !           348:                        default:
        !           349:                                oincr = WORDSIZE;
        !           350:                                break;
        !           351:                        }
        !           352:                        break;
        !           353: 
        !           354:                default:
        !           355:                        switch (dlen) {
        !           356:                        case 'h':
        !           357:                                value = (short) value;
        !           358:                                oincr = 2;
        !           359:                                break;
        !           360:                        case 'b':
        !           361:                                value = (char) value;
        !           362:                                oincr = 1;
        !           363:                                break;
        !           364:                        case 'l':
        !           365:                                value = (long) value;
        !           366:                                oincr = 4;
        !           367:                                break;
        !           368:                        default:
        !           369:                                oincr = WORDSIZE;
        !           370:                                break;
        !           371:                        }
        !           372:                }
        !           373:                if (dfmt == 'x' && (value > 9 || value < 0))
        !           374:                        printf("0x");
        !           375:                else if (dfmt == 'o' && (value > 7 || value < 0))
        !           376:                        printf("0");
        !           377:                printf(pd, value);
        !           378:                return(1);
        !           379:                
        !           380:        case 'f':
        !           381:                pd[1] = 'g';
        !           382:                word.w = value;
        !           383:                printf(pd, word.f);
        !           384:                return(1);
        !           385: 
        !           386:        case 'g':
        !           387:                dbl.ww.w1 = value;
        !           388:                dbl.ww.w2 = (class == N_RSYM) ?
        !           389:                        *(ADDR *)(((ADDR) &u)+R0+(WORDSIZE)*(addr+1)) :
        !           390:                        getval(addr+WORDSIZE, 'd', space);
        !           391:                printf("%.13g", dbl.d);
        !           392:                return(1);
        !           393: 
        !           394:        case 'p':
        !           395:                printf("%s:%d", adrtoprocp(value)->pname,
        !           396:                        adrtolineno(value));
        !           397:                return(1);
        !           398: 
        !           399:        case 's':
        !           400:                addr = getindir(class, addr, type);
        !           401:                goto aa;
        !           402:                        
        !           403:        case 'c':
        !           404:                if (size <= 1) {
        !           405:                        oincr = 1;
        !           406:                        printchar(value);
        !           407:                        return(1);
        !           408:                } else 
        !           409:                        goto aa;
        !           410: 
        !           411:        case 'a':
        !           412:        aa:     sflag = size == 0;
        !           413:                if (sflag)
        !           414:                        size = 128;  /* maximum length for s and a */
        !           415:                else
        !           416:                        oincr = size;
        !           417:                for (;;) {
        !           418:                        word.w = getval(addr, 'd', space);
        !           419:                        for (i=0; i<WORDSIZE; i++) {
        !           420:                                if (sflag && word.c[i] == 0) 
        !           421:                                        return(1);
        !           422:                                if (size-- == 0)
        !           423:                                        return(1);
        !           424:                                printchar(word.c[i]);
        !           425:                        }
        !           426:                        addr += WORDSIZE;
        !           427:                }
        !           428:                break;
        !           429: 
        !           430:        case 'i':
        !           431:        case 'I':
        !           432:                value = chkget(dot, space);
        !           433:                if (errflg) {
        !           434:                        printf("%s", errflg);
        !           435:                        errflg = 0;
        !           436:                        return(-1);
        !           437:                }
        !           438:                printins(dfmt, space, value);
        !           439:                break;
        !           440: 
        !           441:        }
        !           442:        return(1);
        !           443: }
        !           444: 
        !           445: /* print variable as in prvar */
        !           446: printit(metaflag, prvar, addr, desc, class, type, size, subflag, space) 
        !           447: u_char class;
        !           448: char *desc; short type; ADDR addr; {
        !           449:        if (prvar == 0)
        !           450:                return;
        !           451:        if (metaflag) {
        !           452:                if (prvar == 1)
        !           453:                        printf("/ ");
        !           454:                else
        !           455:                        printf("= ");
        !           456:        }
        !           457:        if (prvar == 1)
        !           458:                dispf(addr, desc, class, type, size,
        !           459:                        subflag, space);
        !           460:        else
        !           461:                dispf(addr, desc, 0, -1, 0, 0, DSP);
        !           462: }
        !           463: 
        !           464: printchar(c) {
        !           465:        if ((c & 0177) < ' ') 
        !           466:                printf("^%c", c + ('A' - 1));
        !           467:        else if ((c & 0177) == 0177)
        !           468:                printf("^?");
        !           469:        else
        !           470:                printf("%c", c);
        !           471: }
        !           472: 
        !           473: INT fcor;
        !           474: printmap(s,amap)
        !           475: STRING s; MAP *amap;
        !           476: {
        !           477:        int file;
        !           478:        file=amap->ufd;
        !           479:        printf("%s\t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil)));
        !           480:        printf("b1 = 0x%-16x",amap->b1);
        !           481:        printf("e1 = 0x%-16x",amap->e1);
        !           482:        printf("f1 = 0x%-x",amap->f1);
        !           483:        printf("\nb2 = 0x%-16x",amap->b2);
        !           484:        printf("e2 = 0x%-16x",amap->e2);
        !           485:        printf("f2 = 0x%-x",amap->f2);
        !           486:        printf("\n");
        !           487: }
        !           488: 
        !           489: #define NUMREGS 24     /* number of hardware registers */
        !           490: REGLIST reglist[];
        !           491: 
        !           492: printregs()
        !           493: {
        !           494:        REG REGPTR      p;
        !           495: 
        !           496:        for (p=reglist; p < &reglist[NUMREGS/2]; p++) {
        !           497:                printf("%4.4s/  ", p->rname);
        !           498:                prhex12(*(ADDR *)(((ADDR)&u)+p->roffs));
        !           499:                printf("      %4.4s/  ",(p+NUMREGS/2)->rname);
        !           500:                prhex(*(ADDR *)(((ADDR)&u)+(p+NUMREGS/2)->roffs));
        !           501:                printf("\n");
        !           502:        }
        !           503:        printpc();
        !           504: }
        !           505: 
        !           506: printpc()
        !           507: {
        !           508:        dot= *(ADDR *)(((ADDR)&u)+PC);
        !           509:        prisploc();
        !           510:        printins('i',ISP,chkget(dot,ISP));
        !           511:        printf("\n");
        !           512: }
        !           513:        
        !           514: /* print register */
        !           515: REGLIST reglist[];
        !           516: regout(name, prvar, fmt) 
        !           517: char *name, *fmt; {
        !           518:        REG REGPTR p;
        !           519:        for (p=reglist; p< &reglist[24]; p++) {
        !           520:                if (eqstr(name, p->rname)) {
        !           521:                        printit(0, prvar, *(ADDR *)(((ADDR)&u)+p->roffs),
        !           522:                                fmt[0] ? fmt : "d", N_GSYM, -1, 0, 0, DSP);
        !           523:                        return(p->roffs);
        !           524:                }
        !           525:        }
        !           526:        error("Unknown register variable");
        !           527:        return(-1);
        !           528: }
        !           529: /* Print symbolic location of dot */
        !           530: prisploc() {
        !           531:        struct proct *procp;
        !           532:        int lineno;
        !           533: 
        !           534:        printf("0x%x", dot);
        !           535:        procp = adrtoprocp(dot);
        !           536:        if (procp != badproc) {
        !           537:                printf(" (");
        !           538:                prlnoff(procp, dot);
        !           539:                printf("):  \t");
        !           540:        } else
        !           541:                printf(":  \t");
        !           542: }

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