Return to trace.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / lisp

Annotation of 40BSD/cmd/lisp/trace.c, revision 1.1

1.1     ! root        1: static char *sccsid = "@(#)trace.c     34.1 10/3/80";
        !             2: 
        !             3: #include "global.h"
        !             4: lispval
        !             5: Leval1(){
        !             6:     register struct nament *bindptr;
        !             7:     register lispval handy;
        !             8:     snpand(2);
        !             9:     if (np-lbot == 2) {        /*if two arguments to eval */
        !            10:        if (TYPE((lbot+1)->val) != INT)
        !            11:            error("Eval: 2nd arg not legal alist pointer", FALSE);
        !            12:        bindptr = orgbnp + (lbot+1)->val->i;
        !            13:        if (rsetsw == 0 || rsetatom->a.clb == nil)
        !            14:            error("Not in *rsetmode; second arg is useless - eval", TRUE);
        !            15:        if (bptr_atom->a.clb != nil)
        !            16:            error("WARNING - Nesting 2nd args to eval will give spurious values", TRUE);
        !            17:        if (bindptr < orgbnp || bindptr >bnplim)
        !            18:            error("Illegal pdl pointer as 2nd arg - eval", FALSE);
        !            19:        handy = newdot();
        !            20:        handy->d.car = (lispval)bindptr;
        !            21:        handy->d.cdr = (lispval)bnp;
        !            22:        PUSHDOWN(bptr_atom, handy); 
        !            23:        handy = eval(lbot->val);
        !            24:        POP;
        !            25:        return(handy);
        !            26:     } else {   /* normal case - only one arg */
        !            27:        chkarg(1,"eval");
        !            28:        handy = eval(lbot->val);
        !            29:        return(handy);
        !            30:     };
        !            31: }
        !            32: 
        !            33: lispval
        !            34: Levalhook()
        !            35: {
        !            36:     register lispval handy;
        !            37:     snpand(1);
        !            38:     chkarg(2,"evalhook");
        !            39:     if (evalhsw == 0) 
        !            40:            error("evalhook called before doing sstatus-evalhook", TRUE);
        !            41:     if (rsetsw == 0 || rsetatom->a.clb == nil)
        !            42:            error("evalhook called while not in *rset mode", TRUE);
        !            43:     PUSHDOWN(evalhatom,(lispval)(lbot+1)->val);
        !            44:     /* eval checks evalhcall to see if this is a LISP call to evalhook
        !            45:        in which case it avoids call to evalhook function, but clobbers
        !            46:        value to nil so recursive calls will check.  */
        !            47:     PUSHDOWN(evalhcall,tatom);
        !            48:     handy = eval(lbot->val);
        !            49:     POP;
        !            50:     POP;
        !            51:     return(handy);
        !            52: }
        !            53: 
        !            54: lispval
        !            55: Lrset ()
        !            56:     {
        !            57:     chkarg(1,"rset");
        !            58: 
        !            59:     rsetsw = (lbot->val == nil) ? 0 : 1;
        !            60:     rsetatom->a.clb = (lbot->val == nil) ? nil: tatom;
        !            61:     return(lbot->val);
        !            62: }
        !            63: 

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