Return to tmputil.c CVS log

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

Annotation of 42BSD/ingres/source/iutil/tmputil.c, revision 1.1.1.1

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

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