Move Locale::Maketext::Simple from ext/ to dist/
[perl.git] / x2p / hash.c
1 /*    hash.c
2  *
3  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002,
4  *    2005 by Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  */
9
10 #include <stdio.h>
11 #include "EXTERN.h"
12 #include "a2p.h"
13 #include "util.h"
14
15 #ifdef NETWARE
16 char *savestr(char *str);
17 #endif
18
19 STR *
20 hfetch(register HASH *tb, char *key)
21 {
22     register char *s;
23     register int i;
24     register int hash;
25     register HENT *entry;
26
27     if (!tb)
28         return NULL;
29     for (s=key,         i=0,    hash = 0;
30       /* while */ *s;
31          s++,           i++,    hash *= 5) {
32         hash += *s * coeff[i];
33     }
34     entry = tb->tbl_array[hash & tb->tbl_max];
35     for (; entry; entry = entry->hent_next) {
36         if (entry->hent_hash != hash)           /* strings can't be equal */
37             continue;
38         if (strNE(entry->hent_key,key)) /* is this it? */
39             continue;
40         return entry->hent_val;
41     }
42     return NULL;
43 }
44
45 bool
46 hstore(register HASH *tb, char *key, STR *val)
47 {
48     register char *s;
49     register int i;
50     register int hash;
51     register HENT *entry;
52     register HENT **oentry;
53
54     if (!tb)
55         return FALSE;
56     for (s=key,         i=0,    hash = 0;
57       /* while */ *s;
58          s++,           i++,    hash *= 5) {
59         hash += *s * coeff[i];
60     }
61
62     oentry = &(tb->tbl_array[hash & tb->tbl_max]);
63     i = 1;
64
65     for (entry = *oentry; entry; i=0, entry = entry->hent_next) {
66         if (entry->hent_hash != hash)           /* strings can't be equal */
67             continue;
68         if (strNE(entry->hent_key,key)) /* is this it? */
69             continue;
70         /*NOSTRICT*/
71         safefree(entry->hent_val);
72         entry->hent_val = val;
73         return TRUE;
74     }
75     /*NOSTRICT*/
76     entry = (HENT*) safemalloc(sizeof(HENT));
77
78     entry->hent_key = savestr(key);
79     entry->hent_val = val;
80     entry->hent_hash = hash;
81     entry->hent_next = *oentry;
82     *oentry = entry;
83
84     if (i) {                            /* initial entry? */
85         tb->tbl_fill++;
86         if ((tb->tbl_fill * 100 / (tb->tbl_max + 1)) > FILLPCT)
87             hsplit(tb);
88     }
89
90     return FALSE;
91 }
92
93 void
94 hsplit(HASH *tb)
95 {
96     const int oldsize = tb->tbl_max + 1;
97     register int newsize = oldsize * 2;
98     register int i;
99     register HENT **a;
100     register HENT **b;
101     register HENT *entry;
102     register HENT **oentry;
103
104     a = (HENT**) saferealloc((char*)tb->tbl_array, newsize * sizeof(HENT*));
105     memset(&a[oldsize], 0, oldsize * sizeof(HENT*)); /* zero second half */
106     tb->tbl_max = --newsize;
107     tb->tbl_array = a;
108
109     for (i=0; i<oldsize; i++,a++) {
110         if (!*a)                                /* non-existent */
111             continue;
112         b = a+oldsize;
113         for (oentry = a, entry = *a; entry; entry = *oentry) {
114             if ((entry->hent_hash & newsize) != i) {
115                 *oentry = entry->hent_next;
116                 entry->hent_next = *b;
117                 if (!*b)
118                     tb->tbl_fill++;
119                 *b = entry;
120                 continue;
121             }
122             else
123                 oentry = &entry->hent_next;
124         }
125         if (!*a)                                /* everything moved */
126             tb->tbl_fill--;
127     }
128 }
129
130 HASH *
131 hnew(void)
132 {
133     register HASH *tb = (HASH*)safemalloc(sizeof(HASH));
134
135     tb->tbl_array = (HENT**) safemalloc(8 * sizeof(HENT*));
136     tb->tbl_fill = 0;
137     tb->tbl_max = 7;
138     hiterinit(tb);      /* so each() will start off right */
139     memset(tb->tbl_array, 0, 8 * sizeof(HENT*));
140     return tb;
141 }
142
143 int
144 hiterinit(register HASH *tb)
145 {
146     tb->tbl_riter = -1;
147     tb->tbl_eiter = (HENT*)NULL;
148     return tb->tbl_fill;
149 }