1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2015 Gary Mills
24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
30
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <limits.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <ctype.h>
37 #include <locale.h>
38 #include "hash.h"
39
40 #define Tolower(c) (isupper(c)?tolower(c):c)
41 #define DLEV 2
42
43 /*
44 * ANSI prototypes
45 */
46 static int ily(char *, char *, char *, int);
47 static int s(char *, char *, char *, int);
48 static int es(char *, char *, char *, int);
49 static int subst(char *, char *, char *, int);
50 static int nop(void);
51 static int bility(char *, char *, char *, int);
52 static int i_to_y(char *, char *, char *, int);
53 static int CCe(char *, char *, char *, int);
54 static int y_to_e(char *, char *, char *, int);
55 static int strip(char *, char *, char *, int);
56 static int ize(char *, char *, char *, int);
57 static int tion(char *, char *, char *, int);
58 static int an(char *, char *, char *, int);
59 int prime(char *);
60 static int tryword(char *, char *, int);
61 static int trypref(char *, char *, int);
62 static int trysuff(char *, int);
63 static int vowel(int);
64 static int dict(char *, char *);
65 static int monosyl(char *, char *);
66 static int VCe(char *, char *, char *, int);
67 static char *skipv(char *);
68
69 struct suftab {
70 char *suf;
71 int (*p1)();
72 int n1;
73 char *d1;
74 char *a1;
75 int (*p2)();
76 int n2;
77 char *d2;
78 char *a2;
79 };
80
81 static struct suftab sufa[] = {
82 {"ssen", ily, 4, "-y+iness", "+ness" },
83 {"ssel", ily, 4, "-y+i+less", "+less" },
84 {"se", s, 1, "", "+s", es, 2, "-y+ies", "+es" },
85 {"s'", s, 2, "", "+'s"},
86 {"s", s, 1, "", "+s"},
87 {"ecn", subst, 1, "-t+ce", ""},
88 {"ycn", subst, 1, "-t+cy", ""},
89 {"ytilb", nop, 0, "", ""},
90 {"ytilib", bility, 5, "-le+ility", ""},
91 {"elbaif", i_to_y, 4, "-y+iable", ""},
92 {"elba", CCe, 4, "-e+able", "+able"},
93 {"yti", CCe, 3, "-e+ity", "+ity"},
94 {"ylb", y_to_e, 1, "-e+y", ""},
95 {"yl", ily, 2, "-y+ily", "+ly"},
96 {"laci", strip, 2, "", "+al"},
97 {"latnem", strip, 2, "", "+al"},
98 {"lanoi", strip, 2, "", "+al"},
99 {"tnem", strip, 4, "", "+ment"},
100 {"gni", CCe, 3, "-e+ing", "+ing"},
101 {"reta", nop, 0, "", ""},
102 {"retc", nop, 0, "", ""},
103 {"re", strip, 1, "", "+r", i_to_y, 2, "-y+ier", "+er"},
104 {"de", strip, 1, "", "+d", i_to_y, 2, "-y+ied", "+ed"},
105 {"citsi", strip, 2, "", "+ic"},
106 {"citi", ize, 1, "-ic+e", ""},
107 {"cihparg", i_to_y, 1, "-y+ic", ""},
108 {"tse", strip, 2, "", "+st", i_to_y, 3, "-y+iest", "+est"},
109 {"cirtem", i_to_y, 1, "-y+ic", ""},
110 {"yrtem", subst, 0, "-er+ry", ""},
111 {"cigol", i_to_y, 1, "-y+ic", ""},
112 {"tsigol", i_to_y, 2, "-y+ist", ""},
113 {"tsi", CCe, 3, "-e+ist", "+ist"},
114 {"msi", CCe, 3, "-e+ism", "+ist"},
115 {"noitacifi", i_to_y, 6, "-y+ication", ""},
116 {"noitazi", ize, 4, "-e+ation", ""},
117 {"rota", tion, 2, "-e+or", ""},
118 {"rotc", tion, 2, "", "+or"},
119 {"noit", tion, 3, "-e+ion", "+ion"},
120 {"naino", an, 3, "", "+ian"},
121 {"na", an, 1, "", "+n"},
122 {"evi", subst, 0, "-ion+ive", ""},
123 {"ezi", CCe, 3, "-e+ize", "+ize"},
124 {"pihs", strip, 4, "", "+ship"},
125 {"dooh", ily, 4, "-y+ihood", "+hood"},
126 {"luf", ily, 3, "-y+iful", "+ful"},
127 {"ekil", strip, 4, "", "+like"},
128 0
129 };
130
131 static struct suftab sufb[] = {
132 {"ssen", ily, 4, "-y+iness", "+ness" },
133 {"ssel", ily, 4, "-y+i+less", "+less" },
134 {"se", s, 1, "", "+s", es, 2, "-y+ies", "+es" },
135 {"s'", s, 2, "", "+'s"},
136 {"s", s, 1, "", "+s"},
137 {"ecn", subst, 1, "-t+ce", ""},
138 {"ycn", subst, 1, "-t+cy", ""},
139 {"ytilb", nop, 0, "", ""},
140 {"ytilib", bility, 5, "-le+ility", ""},
141 {"elbaif", i_to_y, 4, "-y+iable", ""},
142 {"elba", CCe, 4, "-e+able", "+able"},
143 {"yti", CCe, 3, "-e+ity", "+ity"},
144 {"ylb", y_to_e, 1, "-e+y", ""},
145 {"yl", ily, 2, "-y+ily", "+ly"},
146 {"laci", strip, 2, "", "+al"},
147 {"latnem", strip, 2, "", "+al"},
148 {"lanoi", strip, 2, "", "+al"},
149 {"tnem", strip, 4, "", "+ment"},
150 {"gni", CCe, 3, "-e+ing", "+ing"},
151 {"reta", nop, 0, "", ""},
152 {"retc", nop, 0, "", ""},
153 {"re", strip, 1, "", "+r", i_to_y, 2, "-y+ier", "+er"},
154 {"de", strip, 1, "", "+d", i_to_y, 2, "-y+ied", "+ed"},
155 {"citsi", strip, 2, "", "+ic"},
156 {"citi", ize, 1, "-ic+e", ""},
157 {"cihparg", i_to_y, 1, "-y+ic", ""},
158 {"tse", strip, 2, "", "+st", i_to_y, 3, "-y+iest", "+est"},
159 {"cirtem", i_to_y, 1, "-y+ic", ""},
160 {"yrtem", subst, 0, "-er+ry", ""},
161 {"cigol", i_to_y, 1, "-y+ic", ""},
162 {"tsigol", i_to_y, 2, "-y+ist", ""},
163 {"tsi", CCe, 3, "-e+ist", "+ist"},
164 {"msi", CCe, 3, "-e+ism", "+ist"},
165 {"noitacifi", i_to_y, 6, "-y+ication", ""},
166 {"noitasi", ize, 4, "-e+ation", ""},
167 {"rota", tion, 2, "-e+or", ""},
168 {"rotc", tion, 2, "", "+or"},
169 {"noit", tion, 3, "-e+ion", "+ion"},
170 {"naino", an, 3, "", "+ian"},
171 {"na", an, 1, "", "+n"},
172 {"evi", subst, 0, "-ion+ive", ""},
173 {"esi", CCe, 3, "-e+ise", "+ise"},
174 {"pihs", strip, 4, "", "+ship"},
175 {"dooh", ily, 4, "-y+ihood", "+hood"},
176 {"luf", ily, 3, "-y+iful", "+ful"},
177 {"ekil", strip, 4, "", "+like"},
178 0
179 };
180
181 static char *preftab[] = {
182 "anti",
183 "auto",
184 "bio",
185 "counter",
186 "dis",
187 "electro",
188 "en",
189 "fore",
190 "geo",
191 "hyper",
192 "intra",
193 "inter",
194 "iso",
195 "kilo",
196 "magneto",
197 "meta",
198 "micro",
199 "mid",
200 "milli",
201 "mis",
202 "mono",
203 "multi",
204 "non",
205 "out",
206 "over",
207 "photo",
208 "poly",
209 "pre",
210 "pseudo",
211 "psycho",
212 "re",
213 "semi",
214 "stereo",
215 "sub",
216 "super",
217 "tele",
218 "thermo",
219 "ultra",
220 "under", /* must precede un */
221 "un",
222 0
223 };
224
225 static int bflag;
226 static int vflag;
227 static int xflag;
228 static struct suftab *suftab;
229 static char *prog;
230 static char word[LINE_MAX];
231 static char original[LINE_MAX];
232 static char *deriv[LINE_MAX];
233 static char affix[LINE_MAX];
234 static FILE *file, *found;
235 /*
236 * deriv is stack of pointers to notes like +micro +ed
237 * affix is concatenated string of notes
238 * the buffer size 141 stems from the sizes of original and affix.
239 */
240
241 /*
242 * in an attempt to defray future maintenance misunderstandings, here is
243 * an attempt to describe the input/output expectations of the spell
244 * program.
245 *
246 * spellprog is intended to be called from the shell file spell.
247 * because of this, there is little error checking (this is historical, not
248 * necessarily advisable).
249 *
250 * spellprog options hashed-list pass
251 *
252 * the hashed-list is a list of the form made by spellin.
253 * there are 2 types of hashed lists:
254 * 1. a stop list: this specifies words that by the rules embodied
255 * in spellprog would be recognized as correct, BUT are really
256 * errors.
257 * 2. a dictionary of correctly spelled words.
258 * the pass number determines how the words found in the specified
259 * hashed-list are treated. If the pass number is 1, the hashed-list is
260 * treated as the stop-list, otherwise, it is treated as the regular
261 * dictionary list. in this case, the value of "pass" is a filename. Found
262 * words are written to this file.
263 *
264 * In the normal case, the filename = /dev/null. However, if the v option
265 * is specified, the derivations are written to this file.
266 * The spellprog looks up words in the hashed-list; if a word is found, it
267 * is printed to the stdout. If the hashed-list was the stop-list, the
268 * words found are presumed to be misspellings. in this case,
269 * a control character is printed ( a "-" is appended to the word.
270 * a hyphen will never occur naturally in the input list because deroff
271 * is used in the shell file before calling spellprog.)
272 * If the regualar spelling list was used (hlista or hlistb), the words
273 * are correct, and may be ditched. (unless the -v option was used -
274 * see the manual page).
275 *
276 * spellprog should be called twice : first with the stop-list, to flag all
277 * a priori incorrectly spelled words; second with the dictionary.
278 *
279 * spellprog hstop 1 |\
280 * spellprog hlista /dev/null
281 *
282 * for a complete scenario, see the shell file: spell.
283 *
284 */
285
286 int
287 main(int argc, char **argv)
288 {
289 char *ep, *cp;
290 char *dp;
291 int fold;
292 int c, j;
293 int pass;
294
295 /* Set locale environment variables local definitions */
296 (void) setlocale(LC_ALL, "");
297 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
298 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */
299 #endif
300 (void) textdomain(TEXT_DOMAIN);
301
302
303 prog = argv[0];
304 while ((c = getopt(argc, argv, "bvx")) != EOF) {
305 switch (c) {
306 case 'b':
307 bflag++;
308 break;
309 case 'v':
310 vflag++;
311 break;
312 case 'x':
313 xflag++;
314 break;
315 }
316 }
317
318 argc -= optind;
319 argv = &argv[optind];
320
321 if ((argc < 2) || !prime(*argv)) {
322 (void) fprintf(stderr,
323 gettext("%s: cannot initialize hash table\n"), prog);
324 exit(1);
325 }
326 argc--;
327 argv++;
328
329 /* Select the correct suffix table */
330 suftab = (bflag == 0) ? sufa : sufb;
331
332 /*
333 * if pass is not 1, it is assumed to be a filename.
334 * found words are written to this file.
335 */
336 pass = **argv;
337 if (pass != '1')
338 found = fopen(*argv, "w");
339
340 for (;;) {
341 affix[0] = 0;
342 file = stdout;
343 for (ep = word; (*ep = j = getchar()) != '\n'; ep++)
344 if (j == EOF)
345 exit(0);
346 /*
347 * here is the hyphen processing. these words were found in the stop
348 * list. however, if they exist as is, (no derivations tried) in the
349 * dictionary, let them through as correct.
350 *
351 */
352 if (ep[-1] == '-') {
353 *--ep = 0;
354 if (!tryword(word, ep, 0))
355 (void) fprintf(file, "%s\n", word);
356 continue;
357 }
358 for (cp = word, dp = original; cp < ep; )
359 *dp++ = *cp++;
360 *dp = 0;
361 fold = 0;
362 for (cp = word; cp < ep; cp++)
363 if (islower(*cp))
364 goto lcase;
365 if (((ep - word) == 1) &&
366 ((word[0] == 'A') || (word[0] == 'I')))
367 continue;
368 if (trypref(ep, ".", 0))
369 goto foundit;
370 ++fold;
371 for (cp = original+1, dp = word+1; dp < ep; dp++, cp++)
372 *dp = Tolower(*cp);
373 lcase:
374 if (((ep - word) == 1) && (word[0] == 'a'))
375 continue;
376 if (trypref(ep, ".", 0)||trysuff(ep, 0))
377 goto foundit;
378 if (isupper(word[0])) {
379 for (cp = original, dp = word; *dp = *cp++; dp++)
380 if (fold) *dp = Tolower(*dp);
381 word[0] = Tolower(word[0]);
382 goto lcase;
383 }
384 (void) fprintf(file, "%s\n", original);
385 continue;
386
387 foundit:
388 if (pass == '1')
389 (void) fprintf(file, "%s-\n", original);
390 else if (affix[0] != 0 && affix[0] != '.') {
391 file = found;
392 (void) fprintf(file, "%s\t%s\n", affix,
393 original);
394 }
395 }
396 }
397
398 /*
399 * strip exactly one suffix and do
400 * indicated routine(s), which may recursively
401 * strip suffixes
402 */
403
404 static int
405 trysuff(char *ep, int lev)
406 {
407 struct suftab *t;
408 char *cp, *sp;
409
410 lev += DLEV;
411 deriv[lev] = deriv[lev-1] = 0;
412 for (t = &suftab[0]; (t != 0 && (sp = t->suf) != 0); t++) {
413 cp = ep;
414 while (*sp)
415 if (*--cp != *sp++)
416 goto next;
417 for (sp = cp; --sp >= word && !vowel(*sp); )
418 ;
419 if (sp < word)
420 return (0);
421 if ((*t->p1)(ep-t->n1, t->d1, t->a1, lev+1))
422 return (1);
423 if (t->p2 != 0) {
424 deriv[lev] = deriv[lev+1] = 0;
425 return ((*t->p2)(ep-t->n2, t->d2, t->a2, lev));
426 }
427 return (0);
428 next:;
429 }
430 return (0);
431 }
432
433 static int
434 nop(void)
435 {
436 return (0);
437 }
438
439 /* ARGSUSED */
440 static int
441 strip(char *ep, char *d, char *a, int lev)
442 {
443 return (trypref(ep, a, lev)||trysuff(ep, lev));
444 }
445
446 static int
447 s(char *ep, char *d, char *a, int lev)
448 {
449 if (lev > DLEV+1)
450 return (0);
451 if (*ep == 's' && ep[-1] == 's')
452 return (0);
453 return (strip(ep, d, a, lev));
454 }
455
456 /* ARGSUSED */
457 static int
458 an(char *ep, char *d, char *a, int lev)
459 {
460 if (!isupper(*word)) /* must be proper name */
461 return (0);
462 return (trypref(ep, a, lev));
463 }
464
465 /* ARGSUSED */
466 static int
467 ize(char *ep, char *d, char *a, int lev)
468 {
469 ep[-1] = 'e';
470 return (strip(ep, "", d, lev));
471 }
472
473 /* ARGSUSED */
474 static int
475 y_to_e(char *ep, char *d, char *a, int lev)
476 {
477 *ep++ = 'e';
478 return (strip(ep, "", d, lev));
479 }
480
481 static int
482 ily(char *ep, char *d, char *a, int lev)
483 {
484 if (ep[-1] == 'i')
485 return (i_to_y(ep, d, a, lev));
486 else
487 return (strip(ep, d, a, lev));
488 }
489
490 static int
491 bility(char *ep, char *d, char *a, int lev)
492 {
493 *ep++ = 'l';
494 return (y_to_e(ep, d, a, lev));
495 }
496
497 static int
498 i_to_y(char *ep, char *d, char *a, int lev)
499 {
500 if (ep[-1] == 'i') {
501 ep[-1] = 'y';
502 a = d;
503 }
504 return (strip(ep, "", a, lev));
505 }
506
507 static int
508 es(char *ep, char *d, char *a, int lev)
509 {
510 if (lev > DLEV)
511 return (0);
512 switch (ep[-1]) {
513 default:
514 return (0);
515 case 'i':
516 return (i_to_y(ep, d, a, lev));
517 case 's':
518 case 'h':
519 case 'z':
520 case 'x':
521 return (strip(ep, d, a, lev));
522 }
523 }
524
525 /* ARGSUSED */
526 static int
527 subst(char *ep, char *d, char *a, int lev)
528 {
529 char *u, *t;
530
531 if (skipv(skipv(ep-1)) < word)
532 return (0);
533 for (t = d; *t != '+'; t++)
534 continue;
535 for (u = ep; *--t != '-'; )
536 *--u = *t;
537 return (strip(ep, "", d, lev));
538 }
539
540
541 static int
542 tion(char *ep, char *d, char *a, int lev)
543 {
544 switch (ep[-2]) {
545 case 'c':
546 case 'r':
547 return (trypref(ep, a, lev));
548 case 'a':
549 return (y_to_e(ep, d, a, lev));
550 }
551 return (0);
552 }
553
554 /* possible consonant-consonant-e ending */
555 static int
556 CCe(char *ep, char *d, char *a, int lev)
557 {
558 switch (ep[-1]) {
559 case 'r':
560 if (ep[-2] == 't')
561 return (y_to_e(ep, d, a, lev));
562 break;
563 case 'l':
564 if (vowel(ep[-2]))
565 break;
566 switch (ep[-2]) {
567 case 'l':
568 case 'r':
569 case 'w':
570 break;
571 default:
572 return (y_to_e(ep, d, a, lev));
573 }
574 break;
575 case 's':
576 if (ep[-2] == 's')
577 break;
578 if (*ep == 'a')
579 return (0);
580 if (vowel(ep[-2]))
581 break;
582 if (y_to_e(ep, d, a, lev))
583 return (1);
584 if (!(ep[-2] == 'n' && ep[-1] == 'g'))
585 return (0);
586 break;
587 case 'c':
588 case 'g':
589 if (*ep == 'a')
590 return (0);
591 if (vowel(ep[-2]))
592 break;
593 if (y_to_e(ep, d, a, lev))
594 return (1);
595 if (!(ep[-2] == 'n' && ep[-1] == 'g'))
596 return (0);
597 break;
598 case 'v':
599 case 'z':
600 if (vowel(ep[-2]))
601 break;
602 if (y_to_e(ep, d, a, lev))
603 return (1);
604 if (!(ep[-2] == 'n' && ep[-1] == 'g'))
605 return (0);
606 break;
607 case 'u':
608 if (y_to_e(ep, d, a, lev))
609 return (1);
610 if (!(ep[-2] == 'n' && ep[-1] == 'g'))
611 return (0);
612 break;
613 }
614 return (VCe(ep, d, a, lev));
615 }
616
617 /* possible consonant-vowel-consonant-e ending */
618 static int
619 VCe(char *ep, char *d, char *a, int lev)
620 {
621 char c;
622 c = ep[-1];
623 if (c == 'e')
624 return (0);
625 if (!vowel(c) && vowel(ep[-2])) {
626 c = *ep;
627 *ep++ = 'e';
628 if (trypref(ep, d, lev)||trysuff(ep, lev))
629 return (1);
630 ep--;
631 *ep = c;
632 }
633 return (strip(ep, d, a, lev));
634 }
635
636 static char *
637 lookuppref(char **wp, char *ep)
638 {
639 char **sp;
640 char *bp, *cp;
641
642 for (sp = preftab; *sp; sp++) {
643 bp = *wp;
644 for (cp = *sp; *cp; cp++, bp++)
645 if (Tolower(*bp) != *cp)
646 goto next;
647 for (cp = bp; cp < ep; cp++)
648 if (vowel(*cp)) {
649 *wp = bp;
650 return (*sp);
651 }
652 next:;
653 }
654 return (0);
655 }
656
657 /*
658 * while word is not in dictionary try stripping
659 * prefixes. Fail if no more prefixes.
660 */
661 static int
662 trypref(char *ep, char *a, int lev)
663 {
664 char *cp;
665 char *bp;
666 char *pp;
667 int val = 0;
668 char space[LINE_MAX * 2];
669 deriv[lev] = a;
670 if (tryword(word, ep, lev))
671 return (1);
672 bp = word;
673 pp = space;
674 deriv[lev+1] = pp;
675 while (cp = lookuppref(&bp, ep)) {
676 *pp++ = '+';
677 while (*pp = *cp++)
678 pp++;
679 if (tryword(bp, ep, lev+1)) {
680 val = 1;
681 break;
682 }
683 }
684 deriv[lev+1] = deriv[lev+2] = 0;
685 return (val);
686 }
687
688 static int
689 tryword(char *bp, char *ep, int lev)
690 {
691 int i, j;
692 char duple[3];
693 if (ep-bp <= 1)
694 return (0);
695 if (vowel(*ep)) {
696 if (monosyl(bp, ep))
697 return (0);
698 }
699 i = dict(bp, ep);
700 if (i == 0 && vowel(*ep) && ep[-1] == ep[-2] && monosyl(bp, ep-1)) {
701 ep--;
702 deriv[++lev] = duple;
703 duple[0] = '+';
704 duple[1] = *ep;
705 duple[2] = 0;
706 i = dict(bp, ep);
707 }
708 if (vflag == 0 || i == 0)
709 return (i);
710 /*
711 * when derivations are wanted, collect them
712 * for printing
713 */
714 j = lev;
715 do {
716 if (deriv[j])
717 (void) strcat(affix, deriv[j]);
718 } while (--j > 0);
719 return (i);
720 }
721
722
723 static int
724 monosyl(char *bp, char *ep)
725 {
726 if (ep < bp+2)
727 return (0);
728 if (vowel(*--ep) || !vowel(*--ep) || ep[1] == 'x' || ep[1] == 'w')
729 return (0);
730 while (--ep >= bp)
731 if (vowel(*ep))
732 return (0);
733 return (1);
734 }
735
736 static char *
737 skipv(char *s)
738 {
739 if (s >= word&&vowel(*s))
740 s--;
741 while (s >= word && !vowel(*s))
742 s--;
743 return (s);
744 }
745
746 static int
747 vowel(int c)
748 {
749 switch (Tolower(c)) {
750 case 'a':
751 case 'e':
752 case 'i':
753 case 'o':
754 case 'u':
755 case 'y':
756 return (1);
757 }
758 return (0);
759 }
760
761 static int
762 dict(char *bp, char *ep)
763 {
764 int temp, result;
765 if (xflag)
766 (void) fprintf(stdout, "=%.*s\n", ep-bp, bp);
767 temp = *ep;
768 *ep = 0;
769 result = hashlook(bp);
770 *ep = temp;
771 return (result);
772 }