Return to step.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / pdx / process

Annotation of 43BSDTahoe/ucb/pascal/pdx/process/step.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)step.c     5.2 (Berkeley) 4/7/87";
        !             9: #endif not lint
        !            10: /*
        !            11:  * Continue execution up to the next source line.
        !            12:  *
        !            13:  * We call "nextaddr" from the machine module to figure out
        !            14:  * what the object address is that corresponds to the next source line.
        !            15:  * If nextaddr returns -1, then the end of the program has been reached.
        !            16:  *
        !            17:  * There are two ways to define the next source line depending on what
        !            18:  * is desired when a procedure or function call is encountered.  Step
        !            19:  * stops at the beginning of the procedure or call; next skips over it.
        !            20:  */
        !            21: 
        !            22: #include "defs.h"
        !            23: #include "process.h"
        !            24: #include "machine.h"
        !            25: #include "breakpoint.h"
        !            26: #include "source.h"
        !            27: #include "mappings.h"
        !            28: #include "process.rep"
        !            29: 
        !            30: /*
        !            31:  * Stepc is what is called when the step command is given.
        !            32:  * It has to play with the "isstopped" information.
        !            33:  */
        !            34: 
        !            35: stepc()
        !            36: {
        !            37:     if (!isstopped) {
        !            38:        error("can't continue execution");
        !            39:     }
        !            40:     isstopped = FALSE;
        !            41:     dostep(FALSE);
        !            42:     isstopped = TRUE;
        !            43: }
        !            44: 
        !            45: next()
        !            46: {
        !            47:     if (!isstopped) {
        !            48:        error("can't continue execution");
        !            49:     }
        !            50:     isstopped = FALSE;
        !            51:     dostep(TRUE);
        !            52:     isstopped = TRUE;
        !            53: }
        !            54: 
        !            55: step()
        !            56: {
        !            57:     dostep(FALSE);
        !            58: }
        !            59: 
        !            60: /*
        !            61:  * Resume execution up to the given address.  It is assumed that
        !            62:  * no breakpoints exist between the current address and the one
        !            63:  * we're stepping to.  This saves us from setting all the breakpoints.
        !            64:  */
        !            65: 
        !            66: stepto(addr)
        !            67: ADDRESS addr;
        !            68: {
        !            69:     setbp(addr);
        !            70:     resume();
        !            71:     unsetbp(addr);
        !            72:     if (!isbperr()) {
        !            73:        printstatus();
        !            74:     }
        !            75: }
        !            76: 
        !            77: LOCAL dostep(isnext)
        !            78: BOOLEAN isnext;
        !            79: {
        !            80:     register ADDRESS addr;
        !            81:     register LINENO line;
        !            82: 
        !            83:     addr = pc;
        !            84:     do {
        !            85:        addr = nextaddr(addr, isnext);
        !            86:        line = linelookup(addr);
        !            87:     } while (line == 0 && !ss_instructions);
        !            88:     stepto(addr);
        !            89:     curline = line;
        !            90: }

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