Return to ehash.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / diction

Annotation of 40BSD/cmd/diction/ehash.c, revision 1.1

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[31];
        !           207: #define aa4tsize 31
        !           208: #define aa4p1 23
        !           209: #define aa4p2 29
        !           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[19];
        !           262: #define aa11tsize 19
        !           263: #define aa11p1 13
        !           264: #define aa11p2 17
        !           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[61];
        !           339: #define aa21tsize 61
        !           340: #define aa21p1 53
        !           341: #define aa21p2 59
        !           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[29];
        !           460: #define aa34tsize 29
        !           461: #define aa34p1 19
        !           462: #define aa34p2 23
        !           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[43];
        !           548: #define aa45tsize 43
        !           549: #define aa45p1 37
        !           550: #define aa45p2 41
        !           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.