Return to lookup.c CVS log

Up to [Research Unix] / researchv10no / cmd / ccom / common

Annotation of researchv10no/cmd/ccom/common/lookup.c, revision 1.1.1.1

1.1       root        1: # include "mfile1.h"
                      2: 
                      3: lookup(name, s)        /* look up name: must agree with s w.r.t. STAG, SMOS and SHIDDEN */
                      4: register char *name; register s;
                      5: {
                      6:        register struct symtab *sp, *spstart;
                      7: 
                      8: # ifndef NODBG
                      9:        extern int ddebug;
                     10:        if (ddebug > 2) {
                     11:                printf("lookup(%s, %d), stwart=%d, instruct=%d\n",
                     12:                        name, s, stwart, instruct);
                     13:        }
                     14: # endif
                     15: 
                     16:        /* compute initial hash index */
                     17:        sp = spstart = stab + ((long)name & 077777) % SYMTSZ;
                     18: 
                     19:        do {     /* look for name */
                     20:                if (sp->stype == TNULL) {       /* empty slot */
                     21:                        sp->sflags = s;         /* set STAG, SMOS if needed */
                     22:                        sp->sname = name;
                     23:                        sp->stype = UNDEF;      /* turn off all others */
                     24:                        sp->sclass = SNULL;
                     25:                        return (sp-stab);
                     26:                }
                     27:                if (sp->sname == name && (sp->sflags & (STAG|SMOS|SHIDDEN)) == s)
                     28:                        return (sp-stab);
                     29:        } while ((++sp >= stab+SYMTSZ ? sp = stab : sp) != spstart);
                     30:        cerror("symbol table full");
                     31: }
                     32: 
                     33: #define HASHSIZE       1013
                     34: #define MAXHUSE                ((3*HASHSIZE)/4)
                     35: #define STRTABSIZE     4096
                     36: 
                     37: struct ht {
                     38:        struct ht *next;
                     39:        int nused;
                     40:        char *ptable[HASHSIZE];
                     41: } hashroot;
                     42: 
                     43: char *
                     44: hash(str)      /* Lookup str in hash tables; if not found, make new entry. */
                     45: char *str;
                     46: {
                     47:        char *calloc(), *savestr();
                     48:        register char *cp, **hstrp, **htptable;
                     49:        register int h, i;
                     50:        register struct ht *htp;
                     51:        int sh;
                     52: 
                     53:        for (cp=str, h=0; *cp; )
                     54:                h = (h << 1) + *cp++;
                     55:        sh = (h & 077777) % HASHSIZE;
                     56: 
                     57:        /* Look through each table for name.  Use quadratic re-hash. */
                     58:        for (htp = &hashroot; htp; htp = htp->next) {
                     59:                htptable = htp->ptable;
                     60:                for (h=sh, i=1; i<HASHSIZE; h += i, i += 2) {
                     61:                        if (h >= HASHSIZE)
                     62:                                h -= HASHSIZE;
                     63:                        hstrp = &htptable[h];
                     64:                        if (*hstrp) {
                     65:                                if (strcmp(*hstrp, str))
                     66:                                        continue;
                     67:                                return *hstrp;
                     68:                        } else {
                     69:                                if (htp->nused > MAXHUSE)
                     70:                                        break;
                     71:                                htp->nused++;
                     72:                                return (*hstrp = savestr(str));
                     73:                        }
                     74:                }
                     75:                if (htp->next == 0)
                     76:                        htp->next = (struct ht *)calloc(1,sizeof(struct ht));
                     77:        }
                     78:        cerror("cannot allocate hash table");
                     79: }
                     80: 
                     81: char *
                     82: savestr(str)   /* Place string into permanent storage. */
                     83: register char *str;
                     84: {
                     85:        char *memcpy(), *malloc();
                     86:        static char *curstp; static int nchleft;
                     87:        register int len;
                     88: 
                     89:        if ((len = strlen(str)+1) > nchleft &&
                     90:            (curstp = malloc(nchleft = len+STRTABSIZE)) == 0)
                     91:                cerror("cannot allocate string table");
                     92:        str = memcpy(curstp, str, len);
                     93:        curstp += len; nchleft -= len;
                     94:        return str;
                     95: }

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