![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ehash.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / diction|
Return to ehash.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / diction |
1.1 root 1: #ifndef lint
2: static char ehash_sccsid[] = "@(#)ehash.c 4.2 (Berkeley) 82/11/06";
3: #endif not lint
4:
5: #
6: struct hnode {
7: char *aakey;
8: struct dict *aadata;
9: };
10: struct dict {
11: char *entry;
12: char val;
13: };
14: char able();
15: struct dict able_d[];
16: char ace();
17: struct dict ace_d[];
18: char age();
19: struct dict age_d[];
20: char ance();
21: struct dict ance_d[];
22: char ant();
23: struct dict ant_d[];
24: char cal();
25: struct dict cal_d[];
26: char cle();
27: struct dict cle_d[];
28: char ee();
29: struct dict ee_d[];
30: char ence();
31: struct dict ence_d[];
32: char ess();
33: struct dict ess_d[];
34: char est();
35: struct dict est_d[];
36: char ful();
37: struct dict ful_d[];
38: char ible();
39: struct dict ible_d[];
40: char ic();
41: struct dict ic_d[];
42: char ice();
43: struct dict ice_d[];
44: char ion();
45: struct dict ion_d[];
46: char ional();
47: struct dict ional_d[];
48: char is();
49: struct dict is_d[];
50: char ish();
51: struct dict ish_d[];
52: char ist();
53: struct dict ist_d[];
54: char ite();
55: struct dict ite_d[];
56: char ive();
57: struct dict ive_d[];
58: char ize();
59: struct dict ize_d[];
60: char lar();
61: struct dict lar_d[];
62: char less();
63: struct dict less_d[];
64: char man();
65: struct dict man_d[];
66: char ment();
67: struct dict ment_d[];
68: char ness();
69: struct dict ness_d[];
70: char ous();
71: struct dict ous_d[];
72: char ship();
73: struct dict ship_d[];
74: char ss();
75: struct dict ss_d[];
76: char ure();
77: struct dict ure_d[];
78: char us();
79: struct dict us_d[];
80: char ing();
81: struct dict ing_d[];
82: char ed();
83: struct dict ed_d[];
84: struct fandd {
85: char (*fun)();
86: struct dict *yd;
87: } arr[] = {
88: able, able_d,
89: ace, ace_d,
90: age, age_d,
91: ance, ance_d,
92: ant, ant_d,
93: cal, cal_d,
94: cle, cle_d,
95: ee, ee_d,
96: ence, ence_d,
97: ess, ess_d,
98: est, est_d,
99: ful, ful_d,
100: ible, ible_d,
101: ic, ic_d,
102: ice, ice_d,
103: ion, ion_d,
104: ional, ional_d,
105: is, is_d,
106: ish, ish_d,
107: ist, ist_d,
108: ite, ite_d,
109: ive, ive_d,
110: ize, ize_d,
111: lar, lar_d,
112: less, less_d,
113: man, man_d,
114: ment, ment_d,
115: ness, ness_d,
116: ous, ous_d,
117: ship, ship_d,
118: ss, ss_d,
119: ure, ure_d,
120: us, us_d,
121: ing, ing_d,
122: ed, ed_d,
123: 0, 0
124: };
125: egetd(){
126: struct dict *pp;
127: struct fandd *ptr;
128: ptr = arr;
129: while(ptr->fun != 0){
130: pp = ptr->yd;
131: while(pp->entry != 0){
132: (*ptr->fun)(pp->entry,0,pp);
133: pp++;
134: }
135: ptr++;
136: }
137: }
138: char
139: aahash(s,ex,aatsize,aapr1,aapr2,tbl,data)
140: char *s;
141: struct hnode tbl[];
142: struct dict *data;
143: {
144: char *cp;
145: int i, key, c, p1, p2;
146: cp = s;
147: key =0;
148: while (c = *cp++)
149: key = key + (key<<5) + c;
150: key &= 077777;
151: p1 = key%aapr1;
152: p2 = key%aapr2;
153: if (p2==0) p2=17;
154: for(i=0; i<aatsize; i++)
155: {
156: if (tbl[p1].aakey==0)
157: { /* new item */
158: if (ex ==0)
159: {
160: tbl[p1].aakey = s;
161: tbl[p1].aadata= data;
162: return(tbl[p1].aadata->val);
163: }
164: else
165: return(0);
166: }
167: else
168: if(strcmp(tbl[p1].aakey, s)== 0)
169: {
170: return(tbl[p1].aadata->val);
171: }
172: p1 = (p1+p2)%aatsize;
173: }
174: fprintf(stderr, "hash table full\n");
175: exit();
176: }
177: struct hnode aa1root[43];
178: #define aa1tsize 43
179: #define aa1p1 37
180: #define aa1p2 41
181: char
182: able(a0,a1,ptr)
183: char *a0;
184: struct dict *ptr;
185: {
186: return(aahash(a0,a1,aa1tsize,aa1p1,aa1p2,aa1root,ptr));
187: }
188: struct hnode aa2root[11];
189: #define aa2tsize 11
190: #define aa2p1 5
191: #define aa2p2 7
192: char
193: ace(a0,a1,ptr)
194: char *a0;
195: struct dict *ptr;
196: {
197: return(aahash(a0,a1,aa2tsize,aa2p1,aa2p2,aa2root,ptr));
198: }
199: struct hnode aa3root[61];
200: #define aa3tsize 61
201: #define aa3p1 53
202: #define aa3p2 59
203: char
204: age(a0,a1,ptr)
205: char *a0;
206: struct dict *ptr;
207: {
208: return(aahash(a0,a1,aa3tsize,aa3p1,aa3p2,aa3root,ptr));
209: }
210: struct hnode aa4root[37];
211: #define aa4tsize 37
212: #define aa4p1 29
213: #define aa4p2 31
214: char
215: ance(a0,a1,ptr)
216: char *a0;
217: struct dict *ptr;
218: {
219: return(aahash(a0,a1,aa4tsize,aa4p1,aa4p2,aa4root,ptr));
220: }
221: struct hnode aa5root[31];
222: #define aa5tsize 31
223: #define aa5p1 23
224: #define aa5p2 29
225: char
226: ant(a0,a1,ptr)
227: char *a0;
228: struct dict *ptr;
229: {
230: return(aahash(a0,a1,aa5tsize,aa5p1,aa5p2,aa5root,ptr));
231: }
232: struct hnode aa7root[19];
233: #define aa7tsize 19
234: #define aa7p1 13
235: #define aa7p2 17
236: char
237: cal(a0,a1,ptr)
238: char *a0;
239: struct dict *ptr;
240: {
241: return(aahash(a0,a1,aa7tsize,aa7p1,aa7p2,aa7root,ptr));
242: }
243: struct hnode aa8root[13];
244: #define aa8tsize 13
245: #define aa8p1 7
246: #define aa8p2 11
247: char
248: cle(a0,a1,ptr)
249: char *a0;
250: struct dict *ptr;
251: {
252: return(aahash(a0,a1,aa8tsize,aa8p1,aa8p2,aa8root,ptr));
253: }
254: struct hnode aa10root[31];
255: #define aa10tsize 31
256: #define aa10p1 23
257: #define aa10p2 29
258: char
259: ee(a0,a1,ptr)
260: char *a0;
261: struct dict *ptr;
262: {
263: return(aahash(a0,a1,aa10tsize,aa10p1,aa10p2,aa10root,ptr));
264: }
265: struct hnode aa11root[31];
266: #define aa11tsize 31
267: #define aa11p1 23
268: #define aa11p2 29
269: char
270: ence(a0,a1,ptr)
271: char *a0;
272: struct dict *ptr;
273: {
274: return(aahash(a0,a1,aa11tsize,aa11p1,aa11p2,aa11root,ptr));
275: }
276: struct hnode aa13root[47];
277: #define aa13tsize 47
278: #define aa13p1 41
279: #define aa13p2 43
280: char
281: ess(a0,a1,ptr)
282: char *a0;
283: struct dict *ptr;
284: {
285: return(aahash(a0,a1,aa13tsize,aa13p1,aa13p2,aa13root,ptr));
286: }
287: struct hnode aa14root[67];
288: #define aa14tsize 67
289: #define aa14p1 59
290: #define aa14p2 61
291: char
292: est(a0,a1,ptr)
293: char *a0;
294: struct dict *ptr;
295: {
296: return(aahash(a0,a1,aa14tsize,aa14p1,aa14p2,aa14root,ptr));
297: }
298: struct hnode aa15root[43];
299: #define aa15tsize 43
300: #define aa15p1 37
301: #define aa15p2 41
302: char
303: ful(a0,a1,ptr)
304: char *a0;
305: struct dict *ptr;
306: {
307: return(aahash(a0,a1,aa15tsize,aa15p1,aa15p2,aa15root,ptr));
308: }
309: struct hnode aa18root[19];
310: #define aa18tsize 19
311: #define aa18p1 13
312: #define aa18p2 17
313: char
314: ible(a0,a1,ptr)
315: char *a0;
316: struct dict *ptr;
317: {
318: return(aahash(a0,a1,aa18tsize,aa18p1,aa18p2,aa18root,ptr));
319: }
320: struct hnode aa19root[151];
321: #define aa19tsize 151
322: #define aa19p1 139
323: #define aa19p2 149
324: char
325: ic(a0,a1,ptr)
326: char *a0;
327: struct dict *ptr;
328: {
329: return(aahash(a0,a1,aa19tsize,aa19p1,aa19p2,aa19root,ptr));
330: }
331: struct hnode aa20root[11];
332: #define aa20tsize 11
333: #define aa20p1 5
334: #define aa20p2 7
335: char
336: ice(a0,a1,ptr)
337: char *a0;
338: struct dict *ptr;
339: {
340: return(aahash(a0,a1,aa20tsize,aa20p1,aa20p2,aa20root,ptr));
341: }
342: struct hnode aa21root[89];
343: #define aa21tsize 89
344: #define aa21p1 79
345: #define aa21p2 83
346: char
347: ion(a0,a1,ptr)
348: char *a0;
349: struct dict *ptr;
350: {
351: return(aahash(a0,a1,aa21tsize,aa21p1,aa21p2,aa21root,ptr));
352: }
353: struct hnode aa22root[13];
354: #define aa22tsize 13
355: #define aa22p1 7
356: #define aa22p2 11
357: char
358: ional(a0,a1,ptr)
359: char *a0;
360: struct dict *ptr;
361: {
362: return(aahash(a0,a1,aa22tsize,aa22p1,aa22p2,aa22root,ptr));
363: }
364: struct hnode aa23root[11];
365: #define aa23tsize 11
366: #define aa23p1 5
367: #define aa23p2 7
368: char
369: is(a0,a1,ptr)
370: char *a0;
371: struct dict *ptr;
372: {
373: return(aahash(a0,a1,aa23tsize,aa23p1,aa23p2,aa23root,ptr));
374: }
375: struct hnode aa24root[71];
376: #define aa24tsize 71
377: #define aa24p1 61
378: #define aa24p2 67
379: char
380: ish(a0,a1,ptr)
381: char *a0;
382: struct dict *ptr;
383: {
384: return(aahash(a0,a1,aa24tsize,aa24p1,aa24p2,aa24root,ptr));
385: }
386: struct hnode aa25root[151];
387: #define aa25tsize 151
388: #define aa25p1 139
389: #define aa25p2 149
390: char
391: ist(a0,a1,ptr)
392: char *a0;
393: struct dict *ptr;
394: {
395: return(aahash(a0,a1,aa25tsize,aa25p1,aa25p2,aa25root,ptr));
396: }
397: struct hnode aa26root[79];
398: #define aa26tsize 79
399: #define aa26p1 71
400: #define aa26p2 73
401: char
402: ite(a0,a1,ptr)
403: char *a0;
404: struct dict *ptr;
405: {
406: return(aahash(a0,a1,aa26tsize,aa26p1,aa26p2,aa26root,ptr));
407: }
408: struct hnode aa28root[151];
409: #define aa28tsize 151
410: #define aa28p1 139
411: #define aa28p2 149
412: char
413: ive(a0,a1,ptr)
414: char *a0;
415: struct dict *ptr;
416: {
417: return(aahash(a0,a1,aa28tsize,aa28p1,aa28p2,aa28root,ptr));
418: }
419: struct hnode aa29root[11];
420: #define aa29tsize 11
421: #define aa29p1 5
422: #define aa29p2 7
423: char
424: ize(a0,a1,ptr)
425: char *a0;
426: struct dict *ptr;
427: {
428: return(aahash(a0,a1,aa29tsize,aa29p1,aa29p2,aa29root,ptr));
429: }
430: struct hnode aa30root[37];
431: #define aa30tsize 37
432: #define aa30p1 29
433: #define aa30p2 31
434: char
435: lar(a0,a1,ptr)
436: char *a0;
437: struct dict *ptr;
438: {
439: return(aahash(a0,a1,aa30tsize,aa30p1,aa30p2,aa30root,ptr));
440: }
441: struct hnode aa31root[11];
442: #define aa31tsize 11
443: #define aa31p1 5
444: #define aa31p2 7
445: char
446: less(a0,a1,ptr)
447: char *a0;
448: struct dict *ptr;
449: {
450: return(aahash(a0,a1,aa31tsize,aa31p1,aa31p2,aa31root,ptr));
451: }
452: struct hnode aa33root[11];
453: #define aa33tsize 11
454: #define aa33p1 5
455: #define aa33p2 7
456: char
457: man(a0,a1,ptr)
458: char *a0;
459: struct dict *ptr;
460: {
461: return(aahash(a0,a1,aa33tsize,aa33p1,aa33p2,aa33root,ptr));
462: }
463: struct hnode aa34root[37];
464: #define aa34tsize 37
465: #define aa34p1 29
466: #define aa34p2 31
467: char
468: ment(a0,a1,ptr)
469: char *a0;
470: struct dict *ptr;
471: {
472: return(aahash(a0,a1,aa34tsize,aa34p1,aa34p2,aa34root,ptr));
473: }
474: struct hnode aa35root[11];
475: #define aa35tsize 11
476: #define aa35p1 5
477: #define aa35p2 7
478: char
479: ness(a0,a1,ptr)
480: char *a0;
481: struct dict *ptr;
482: {
483: return(aahash(a0,a1,aa35tsize,aa35p1,aa35p2,aa35root,ptr));
484: }
485: struct hnode aa37root[11];
486: #define aa37tsize 11
487: #define aa37p1 5
488: #define aa37p2 7
489: char
490: ous(a0,a1,ptr)
491: char *a0;
492: struct dict *ptr;
493: {
494: return(aahash(a0,a1,aa37tsize,aa37p1,aa37p2,aa37root,ptr));
495: }
496: struct hnode aa39root[11];
497: #define aa39tsize 11
498: #define aa39p1 5
499: #define aa39p2 7
500: char
501: ship(a0,a1,ptr)
502: char *a0;
503: struct dict *ptr;
504: {
505: return(aahash(a0,a1,aa39tsize,aa39p1,aa39p2,aa39root,ptr));
506: }
507: struct hnode aa40root[61];
508: #define aa40tsize 61
509: #define aa40p1 53
510: #define aa40p2 59
511: char
512: ss(a0,a1,ptr)
513: char *a0;
514: struct dict *ptr;
515: {
516: return(aahash(a0,a1,aa40tsize,aa40p1,aa40p2,aa40root,ptr));
517: }
518: struct hnode aa42root[89];
519: #define aa42tsize 89
520: #define aa42p1 79
521: #define aa42p2 83
522: char
523: ure(a0,a1,ptr)
524: char *a0;
525: struct dict *ptr;
526: {
527: return(aahash(a0,a1,aa42tsize,aa42p1,aa42p2,aa42root,ptr));
528: }
529: struct hnode aa43root[19];
530: #define aa43tsize 19
531: #define aa43p1 13
532: #define aa43p2 17
533: char
534: us(a0,a1,ptr)
535: char *a0;
536: struct dict *ptr;
537: {
538: return(aahash(a0,a1,aa43tsize,aa43p1,aa43p2,aa43root,ptr));
539: }
540: struct hnode aa44root[23];
541: #define aa44tsize 23
542: #define aa44p1 17
543: #define aa44p2 19
544: char
545: ing(a0,a1,ptr)
546: char *a0;
547: struct dict *ptr;
548: {
549: return(aahash(a0,a1,aa44tsize,aa44p1,aa44p2,aa44root,ptr));
550: }
551: struct hnode aa45root[47];
552: #define aa45tsize 47
553: #define aa45p1 41
554: #define aa45p2 43
555: char
556: ed(a0,a1,ptr)
557: char *a0;
558: struct dict *ptr;
559: {
560: return(aahash(a0,a1,aa45tsize,aa45p1,aa45p2,aa45root,ptr));
561: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.