Return to hash.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / tsort

Annotation of coherent/d/bin/tsort/hash.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "tsort.h"
                      3: 
                      4: 
                      5: /*
                      6:  *     Htab is the hash table.
                      7:  */
                      8: 
                      9:        static struct wordlist *htable[HASHSIZE];
                     10: 
                     11: 
                     12: /*
                     13:  *     The function insert returns a pointer to the hash table entry
                     14:  *     corresponding to the name "str".
                     15:  *     If the entry is new, then it initializes the ancestors field to
                     16:  *     NULL.
                     17:  */
                     18: 
                     19: struct word *
                     20: insert(str)
                     21: register char *str;
                     22: {
                     23:        register struct wordlist *ptr; 
                     24:        unsigned hindex;
                     25:        unsigned hash();
                     26:        struct word *newword();
                     27:        struct wordlist *newwordl();
                     28: 
                     29:        hindex = hash(str) % HASHSIZE;
                     30:        for (ptr=htable[hindex]; ptr != NULL; ptr=ptr->next)
                     31:                if (strcmp(ptr->element->name, str) == 0)
                     32:                        return (ptr->element);
                     33:        ptr = newwordl(newword(str));
                     34:        ptr->next = htable[hindex];
                     35:        htable[hindex] = ptr;
                     36:        return (ptr->element);
                     37: }
                     38: 
                     39: 
                     40: /*
                     41:  *     The function hash computes the hash index of the
                     42:  *     string pointed to by "str".
                     43:  */
                     44: 
                     45: static unsigned
                     46: hash(str)
                     47: register char *str;
                     48: {
                     49:        register unsigned result = 0;
                     50:        register int ch;
                     51: 
                     52:        while ((ch = *str++) != '\0')
                     53:                result = 128 * result - result + 16 * (ch % 16) + (ch / 16);
                     54:        return (result);
                     55: }
                     56: 
                     57: 
                     58: /*
                     59:  *     Cmphash returns a pointer to a wordlist which is a linked list
                     60:  *     of all words in the hash table.
                     61:  */
                     62: 
                     63: struct wordlist *
                     64: cmphash()
                     65: {
                     66:        register struct wordlist *mrk;
                     67:        register struct wordlist *head;
                     68:        register struct wordlist **htabp;
                     69: 
                     70:        head = NULL;
                     71:        for (htabp = htable; htabp - htable < HASHSIZE; ++htabp)
                     72:                if (*htabp != NULL) {
                     73:                        for (mrk = *htabp; mrk->next != NULL; mrk = mrk->next)
                     74:                                ;
                     75:                        mrk->next = head;
                     76:                        head = *htabp;
                     77:                }
                     78:        return (head);
                     79: }

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