Return to what4.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / refer

Annotation of 43BSD/usr.bin/refer/what4.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char *sccsid = "@(#)what4.c     4.1 (Berkeley) 5/6/83";
        !             3: #endif
        !             4: 
        !             5: #include "what..c"
        !             6: #define NW 5
        !             7: #define ZIPF 10
        !             8: #define HASHF 3
        !             9: #define WLEN 10
        !            10: #define SAME 0
        !            11: #define TSIZE HASHF*ZIPF*NW
        !            12: #define NF 10
        !            13: 
        !            14: struct wst { 
        !            15:        char *tx; 
        !            16:        int ct; 
        !            17: } 
        !            18: ;
        !            19: int HSIZE;
        !            20: static struct wst word[TSIZE];
        !            21: static char tbuf[NW*ZIPF*WLEN], *tp tbuf;
        !            22: 
        !            23: freqwd ( fn, wd, nin )
        !            24: char *fn[], *wd[];
        !            25: {
        !            26:        FILE *fi[NF];
        !            27:        int nw 0, i, any, nf, j, wexch(), wcomp();
        !            28:        char tw[20];
        !            29:        for(HSIZE=TSIZE; !prime(HSIZE); HSIZE--);
        !            30:        for(nf=0; fn[nf] && nf<NF; nf++)
        !            31:                fi[nf] = fn[nf][0] ? fopen(fn[nf], "r") : NULL;
        !            32:        do {
        !            33:                any=0;
        !            34:                for(i=0; i<nf; i++)
        !            35:                {
        !            36:                        if (fi[i]==NULL) continue;
        !            37:                        if (gw(fi[i], tw)==0)
        !            38:                        {
        !            39:                                fclose(fi[i]);
        !            40:                                fi[i]==NULL;
        !            41:                                continue;
        !            42:                        }
        !            43:                        any=1;
        !            44:                        if (common(tw)) continue;
        !            45:                        if (strlen(tw)<3) continue;
        !            46:                        j = lookup (tw);
        !            47:                        if (j<0 && nw < ZIPF*NW)
        !            48:                        {
        !            49:                                j = -j;
        !            50:                                strcpy (tp, tw);
        !            51:                                word[j].tx = tp;
        !            52:                                while (*tp++);
        !            53:                                _assert (tp < tbuf+NW*ZIPF*WLEN);
        !            54:                                word[j].ct = 1;
        !            55:                                nw++;
        !            56:                        }
        !            57:                        else if (j>0)
        !            58:                                word[j].ct++;
        !            59:                }
        !            60:        } 
        !            61:        while (any>0);
        !            62:        shell ( TSIZE, wcomp, wexch );
        !            63:        for(nw=0; word[nw].ct >0 && nw<TSIZE; nw++)
        !            64:                if (nw>=nin*2 && word[nw].ct != word[0].ct)
        !            65:                        break;
        !            66:        for(i=0; i<nw; i++)
        !            67:                wd[i] = word[i].tx;
        !            68:        return(nw);
        !            69: }
        !            70: 
        !            71: lookup (wt)
        !            72: char *wt;
        !            73: {
        !            74:        int h;
        !            75:        h = hash(wt);
        !            76:        for( h = h%HSIZE; word[h].tx; h = (h+1)%HSIZE)
        !            77:        {
        !            78:                if (h==0) continue;
        !            79:                if (strcmp(wt, word[h].tx) == SAME)
        !            80:                        return (h);
        !            81:        }
        !            82:        return ( -h );
        !            83: }
        !            84: 
        !            85: hash (s)
        !            86: char *s;
        !            87: {
        !            88:        int k 0, c 0, i 0;
        !            89:        while ( c = *s++ )
        !            90:                k ^= (c << (i++%5) );
        !            91:        return (k>0 ? k : -k);
        !            92: }
        !            93: 
        !            94: gw (f, t)
        !            95: char *t;
        !            96: FILE *f;
        !            97: {
        !            98:        int start 1, oldc ' ', c;
        !            99:        if (f==NULL) return (0);
        !           100:        while ( (c=getc(f)) != EOF)
        !           101:        {
        !           102:                if (isupper(c)) c= tolower(c);
        !           103:                if (start==1)
        !           104:                        if (!alphanum(c, oldc))
        !           105:                                continue;
        !           106:                        else
        !           107:                                start=0;
        !           108:                if (start==0)
        !           109:                        if (alphanum(c, oldc))
        !           110:                                *t++ = c;
        !           111:                        else
        !           112:                        {
        !           113:                                *t=0;
        !           114:                                return(1);
        !           115:                        }
        !           116:                oldc=c;
        !           117:        }
        !           118:        return(0);
        !           119: }
        !           120: 
        !           121: alphanum( c, oldc )
        !           122: {
        !           123:        if (isalpha(c) || isdigit(c)) return(1);
        !           124:        if (isalpha(oldc))
        !           125:                if (c== '\'' || c == '-') return(1);
        !           126:        return(0);
        !           127: }
        !           128: 
        !           129: wcomp (n1, n2)
        !           130: {
        !           131:        return (word[n1].ct >= word[n2].ct);
        !           132: }
        !           133: 
        !           134: wexch (n1, n2)
        !           135: {
        !           136:        struct wst tt;
        !           137:        tt.tx = word[n1].tx; 
        !           138:        tt.ct = word[n1].ct;
        !           139:        word[n1].tx = word[n2].tx; 
        !           140:        word[n1].ct = word[n2].ct;
        !           141:        word[n2].tx = tt.tx; 
        !           142:        word[n2].ct = tt.ct;
        !           143: }
        !           144: 
        !           145: prime(n)
        !           146: {
        !           147:        /* only executed once- slow is ok */
        !           148:        int i;
        !           149:        if (n%2==0) return(0);
        !           150:        for(i=3; i*i<=n; i+= 2)
        !           151:                if (n%i ==0 ) return(0);
        !           152:        return(1);
        !           153: }
        !           154: 
        !           155: trimnl(s)
        !           156: char *s;
        !           157: {
        !           158:        while (*s)s++;
        !           159:        if (*--s=='\n') *s=0;
        !           160: }
        !           161: 
        !           162: /* this is the test for what4.c as a standalone prog ... */
        !           163: # ifdef 0
        !           164: main (argc, argv)
        !           165: char *argv[];
        !           166: {
        !           167:        char *ff[10], *wd[20], **ffp ff;
        !           168:        int n, i;
        !           169: 
        !           170:        while (--argc)
        !           171:                *ffp++ = *++argv;
        !           172:        *ffp=0;
        !           173:        n=freqwd(ff,wd);
        !           174:        for(i=0; i<n; i++)
        !           175:                printf("%s\n",wd[i]);
        !           176:        printf("total of %d items\n",n);
        !           177: }
        !           178: # endif 0

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