Return to hashlook.c CVS log

Up to [Research Unix] / researchv8dc / cmd / spell

Annotation of researchv8dc/cmd/spell/hashlook.c, revision 1.1

1.1     ! root        1: /*     @(#)hashlook.c  1.4     */
        !             2: #include <stdio.h>
        !             3: #include "hash.h"
        !             4: #include "huff.h"
        !             5: 
        !             6: unsigned *table;
        !             7: unsigned short index[NI];
        !             8: 
        !             9: #define B (BYTE*sizeof(unsigned))
        !            10: #define L (BYTE*sizeof(long)-1)
        !            11: #define MASK (~(1L<<L))
        !            12: 
        !            13: #ifdef pdp11   /*sizeof(unsigned)==sizeof(long)/2 */
        !            14: #define fetch(wp,bp)\
        !            15:        (((((long)wp[0]<<B)|wp[1])<<(B-bp))|(wp[2]>>bp))
        !            16: #else          /*sizeof(unsigned)==sizeof(long)*/
        !            17: #define fetch(wp,bp) (bp==B?wp[0]:((wp[0]<<(B-bp))|(wp[1]>>bp)))
        !            18: #endif
        !            19: 
        !            20: hashlook(s)
        !            21: char *s;
        !            22: {
        !            23:        long h;
        !            24:        long t;
        !            25:        register bp;
        !            26:        register unsigned *wp;
        !            27:        int i;
        !            28:        long sum;
        !            29:        unsigned *tp;
        !            30: 
        !            31:        h = hash(s);
        !            32:        t = h>>(HASHWIDTH-INDEXWIDTH);
        !            33:        wp = &table[index[t]];
        !            34:        tp = &table[index[t+1]];
        !            35:        bp = B;
        !            36:        sum = (long)t<<(HASHWIDTH-INDEXWIDTH);
        !            37:        for(;;) {
        !            38:                {/*     this block is equivalent to
        !            39:                         bp -= decode((fetch(wp,bp)>>1)&MASK, &t);*/
        !            40:                        long y;
        !            41:                        long v;
        !            42:                        y = (fetch(wp,bp)>>1) & MASK;
        !            43:                        if(y < cs) {
        !            44:                                t = y >> (L+1-w);
        !            45:                                bp -= w-1;
        !            46:                        }
        !            47:                        else {
        !            48:                                for(bp-=w,v=v0; y>=qcs; y=(y<<1)&MASK,v+=n)
        !            49:                                        bp -= 1;
        !            50:                                t = v + (y>>(L-w));
        !            51:                        }
        !            52:                }
        !            53:                while(bp<=0) {
        !            54:                        bp += B;
        !            55:                        wp++;
        !            56:                }
        !            57:                if(wp>=tp&&(wp>tp||bp<B))
        !            58:                        return(0);
        !            59:                sum += t;
        !            60:                if(sum<h)
        !            61:                        continue;
        !            62:                return(sum==h);
        !            63:        }
        !            64: }
        !            65: 
        !            66: 
        !            67: prime(argc,argv)
        !            68: char **argv;
        !            69: {
        !            70:        register FILE *f;
        !            71:        register fd;
        !            72:        extern char *malloc();
        !            73:        if(argc <= 1)
        !            74:                return(0);
        !            75: #ifndef pdp11
        !            76:        if(sizeof(long) > sizeof(unsigned))
        !            77:                abort();        /*wrong fetch macro*/
        !            78: #endif
        !            79: #ifdef pdp11   /* because of insufficient address space for buffers*/
        !            80:        fd = dup(0);
        !            81:        close(0);
        !            82:        if(open(argv[1], 0) != 0)
        !            83:                return(0);
        !            84:        f = stdin;
        !            85:        if(rhuff(f)==0
        !            86:        || read(fileno(f), (char *)index, NI*sizeof(*index)) != NI*sizeof(*index)
        !            87:        || (table = (unsigned*)malloc(index[NI-1]*sizeof(*table))) == 0
        !            88:        || read(fileno(f), (char*)table, sizeof(*table)*index[NI-1])
        !            89:           != index[NI-1]*sizeof(*table))
        !            90:                return(0);
        !            91:        close(0);
        !            92:        if(dup(fd) != 0)
        !            93:                return(0);
        !            94:        close(fd);
        !            95: #else
        !            96:        if((f = fopen(argv[1], "ri")) == NULL)
        !            97:                return(0);
        !            98:        if(rhuff(f)==0
        !            99:        || fread((char*)index, sizeof(*index),  NI, f) != NI
        !           100:        || (table = (unsigned*)malloc(index[NI-1]*sizeof(*table))) == 0
        !           101:        || fread((char*)table, sizeof(*table), index[NI-1], f)
        !           102:           != index[NI-1])
        !           103:                return(0);
        !           104:        fclose(f);
        !           105: #endif
        !           106:        hashinit();
        !           107:        return(1);
        !           108: }

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