Return to db4.c CVS log

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

Annotation of coherent/b/bin/db/db4.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * db/db4.c
        !             3:  * A debugger.
        !             4:  * Breakpoints.
        !             5:  */
        !             6: 
        !             7: #include "db.h"
        !             8: 
        !             9: /*
        !            10:  * Delete a breakpoint.
        !            11:  * If 'r' is set, it is a return breakpoint.
        !            12:  * If 's' is set, it is a :sc breakpoint.
        !            13:  */
        !            14: int
        !            15: bpt_del(t, addr) int t; ADDR_T addr;
        !            16: {
        !            17:        register int f;
        !            18:        register BPT *bp;
        !            19: 
        !            20:        switch (t) {
        !            21:        case 'b':       f = BBPT;       break;
        !            22:        case 'r':       f = BRET;       break;
        !            23:        case 's':       f = BSIN;       break;
        !            24:        }
        !            25: 
        !            26:        for (bp = &bpt[0]; bp < &bpt[NBPT]; bp++) {
        !            27:                if ((bp->b_flag & f) == 0 || bp->b_badd != addr)
        !            28:                        continue;
        !            29:                bp->b_flag &= ~f;
        !            30:                return 1;
        !            31:        }
        !            32:        return 0;
        !            33: }
        !            34: 
        !            35: /*
        !            36:  * Initialize the breakpoint table.
        !            37:  */
        !            38: void
        !            39: bpt_init()
        !            40: {
        !            41:        register BPT *bp;
        !            42: 
        !            43:        for (bp = &bpt[0]; bp < &bpt[NBPT]; bp++) {
        !            44:                bp->b_flag = 0;
        !            45:                bp->b_bcom = bp->b_rcom = NULL;
        !            46:        }
        !            47: }
        !            48: 
        !            49: /*
        !            50:  * Display breakpoints.
        !            51:  */
        !            52: void
        !            53: bpt_display()
        !            54: {
        !            55:        register BPT *bp;
        !            56: 
        !            57:        for (bp = &bpt[0]; bp < &bpt[NBPT]; bp++) {
        !            58:                if (testint())
        !            59:                        return;
        !            60:                if ((bp->b_flag&BBPT) != 0)
        !            61:                        bpt_print(' ', bp->b_badd, bp->b_bcom);
        !            62:                if (testint())
        !            63:                        return;
        !            64:                if ((bp->b_flag&BRET) != 0)
        !            65:                        bpt_print('r', bp->b_badd, bp->b_rcom);
        !            66:                if (testint())
        !            67:                        return;
        !            68:                if ((bp->b_flag&BSIN) != 0)
        !            69:                        bpt_print('s', bp->b_badd, "");
        !            70:        }
        !            71: }
        !            72: 
        !            73: /*
        !            74:  * Print a breakpoint address, type and command.
        !            75:  */
        !            76: void
        !            77: bpt_print(t, addr, cmd) int t; ADDR_T addr; register char *cmd;
        !            78: {
        !            79:        register int c;
        !            80: 
        !            81:        printx(addr_fmt, addr);
        !            82:        printx("%c (", t);
        !            83:        putaddr(ISEG, addr);
        !            84:        printx(") ");
        !            85:        while ((c = *cmd++) != '\0') {
        !            86:                if (c == '\n') {
        !            87:                        printx("\\n");
        !            88:                        continue;
        !            89:                }
        !            90:                if (c == '\\') {
        !            91:                        printx("\\\\");
        !            92:                        continue;
        !            93:                }
        !            94:                putx(c);
        !            95:        }
        !            96:        putx('\n');
        !            97: }
        !            98: 
        !            99: /*
        !           100:  * Set a breakpoint.
        !           101:  */
        !           102: int
        !           103: bpt_set(f, addr, fp, cmd) int f; ADDR_T addr, fp; char *cmd;
        !           104: {
        !           105:        register BPT *bp;
        !           106:        int bits;
        !           107: 
        !           108:        dbprintf(("bpt_set(%d, 0x%lX, 0x%lX, %s)\n", f, addr, fp, cmd));
        !           109: 
        !           110:        /* Make sure "addr" is a valid text address. */
        !           111:        add = addr;
        !           112:        if (getb(ISEG, (char *)&bits, sizeof(bits)) == 0)
        !           113:                return 0;
        !           114: 
        !           115:        /* Look for existing breakpoint at same address. */
        !           116:        for (bp = &bpt[0]; bp < &bpt[NBPT]; bp++)
        !           117:                if (bp->b_flag && bp->b_badd == addr)
        !           118:                        goto out;
        !           119: 
        !           120:        /* Look for unused breakpoint. */
        !           121:        for (bp = &bpt[0]; bp < &bpt[NBPT]; bp++)
        !           122:                if (bp->b_flag == 0)
        !           123:                        goto out;
        !           124:        return 0;
        !           125: 
        !           126: out:
        !           127:        dbprintf(("setting bpt[%d]\n", bp - bpt));
        !           128:        if (f != BBPT && (bp->b_flag&f) != 0)
        !           129:                return 0;               /* already set, ignore */
        !           130:        bp->b_flag |= f;
        !           131:        bp->b_badd = addr;
        !           132:        bp->b_bins[0] = bits & 0xFF;    /* store original contents */
        !           133:        switch (f) {
        !           134:        case BBPT:
        !           135:                bp->b_bcom = save_cmd(bp->b_bcom, cmd);
        !           136:                break;
        !           137:        case BRET:
        !           138:                bp->b_rfpt = fp;
        !           139:                bp->b_rcom = save_cmd(bp->b_rcom, cmd);
        !           140:                break;
        !           141:        case BSIN:
        !           142:                bp->b_sfpt = fp;
        !           143:                break;
        !           144:        }
        !           145:        return 1;
        !           146: }
        !           147: 
        !           148: /* end of db/db4.c */

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