![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sprog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / spell|
Return to sprog.c CVS log | Up to [Research Unix] / researchv10dc / cmd / spell |
1.1 root 1:
2: #include "code.h"
3:
4: #ifndef _POSIX_SOURCE
5:
6: #include <stdio.h>
7: #include <ctype.h>
8: #include <libc.h>
9:
10: #else
11:
12: #include <fcntl.h>
13: #include <stdio.h>
14: #include <ctype.h>
15: #include <stdlib.h>
16: #include <unistd.h>
17: #include <string.h>
18:
19: #endif
20:
21: #define isvowel(c) voweltab[c]
22: #define Tolower(c) (isupper(c)? (c)-'A'+'a': (c))
23: #define pair(a,b) (((a)<<8) | (b))
24: #define DLEV 2
25: #define DSIZ 40
26:
27: typedef long Bits;
28: typedef unsigned char uchar;
29: #define Set(h, f) ((long)(h) & (f))
30:
31: Bits nop(char*, char*, char*, int, int);
32: Bits strip(char*, char*, char*, int, int);
33: Bits ize(char*, char*, char*, int, int);
34: Bits i_to_y(char*, char*, char*, int, int);
35: Bits ily(char*, char*, char*, int, int);
36: Bits subst(char*, char*, char*, int, int);
37: Bits CCe(char*, char*, char*, int, int);
38: Bits tion(char*, char*, char*, int, int);
39: Bits an(char*, char*, char*, int, int);
40: Bits s(char*, char*, char*, int, int);
41: Bits es(char*, char*, char*, int, int);
42: Bits bility(char*, char*, char*, int, int);
43: Bits y_to_e(char*, char*, char*, int, int);
44: Bits VCe(char*, char*, char*, int, int);
45:
46: Bits trypref(char*, char*, int, int);
47: Bits tryword(char*, char*, int, int);
48: Bits trysuff(char*, int, int);
49: Bits dict(char*, char*);
50: void typeprint(Bits);
51: void pcomma(char*);
52:
53: void runout(char*);
54: void ise(void);
55: int ordinal(void);
56: char* skipv(char*);
57: int inun(char*, Bits);
58: char* ztos(char*);
59: void readdict(char*);
60:
61: char *strdupl(char *);
62:
63: typedef struct Ptab Ptab;
64: struct Ptab
65: {
66: char* s;
67: int flag;
68: };
69:
70: typedef struct Suftab Suftab;
71: struct Suftab
72: {
73: char *suf;
74: Bits (*p1)(char*, char*, char*, int, int);
75: int n1;
76: char *d1;
77: char *a1;
78: int flag;
79: int affixable;
80: Bits (*p2)(char*, char*, char*, int, int);
81: int n2;
82: char *d2;
83: char *a2;
84: };
85:
86: Suftab staba[] = {
87: {"aibohp",subst,1,"-e+ia","",NOUN, NOUN},
88: 0
89: };
90:
91: Suftab stabc[] =
92: {
93: {"cai",strip,1,"","+c",N_AFFIX, ADJ|NOUN},
94: {"citsi",strip,2,"","+ic",N_AFFIX, ADJ | N_AFFIX | NOUN},
95: {"citi",ize,1,"-e+ic","",N_AFFIX, ADJ },
96: {"cihparg",i_to_y,1,"-y+ic","",NOUN, ADJ|NOUN },
97: {"cipocs",ize,1,"-e+ic","",NOUN, ADJ },
98: {"cirtem",i_to_y,1,"-y+ic","",NOUN, ADJ },
99: {"cigol",i_to_y,1,"-y+ic","",NOUN, ADJ },
100: {"cimono",i_to_y,1,"-y+ic","",NOUN, ADJ },
101: {"cibohp",subst,1,"-e+ic","",NOUN, ADJ },
102: 0
103: };
104: Suftab stabd[] =
105: {
106: {"de",strip,1,"","+d",ED,ADJ |COMP,i_to_y,2,"-y+ied","+ed"},
107: {"dooh",ily,4,"-y+ihood","+hood",NOUN | ADV, NOUN},
108: 0
109: };
110: Suftab stabe[] =
111: {
112: /*
113: * V_affix for comment ->commence->commentment??
114: */
115: {"ecn",subst,1,"-t+ce","",ADJ,N_AFFIX|_Y|NOUN|VERB|ACTOR|V_AFFIX},
116: {"elbaif",i_to_y,4,"-y+iable","",V_IRREG,ADJ},
117: {"elba",CCe,4,"-e+able","+able",V_AFFIX,ADJ},
118: {"evi",subst,0,"-ion+ive","",N_AFFIX | V_AFFIX,NOUN | N_AFFIX| ADJ},
119: {"ezi",CCe,3,"-e+ize","+ize",N_AFFIX|ADJ ,V_AFFIX | VERB |ION | COMP},
120: {"ekil",strip,4,"","+like",N_AFFIX ,ADJ},
121: 0
122: };
123: Suftab stabg[] =
124: {
125: {"gniee",strip,3,"","+ing",V_IRREG ,ADJ|NOUN},
126: {"gnikam",strip,6,"","+making",NOUN,NOUN},
127: {"gnipeek",strip,7,"","+keeping",NOUN,NOUN},
128: {"gni",CCe,3,"-e+ing","+ing",V_IRREG ,ADJ|ED|NOUN},
129: 0
130: };
131: Suftab stabl[] =
132: {
133: {"ladio",strip,2,"","+al",NOUN |ADJ,ADJ},
134: {"laci",strip,2,"","+al",NOUN |ADJ,ADJ |NOUN|N_AFFIX},
135: {"latnem",strip,2,"","+al",N_AFFIX,ADJ},
136: {"lanoi",strip,2,"","+al",N_AFFIX,ADJ|NOUN},
137: {"luf",ily,3,"-y+iful","+ful",N_AFFIX,ADJ | NOUN},
138: 0
139: };
140: Suftab stabm[] =
141: {
142: /* congregational + ism */
143: {"msi",CCe,3,"-e+ism","ism",N_AFFIX|ADJ,NOUN},
144: {"margo",subst,-1,"-ph+m","",NOUN,NOUN},
145: 0
146: };
147: Suftab stabn[] =
148: {
149: {"noitacifi",i_to_y,6,"-y+ication","",ION,NOUN | N_AFFIX},
150: {"noitazi",ize,4,"-e+ation","",ION,NOUN| N_AFFIX},
151: {"noit",tion,3,"-e+ion","+ion",ION,NOUN| N_AFFIX | V_AFFIX |VERB|ACTOR},
152: {"naino",an,3,"","+ian",NOUN|PROP_COLLECT,NOUN| N_AFFIX},
153: {"namow",strip,5,"","+woman",MAN,PROP_COLLECT|N_AFFIX},
154: {"nam",strip,3,"","+man",MAN,PROP_COLLECT | N_AFFIX | VERB},
155: {"na",an,1,"","+n",NOUN|PROP_COLLECT,NOUN | N_AFFIX},
156: {"nemow",strip,5,"","+women",MAN,PROP_COLLECT},
157: {"nem",strip,3,"","+man",MAN,PROP_COLLECT},
158: 0
159: };
160: Suftab stabp[] =
161: {
162: {"pihs",strip,4,"","+ship",NOUN|PROP_COLLECT,NOUN| N_AFFIX},
163: 0
164: };
165: Suftab stabr[] =
166: {
167: {"rehparg",subst,1,"-y+er","",ACTOR,NOUN,strip,2,"","+er"},
168: {"reyhparg",nop,0,"","",0,NOUN},
169: {"rekam",strip,5,"","+maker",NOUN,NOUN},
170: {"repeek",strip,6,"","+keeper",NOUN,NOUN},
171: {"re",strip,1,"","+r",ACTOR,NOUN | N_AFFIX|VERB|ADJ, i_to_y,2,"-y+ier","+er"},
172: {"rota",tion,2,"-e+or","",ION,NOUN| N_AFFIX|_Y},
173: {"rotc",tion,2,"","+or",ION,NOUN| N_AFFIX},
174: {"rotp",tion,2,"","+or",ION,NOUN| N_AFFIX},
175: 0
176: };
177: Suftab stabs[] =
178: {
179: {"ssen",ily,4,"-y+iness","+ness",ADJ|ADV,NOUN| N_AFFIX},
180: {"ssel",ily,4,"-y+iless","+less",NOUN | PROP_COLLECT,ADJ },
181: {"se",s,1,"","+s",NOUN | V_IRREG,DONT_TOUCH , es,2,"-y+ies","+es"},
182: {"s'",s,2,"","+'s",PROP_COLLECT | NOUN,DONT_TOUCH },
183: {"s",s,1,"","+s",NOUN | V_IRREG,DONT_TOUCH },
184: 0
185: };
186: Suftab stabt[] =
187: {
188: {"tnem",strip,4,"","+ment",V_AFFIX,NOUN | N_AFFIX | ADJ|VERB},
189: {"tse",strip,2,"","+st",EST,DONT_TOUCH, i_to_y,3,"-y+iest","+est" },
190: {"tsigol",i_to_y,2,"-y+ist","",N_AFFIX,NOUN | N_AFFIX},
191: {"tsi",CCe,3,"-e+ist","+ist",N_AFFIX|ADJ,NOUN | N_AFFIX|COMP},
192: 0
193: };
194: Suftab staby[] =
195: {
196: {"ytilb",nop,0,"","",0,NOUN},
197: {"ycn",subst,1,"-t+cy","",ADJ | N_AFFIX,NOUN | N_AFFIX},
198: {"ytilib",bility,5,"-le+ility","",ADJ | V_AFFIX,NOUN | N_AFFIX},
199: {"ytisuo",nop,0,"","",NOUN},
200: {"yti",CCe,3,"-e+ity","+ity",ADJ ,NOUN | N_AFFIX },
201: {"ylb",y_to_e,1,"-e+y","",ADJ,ADV},
202: {"ylc",nop,0,"","",0},
203: {"yl",ily,2,"-y+ily","+ly",ADJ,ADV|COMP},
204: {"yrtem",subst,0,"-er+ry","",NOUN,NOUN | N_AFFIX},
205: {"y",CCe,1,"-e+y","+y",_Y,ADJ|COMP},
206: 0
207: };
208: Suftab stabz[] =
209: {
210: 0
211: };
212: Suftab* suftab[] =
213: {
214: staba,
215: stabz,
216: stabc,
217: stabd,
218: stabe,
219: stabz,
220: stabg,
221: stabz,
222: stabz,
223: stabz,
224: stabz,
225: stabl,
226: stabm,
227: stabn,
228: stabz,
229: stabp,
230: stabz,
231: stabr,
232: stabs,
233: stabt,
234: stabz,
235: stabz,
236: stabz,
237: stabz,
238: staby,
239: stabz,
240: };
241:
242: Ptab ptaba[] =
243: {
244: "anti", 0,
245: "auto", 0,
246: 0
247: };
248: Ptab ptabb[] =
249: {
250: "bio", 0,
251: 0
252: };
253: Ptab ptabc[] =
254: {
255: "counter", 0,
256: 0
257: };
258: Ptab ptabd[] =
259: {
260: "dis", 0,
261: 0
262: };
263: Ptab ptabe[] =
264: {
265: "electro", 0,
266: 0
267: };
268: Ptab ptabf[] =
269: {
270: "femto", 0,
271: 0
272: };
273: Ptab ptabg[] =
274: {
275: "geo", 0,
276: "giga", 0,
277: 0
278: };
279: Ptab ptabh[] =
280: {
281: "hyper", 0,
282: 0
283: };
284: Ptab ptabi[] =
285: {
286: "immuno", 0,
287: "im", IN,
288: "intra", 0,
289: "inter", 0,
290: "in", IN,
291: "ir", IN,
292: "iso", 0,
293: 0
294: };
295: Ptab ptabj[] =
296: {
297: 0
298: };
299: Ptab ptabk[] =
300: {
301: "kilo", 0,
302: 0
303: };
304: Ptab ptabl[] =
305: {
306: 0
307: };
308: Ptab ptabm[] =
309: {
310: "magneto", 0,
311: "mega", 0,
312: "meta", 0,
313: "micro", 0,
314: "mid", 0,
315: "milli", 0,
316: "mini", 0,
317: "mis", 0,
318: "mono", 0,
319: "multi", 0,
320: 0
321: };
322: Ptab ptabn[] =
323: {
324: "nano", 0,
325: "neuro", 0,
326: "non", 0,
327: 0
328: };
329: Ptab ptabo[] =
330: {
331: "out", 0,
332: "over", 0,
333: 0
334: };
335: Ptab ptabp[] =
336: {
337: "para", 0,
338: "photo", 0,
339: "pico", 0,
340: "poly", 0,
341: "pre", 0,
342: "pseudo", 0,
343: "psycho", 0,
344: 0
345: };
346: Ptab ptabq[] =
347: {
348: "quasi", 0,
349: 0
350: };
351: Ptab ptabr[] =
352: {
353: "radio", 0,
354: "re", 0,
355: 0
356: };
357: Ptab ptabs[] =
358: {
359: "semi", 0,
360: "stereo", 0,
361: "sub", 0,
362: "super", 0,
363: 0
364: };
365: Ptab ptabt[] =
366: {
367: "tele", 0,
368: "thermo", 0,
369: 0
370: };
371: Ptab ptabu[] =
372: {
373: "ultra", 0,
374: "under", 0, /*must precede un*/
375: "un", IN,
376: 0
377: };
378: Ptab ptabv[] =
379: {
380: 0
381: };
382: Ptab ptabw[] =
383: {
384: 0
385: };
386: Ptab ptabx[] =
387: {
388: 0
389: };
390: Ptab ptaby[] =
391: {
392: 0
393: };
394: Ptab ptabz[] =
395: {
396: 0
397: };
398:
399: Ptab* preftab[] =
400: {
401: ptaba,
402: ptabb,
403: ptabc,
404: ptabd,
405: ptabe,
406: ptabf,
407: ptabg,
408: ptabh,
409: ptabi,
410: ptabj,
411: ptabk,
412: ptabl,
413: ptabm,
414: ptabn,
415: ptabo,
416: ptabp,
417: ptabq,
418: ptabr,
419: ptabs,
420: ptabt,
421: ptabu,
422: ptabv,
423: ptabw,
424: ptabx,
425: ptaby,
426: ptabz,
427: };
428:
429: typedef struct {
430: char *mesg;
431: enum { NONE, SUFF, PREF} type;
432: } Deriv;
433:
434: int cflag;
435: int fflag;
436: int vflag;
437: int xflag;
438: char word[500];
439: char original[500];
440: Deriv deriv[DSIZ+3];
441: Deriv emptyderiv;
442: char affix[DSIZ*10]; /* 10 is longest affix message */
443: int prefcount;
444: int suffcount;
445: char space[300000]; /* must be as large as "words"+"space" in pcode run */
446: Bits encode[2048]; /* must be as long as "codes" in pcode run */
447: int nencode;
448: char voweltab[128];
449: char* spacep[128*128+1]; /* pointer to words starting with 'xx' */
450:
451: char* codefile = "/usr/lib/spell/amspell";
452: char* brfile = "/usr/lib/spell/brspell";
453:
454: main(int argc, char *argv[])
455: {
456: char *ep, *cp;
457: char *dp;
458: int j, i, c;
459: int low = 0;
460: Bits h;
461:
462: for(i=0; c = "aeiouyAEIOUY"[i]; i++)
463: voweltab[c] = 1;
464: while(argc > 1) {
465: if(argv[1][0] != '-')
466: break;
467: for(i=1; c = argv[1][i]; i++)
468: switch(c) {
469: default:
470: fprintf(stderr, "usage: spell [-bcvx] [-f file]\n");
471: exit(1);
472:
473: case 'b':
474: ise();
475: if(!fflag)
476: codefile = brfile;
477: continue;
478:
479: case 'C':
480: vflag++;
481: case 'c':
482: setbuf(stdout,0);
483: cflag++;
484: continue;
485:
486: case 'v':
487: vflag++;
488: continue;
489:
490: case 'x':
491: xflag++;
492: continue;
493:
494: case 'f':
495: if(argc <= 2) {
496: fprintf(stderr, "spell: -f requires another argument\n");
497: exit(1);
498: }
499: argv++;
500: argc--;
501: fflag++;
502: codefile = argv[1];
503: goto brk;
504: }
505: brk:
506: argv++;
507: argc--;
508: }
509: readdict(codefile);
510: if(argc > 1) {
511: fprintf(stderr, "usage: spell [-bcvx] [-f file]\n");
512: exit(1);
513: }
514: for(;;) {
515: loop:
516: affix[0] = 0;
517: for(ep=original; ; ep++) {
518: if(ep >= original + sizeof(original) - 1) {
519: *ep = 0;
520: runout(original);
521: goto loop;
522: }
523: j = getchar();
524: if(j == EOF)
525: exit(0);
526: if(j != '\n')
527: *ep = j;
528: else {
529: *ep = 0;
530: break;
531: }
532: }
533: low = 0;
534: for(ep=word,dp=original; j = *dp; ep++,dp++) {
535: if(islower(j))
536: low++;
537: if(ep >= word+sizeof(word)-1)
538: break;
539: *ep = j;
540: }
541: *ep = 0;
542:
543: h = ~STOP;
544: if(word[1] == 0 && isalnum(word[0]) ||
545: isdigit(word[0]) && ordinal())
546: goto check;
547:
548: h = 0;
549: if(!low && !(h = trypref(ep,".",0,ALL|STOP|DONT_TOUCH)))
550: for(cp=original+1,dp=word+1; dp<ep; dp++,cp++)
551: *dp = Tolower(*cp);
552: if(!h)
553: for(;;) { /* at most twice */
554: if(h = trypref(ep,".",0,ALL|STOP|DONT_TOUCH))
555: break;
556: if(h = trysuff(ep,0,ALL|STOP|DONT_TOUCH))
557: break;
558: if(!isupper(word[0]))
559: break;
560: cp = original;
561: dp = word;
562: while(*dp = *cp++) {
563: if(!low)
564: *dp = Tolower(*dp);
565: dp++;
566: }
567: word[0] = Tolower(word[0]);
568: }
569: check:
570: if(cflag) {
571: if(!h || Set(h,STOP))
572: putchar('-');
573: else if(!vflag)
574: putchar('+');
575: else
576: putchar('0' + (suffcount>0) +
577: (prefcount>4? 8: 2*prefcount));
578: } else if(!h || Set(h,STOP))
579: printf("%s\n", original);
580: else if(affix[0] != 0 && affix[0] != '.')
581: printf("%s\t%s\n", affix, original);
582: }
583: }
584:
585: /* strip exactly one suffix and do
586: * indicated routine(s), which may recursively
587: * strip suffixes
588: */
589: Bits
590: trysuff(char* ep, int lev, int flag)
591: {
592: Suftab *t;
593: char *cp, *sp;
594: Bits h = 0;
595: int initchar = ep[-1];
596:
597: flag &= ~MONO;
598: lev += DLEV;
599: if(lev<DSIZ)
600: deriv[lev] = deriv[lev-1] = emptyderiv;
601: if(!islower(initchar))
602: return h;
603: for(t=suftab[initchar-'a']; sp=t->suf; t++) {
604: cp = ep;
605: while(*sp)
606: if(*--cp != *sp++)
607: goto next;
608: for(sp=ep-t->n1; --sp >= word && !isvowel(*sp);)
609: ;
610: if(sp < word)
611: continue;
612: if(!(t->affixable & flag))
613: return 0;
614: h = (*t->p1)(ep-t->n1, t->d1, t->a1, lev+1, t->flag|STOP);
615: if(!h && t->p2!=0) {
616: if(lev<DSIZ)
617: deriv[lev] = deriv[lev+1] = emptyderiv;
618: h = (*t->p2)(ep-t->n2, t->d2, t->a2, lev, t->flag|STOP);
619: }
620: break;
621: next:;
622: }
623: return h;
624: }
625:
626: Bits
627: nop(char* ep, char* d, char* a, int lev, int flag)
628: {
629: #pragma ref ep
630: #pragma ref d
631: #pragma ref a
632: #pragma ref lev
633: #pragma ref flag
634: return 0;
635: }
636:
637: Bits
638: cstrip(char* ep, char* d, char* a, int lev, int flag)
639: {
640: int temp = ep[0];
641:
642: if(isvowel(temp) && isvowel(ep[-1])) {
643: switch(pair(ep[-1],ep[0])) {
644: case pair('a', 'a'):
645: case pair('a', 'e'):
646: case pair('a', 'i'):
647: case pair('e', 'a'):
648: case pair('e', 'e'):
649: case pair('e', 'i'):
650: case pair('i', 'i'):
651: case pair('o', 'a'):
652: return 0;
653: }
654: } else
655: if(temp==ep[-1]&&temp==ep[-2])
656: return 0;
657: return strip(ep,d,a,lev,flag);
658: }
659:
660: Bits
661: strip(char* ep, char* d, char* a, int lev, int flag)
662: {
663: #pragma ref d
664: Bits h = trypref(ep, a, lev, flag);
665:
666: if(Set(h,MONO) && isvowel(*ep) && isvowel(ep[-2]))
667: h = 0;
668: if(h)
669: return h;
670: if(isvowel(*ep) && !isvowel(ep[-1]) && ep[-1]==ep[-2]) {
671: h = trypref(ep-1,a,lev,flag|MONO);
672: if(h)
673: return h;
674: }
675: return trysuff(ep,lev,flag);
676: }
677:
678: Bits
679: s(char* ep, char* d, char* a, int lev, int flag)
680: {
681: if(lev > DLEV+1)
682: return 0;
683: if(*ep=='s') {
684: switch(ep[-1]) {
685: case 'y':
686: if(isvowel(ep[-2])||isupper(*word))
687: break; /*says Kennedys*/
688: case 'x':
689: case 'z':
690: case 's':
691: return 0;
692: case 'h':
693: switch(ep[-2]) {
694: case 'c':
695: case 's':
696: return 0;
697: }
698: }
699: }
700: return strip(ep,d,a,lev,flag);
701: }
702:
703: Bits
704: an(char* ep, char* d, char* a, int lev, int flag)
705: {
706: #pragma ref d
707: if(!isupper(*word)) /*must be proper name*/
708: return 0;
709: return trypref(ep,a,lev,flag);
710: }
711:
712: Bits
713: ize(char* ep, char* d, char* a, int lev, int flag)
714: {
715: #pragma ref a
716: int temp = ep[-1];
717: Bits h;
718:
719: ep[-1] = 'e';
720: h = strip(ep,"",d,lev,flag);
721: ep[-1] = temp;
722: return h;
723: }
724:
725: Bits
726: y_to_e(char* ep, char* d, char* a, int lev, int flag)
727: {
728: #pragma ref a
729: Bits h;
730: int temp;
731:
732: switch(ep[-1]) {
733: case 'a':
734: case 'e':
735: case 'i':
736: return 0;
737: }
738: temp = *ep;
739: *ep++ = 'e';
740: h = strip(ep,"",d,lev,flag);
741: *--ep = temp;
742: return h;
743: }
744:
745: Bits
746: ily(char* ep, char* d, char* a, int lev, int flag)
747: {
748: int temp = ep[0];
749: char *cp = ep;
750:
751: if(temp==ep[-1]&&temp==ep[-2]) /* sillly */
752: return 0;
753: if(*--cp=='y' && !isvowel(*--cp)) /* happyly */
754: while(cp>word)
755: if(isvowel(*--cp)) /* shyness */
756: return 0;
757: if(ep[-1]=='i')
758: return i_to_y(ep,d,a,lev,flag);
759: return cstrip(ep,d,a,lev,flag);
760: }
761:
762: Bits
763: bility(char* ep, char* d, char* a, int lev, int flag)
764: {
765: *ep++ = 'l';
766: return y_to_e(ep,d,a,lev,flag);
767: }
768:
769: Bits
770: i_to_y(char* ep, char* d, char* a, int lev, int flag)
771: {
772: Bits h;
773: int temp;
774:
775: if(isupper(*word))
776: return 0;
777: if((temp=ep[-1])=='i' && !isvowel(ep[-2])) {
778: ep[-1] = 'y';
779: a = d;
780: }
781: h = cstrip(ep,"",a,lev,flag);
782: ep[-1] = temp;
783: return h;
784: }
785:
786: Bits
787: es(char* ep, char* d, char* a, int lev, int flag)
788: {
789: if(lev>DLEV)
790: return 0;
791: switch(ep[-1]) {
792: default:
793: return 0;
794: case 'i':
795: return i_to_y(ep,d,a,lev,flag);
796: case 'h':
797: switch(ep[-2]) {
798: default:
799: return 0;
800: case 'c':
801: case 's':
802: break;
803: }
804: case 's':
805: case 'z':
806: case 'x':
807: return strip(ep,d,a,lev,flag);
808: }
809: }
810:
811: Bits
812: subst(char* ep, char* d, char* a, int lev, int flag)
813: {
814: #pragma ref a
815: char *u,*t;
816: Bits h;
817:
818: if(skipv(skipv(ep-1)) < word)
819: return 0;
820: for(t=d; *t!='+'; t++)
821: continue;
822: for(u=ep; *--t!='-';)
823: *--u = *t;
824: h = strip(ep,"",d,lev,flag);
825: while(*++t != '+')
826: continue;
827: while(*++t)
828: *u++ = *t;
829: return h;
830: }
831:
832: Bits
833: tion(char* ep, char* d, char* a, int lev, int flag)
834: {
835: switch(ep[-2]) {
836: default:
837: return trypref(ep,a,lev,flag);
838: case 'a':
839: case 'e':
840: case 'i':
841: case 'o':
842: case 'u':
843: return y_to_e(ep,d,a,lev,flag);
844: }
845: }
846:
847: /*
848: * possible consonant-consonant-e ending
849: */
850: Bits
851: CCe(char* ep, char* d, char* a, int lev, int flag)
852: {
853: Bits h;
854:
855: switch(ep[-1]) {
856: case 'l':
857: if(isvowel(ep[-2]))
858: break;
859: switch(ep[-2]) {
860: case 'l':
861: case 'r':
862: case 'w':
863: break;
864: default:
865: return y_to_e(ep,d,a,lev,flag);
866: }
867: break;
868: case 'c':
869: case 'g':
870: if(*ep == 'a') /* prevent -able for -eable */
871: return 0;
872: case 's':
873: case 'v':
874: case 'z':
875: if(ep[-2]==ep[-1])
876: break;
877: if(isvowel(ep[-2]))
878: break;
879: case 'u':
880: if(h = y_to_e(ep,d,a,lev,flag))
881: return h;
882: if(!(ep[-2]=='n' && ep[-1]=='g'))
883: return 0;
884: }
885: return VCe(ep,d,a,lev,flag);
886: }
887:
888: /*
889: * possible consonant-vowel-consonant-e ending
890: */
891: Bits
892: VCe(char* ep, char* d, char* a, int lev, int flag)
893: {
894: int c;
895: Bits h;
896:
897: c = ep[-1];
898: if(c=='e')
899: return 0;
900: if(!isvowel(c) && isvowel(ep[-2])) {
901: c = *ep;
902: *ep++ = 'e';
903: h = trypref(ep,d,lev,flag);
904: if(!h)
905: h = trysuff(ep,lev,flag);
906: if(h)
907: return h;
908: ep--;
909: *ep = c;
910: }
911: return cstrip(ep,d,a,lev,flag);
912: }
913:
914: Ptab*
915: lookuppref(char** wp, char* ep)
916: {
917: Ptab *sp;
918: char *bp,*cp;
919: int initchar = Tolower(**wp);
920:
921: if(!isalpha(initchar))
922: return 0;
923: for(sp=preftab[initchar-'a'];sp->s;sp++) {
924: bp = *wp;
925: for(cp= sp->s;*cp; )
926: if(*bp++!=*cp++)
927: goto next;
928: for(cp=bp;cp<ep;cp++)
929: if(isvowel(*cp)) {
930: *wp = bp;
931: return sp;
932: }
933: next:;
934: }
935: return 0;
936: }
937:
938: /* while word is not in dictionary try stripping
939: * prefixes. Fail if no more prefixes.
940: */
941: Bits
942: trypref(char* ep, char* a, int lev, int flag)
943: {
944: Ptab *tp;
945: char *bp, *cp;
946: char *pp;
947: Bits h;
948: char space[20];
949:
950: if(lev<DSIZ) {
951: deriv[lev].mesg = a;
952: deriv[lev].type = *a=='.'? NONE: SUFF;
953: }
954: if(h = tryword(word,ep,lev,flag)) {
955: if(Set(h, flag&~MONO) && (flag&MONO) <= Set(h, MONO))
956: return h;
957: h = 0;
958: }
959: bp = word;
960: pp = space;
961: if(lev<DSIZ) {
962: deriv[lev+1].mesg = pp;
963: deriv[lev+1].type = 0;
964: }
965: while(tp=lookuppref(&bp,ep)) {
966: *pp++ = '+';
967: cp = tp->s;
968: while(pp<space+sizeof(space) && (*pp = *cp++))
969: pp++;
970: deriv[lev+1].type += PREF;
971: h = tryword(bp,ep,lev+1,flag);
972: if(Set(h,NOPREF) ||
973: ((tp->flag&IN) && inun(bp-2,h)==0)) {
974: h = 0;
975: break;
976: }
977: if(Set(h,flag&~MONO) && (flag&MONO) <= Set(h, MONO))
978: break;
979: h = 0;
980: }
981: if(lev<DSIZ)
982: deriv[lev+1] = deriv[lev+2] = emptyderiv;
983: return h;
984: }
985:
986: Bits
987: tryword(char* bp, char* ep, int lev, int flag)
988: {
989: int j;
990: Bits h = 0;
991: char duple[3];
992:
993: if(ep-bp <= 1)
994: return h;
995: if(flag&MONO) {
996: if(lev<DSIZ) {
997: deriv[++lev].mesg = duple;
998: deriv[lev].type = SUFF;
999: }
1000: duple[0] = '+';
1001: duple[1] = *ep;
1002: duple[2] = 0;
1003: }
1004: h = dict(bp, ep);
1005: if(vflag==0 || h==0)
1006: return h;
1007: /*
1008: * when derivations are wanted, collect them
1009: * for printing
1010: */
1011: j = lev;
1012: prefcount = suffcount = 0;
1013: do {
1014: if(j<DSIZ && deriv[j].type) {
1015: strcat(affix, deriv[j].mesg);
1016: if(deriv[j].type == SUFF)
1017: suffcount++;
1018: else if(deriv[j].type != NONE)
1019: prefcount = deriv[j].type/PREF;
1020: }
1021: } while(--j > 0);
1022: return h;
1023: }
1024:
1025: int
1026: inun(char* bp, Bits h)
1027: {
1028: if(*bp == 'u')
1029: return Set(h, IN) == 0;
1030: /* *bp == 'i' */
1031: if(Set(h, IN) == 0)
1032: return 0;
1033: switch(bp[2]) {
1034: case 'r':
1035: return bp[1] == 'r';
1036: case 'm':
1037: case 'p':
1038: return bp[1] == 'm';
1039: }
1040: return bp[1] == 'n';
1041: }
1042:
1043: char*
1044: skipv(char *s)
1045: {
1046: if(s >= word && isvowel(*s))
1047: s--;
1048: while(s >= word && !isvowel(*s))
1049: s--;
1050: return s;
1051: }
1052:
1053: /*
1054: * crummy way to Britishise
1055: */
1056: void
1057: ise(void)
1058: {
1059: Suftab *p;
1060: int i;
1061:
1062: for(i=0; i<26; i++)
1063: for(p = suftab[i]; p->suf; p++) {
1064: p->suf = ztos(p->suf);
1065: p->d1 = ztos(p->d1);
1066: p->a1 = ztos(p->a1);
1067: }
1068: }
1069:
1070: char*
1071: ztos(char *as)
1072: {
1073: char *s, *ds;
1074:
1075: for(s=as; *s; s++)
1076: if(*s == 'z')
1077: goto copy;
1078: return as;
1079:
1080: copy:
1081: ds = strdupl(as);
1082: for(s=ds; *s; s++)
1083: if(*s == 'z')
1084: *s = 's';
1085: return ds;
1086: }
1087:
1088: Bits
1089: dict(char* bp, char* ep)
1090: {
1091: char *cp, *cp1, *w, *wp, *we;
1092: int n, f;
1093:
1094: w = bp;
1095: we = ep;
1096: n = ep-bp;
1097: if(n <= 1)
1098: return NOUN;
1099:
1100: f = w[0] & 0x7f;
1101: f *= 128;
1102: f += w[1] & 0x7f;
1103: bp = spacep[f];
1104: ep = spacep[f+1];
1105:
1106: loop:
1107: if(bp >= ep) {
1108: if(xflag)
1109: fprintf(stderr,"=%.*s\n",n, w);
1110: return 0;
1111: }
1112: /*
1113: * find the beginning of some word in the middle
1114: */
1115: cp = bp + (ep-bp)/2;
1116:
1117: while(cp > bp && !(*cp & 0x80))
1118: cp--;
1119: while(cp > bp && (cp[-1] & 0x80))
1120: cp--;
1121:
1122: wp = w + 2; /* skip two letters */
1123: cp1 = cp + 2; /* skip affix code */
1124: for(;;) {
1125: if(wp >= we) {
1126: if(*cp1&0x80)
1127: goto found;
1128: else
1129: f = 1;
1130: break;
1131: }
1132: if(*cp1&0x80) {
1133: f = -1;
1134: break;
1135: }
1136: f = *cp1++ - *wp++;
1137: if(f != 0)
1138: break;
1139: }
1140:
1141: if(f < 0) {
1142: while(!(*cp1&0x80))
1143: cp1++;
1144: bp = cp1;
1145: goto loop;
1146: }
1147: ep = cp;
1148: goto loop;
1149: found:
1150: f = ((cp[0] & 0x7) << 8) |
1151: (cp[1] & 0xff);
1152: if(xflag) {
1153: fprintf(stderr,"=%.*s ",n,w);
1154: typeprint(encode[f]);
1155: }
1156: return encode[f];
1157: }
1158:
1159: void
1160: typeprint(Bits h)
1161: {
1162:
1163: pcomma("");
1164: if(h & NOUN)
1165: pcomma("n");
1166: if(h & PROP_COLLECT)
1167: pcomma("pc");
1168: if(h & VERB) {
1169: if((h & VERB) == VERB)
1170: pcomma("v");
1171: else
1172: if((h & VERB) == V_IRREG)
1173: pcomma("vi");
1174: else
1175: if(h & ED)
1176: pcomma("ed");
1177: }
1178: if(h & ADJ)
1179: pcomma("a");
1180: if(h & COMP) {
1181: if((h & COMP) == ACTOR)
1182: pcomma("er");
1183: else
1184: pcomma("comp");
1185: }
1186: if(h & DONT_TOUCH)
1187: pcomma("d");
1188: if(h & N_AFFIX)
1189: pcomma("na");
1190: if(h & ADV)
1191: pcomma("adv");
1192: if(h & ION)
1193: pcomma("ion");
1194: if(h & V_AFFIX)
1195: pcomma("va");
1196: if(h & MAN)
1197: pcomma("man");
1198: if(h & NOPREF)
1199: pcomma("nopref");
1200: if(h & MONO)
1201: pcomma("ms");
1202: if(h & IN)
1203: pcomma("in");
1204: if(h & _Y)
1205: pcomma("y");
1206: if(h & STOP)
1207: pcomma("s");
1208: fprintf(stderr, "\n");
1209: }
1210:
1211: void
1212: pcomma(char *s)
1213: {
1214: static flag;
1215:
1216: if(*s == 0) {
1217: flag = 0;
1218: return;
1219: }
1220: if(!flag) {
1221: fprintf(stderr, "%s", s);
1222: flag = 1;
1223: } else
1224: fprintf(stderr, ",%s", s);
1225: }
1226:
1227: int
1228: ordinal(void)
1229: {
1230: char *cp = word;
1231: static char sp[4];
1232:
1233: while(isdigit(*cp))
1234: cp++;
1235: strncpy(sp,cp,3);
1236: if(isupper(cp[0]) && isupper(cp[1])) {
1237: sp[0] = Tolower(cp[0]);
1238: sp[1] = Tolower(cp[1]);
1239: }
1240: return 0 == strncmp(sp,
1241: cp[-2]=='1'? "th": /* out of bounds if 1 digit */
1242: *--cp=='1'? "st": /* harmless */
1243: *cp=='2'? "nd":
1244: *cp=='3'? "rd":
1245: "th", 3);
1246: }
1247:
1248: /* layout of file entry: first byte has bit 0x80 turned on.
1249: next 4 bits count number of characters common between this
1250: entry and previous one. last three bits concatenated with
1251: second byte are the affixing code, so arranged that the 0x80
1252: bit is zero in all bytes but the first. 3rd and following
1253: bytes are the remainder of the dictionary word.
1254:
1255: layout in memory: common prefixes are expanded, and the
1256: first two letters of each word are deleted and found
1257: instead by lookup in table spacep, which points to the
1258: first word for each two-letter prefix.
1259: */
1260:
1261: void
1262: readdict(char *file)
1263: {
1264: char *s, *is, *lasts, *ls;
1265: int c, i, sp, p;
1266: int f;
1267: long l;
1268:
1269: f = open(file, 0);
1270: if(f == -1) {
1271: fprintf(stderr, "spell: cannot open %s\n", file);
1272: exit(1);
1273: }
1274: if(read(f, space, 2) != 2)
1275: goto bad;
1276: nencode = ((space[0]&0xff)<<8) | (space[1]&0xff);
1277: if(nencode > sizeof(encode)/sizeof(*encode))
1278: goto noroom;
1279: if(read(f, space, nencode*sizeof(*encode))
1280: != nencode*sizeof(*encode))
1281: goto bad;
1282: s = space;
1283: for(i=0; i<nencode; i++) {
1284: l = (long)(s[0] & 0xff) << 24;
1285: l |= (s[1] & 0xff) << 16;
1286: l |= (s[2] & 0xff) << 8;
1287: l |= s[3] & 0xff;
1288: encode[i] = (Bits)l;
1289: s += 4;
1290: }
1291: l = read(f, space, sizeof(space));
1292: if(l >= sizeof(space))
1293: goto noroom;
1294: is = space + (sizeof(space) - l);
1295: memmove(is, space, l);
1296:
1297: s = space;
1298: c = *is++ & 0xff;
1299: sp = -1;
1300: i = 0;
1301: lasts = 0; /* to prevent diagnostics */
1302: loop:
1303: if(s > is)
1304: goto noroom;
1305: if(c < 0) {
1306: close(f);
1307: while(sp < 128*128)
1308: spacep[++sp] = s;
1309: *s++ = 0x80; /* fence */
1310: return;
1311: }
1312: p = (c>>3) & 0xf;
1313: *s++ = c;
1314: *s++ = *is++ & 0xff;
1315: if(p <= 0)
1316: i = (*is++ & 0xff)*128;
1317: if(p <= 1) {
1318: if(!(*is & 0x80))
1319: i = i/128*128 + (*is++ & 0xff);
1320: if(i <= sp) {
1321: fprintf(stderr, "spell: the dict isn't "
1322: "sorted or memmove didn't work\n");
1323: goto bad;
1324: }
1325: while(sp < i)
1326: spacep[++sp] = s-2;
1327: }
1328: ls = lasts;
1329: lasts = s;
1330: for(p-=2; p>0; p--)
1331: *s++ = *ls++;
1332: for(;;) {
1333: if(is >= space+sizeof(space)) {
1334: c = -1;
1335: break;
1336: }
1337: c = *is++ & 0xff;
1338: if(c & 0x80)
1339: break;
1340: *s++ = c;
1341: }
1342: *s = 0;
1343: goto loop;
1344:
1345: bad:
1346: fprintf(stderr, "spell: trouble reading %s\n", file);
1347: exit(1);
1348: noroom:
1349: fprintf(stderr,"spell: not enough space for dictionary\n");
1350: exit(1);
1351: }
1352:
1353: char * /* same as strdup; portability hack */
1354: strdupl(char *s)
1355: {
1356: char *t = (char*)malloc(strlen(s)+1);
1357: strcpy(t, s);
1358: return t;
1359: }
1360:
1361: void
1362: runout(char *s)
1363: {
1364: int c;
1365: if(!cflag)
1366: printf("%s", s);
1367: else {
1368: putchar('-');
1369: fflush(stdout);
1370: }
1371: do {
1372: if((c=getchar()) == EOF)
1373: exit(0);
1374: if(!cflag)
1375: putchar(c);
1376: } while(c != '\n');
1377: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.