2 * sdbm - ndbm work-alike hashed database library
3 * based on Per-Aake Larson's Dynamic Hashing algorithms. BIT 18 (1978).
4 * author: oz@nexus.yorku.ca
5 * status: public domain.
11 static char rcsid[] = "$Id: pair.c,v 1.10 90/12/13 13:00:35 oz Exp $";
19 #define exhash(item) sdbm_hash((item).dptr, (item).dsize)
24 static int seepair proto((char *, int, char *, int));
28 * +------------------------------+
29 * ino | n | keyoff | datoff | keyoff |
30 * +------------+--------+--------+
31 * | datoff | - - - ----> |
32 * +--------+---------------------+
34 * +--------------+---------------+
35 * | <---- - - - | data |
36 * +--------+-----+----+----------+
37 * | key | data | key |
38 * +--------+----------+----------+
40 * calculating the offsets for free area: if the number
41 * of entries (ino[0]) is zero, the offset to the END of
42 * the free area is the block size. Otherwise, it is the
43 * nth (ino[ino[0]]) entry's offset.
54 register short *ino = (short *) pag;
56 off = ((n = ino[0]) > 0) ? ino[n] : PBLKSIZ;
57 free = off - (n + 1) * sizeof(short);
58 need += 2 * sizeof(short);
60 debug(("free %d need %d\n", free, need));
66 putpair(pag, key, val)
73 register short *ino = (short *) pag;
75 off = ((n = ino[0]) > 0) ? ino[n] : PBLKSIZ;
80 (void) memcpy(pag + off, key.dptr, key.dsize);
86 (void) memcpy(pag + off, val.dptr, val.dsize);
102 register short *ino = (short *) pag;
104 if ((n = ino[0]) == 0)
107 if ((i = seepair(pag, n, key.dptr, key.dsize)) == 0)
110 val.dptr = pag + ino[i + 1];
111 val.dsize = ino[i] - ino[i + 1];
121 register short *ino = (short *) pag;
122 return ino[0] > 0 && seepair(pag, ino[0], key.dptr, key.dsize) > 0;
133 register short *ino = (short *) pag;
136 if (ino[0] == 0 || num > ino[0])
139 off = (num > 1) ? ino[num - 1] : PBLKSIZ;
141 key.dptr = pag + ino[num];
142 key.dsize = off - ino[num];
154 register short *ino = (short *) pag;
156 if ((n = ino[0]) == 0)
159 if ((i = seepair(pag, n, key.dptr, key.dsize)) == 0)
162 * found the key. if it is the last entry
163 * [i.e. i == n - 1] we just adjust the entry count.
164 * hard case: move all data down onto the deleted pair,
165 * shift offsets onto deleted offsets, and adjust them.
170 register char *dst = pag + (i == 1 ? PBLKSIZ : ino[i - 1]);
171 register char *src = pag + ino[i + 1];
172 register int zoo = dst - src;
174 debug(("free-up %d ", zoo));
176 * shift data/keys down
178 m = ino[i + 1] - ino[n];
180 #define MOVB *--dst = *--src
183 register int loop = (m + 8 - 1) >> 3;
185 switch (m & (8 - 1)) {
188 case 6: MOVB; case 5: MOVB;
189 case 4: MOVB; case 3: MOVB;
190 case 2: MOVB; case 1: MOVB;
198 memmove(dst, src, m);
205 * adjust offset index up
208 ino[i] = ino[i + 2] + zoo;
217 * search for the key in the page.
218 * return offset index in the range 0 < i < n.
219 * return 0 if not found.
222 seepair(pag, n, key, siz)
229 register int off = PBLKSIZ;
230 register short *ino = (short *) pag;
232 for (i = 1; i < n; i += 2) {
233 if (siz == off - ino[i] &&
234 memcmp(key, pag + ino[i], siz) == 0)
242 splpage(pag, new, sbit)
251 register int off = PBLKSIZ;
253 register short *ino = (short *) cur;
255 (void) memcpy(cur, pag, PBLKSIZ);
256 (void) memset(pag, 0, PBLKSIZ);
257 (void) memset(new, 0, PBLKSIZ);
260 for (ino++; n > 0; ino += 2) {
261 key.dptr = cur + ino[0];
262 key.dsize = off - ino[0];
263 val.dptr = cur + ino[1];
264 val.dsize = ino[0] - ino[1];
266 * select the page pointer (by looking at sbit) and insert
268 (void) putpair((exhash(key) & sbit) ? new : pag, key, val);
274 debug(("%d split %d/%d\n", ((short *) cur)[0] / 2,
275 ((short *) new)[0] / 2,
276 ((short *) pag)[0] / 2));
281 * number of entries should be something
282 * reasonable, and all offsets in the index should be in order.
283 * this could be made more rigorous.
291 register short *ino = (short *) pag;
293 if ((n = ino[0]) < 0 || n > PBLKSIZ / sizeof(short))
298 for (ino++; n > 0; ino += 2) {
299 if (ino[0] > off || ino[1] > off ||