Return to inv6.c CVS log

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

Annotation of 42BSD/usr.bin/refer/inv6.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char *sccsid = "@(#)inv6.c      4.1 (Berkeley) 5/6/83";
                      3: #endif
                      4: 
                      5: #include <stdio.h>
                      6: #include <assert.h>
                      7: 
                      8: whash(ft, fa, fb, nhash, iflong, ptotct, phused)
                      9: FILE *fa, *fb, *ft;
                     10: int nhash, *phused;
                     11: long *ptotct;
                     12: {
                     13:        char line[100];
                     14:        int hash = 0, hused = 0;
                     15:        long totct = 0L;
                     16:        int ct = 0;
                     17:        long point;
                     18:        long opoint = -1;
                     19:        int m;
                     20:        int k; 
                     21:        long lp;
                     22:        long *hpt;
                     23:        int *hfreq = NULL;
                     24: 
                     25:        hpt = calloc (nhash+1, sizeof(*hpt));
                     26:        _assert (hpt != NULL);
                     27:        hfreq = calloc (nhash, sizeof(*hfreq));
                     28:        _assert (hfreq !=NULL);
                     29:        hpt[0] = 0;
                     30:        lp= 0;
                     31:        while (fgets(line, 100, ft))
                     32:        {
                     33:                totct++;
                     34:                sscanf(line, "%d %ld", &k, &point);
                     35:                if (hash < k)
                     36:                {
                     37:                        hused++;
                     38:                        if (iflong) putl(-1L, fb); 
                     39:                        else putw(-1, fb);
                     40:                        hfreq[hash]=ct;
                     41:                        while (hash<k)
                     42:                        {
                     43:                                hpt[++hash] = lp;
                     44:                                hfreq[hash] = 0;
                     45:                        }
                     46:                        hpt[hash] = lp += iflong? sizeof(long) : sizeof(int);
                     47:                        opoint= -1;
                     48:                        ct=0;
                     49:                }
                     50:                if (point!=opoint)
                     51:                {
                     52:                        if (iflong)
                     53:                                putl(opoint=point, fb);
                     54:                        else
                     55:                                putw( (int)(opoint=point), fb);
                     56:                        lp += iflong? sizeof(long) : sizeof(int);
                     57:                        ct++;
                     58:                }
                     59:        }
                     60:        if (iflong) putl(-1L, fb); 
                     61:        else putw(-1,fb);
                     62:        while (hash<nhash)
                     63:                hpt[++hash]=lp;
                     64:        fwrite(&nhash, sizeof(nhash), 1, fa);
                     65:        fwrite(&iflong, sizeof(iflong), 1, fa);
                     66:        fwrite(hpt, sizeof(*hpt), nhash, fa);
                     67:        fwrite (hfreq, sizeof(*hfreq), nhash, fa);
                     68:        *ptotct = totct;
                     69:        *phused = hused;
                     70: }
                     71: 
                     72: putl(ll, f)
                     73: long ll;
                     74: FILE *f;
                     75: {
                     76:        putw(ll, f);
                     77: }
                     78: 
                     79: long
                     80: getl(f)
                     81: FILE *f;
                     82: {
                     83:        return(getw(f));
                     84: }

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