Return to address.c CVS log

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

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

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