Return to rlook.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / ratfor

Annotation of 40BSD/cmd/ratfor/rlook.c, revision 1.1

1.1     ! root        1: #define NULL 0
        !             2: #define EOS 0
        !             3: #define        HSHSIZ  101
        !             4: struct nlist {
        !             5:        char    *name;
        !             6:        char    *def;
        !             7:        int     ydef;
        !             8:        struct  nlist *next;
        !             9: };
        !            10: 
        !            11: struct nlist   *hshtab[HSHSIZ];
        !            12: struct nlist   *lookup();
        !            13: char   *install();
        !            14: char   *malloc();
        !            15: char   *copy();
        !            16: int    hshval;
        !            17: 
        !            18: struct nlist *lookup(str)
        !            19: char *str;
        !            20: {
        !            21:        register char *s1, *s2;
        !            22:        register struct nlist *np;
        !            23:        static struct nlist nodef;
        !            24: 
        !            25:        s1 = str;
        !            26:        for (hshval = 0; *s1; )
        !            27:                hshval += *s1++;
        !            28:        hshval %= HSHSIZ;
        !            29:        for (np = hshtab[hshval]; np!=NULL; np = np->next) {
        !            30:                s1 = str;
        !            31:                s2 = np->name;
        !            32:                while (*s1++ == *s2)
        !            33:                        if (*s2++ == EOS)
        !            34:                                return(np);
        !            35:        }
        !            36:        return(&nodef);
        !            37: }
        !            38: 
        !            39: char *install(nam, val, tran)
        !            40: char *nam, *val;
        !            41: int tran;
        !            42: {
        !            43:        register struct nlist *np;
        !            44: 
        !            45:        if ((np = lookup(nam))->name == NULL) {
        !            46:                np = (struct nlist *)malloc(sizeof(*np));
        !            47:                np->name = copy(nam);
        !            48:                np->def = copy(val);
        !            49:                np->ydef = tran;
        !            50:                np->next = hshtab[hshval];
        !            51:                hshtab[hshval] = np;
        !            52:                return(np->def);
        !            53:        }
        !            54:        free(np->def);
        !            55:        np->def = copy(val);
        !            56:        return(np->def);
        !            57: }
        !            58: 
        !            59: char *copy(s)
        !            60: register char *s;
        !            61: {
        !            62:        register char *p, *s1;
        !            63: 
        !            64:        p = s1 = (char *) malloc((unsigned)strlen(s)+1);
        !            65:        while (*s1++ = *s++);
        !            66:        return(p);
        !            67: }

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