Return to utility.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ingres / source / iutil

Annotation of 42BSD/ingres/source/iutil/utility.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <access.h>
        !             3: # include      <sccs.h>
        !             4: 
        !             5: SCCSID(@(#)utility.c   7.1     2/5/81)
        !             6: 
        !             7: dumptid(tid)
        !             8: register TID   *tid;
        !             9: {
        !            10:        long    pageid;
        !            11: 
        !            12:        pluck_page(tid, &pageid);
        !            13:        printf("tid: %ld/%d\n", pageid, (tid->line_id & I1MASK));
        !            14:        return (0);
        !            15: }
        !            16: 
        !            17: /*
        !            18: **     struct for extracting page number from a tid
        !            19: **     and storing in a long
        !            20: **
        !            21: **     We want the line number (lpgx) to be in the low-order part of
        !            22: **     a long.  Since PDP's and VAXes have the order of the half-
        !            23: **     words reversed, this structure must be different.
        !            24: */
        !            25: 
        !            26: struct lpage
        !            27: {
        !            28: # ifdef PDP11
        !            29:        char    lpg0, lpgx;
        !            30:        char    lpg2, lpg1;
        !            31: # else
        !            32:        char    lpg2, lpg1, lpg0, lpgx;
        !            33: # endif
        !            34: };
        !            35: /*  PLUCK_PAGE
        !            36: **
        !            37: **     pluck_page extracts the three byte page_id from a TID
        !            38: **     and puts it into a long variable with proper allignment.
        !            39: */
        !            40: 
        !            41: pluck_page(t, var)
        !            42: register TID   *t;
        !            43: long           *var;
        !            44: {
        !            45:        register struct lpage   *v;
        !            46: 
        !            47:        v = (struct lpage *) var;
        !            48:        v->lpg0 = t->pg0;
        !            49:        v->lpg1 = t->pg1;
        !            50:        v->lpg2 = t->pg2;
        !            51:        v->lpgx = 0;
        !            52:        return (0);
        !            53: }
        !            54: 
        !            55: /*     stuff_page is the reverse of pluck_page */
        !            56: stuff_page(t, var)
        !            57: register TID   *t;
        !            58: long           *var;
        !            59: {
        !            60:        register struct lpage   *v;
        !            61: 
        !            62:        v = (struct lpage *) var;
        !            63:        t->pg0 = v->lpg0;
        !            64:        t->pg1 = v->lpg1;
        !            65:        t->pg2 = v->lpg2;
        !            66:        return (0);
        !            67: }

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