Return to step.c CVS log

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

Annotation of 43BSD/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.1 (Berkeley) 6/6/85";
        !             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: #   if (isvax)
        !            31: #       include "machine/vaxops.h"
        !            32: 
        !            33:        LOCAL ADDRESS getcall();
        !            34: #   endif
        !            35: 
        !            36: /*
        !            37:  * Stepc is what is called when the step command is given.
        !            38:  * It has to play with the "isstopped" information.
        !            39:  */
        !            40: 
        !            41: stepc()
        !            42: {
        !            43:     if (!isstopped) {
        !            44:        error("can't continue execution");
        !            45:     }
        !            46:     isstopped = FALSE;
        !            47:     dostep(FALSE);
        !            48:     isstopped = TRUE;
        !            49: }
        !            50: 
        !            51: next()
        !            52: {
        !            53:     if (!isstopped) {
        !            54:        error("can't continue execution");
        !            55:     }
        !            56:     isstopped = FALSE;
        !            57:     dostep(TRUE);
        !            58:     isstopped = TRUE;
        !            59: }
        !            60: 
        !            61: step()
        !            62: {
        !            63:     dostep(FALSE);
        !            64: }
        !            65: 
        !            66: /*
        !            67:  * Resume execution up to the given address.  It is assumed that
        !            68:  * no breakpoints exist between the current address and the one
        !            69:  * we're stepping to.  This saves us from setting all the breakpoints.
        !            70:  */
        !            71: 
        !            72: stepto(addr)
        !            73: ADDRESS addr;
        !            74: {
        !            75:     setbp(addr);
        !            76:     resume();
        !            77:     unsetbp(addr);
        !            78:     if (!isbperr()) {
        !            79:        printstatus();
        !            80:     }
        !            81: }
        !            82: 
        !            83: LOCAL dostep(isnext)
        !            84: BOOLEAN isnext;
        !            85: {
        !            86:     register ADDRESS addr;
        !            87:     register LINENO line;
        !            88:     char *filename;
        !            89: 
        !            90:     addr = pc;
        !            91:     do {
        !            92: #       if (isvaxpx)
        !            93:            addr = nextaddr(addr, isnext);
        !            94: #       else
        !            95:            if (isnext && (addr = getcall(addr)) != 0) {
        !            96:                stepto(addr);
        !            97:            } else {
        !            98:                pstep(process);
        !            99:                addr = process->pc;
        !           100:                pc = process->pc;
        !           101:                errnum = process->signo;
        !           102:                if (!isbperr()) {
        !           103:                    printstatus();
        !           104:                }
        !           105:            }
        !           106: #       endif
        !           107:        line = linelookup(addr);
        !           108:     } while (line == 0 && !ss_instructions);
        !           109:     stepto(addr);
        !           110:     curline = line;
        !           111: }
        !           112: 
        !           113: # if (isvax)
        !           114: 
        !           115: /*
        !           116:  * If the current address contains a call instruction, return the
        !           117:  * address of the instruction where control will return.
        !           118:  *
        !           119:  * This function is intentionally dependent on a particular type
        !           120:  * of calling sequence.
        !           121:  */
        !           122: 
        !           123: LOCAL ADDRESS getcall(addr)
        !           124: ADDRESS addr;
        !           125: {
        !           126:     VAXOP op;
        !           127: 
        !           128:     iread(&op, addr, sizeof(addr));
        !           129:     if (op == O_CALLS) {
        !           130:        return(addr + 7);
        !           131:     } else {
        !           132:        return(0);
        !           133:     }
        !           134: }
        !           135: 
        !           136: # endif

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