Return to step.c CVS log

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

Annotation of 42BSD/ucb/pascal/pdx/process/step.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1982 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)step.c 1.2 2/11/82";
                      4: 
                      5: /*
                      6:  * Continue execution up to the next source line.
                      7:  *
                      8:  * We call "nextaddr" from the machine module to figure out
                      9:  * what the object address is that corresponds to the next source line.
                     10:  * If nextaddr returns -1, then the end of the program has been reached.
                     11:  *
                     12:  * There are two ways to define the next source line depending on what
                     13:  * is desired when a procedure or function call is encountered.  Step
                     14:  * stops at the beginning of the procedure or call; next skips over it.
                     15:  */
                     16: 
                     17: #include "defs.h"
                     18: #include "process.h"
                     19: #include "machine.h"
                     20: #include "breakpoint.h"
                     21: #include "source.h"
                     22: #include "mappings.h"
                     23: #include "process.rep"
                     24: 
                     25: #   if (isvax)
                     26: #       include "machine/vaxops.h"
                     27: 
                     28:        LOCAL ADDRESS getcall();
                     29: #   endif
                     30: 
                     31: /*
                     32:  * Stepc is what is called when the step command is given.
                     33:  * It has to play with the "isstopped" information.
                     34:  */
                     35: 
                     36: stepc()
                     37: {
                     38:     if (!isstopped) {
                     39:        error("can't continue execution");
                     40:     }
                     41:     isstopped = FALSE;
                     42:     dostep(FALSE);
                     43:     isstopped = TRUE;
                     44: }
                     45: 
                     46: next()
                     47: {
                     48:     if (!isstopped) {
                     49:        error("can't continue execution");
                     50:     }
                     51:     isstopped = FALSE;
                     52:     dostep(TRUE);
                     53:     isstopped = TRUE;
                     54: }
                     55: 
                     56: step()
                     57: {
                     58:     dostep(FALSE);
                     59: }
                     60: 
                     61: /*
                     62:  * Resume execution up to the given address.  It is assumed that
                     63:  * no breakpoints exist between the current address and the one
                     64:  * we're stepping to.  This saves us from setting all the breakpoints.
                     65:  */
                     66: 
                     67: stepto(addr)
                     68: ADDRESS addr;
                     69: {
                     70:     setbp(addr);
                     71:     resume();
                     72:     unsetbp(addr);
                     73:     if (!isbperr()) {
                     74:        printstatus();
                     75:     }
                     76: }
                     77: 
                     78: LOCAL dostep(isnext)
                     79: BOOLEAN isnext;
                     80: {
                     81:     register ADDRESS addr;
                     82:     register LINENO line;
                     83:     char *filename;
                     84: 
                     85:     addr = pc;
                     86:     do {
                     87: #       if (isvaxpx)
                     88:            addr = nextaddr(addr, isnext);
                     89: #       else
                     90:            if (isnext && (addr = getcall(addr)) != 0) {
                     91:                stepto(addr);
                     92:            } else {
                     93:                pstep(process);
                     94:                addr = process->pc;
                     95:                pc = process->pc;
                     96:                errnum = process->signo;
                     97:                if (!isbperr()) {
                     98:                    printstatus();
                     99:                }
                    100:            }
                    101: #       endif
                    102:        line = linelookup(addr);
                    103:     } while (line == 0 && !ss_instructions);
                    104:     stepto(addr);
                    105:     curline = line;
                    106: }
                    107: 
                    108: # if (isvax)
                    109: 
                    110: /*
                    111:  * If the current address contains a call instruction, return the
                    112:  * address of the instruction where control will return.
                    113:  *
                    114:  * This function is intentionally dependent on a particular type
                    115:  * of calling sequence.
                    116:  */
                    117: 
                    118: LOCAL ADDRESS getcall(addr)
                    119: ADDRESS addr;
                    120: {
                    121:     VAXOP op;
                    122: 
                    123:     iread(&op, addr, sizeof(addr));
                    124:     if (op == O_CALLS) {
                    125:        return(addr + 7);
                    126:     } else {
                    127:        return(0);
                    128:     }
                    129: }
                    130: 
                    131: # endif

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