Return to rhash.c CVS log

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

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

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <symbol.h>
        !             4: # include      <access.h>
        !             5: # include      <lock.h>
        !             6: # include      <sccs.h>
        !             7: 
        !             8: SCCSID(@(#)rhash.c     7.2     5/31/83)
        !             9: 
        !            10: /*
        !            11: **  RHASH -- perform a randomizing hash on the full key.
        !            12: **
        !            13: **     Trace Flags:
        !            14: **             26.12-13
        !            15: */
        !            16: 
        !            17: long
        !            18: rhash(d, key)
        !            19: register DESC  *d;
        !            20: char           key[MAXTUP];
        !            21: {
        !            22:        register int    i;
        !            23:        register char   *cp;
        !            24:        long            bucket;
        !            25:        char            tmp;
        !            26:        int             j, *k, knt, numeric;
        !            27: 
        !            28:        bucket = 0;
        !            29:        knt = 0;
        !            30:        for (i = 1; i <= d->reldum.relatts; i++)
        !            31:                if (d->relxtra[i])
        !            32:                {
        !            33:                        /* form pointer to field */
        !            34:                        cp = &key[d->reloff[i]];
        !            35:                        numeric = d->relfrmt[i] != CHAR;
        !            36:                        for (j = 0; j < (d->relfrml[i] & I1MASK); j++)
        !            37:                                if (((tmp = *cp++) != ' ') || numeric)
        !            38:                                        addabyte(tmp, &bucket, knt++);
        !            39:                }
        !            40:        /* remove sign bit from bucket the hard way */
        !            41:        k = &bucket;
        !            42:        *k &= 077777;
        !            43: #      ifdef xATR3
        !            44:        if (tTf(19, 12))
        !            45:                printf("rhash:hval=%ld", bucket);
        !            46: #      endif
        !            47:        bucket %= d->reldum.relprim;
        !            48: #      ifdef xATR3
        !            49:        if (tTf(19, 12))
        !            50:                printf(",returning %ld\n", bucket);
        !            51: #      endif
        !            52:        return (bucket);
        !            53: }
        !            54: /*
        !            55: ** ADDABYTE is used to map a long key into a four byte integer.
        !            56: ** As bytes are added, they are first rotated, then exclusive ored
        !            57: ** into the existing key.
        !            58: */
        !            59: 
        !            60: addabyte(ch, word, knt1)
        !            61: char   ch;
        !            62: long   *word;
        !            63: int    knt1;
        !            64: {
        !            65:        register int    knt;
        !            66:        long            i;
        !            67: 
        !            68:        knt = knt1;
        !            69:        i = ch & 0377;  /*get rid of any sign extension*/
        !            70:        knt += 8 * (knt & 3);   /*alternately add 0, 8, 16 or 24 to knt */
        !            71:        knt &= 037;
        !            72:        *word ^= (i << (knt) | i >> (32 - knt));
        !            73: }

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