![[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] / researchv10no / cmd / spell|
Return to sprog.c CVS log | Up to [Research Unix] / researchv10no / 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: "tera", 0,
369: "thermo", 0,
370: 0
371: };
372: Ptab ptabu[] =
373: {
374: "ultra", 0,
375: "under", 0, /*must precede un*/
376: "un", IN,
377: 0
378: };
379: Ptab ptabv[] =
380: {
381: 0
382: };
383: Ptab ptabw[] =
384: {
385: 0
386: };
387: Ptab ptabx[] =
388: {
389: 0
390: };
391: Ptab ptaby[] =
392: {
393: 0
394: };
395: Ptab ptabz[] =
396: {
397: 0
398: };
399:
400: Ptab* preftab[] =
401: {
402: ptaba,
403: ptabb,
404: ptabc,
405: ptabd,
406: ptabe,
407: ptabf,
408: ptabg,
409: ptabh,
410: ptabi,
411: ptabj,
412: ptabk,
413: ptabl,
414: ptabm,
415: ptabn,
416: ptabo,
417: ptabp,
418: ptabq,
419: ptabr,
420: ptabs,
421: ptabt,
422: ptabu,
423: ptabv,
424: ptabw,
425: ptabx,
426: ptaby,
427: ptabz,
428: };
429:
430: typedef struct {
431: char *mesg;
432: enum { NONE, SUFF, PREF} type;
433: } Deriv;
434:
435: int cflag;
436: int fflag;
437: int vflag;
438: int xflag;
439: char word[500];
440: char original[500];
441: Deriv deriv[DSIZ+3];
442: Deriv emptyderiv;
443: char affix[DSIZ*10]; /* 10 is longest affix message */
444: int prefcount;
445: int suffcount;
446: char space[300000]; /* must be as large as "words"+"space" in pcode run */
447: Bits encode[2048]; /* must be as long as "codes" in pcode run */
448: int nencode;
449: char voweltab[128];
450: char* spacep[128*128+1]; /* pointer to words starting with 'xx' */
451:
452: char* codefile = "/usr/lib/spell/amspell";
453: char* brfile = "/usr/lib/spell/brspell";
454:
455: main(int argc, char *argv[])
456: {
457: char *ep, *cp;
458: char *dp;
459: int j, i, c;
460: int low = 0;
461: Bits h;
462:
463: for(i=0; c = "aeiouyAEIOUY"[i]; i++)
464: voweltab[c] = 1;
465: while(argc > 1) {
466: if(argv[1][0] != '-')
467: break;
468: for(i=1; c = argv[1][i]; i++)
469: switch(c) {
470: default:
471: fprintf(stderr, "usage: spell [-bcvx] [-f file]\n");
472: exit(1);
473:
474: case 'b':
475: ise();
476: if(!fflag)
477: codefile = brfile;
478: continue;
479:
480: case 'C':
481: vflag++;
482: case 'c':
483: setbuf(stdout,0);
484: cflag++;
485: continue;
486:
487: case 'v':
488: vflag++;
489: continue;
490:
491: case 'x':
492: xflag++;
493: continue;
494:
495: case 'f':
496: if(argc <= 2) {
497: fprintf(stderr, "spell: -f requires another argument\n");
498: exit(1);
499: }
500: argv++;
501: argc--;
502: fflag++;
503: codefile = argv[1];
504: goto brk;
505: }
506: brk:
507: argv++;
508: argc--;
509: }
510: readdict(codefile);
511: if(argc > 1) {
512: fprintf(stderr, "usage: spell [-bcvx] [-f file]\n");
513: exit(1);
514: }
515: for(;;) {
516: loop:
517: affix[0] = 0;
518: for(ep=original; ; ep++) {
519: if(ep >= original + sizeof(original) - 1) {
520: *ep = 0;
521: runout(original);
522: goto loop;
523: }
524: j = getchar();
525: if(j == EOF)
526: exit(0);
527: if(j != '\n')
528: *ep = j;
529: else {
530: *ep = 0;
531: break;
532: }
533: }
534: low = 0;
535: for(ep=word,dp=original; j = *dp; ep++,dp++) {
536: if(islower(j))
537: low++;
538: if(ep >= word+sizeof(word)-1)
539: break;
540: *ep = j;
541: }
542: *ep = 0;
543:
544: h = ~STOP;
545: if(word[1] == 0 && isalnum(word[0]) ||
546: isdigit(word[0]) && ordinal())
547: goto check;
548:
549: h = 0;
550: if(!low && !(h = trypref(ep,".",0,ALL|STOP|DONT_TOUCH)))
551: for(cp=original+1,dp=word+1; dp<ep; dp++,cp++)
552: *dp = Tolower(*cp);
553: if(!h)
554: for(;;) { /* at most twice */
555: if(h = trypref(ep,".",0,ALL|STOP|DONT_TOUCH))
556: break;
557: if(h = trysuff(ep,0,ALL|STOP|DONT_TOUCH))
558: break;
559: if(!isupper(word[0]))
560: break;
561: cp = original;
562: dp = word;
563: while(*dp = *cp++) {
564: if(!low)
565: *dp = Tolower(*dp);
566: dp++;
567: }
568: word[0] = Tolower(word[0]);
569: }
570: check:
571: if(cflag) {
572: if(!h || Set(h,STOP))
573: putchar('-');
574: else if(!vflag)
575: putchar('+');
576: else
577: putchar('0' + (suffcount>0) +
578: (prefcount>4? 8: 2*prefcount));
579: } else if(!h || Set(h,STOP))
580: printf("%s\n", original);
581: else if(affix[0] != 0 && affix[0] != '.')
582: printf("%s\t%s\n", affix, original);
583: }
584: }
585:
586: /* strip exactly one suffix and do
587: * indicated routine(s), which may recursively
588: * strip suffixes
589: */
590: Bits
591: trysuff(char* ep, int lev, int flag)
592: {
593: Suftab *t;
594: char *cp, *sp;
595: Bits h = 0;
596: int initchar = ep[-1];
597:
598: flag &= ~MONO;
599: lev += DLEV;
600: if(lev<DSIZ)
601: deriv[lev] = deriv[lev-1] = emptyderiv;
602: if(!islower(initchar))
603: return h;
604: for(t=suftab[initchar-'a']; sp=t->suf; t++) {
605: cp = ep;
606: while(*sp)
607: if(*--cp != *sp++)
608: goto next;
609: for(sp=ep-t->n1; --sp >= word && !isvowel(*sp);)
610: ;
611: if(sp < word)
612: continue;
613: if(!(t->affixable & flag))
614: return 0;
615: h = (*t->p1)(ep-t->n1, t->d1, t->a1, lev+1, t->flag|STOP);
616: if(!h && t->p2!=0) {
617: if(lev<DSIZ)
618: deriv[lev] = deriv[lev+1] = emptyderiv;
619: h = (*t->p2)(ep-t->n2, t->d2, t->a2, lev, t->flag|STOP);
620: }
621: break;
622: next:;
623: }
624: return h;
625: }
626:
627: Bits
628: nop(char* ep, char* d, char* a, int lev, int flag)
629: {
630: #pragma ref ep
631: #pragma ref d
632: #pragma ref a
633: #pragma ref lev
634: #pragma ref flag
635: return 0;
636: }
637:
638: Bits
639: cstrip(char* ep, char* d, char* a, int lev, int flag)
640: {
641: int temp = ep[0];
642:
643: if(isvowel(temp) && isvowel(ep[-1])) {
644: switch(pair(ep[-1],ep[0])) {
645: case pair('a', 'a'):
646: case pair('a', 'e'):
647: case pair('a', 'i'):
648: case pair('e', 'a'):
649: case pair('e', 'e'):
650: case pair('e', 'i'):
651: case pair('i', 'i'):
652: case pair('o', 'a'):
653: return 0;
654: }
655: } else
656: if(temp==ep[-1]&&temp==ep[-2])
657: return 0;
658: return strip(ep,d,a,lev,flag);
659: }
660:
661: Bits
662: strip(char* ep, char* d, char* a, int lev, int flag)
663: {
664: #pragma ref d
665: Bits h = trypref(ep, a, lev, flag);
666:
667: if(Set(h,MONO) && isvowel(*ep) && isvowel(ep[-2]))
668: h = 0;
669: if(h)
670: return h;
671: if(isvowel(*ep) && !isvowel(ep[-1]) && ep[-1]==ep[-2]) {
672: h = trypref(ep-1,a,lev,flag|MONO);
673: if(h)
674: return h;
675: }
676: return trysuff(ep,lev,flag);
677: }
678:
679: Bits
680: s(char* ep, char* d, char* a, int lev, int flag)
681: {
682: if(lev > DLEV+1)
683: return 0;
684: if(*ep=='s') {
685: switch(ep[-1]) {
686: case 'y':
687: if(isvowel(ep[-2])||isupper(*word))
688: break; /*says Kennedys*/
689: case 'x':
690: case 'z':
691: case 's':
692: return 0;
693: case 'h':
694: switch(ep[-2]) {
695: case 'c':
696: case 's':
697: return 0;
698: }
699: }
700: }
701: return strip(ep,d,a,lev,flag);
702: }
703:
704: Bits
705: an(char* ep, char* d, char* a, int lev, int flag)
706: {
707: #pragma ref d
708: if(!isupper(*word)) /*must be proper name*/
709: return 0;
710: return trypref(ep,a,lev,flag);
711: }
712:
713: Bits
714: ize(char* ep, char* d, char* a, int lev, int flag)
715: {
716: #pragma ref a
717: int temp = ep[-1];
718: Bits h;
719:
720: ep[-1] = 'e';
721: h = strip(ep,"",d,lev,flag);
722: ep[-1] = temp;
723: return h;
724: }
725:
726: Bits
727: y_to_e(char* ep, char* d, char* a, int lev, int flag)
728: {
729: #pragma ref a
730: Bits h;
731: int temp;
732:
733: switch(ep[-1]) {
734: case 'a':
735: case 'e':
736: case 'i':
737: return 0;
738: }
739: temp = *ep;
740: *ep++ = 'e';
741: h = strip(ep,"",d,lev,flag);
742: *--ep = temp;
743: return h;
744: }
745:
746: Bits
747: ily(char* ep, char* d, char* a, int lev, int flag)
748: {
749: int temp = ep[0];
750: char *cp = ep;
751:
752: if(temp==ep[-1]&&temp==ep[-2]) /* sillly */
753: return 0;
754: if(*--cp=='y' && !isvowel(*--cp)) /* happyly */
755: while(cp>word)
756: if(isvowel(*--cp)) /* shyness */
757: return 0;
758: if(ep[-1]=='i')
759: return i_to_y(ep,d,a,lev,flag);
760: return cstrip(ep,d,a,lev,flag);
761: }
762:
763: Bits
764: bility(char* ep, char* d, char* a, int lev, int flag)
765: {
766: *ep++ = 'l';
767: return y_to_e(ep,d,a,lev,flag);
768: }
769:
770: Bits
771: i_to_y(char* ep, char* d, char* a, int lev, int flag)
772: {
773: Bits h;
774: int temp;
775:
776: if(isupper(*word))
777: return 0;
778: if((temp=ep[-1])=='i' && !isvowel(ep[-2])) {
779: ep[-1] = 'y';
780: a = d;
781: }
782: h = cstrip(ep,"",a,lev,flag);
783: ep[-1] = temp;
784: return h;
785: }
786:
787: Bits
788: es(char* ep, char* d, char* a, int lev, int flag)
789: {
790: if(lev>DLEV)
791: return 0;
792: switch(ep[-1]) {
793: default:
794: return 0;
795: case 'i':
796: return i_to_y(ep,d,a,lev,flag);
797: case 'h':
798: switch(ep[-2]) {
799: default:
800: return 0;
801: case 'c':
802: case 's':
803: break;
804: }
805: case 's':
806: case 'z':
807: case 'x':
808: return strip(ep,d,a,lev,flag);
809: }
810: }
811:
812: Bits
813: subst(char* ep, char* d, char* a, int lev, int flag)
814: {
815: #pragma ref a
816: char *u,*t;
817: Bits h;
818:
819: if(skipv(skipv(ep-1)) < word)
820: return 0;
821: for(t=d; *t!='+'; t++)
822: continue;
823: for(u=ep; *--t!='-';)
824: *--u = *t;
825: h = strip(ep,"",d,lev,flag);
826: while(*++t != '+')
827: continue;
828: while(*++t)
829: *u++ = *t;
830: return h;
831: }
832:
833: Bits
834: tion(char* ep, char* d, char* a, int lev, int flag)
835: {
836: switch(ep[-2]) {
837: default:
838: return trypref(ep,a,lev,flag);
839: case 'a':
840: case 'e':
841: case 'i':
842: case 'o':
843: case 'u':
844: return y_to_e(ep,d,a,lev,flag);
845: }
846: }
847:
848: /*
849: * possible consonant-consonant-e ending
850: */
851: Bits
852: CCe(char* ep, char* d, char* a, int lev, int flag)
853: {
854: Bits h;
855:
856: switch(ep[-1]) {
857: case 'l':
858: if(isvowel(ep[-2]))
859: break;
860: switch(ep[-2]) {
861: case 'l':
862: case 'r':
863: case 'w':
864: break;
865: default:
866: return y_to_e(ep,d,a,lev,flag);
867: }
868: break;
869: case 'c':
870: case 'g':
871: if(*ep == 'a') /* prevent -able for -eable */
872: return 0;
873: case 's':
874: case 'v':
875: case 'z':
876: if(ep[-2]==ep[-1])
877: break;
878: if(isvowel(ep[-2]))
879: break;
880: case 'u':
881: if(h = y_to_e(ep,d,a,lev,flag))
882: return h;
883: if(!(ep[-2]=='n' && ep[-1]=='g'))
884: return 0;
885: }
886: return VCe(ep,d,a,lev,flag);
887: }
888:
889: /*
890: * possible consonant-vowel-consonant-e ending
891: */
892: Bits
893: VCe(char* ep, char* d, char* a, int lev, int flag)
894: {
895: int c;
896: Bits h;
897:
898: c = ep[-1];
899: if(c=='e')
900: return 0;
901: if(!isvowel(c) && isvowel(ep[-2])) {
902: c = *ep;
903: *ep++ = 'e';
904: h = trypref(ep,d,lev,flag);
905: if(!h)
906: h = trysuff(ep,lev,flag);
907: if(h)
908: return h;
909: ep--;
910: *ep = c;
911: }
912: return cstrip(ep,d,a,lev,flag);
913: }
914:
915: Ptab*
916: lookuppref(char** wp, char* ep)
917: {
918: Ptab *sp;
919: char *bp,*cp;
920: int initchar = Tolower(**wp);
921:
922: if(!isalpha(initchar))
923: return 0;
924: for(sp=preftab[initchar-'a'];sp->s;sp++) {
925: bp = *wp;
926: for(cp= sp->s;*cp; )
927: if(*bp++!=*cp++)
928: goto next;
929: for(cp=bp;cp<ep;cp++)
930: if(isvowel(*cp)) {
931: *wp = bp;
932: return sp;
933: }
934: next:;
935: }
936: return 0;
937: }
938:
939: /* while word is not in dictionary try stripping
940: * prefixes. Fail if no more prefixes.
941: */
942: Bits
943: trypref(char* ep, char* a, int lev, int flag)
944: {
945: Ptab *tp;
946: char *bp, *cp;
947: char *pp;
948: Bits h;
949: char space[20];
950:
951: if(lev<DSIZ) {
952: deriv[lev].mesg = a;
953: deriv[lev].type = *a=='.'? NONE: SUFF;
954: }
955: if(h = tryword(word,ep,lev,flag)) {
956: if(Set(h, flag&~MONO) && (flag&MONO) <= Set(h, MONO))
957: return h;
958: h = 0;
959: }
960: bp = word;
961: pp = space;
962: if(lev<DSIZ) {
963: deriv[lev+1].mesg = pp;
964: deriv[lev+1].type = 0;
965: }
966: while(tp=lookuppref(&bp,ep)) {
967: *pp++ = '+';
968: cp = tp->s;
969: while(pp<space+sizeof(space) && (*pp = *cp++))
970: pp++;
971: deriv[lev+1].type += PREF;
972: h = tryword(bp,ep,lev+1,flag);
973: if(Set(h,NOPREF) ||
974: ((tp->flag&IN) && inun(bp-2,h)==0)) {
975: h = 0;
976: break;
977: }
978: if(Set(h,flag&~MONO) && (flag&MONO) <= Set(h, MONO))
979: break;
980: h = 0;
981: }
982: if(lev<DSIZ)
983: deriv[lev+1] = deriv[lev+2] = emptyderiv;
984: return h;
985: }
986:
987: Bits
988: tryword(char* bp, char* ep, int lev, int flag)
989: {
990: int j;
991: Bits h = 0;
992: char duple[3];
993:
994: if(ep-bp <= 1)
995: return h;
996: if(flag&MONO) {
997: if(lev<DSIZ) {
998: deriv[++lev].mesg = duple;
999: deriv[lev].type = SUFF;
1000: }
1001: duple[0] = '+';
1002: duple[1] = *ep;
1003: duple[2] = 0;
1004: }
1005: h = dict(bp, ep);
1006: if(vflag==0 || h==0)
1007: return h;
1008: /*
1009: * when derivations are wanted, collect them
1010: * for printing
1011: */
1012: j = lev;
1013: prefcount = suffcount = 0;
1014: do {
1015: if(j<DSIZ && deriv[j].type) {
1016: strcat(affix, deriv[j].mesg);
1017: if(deriv[j].type == SUFF)
1018: suffcount++;
1019: else if(deriv[j].type != NONE)
1020: prefcount = deriv[j].type/PREF;
1021: }
1022: } while(--j > 0);
1023: return h;
1024: }
1025:
1026: int
1027: inun(char* bp, Bits h)
1028: {
1029: if(*bp == 'u')
1030: return Set(h, IN) == 0;
1031: /* *bp == 'i' */
1032: if(Set(h, IN) == 0)
1033: return 0;
1034: switch(bp[2]) {
1035: case 'r':
1036: return bp[1] == 'r';
1037: case 'm':
1038: case 'p':
1039: return bp[1] == 'm';
1040: }
1041: return bp[1] == 'n';
1042: }
1043:
1044: char*
1045: skipv(char *s)
1046: {
1047: if(s >= word && isvowel(*s))
1048: s--;
1049: while(s >= word && !isvowel(*s))
1050: s--;
1051: return s;
1052: }
1053:
1054: /*
1055: * crummy way to Britishise
1056: */
1057: void
1058: ise(void)
1059: {
1060: Suftab *p;
1061: int i;
1062:
1063: for(i=0; i<26; i++)
1064: for(p = suftab[i]; p->suf; p++) {
1065: p->suf = ztos(p->suf);
1066: p->d1 = ztos(p->d1);
1067: p->a1 = ztos(p->a1);
1068: }
1069: }
1070:
1071: char*
1072: ztos(char *as)
1073: {
1074: char *s, *ds;
1075:
1076: for(s=as; *s; s++)
1077: if(*s == 'z')
1078: goto copy;
1079: return as;
1080:
1081: copy:
1082: ds = strdupl(as);
1083: for(s=ds; *s; s++)
1084: if(*s == 'z')
1085: *s = 's';
1086: return ds;
1087: }
1088:
1089: Bits
1090: dict(char* bp, char* ep)
1091: {
1092: char *cp, *cp1, *w, *wp, *we;
1093: int n, f;
1094:
1095: w = bp;
1096: we = ep;
1097: n = ep-bp;
1098: if(n <= 1)
1099: return NOUN;
1100:
1101: f = w[0] & 0x7f;
1102: f *= 128;
1103: f += w[1] & 0x7f;
1104: bp = spacep[f];
1105: ep = spacep[f+1];
1106:
1107: loop:
1108: if(bp >= ep) {
1109: if(xflag)
1110: fprintf(stderr,"=%.*s\n",n, w);
1111: return 0;
1112: }
1113: /*
1114: * find the beginning of some word in the middle
1115: */
1116: cp = bp + (ep-bp)/2;
1117:
1118: while(cp > bp && !(*cp & 0x80))
1119: cp--;
1120: while(cp > bp && (cp[-1] & 0x80))
1121: cp--;
1122:
1123: wp = w + 2; /* skip two letters */
1124: cp1 = cp + 2; /* skip affix code */
1125: for(;;) {
1126: if(wp >= we) {
1127: if(*cp1&0x80)
1128: goto found;
1129: else
1130: f = 1;
1131: break;
1132: }
1133: if(*cp1&0x80) {
1134: f = -1;
1135: break;
1136: }
1137: f = *cp1++ - *wp++;
1138: if(f != 0)
1139: break;
1140: }
1141:
1142: if(f < 0) {
1143: while(!(*cp1&0x80))
1144: cp1++;
1145: bp = cp1;
1146: goto loop;
1147: }
1148: ep = cp;
1149: goto loop;
1150: found:
1151: f = ((cp[0] & 0x7) << 8) |
1152: (cp[1] & 0xff);
1153: if(xflag) {
1154: fprintf(stderr,"=%.*s ",n,w);
1155: typeprint(encode[f]);
1156: }
1157: return encode[f];
1158: }
1159:
1160: void
1161: typeprint(Bits h)
1162: {
1163:
1164: pcomma("");
1165: if(h & NOUN)
1166: pcomma("n");
1167: if(h & PROP_COLLECT)
1168: pcomma("pc");
1169: if(h & VERB) {
1170: if((h & VERB) == VERB)
1171: pcomma("v");
1172: else
1173: if((h & VERB) == V_IRREG)
1174: pcomma("vi");
1175: else
1176: if(h & ED)
1177: pcomma("ed");
1178: }
1179: if(h & ADJ)
1180: pcomma("a");
1181: if(h & COMP) {
1182: if((h & COMP) == ACTOR)
1183: pcomma("er");
1184: else
1185: pcomma("comp");
1186: }
1187: if(h & DONT_TOUCH)
1188: pcomma("d");
1189: if(h & N_AFFIX)
1190: pcomma("na");
1191: if(h & ADV)
1192: pcomma("adv");
1193: if(h & ION)
1194: pcomma("ion");
1195: if(h & V_AFFIX)
1196: pcomma("va");
1197: if(h & MAN)
1198: pcomma("man");
1199: if(h & NOPREF)
1200: pcomma("nopref");
1201: if(h & MONO)
1202: pcomma("ms");
1203: if(h & IN)
1204: pcomma("in");
1205: if(h & _Y)
1206: pcomma("y");
1207: if(h & STOP)
1208: pcomma("s");
1209: fprintf(stderr, "\n");
1210: }
1211:
1212: void
1213: pcomma(char *s)
1214: {
1215: static flag;
1216:
1217: if(*s == 0) {
1218: flag = 0;
1219: return;
1220: }
1221: if(!flag) {
1222: fprintf(stderr, "%s", s);
1223: flag = 1;
1224: } else
1225: fprintf(stderr, ",%s", s);
1226: }
1227:
1228: int
1229: ordinal(void)
1230: {
1231: char *cp = word;
1232: static char sp[4];
1233:
1234: while(isdigit(*cp))
1235: cp++;
1236: strncpy(sp,cp,3);
1237: if(isupper(cp[0]) && isupper(cp[1])) {
1238: sp[0] = Tolower(cp[0]);
1239: sp[1] = Tolower(cp[1]);
1240: }
1241: return 0 == strncmp(sp,
1242: cp[-2]=='1'? "th": /* out of bounds if 1 digit */
1243: *--cp=='1'? "st": /* harmless */
1244: *cp=='2'? "nd":
1245: *cp=='3'? "rd":
1246: "th", 3);
1247: }
1248:
1249: /* layout of file entry: first byte has bit 0x80 turned on.
1250: next 4 bits count number of characters common between this
1251: entry and previous one. last three bits concatenated with
1252: second byte are the affixing code, so arranged that the 0x80
1253: bit is zero in all bytes but the first. 3rd and following
1254: bytes are the remainder of the dictionary word.
1255:
1256: layout in memory: common prefixes are expanded, and the
1257: first two letters of each word are deleted and found
1258: instead by lookup in table spacep, which points to the
1259: first word for each two-letter prefix.
1260: */
1261:
1262: void
1263: readdict(char *file)
1264: {
1265: char *s, *is, *lasts, *ls;
1266: int c, i, sp, p;
1267: int f;
1268: long l;
1269:
1270: f = open(file, 0);
1271: if(f == -1) {
1272: fprintf(stderr, "spell: cannot open %s\n", file);
1273: exit(1);
1274: }
1275: if(read(f, space, 2) != 2)
1276: goto bad;
1277: nencode = ((space[0]&0xff)<<8) | (space[1]&0xff);
1278: if(nencode > sizeof(encode)/sizeof(*encode))
1279: goto noroom;
1280: if(read(f, space, nencode*sizeof(*encode))
1281: != nencode*sizeof(*encode))
1282: goto bad;
1283: s = space;
1284: for(i=0; i<nencode; i++) {
1285: l = (long)(s[0] & 0xff) << 24;
1286: l |= (s[1] & 0xff) << 16;
1287: l |= (s[2] & 0xff) << 8;
1288: l |= s[3] & 0xff;
1289: encode[i] = (Bits)l;
1290: s += 4;
1291: }
1292: l = read(f, space, sizeof(space));
1293: if(l >= sizeof(space))
1294: goto noroom;
1295: is = space + (sizeof(space) - l);
1296: memmove(is, space, l);
1297:
1298: s = space;
1299: c = *is++ & 0xff;
1300: sp = -1;
1301: i = 0;
1302: lasts = 0; /* to prevent diagnostics */
1303: loop:
1304: if(s > is)
1305: goto noroom;
1306: if(c < 0) {
1307: close(f);
1308: while(sp < 128*128)
1309: spacep[++sp] = s;
1310: *s++ = 0x80; /* fence */
1311: return;
1312: }
1313: p = (c>>3) & 0xf;
1314: *s++ = c;
1315: *s++ = *is++ & 0xff;
1316: if(p <= 0)
1317: i = (*is++ & 0xff)*128;
1318: if(p <= 1) {
1319: if(!(*is & 0x80))
1320: i = i/128*128 + (*is++ & 0xff);
1321: if(i <= sp) {
1322: fprintf(stderr, "spell: the dict isn't "
1323: "sorted or memmove didn't work\n");
1324: goto bad;
1325: }
1326: while(sp < i)
1327: spacep[++sp] = s-2;
1328: }
1329: ls = lasts;
1330: lasts = s;
1331: for(p-=2; p>0; p--)
1332: *s++ = *ls++;
1333: for(;;) {
1334: if(is >= space+sizeof(space)) {
1335: c = -1;
1336: break;
1337: }
1338: c = *is++ & 0xff;
1339: if(c & 0x80)
1340: break;
1341: *s++ = c;
1342: }
1343: *s = 0;
1344: goto loop;
1345:
1346: bad:
1347: fprintf(stderr, "spell: trouble reading %s\n", file);
1348: exit(1);
1349: noroom:
1350: fprintf(stderr,"spell: not enough space for dictionary\n");
1351: exit(1);
1352: }
1353:
1354: char * /* same as strdup; portability hack */
1355: strdupl(char *s)
1356: {
1357: char *t = (char*)malloc(strlen(s)+1);
1358: strcpy(t, s);
1359: return t;
1360: }
1361:
1362: void
1363: runout(char *s)
1364: {
1365: int c;
1366: if(!cflag)
1367: printf("%s", s);
1368: else {
1369: putchar('-');
1370: fflush(stdout);
1371: }
1372: do {
1373: if((c=getchar()) == EOF)
1374: exit(0);
1375: if(!cflag)
1376: putchar(c);
1377: } while(c != '\n');
1378: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.