Return to print.c CVS log

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

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

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