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