Return to b1com.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bsmall

Annotation of 43BSD/contrib/B/src/bsmall/b1com.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
        !             2: /* $Header: b1com.c,v 1.1 84/06/28 00:49:03 timo Exp $ */
        !             3: 
        !             4: /************************************************************************/
        !             5: /* B compounds                                                          */
        !             6: /* plus Hows Funs and other odd types that don't fit anywhere else      */
        !             7: /*                                                                      */
        !             8: /* A compound is modelled as a sequence of len values, its fields.      */
        !             9: /*                                                                      */
        !            10: /************************************************************************/
        !            11: 
        !            12: #include "b.h"
        !            13: #include "b1obj.h"
        !            14: 
        !            15: Visible value* field(v, k) value v; intlet k; { /* k in {0..size-1}; no copy */
        !            16:        return (value *) Field(v, k);
        !            17: }
        !            18: 
        !            19: Visible Procedure put_in_field(v, c, i) value v, *c; intlet i; {
        !            20:        /*Note that no copy of v is made: the caller must do this*/
        !            21:        *(Ats(*c)+i)= v;
        !            22: }
        !            23: 
        !            24: /* Other types */
        !            25: Visible loc mk_simploc(id, en) basidf id; env en; {
        !            26:        loc l= grab_sim();
        !            27:        (*Ats(l))= copy(id); (*(Ats(l)+1))= (value) en;
        !            28:        return l;
        !            29: }
        !            30: 
        !            31: Visible loc mk_trimloc(R, B, C) loc R; intlet B, C; {
        !            32:        loc l= grab_tri(); trimloc *ll= (trimloc *)Ats(l);
        !            33:        ll->R= copy(R); ll->B= B; ll->C= C;
        !            34:        return l;
        !            35: }
        !            36: 
        !            37: Visible loc mk_tbseloc(R, K) loc R; value K; {
        !            38:        loc l= grab_tse(); tbseloc *ll= (tbseloc *)Ats(l);
        !            39:        ll->R= copy(R); ll->K= copy(K);
        !            40:        return l;
        !            41: }
        !            42: 
        !            43: Visible fun mk_fun(L, H, adic, def, fux, lux, reftab, filed)
        !            44:  intlet L, H; literal adic, def; txptr fux, lux; value reftab; bool filed; {
        !            45:        fun f= grab_fun(); funprd *ff= (funprd *)Ats(f);
        !            46:        ff->L= L; ff->H= H; ff->adic= adic; ff->def= def; ff->fux= fux;
        !            47:        ff->lux= lux; ff->reftab= reftab; ff->filed= filed;
        !            48:        return f;
        !            49: }
        !            50: 
        !            51: Visible prd mk_prd(adic, def, fux, lux, reftab, filed)
        !            52:  literal adic, def; txptr fux, lux; value reftab; bool filed; {
        !            53:        prd p= grab_prd(); funprd *pp= (funprd *)Ats(p);
        !            54:        pp->adic= adic; pp->def= def; pp->fux= fux;
        !            55:        pp->lux= lux; pp->reftab= reftab; pp->filed= filed;
        !            56:        return p;
        !            57: }
        !            58: 
        !            59: Visible value mk_how(fux, lux, reftab, filed)
        !            60:  txptr fux, lux; value reftab; bool filed; {
        !            61:        value h= grab_how(); how *hh= (how *)Ats(h);
        !            62:        hh->fux= fux; hh->lux= lux; hh->reftab= reftab; hh->filed= filed;
        !            63:        return h;
        !            64: }
        !            65: 
        !            66: Visible value mk_ref(rp, rlino) txptr rp; intlet rlino; {
        !            67:        value r= grab_ref();
        !            68:        ((ref *)Ats(r))->rp= rp;
        !            69:        ((ref *)Ats(r))->rlino= rlino;
        !            70:        return r;
        !            71: }
        !            72: 
        !            73: Visible value mk_per(v) value v; {
        !            74:        value p= grab_per();
        !            75:        *Ats(p)= copy(v);
        !            76:        return p;
        !            77: }

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