Return to print.c CVS log

Up to [Research Unix] / researchv9 / cmd / adb / comm

Annotation of researchv9/cmd/adb/comm/print.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *
        !             3:  *     UNIX debugger
        !             4:  *
        !             5:  */
        !             6: #include "defs.h"
        !             7: #include "regs.h"
        !             8: #include "sym.h"
        !             9: #include "bkpt.h"
        !            10: #include "map.h"
        !            11: #include "space.h"
        !            12: 
        !            13: extern int     infile;
        !            14: extern int     outfile;
        !            15: extern int     maxpos;
        !            16: extern int     radix;
        !            17: extern char    lastc;
        !            18: extern int     maxargs;
        !            19: 
        !            20: /* general printing routines ($) */
        !            21: 
        !            22: char   *Ipath = "/usr/lib/adb";
        !            23: 
        !            24: printtrace(modif)
        !            25: {
        !            26:        int     i;
        !            27:        register BKPT *bk;
        !            28:        register struct sym *sp;
        !            29:        int     stack;
        !            30:        char    *fname;
        !            31:        char    *getfname();
        !            32: 
        !            33:        if (cntflg==0)
        !            34:                cntval = -1;
        !            35:        switch (modif) {
        !            36: 
        !            37:        case '<':
        !            38:                if (cntval == 0) {
        !            39:                        while (readchar() != EOR)
        !            40:                                ;
        !            41:                        reread();
        !            42:                        break;
        !            43:                }
        !            44:                if (rdc() == '<')
        !            45:                        stack = 1;
        !            46:                else {
        !            47:                        stack = 0;
        !            48:                        reread();
        !            49:                }
        !            50:                fname = getfname();
        !            51:                redirin(stack, fname);
        !            52:                break;
        !            53: 
        !            54:        case '>':
        !            55:                fname = getfname();
        !            56:                redirout(fname);
        !            57:                break;
        !            58: 
        !            59:        case 'p':
        !            60:                kmproc();
        !            61:                break;
        !            62: 
        !            63:        case 'k':
        !            64:                kmsys();
        !            65:                break;
        !            66: 
        !            67:        case 'd':
        !            68:                if (adrflg) {
        !            69:                        if (adrval != 0
        !            70:                        &&  (adrval<2 || adrval>16))
        !            71:                                error("radix should be between 2 and 16, or 0");
        !            72:                        radix = adrval;
        !            73:                        if (radix)
        !            74:                                printf("radix=%d base ten",radix);
        !            75:                        else
        !            76:                                printf("radix=magic");
        !            77:                }
        !            78:                break;
        !            79: 
        !            80:        case 'q':
        !            81:        case 'Q':
        !            82:                done();
        !            83: 
        !            84:        case 'w':
        !            85:                maxpos=(adrflg?adrval:MAXPOS);
        !            86:                break;
        !            87: 
        !            88:        case 'S':
        !            89:                printsym();
        !            90:                break;
        !            91: 
        !            92:        case 's':
        !            93:                maxoff=(adrflg?adrval:MAXOFF);
        !            94:                break;
        !            95: 
        !            96:        case 'v':
        !            97:                for (i=0;i<NVARS;i++) {
        !            98:                        if (var[i])
        !            99:                                printf("%-8R >%c\n", var[i],
        !           100:                                        (i<=9 ? '0' : 'a'-10) + i);
        !           101:                }
        !           102:                break;
        !           103: 
        !           104:        case 'm':
        !           105:                printmap("? map", symmap);
        !           106:                printmap("/ map", cormap);
        !           107:                break;
        !           108: 
        !           109:        case 0:
        !           110:        case '?':
        !           111:                if (pid)
        !           112:                        printf("pcs id = %d\n",pid);
        !           113:                else
        !           114:                        prints("no process\n");
        !           115:                sigprint();
        !           116:                flushbuf();
        !           117: 
        !           118:        case 'r':
        !           119:        case 'R':
        !           120:                printregs(modif);
        !           121:                return;
        !           122: 
        !           123:        case 'c':
        !           124:        case 'C':
        !           125:                ctrace(modif);
        !           126:                break;
        !           127: 
        !           128:        case 'a':
        !           129:                if (adrflg)
        !           130:                        maxargs = adrval;
        !           131:                else
        !           132:                        printf("%R$a\n", maxargs);
        !           133:                return;
        !           134: 
        !           135:                /*print externals*/
        !           136:        case 'e':
        !           137:                for (sp = symtab; sp; sp = sp->y_next) {
        !           138:                        if (sp->y_type==S_DATA)
        !           139:                                printf("%s/%12t%R\n", sp->y_name,
        !           140:                                        ltow(lget(sp->y_value,CORF|DATASP)));
        !           141:                }
        !           142:                break;
        !           143: 
        !           144:                /*print breakpoints*/
        !           145:        case 'b':
        !           146:        case 'B':
        !           147:                for (bk=bkpthead; bk; bk=bk->nxtbkpt)
        !           148:                        if (bk->flag) {
        !           149:                                psymoff((WORD)bk->loc,INSTSP,"");
        !           150:                                if (bk->count != 1)
        !           151:                                        printf(",%d", bk->count);
        !           152:                                printf(":%c %s", bk->flag == BKPTTMP ? 'B' : 'b', bk->comm);
        !           153:                        }
        !           154:                break;
        !           155: 
        !           156:        default:
        !           157:                error("bad `$' command");
        !           158:        }
        !           159: 
        !           160: }
        !           161: 
        !           162: static
        !           163: char *
        !           164: getfname()
        !           165: {
        !           166:        static char fname[ARB];
        !           167:        register char *p;
        !           168: 
        !           169:        if (rdc() == EOR) {
        !           170:                reread();
        !           171:                return (NULL);
        !           172:        }
        !           173:        p = fname;
        !           174:        do {
        !           175:                *p++ = lastc;
        !           176:                if (p >= &fname[ARB-1])
        !           177:                        error("filename too long");
        !           178:        } while (rdc() != EOR);
        !           179:        *p = 0;
        !           180:        reread();
        !           181:        return (fname);
        !           182: }
        !           183: 
        !           184: static
        !           185: redirin(stack, file)
        !           186: int stack;
        !           187: char *file;
        !           188: {
        !           189:        char pfile[ARB];
        !           190: 
        !           191:        if (file == NULL) {
        !           192:                iclose(-1, 0);
        !           193:                return;
        !           194:        }
        !           195:        iclose(stack, 0);
        !           196:        if ((infile = open(file, 0)) < 0) {
        !           197:                strcpy(pfile, Ipath);
        !           198:                strcat(pfile, "/");
        !           199:                strcat(pfile, file);
        !           200:                if ((infile = open(pfile, 0)) < 0) {
        !           201:                        infile = STDIN;
        !           202:                        error("cannot open");
        !           203:                }
        !           204:        }
        !           205:        if (cntflg)
        !           206:                var[9] = cntval;
        !           207:        else
        !           208:                var[9] = 1;
        !           209: }
        !           210: 
        !           211: static
        !           212: redirout(file)
        !           213: char *file;
        !           214: {
        !           215: 
        !           216:        oclose();
        !           217:        if (file == NULL)
        !           218:                return;
        !           219:        if ((outfile = open(file, 1)) >= 0)
        !           220:                lseek(outfile, 0L, 2);
        !           221:        else if ((outfile = creat(file, 0666)) < 0) {
        !           222:                outfile = STDOUT;
        !           223:                error("cannot create");
        !           224:        }
        !           225: }
        !           226: 
        !           227: printmap(s,mp)
        !           228: char *s;
        !           229: register MAP *mp;
        !           230: {
        !           231:        char *maptype();
        !           232: 
        !           233:        if (mp == symmap)
        !           234:                printf("%s%12t`%s'\n", s, fsym < 0 ? "-" : symfil);
        !           235:        else if (mp == cormap)
        !           236:                printf("%s%12t`%s'\n", s, fcor < 0 ? "-" : corfil);
        !           237:        else
        !           238:                printf("%s\n", s);
        !           239:        for (; mp->flag & MPINUSE; mp++)
        !           240:                printf("%-8s b = %-16Re = %-16Rf = %-16R\n",
        !           241:                    maptype(mp->sp), (WORD)mp->b, (WORD)mp->e, (WORD)mp->f);
        !           242: }
        !           243: 
        !           244: char *
        !           245: maptype(sp)
        !           246: int sp;
        !           247: {
        !           248: 
        !           249:        switch (sp & SPTYPE) {
        !           250:        case INSTSP:
        !           251:                return ("text");
        !           252:        case DATASP:
        !           253:                return ("data");
        !           254:        case UBLKSP:
        !           255:                return ("user");
        !           256:        default:
        !           257:                return ("nonsense");
        !           258:        }
        !           259: }

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