Return to address.c CVS log

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

Annotation of 42BSD/ucb/pascal/pdx/runtime/address.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1982 Regents of the University of California */
        !             2: 
        !             3: static char sccsid[] = "@(#)address.c 1.2 3/8/82";
        !             4: 
        !             5: /*
        !             6:  * Some machine and runtime dependent manipulation of a symbol.
        !             7:  */
        !             8: 
        !             9: #include "defs.h"
        !            10: #include "runtime.h"
        !            11: #include "sym.h"
        !            12: #include "machine.h"
        !            13: #include "process.h"
        !            14: #include "object.h"
        !            15: #include "mappings.h"
        !            16: #include "sym/classes.h"
        !            17: #include "frame.rep"
        !            18: #include "sym/sym.rep"
        !            19: 
        !            20: /*
        !            21:  * Calculate the address of a symbol.
        !            22:  * If frame is not NIL, then it is the frame associated with the
        !            23:  * activation in which the symbol we're interested in is defined.
        !            24:  */
        !            25: 
        !            26: ADDRESS address(s, frame)
        !            27: register SYM *s;
        !            28: FRAME *frame;
        !            29: {
        !            30:     SYM *f;
        !            31:     FRAME *frp;
        !            32:     ADDRESS r, *dp, *disp;
        !            33:     short offs;
        !            34: 
        !            35:     f = s->func;
        !            36:     if (s->class == FVAR) {
        !            37:        offs = f->symvalue.offset;
        !            38:     } else {
        !            39:        offs = s->symvalue.offset;
        !            40:     }
        !            41:     if (f == program) {
        !            42:        r = (ADDRESS) dispval(MAINBLK) + offs;
        !            43:     } else if (f == curfunc && frame == NIL) {
        !            44:        dp = curdp();
        !            45:        disp = contents(dp);
        !            46:        r = (ADDRESS) disp + offs;
        !            47:     } else {
        !            48:        if (frame == NIL) {
        !            49:            frp = findframe(s->func);
        !            50:            if (frp == NIL) {
        !            51:                panic("address: findframe returned NIL");
        !            52:            }
        !            53:        } else {
        !            54:            frp = frame;
        !            55:        }
        !            56:        r = stkaddr(frp, s->blkno) + offs;
        !            57:     }
        !            58:     return r;
        !            59: }
        !            60: 
        !            61: /*
        !            62:  * The next three routines assume the procedure entry code is
        !            63:  *
        !            64:  *      f:  tra4    A
        !            65:  *          ...
        !            66:  *      A:  beg
        !            67:  *      B:  <code for first line>
        !            68:  *
        !            69:  * Pi gives f, we compute and store A with "findbeginning(f)",
        !            70:  * (retrieved by "codeloc(f)"), B is computed by "firstline(f)".
        !            71:  *
        !            72:  * The procedure "runtofirst" assumes you're at A and want to step to B.
        !            73:  * It should be changed to a nop if A is equal to B.
        !            74:  */
        !            75: 
        !            76: /*
        !            77:  * Find the beginning of a procedure or function.  This is a destructive
        !            78:  * routine, it changes the value associated with the procedure symbol.
        !            79:  * Should only be called once per symbol.
        !            80:  */
        !            81: 
        !            82: findbeginning(f)
        !            83: SYM *f;
        !            84: {
        !            85:     f->symvalue.funcv.codeloc = nextaddr(f->symvalue.funcv.codeloc, FALSE);
        !            86: }
        !            87: 
        !            88: /*
        !            89:  * Find the object code associated with the first line of a block.
        !            90:  */
        !            91: 
        !            92: ADDRESS firstline(f)
        !            93: SYM *f;
        !            94: {
        !            95:     ADDRESS addr;
        !            96: 
        !            97:     addr = codeloc(f);
        !            98:     while (linelookup(addr) == 0) {
        !            99:        if (isendofproc(addr)) {
        !           100:            return -1;
        !           101:        }
        !           102:        addr = nextaddr(addr, FALSE);
        !           103:     }
        !           104:     return addr;
        !           105: }
        !           106: 
        !           107: /*
        !           108:  * Catcher drops strike three ...
        !           109:  */
        !           110: 
        !           111: runtofirst()
        !           112: {
        !           113:     stepto(firstline(curfunc));
        !           114: }
        !           115: 
        !           116: /*
        !           117:  * Calculate the address of the last line in the program.
        !           118:  * This is assumed to be at the physical end.
        !           119:  */
        !           120: 
        !           121: ADDRESS lastaddr()
        !           122: {
        !           123:     if (objsize == 0) {
        !           124:        panic("lastaddr: objsize = 0!");
        !           125:     }
        !           126:     return(objsize - sizeof(short));
        !           127: }

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