xref: /illumos-gate/usr/src/cmd/spell/spellprog.c (revision 17723245e5b42ca8abb9964a36c0b051c0b237fe)
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
main(int argc,char ** argv)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
trysuff(char * ep,int lev)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
nop(void)434 nop(void)
435 {
436 	return (0);
437 }
438 
439 /* ARGSUSED */
440 static int
strip(char * ep,char * d,char * a,int lev)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
s(char * ep,char * d,char * a,int lev)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
an(char * ep,char * d,char * a,int lev)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
ize(char * ep,char * d,char * a,int lev)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
y_to_e(char * ep,char * d,char * a,int lev)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
ily(char * ep,char * d,char * a,int lev)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
bility(char * ep,char * d,char * a,int lev)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
i_to_y(char * ep,char * d,char * a,int lev)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
es(char * ep,char * d,char * a,int lev)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
subst(char * ep,char * d,char * a,int lev)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
tion(char * ep,char * d,char * a,int lev)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
CCe(char * ep,char * d,char * a,int lev)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
VCe(char * ep,char * d,char * a,int lev)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 *
lookuppref(char ** wp,char * ep)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
trypref(char * ep,char * a,int lev)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
tryword(char * bp,char * ep,int lev)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
monosyl(char * bp,char * ep)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 *
skipv(char * s)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
vowel(int c)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
dict(char * bp,char * ep)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 }
773