usr/src/cmd/spell/spellprog.c

   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 }