Return to utility.c CVS log

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

Annotation of 43BSD/ingres/source/iutil/utility.c, revision 1.1.1.1

1.1       root        1: # include      <ingres.h>
                      2: # include      <access.h>
                      3: # include      <sccs.h>
                      4: 
                      5: SCCSID(@(#)utility.c   8.2     12/8/85)
                      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 SUN's and VAXes have the order of the
                     23: **     words reversed, this structure must be different.
                     24: */
                     25: 
                     26: struct lpage
                     27: {
                     28: # ifdef VAX
                     29:        char    lpg2, lpg1, lpg0, lpgx;
                     30: # else
                     31:        char    lpgx, lpg0, lpg1, lpg2;
                     32: # endif
                     33: };
                     34: /*  PLUCK_PAGE
                     35: **
                     36: **     pluck_page extracts the three byte page_id from a TID
                     37: **     and puts it into a long variable with proper allignment.
                     38: */
                     39: 
                     40: pluck_page(t, var)
                     41: register TID   *t;
                     42: long           *var;
                     43: {
                     44:        register struct lpage   *v;
                     45: 
                     46:        v = (struct lpage *) var;
                     47:        v->lpg0 = t->pg0;
                     48:        v->lpg1 = t->pg1;
                     49:        v->lpg2 = t->pg2;
                     50:        v->lpgx = 0;
                     51:        return (0);
                     52: }
                     53: 
                     54: /*     stuff_page is the reverse of pluck_page */
                     55: stuff_page(t, var)
                     56: register TID   *t;
                     57: long           *var;
                     58: {
                     59:        register struct lpage   *v;
                     60: 
                     61:        v = (struct lpage *) var;
                     62:        t->pg0 = v->lpg0;
                     63:        t->pg1 = v->lpg1;
                     64:        t->pg2 = v->lpg2;
                     65:        return (0);
                     66: }

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