Thread View: net.sources.bugs
2 messages
2 total messages
Started by geoff
Sun, 29 Mar 1987 09:13
Patch #1 to the "enhanced" ispell
Author: geoff
Date: Sun, 29 Mar 1987 09:13
Date: Sun, 29 Mar 1987 09:13
2055 lines
54284 bytes
54284 bytes
:
: 'See below (file Patch1) for explanations and instructions'
:
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# Patch1
# icombine.c
# munchlist.X
# This archive created: Sun Mar 29 01:06:36 1987
export PATH; PATH=/bin:$PATH
echo shar: extracting "'Patch1'" '(37715 characters)'
if test -f 'Patch1'
then
echo shar: will not over-write existing file "'Patch1'"
else
sed 's/^X //' << \SHAR_EOF > 'Patch1'
X
X This is patch number 1 for the version of ispell I posted recently. My
X thanks to the many people (listed in the man page) who submitted changes,
X fixes, and improvements, and my apologies to Walt Buehring, whom I
X inadvertently failed to credit fully in my previous posting.
X
X This patch consists of three parts: this file (Patch1), a new program named
X icombine.c (thanks to Gary Puckering), and a replacement for the
X "munchlist.sh" shell script (now called "munchlist.X" thanks to Rich Salz's
X configurability improvements).
X
X To apply this patch:
X
X (1) Unshar this file by piping it through /bin/sh
X (2) Remove "munchlist.sh"
X (3) Type "patch < Patch1" in the ispell directory.
X (4) Move all ispell.words files to ".ispell_words" after rebuilding.
X
X Improvements added in this patch:
X
X (1) Configuration is simpler. You still must edit both the Makefile
X and config.h, but each variable is defined in only one place, so
X there are no consistency worries. There are also a few
X explanatory comments. (Rich Salz)
X (2) The LOOK command is now configurable. If LOOK is defined, it is
X the command to use for lookup.
X (2) The install dependency now installs the manual. (Rich Salz)
X (3) Buildhash is a hair faster. (Rich Salz)
X (4) The dictionary file does not require slashes separating each flag.
X Thus, "PLOT/G/S" can now be written "PLOT/GS". This saves a bit
X of dictionary space. This format is not required, but is generated
X by ispell (for the personal dictionary), icombine, and munchlist.
X (Rich Salz)
X (5) The default personal dictionary is now a dot file, ".ispell_words".
X (6) Ispell will now offer up to 100 possible corrections, instead of
X only 10. Most corrections still require only a single keystroke.
X (7) Ispell now makes use of the extra lines on tall terminals.
X (8) Perry Smith's region support for ispell.el has been reintegrated.
X (9) Ispell now sorts the list of possible corrections.
X (10) The -t switch selects TeX mode, wherein TeX-style constructs are
X skipped. (Don Kark, Greg Schaffer)
X (11) The troff processing has been improved somewhat so that string
X and number defines are ignored. (Gary Puckering)
X
X Problems fixed by this patch:
X
X (1) The Makefile wouldn't find buildhash if "." wasn't in the path.
X (Rich Salz)
X (2) On BSD systems, param.h gets types.h, so buildhash.c can't
X include both. (Jim Knutson)
X (3) Buildhash was neglecting to initialize the "keep" flag. (Don Kark)
X (4) In config.h (now config.X), there was an ifdef that used SYSV
X instead of USG. (Dave Mason)
X (5) Ispell's temp file was named "spell*" and was in /usr/tmp, not /tmp.
X (Rich Salz)
X (6) The s_ending routine in good.c had an unintended, but harmless,
X fallthrough in one of the case statements. (Greg Schaffer)
X (7) If the dictionary has more than 32K words, the hash routine could
X generate a negative hash code.
X (8) Ispell no longer generates a spurious CR on every line in -l mode.
X (Gary Puckering)
X (9) A missing type declaration in lookup.c could cause bugs on
X pointer != int machines. (Jim Knutson, Rich Salz, Bill Randle)
X (10) The startup code didn't set ospeed, so padding didn't work.
X (Perry Smith)
X
X
X
X Index: Makefile
X
X *** Makefile.old Sun Mar 29 00:09:29 1987
X --- Makefile Sun Mar 29 00:09:32 1987
X ***************
X *** 2,4
X
X ! # Look over config.h before building.
X #
X
X --- 2,4 -----
X
X ! # Look over config.X before building.
X #
X ***************
X *** 4,6
X #
X ! # LIBDIR, DEFHASH, DEFDICT should match definitions in config.h.
X #
X
X --- 4,7 -----
X #
X ! # You may want to edit BINDIR, LIBDIR, DEFHASH, DEFDICT, MANDIR, and
X ! # MANEXT below; the Makefile will update all other files to match.
X #
X ***************
X *** 6,7
X #
X # The ifdef NO8BIT may be used if 8 bit extended text characters
X
X --- 7,10 -----
X #
X + # On USG systems, add -DUSG to CFLAGS.
X + #
X # The ifdef NO8BIT may be used if 8 bit extended text characters
X ***************
X *** 15,16
X CFLAGS = -O
X BINDIR = /usr/local/bin
X
X --- 18,20 -----
X CFLAGS = -O
X + # BINDIR, LIBDIR, DEFHASH, DEFDICT, MANDIR, MANEXT
X BINDIR = /usr/local/bin
X ***************
X *** 19,20
X DEFDICT = dict.191
X
X
X --- 23,27 -----
X DEFDICT = dict.191
X + MANDIR = /usr/man/u_man/man1
X + MANEXT = .1l
X + SHELL = /bin/sh
X
X ***************
X *** 22,24
X TERMLIB = -ltermlib
X - all: buildhash ispell $(DEFHASH)
X
X
X --- 29,30 -----
X TERMLIB = -ltermlib
X
X ***************
X *** 24,25
X
X ispell.hash: buildhash $(DEFDICT)
X
X --- 30,33 -----
X
X + all: buildhash ispell icombine munchlist $(DEFHASH)
X +
X ispell.hash: buildhash $(DEFDICT)
X ***************
X *** 25,27
X ispell.hash: buildhash $(DEFDICT)
X ! buildhash
X
X
X --- 33,35 -----
X ispell.hash: buildhash $(DEFDICT)
X ! ./buildhash $(DEFDICT) $(DEFHASH)
X
X ***************
X *** 27,35
X
X ! install: buildhash ispell $(DEFHASH)
X ! cp ispell ${BINDIR}/ispell
X ! cp munchlist.sh $(BINDIR)/munchlist
X ! cp ispell.hash ${LIBDIR}/${DEFHASH}
X ! cp expand1.sed expand2.sed $(LIBDIR)
X ! chmod 755 ${BINDIR}/ispell $(BINDIR)/munchlist
X ! chmod 644 ${LIBDIR}/$(DEFHASH) $(LIBDIR)/expand1.sed \
X $(LIBDIR)/expand2.sed
X
X --- 35,43 -----
X
X ! install: all
X ! cp ispell $(BINDIR)/ispell
X ! cp munchlist $(BINDIR)/munchlist
X ! cp ispell.hash $(LIBDIR)/$(DEFHASH)
X ! cp expand1.sed expand2.sed icombine $(LIBDIR)
X ! chmod 755 $(BINDIR)/ispell $(BINDIR)/munchlist $(LIBDIR)/icombine
X ! chmod 644 $(LIBDIR)/$(DEFHASH) $(LIBDIR)/expand1.sed \
X $(LIBDIR)/expand2.sed
X ***************
X *** 35,36
X $(LIBDIR)/expand2.sed
X
X
X --- 43,45 -----
X $(LIBDIR)/expand2.sed
X + cp ispell.1 $(MANDIR)/ispell$(MANEXT)
X
X ***************
X *** 37,39
X buildhash: buildhash.o hash.o
X ! cc -o buildhash buildhash.o hash.o
X
X
X --- 46,48 -----
X buildhash: buildhash.o hash.o
X ! $(CC) $(CFLAGS) -o buildhash buildhash.o hash.o
X
X ***************
X *** 39,43
X
X ! ispell: ispell.o term.o good.o lookup.o hash.o tree.o
X ! cc $(CFLAGS) -o ispell ispell.o term.o good.o lookup.o \
X ! hash.o tree.o $(TERMLIB)
X
X
X --- 48,51 -----
X
X ! icombine: icombine.c
X ! $(CC) $(CFLAGS) -o icombine icombine.c
X
X ***************
X *** 43,44
X
X clean:
X
X --- 51,67 -----
X
X + munchlist: munchlist.X Makefile
X + sed -e 's@!!LIBDIR!!@$(LIBDIR)@' -e 's@!!DEFDICT!!@$(DEFDICT)@' \
X + <munchlist.X >munchlist
X + chmod +x munchlist
X +
X + OBJS=ispell.o term.o good.o lookup.o hash.o tree.o
X + ispell: $(OBJS)
X + cc $(CFLAGS) -o ispell $(OBJS) $(TERMLIB)
X +
X + $(OBJS) buildhash.o: config.h
X +
X + config.h: config.X Makefile
X + sed -e 's@!!LIBDIR!!@$(LIBDIR)@' -e 's@!!DEFDICT!!@$(DEFDICT)@' \
X + -e 's@!!DEFHASH!!@$(DEFHASH)@' <config.X >config.h
X +
X clean:
X ***************
X *** 45,46
X rm -f *.o buildhash ispell core a.out mon.out hash.out \
X ! *.stat *.cnt
X
X --- 68,69 -----
X rm -f *.o buildhash ispell core a.out mon.out hash.out \
X ! *.stat *.cnt munchlist config.h
X
X
X Index: buildhash.c
X
X *** buildhash.c.old Sun Mar 29 00:09:44 1987
X --- buildhash.c Sun Mar 29 00:09:48 1987
X ***************
X *** 8,9
X #include <stdio.h>
X #include <sys/types.h>
X
X --- 8,10 -----
X #include <stdio.h>
X + #ifdef USG
X #include <sys/types.h>
X ***************
X *** 9,10
X #include <sys/types.h>
X #include <sys/stat.h>
X
X --- 10,12 -----
X #include <sys/types.h>
X + #endif
X #include <sys/stat.h>
X ***************
X *** 202,204
X while (fgets (lbuf, sizeof lbuf, dictf) != NULL) {
X ! if (i % 1000 == 0) {
X printf ("%d ", i);
X
X --- 204,206 -----
X while (fgets (lbuf, sizeof lbuf, dictf) != NULL) {
X ! if ((i & 1023) == 0) {
X printf ("%d ", i);
X ***************
X *** 269,270
X d->m_flag = 0;
X
X
X --- 271,273 -----
X d->m_flag = 0;
X + d->keep = 0;
X
X ***************
X *** 282,284
X p++;
X ! while (*p != NULL) {
X switch (*p) {
X
X --- 285,287 -----
X p++;
X ! while (*p != '\0' && *p != '\n') {
X switch (*p) {
X ***************
X *** 299,301
X case 0:
X ! fprintf (stderr, "no key word %s\n", lbuf);
X continue;
X
X --- 302,304 -----
X case 0:
X ! fprintf (stderr, "no flags on word %s\n", lbuf);
X continue;
X ***************
X *** 307,314
X p++;
X ! if (*p != '/' && *p != NULL && *p != '\n') {
X ! fprintf (stderr, "bad format %s (%c 0%o)\n",
X ! lbuf, *p, *p);
X ! break;
X ! }
X ! if (*p)
X p++;
X
X --- 310,312 -----
X p++;
X ! if (*p == '/') /* Handle old-format dictionaries too */
X p++;
X ***************
X *** 314,316
X p++;
X -
X }
X
X --- 312,313 -----
X p++;
X }
X ***************
X *** 332,337
X
X ! i = 0;
X ! while (fgets (buf, sizeof buf, d) != NULL) {
X ! i++;
X ! if (i % 1000 == 0) {
X printf ("%d ", i);
X
X --- 329,332 -----
X
X ! for (i = 0; fgets (buf, sizeof buf, d); )
X ! if ((++i & 1023) == 0) {
X printf ("%d ", i);
X ***************
X *** 339,341
X }
X - }
X fclose (d);
X
X --- 334,335 -----
X }
X fclose (d);
X
X
X Index: config.X
X
X *** config.X.old Sun Mar 29 00:10:04 1987
X --- config.X Sun Mar 29 00:10:08 1987
X ***************
X *** 1,2
X /*
X ** library directory for hash table(s) / default hash table name
X
X --- 1,16 -----
X /*
X + * This is the configuration file for ispell. Thanks to Bob McQueer
X + * for creating it and making the necessary changes elsewhere to
X + * support it.
X + * Look through this file from top to bottom, and edit anything that
X + * needs editing. There are also five or six variables in the
X + * Makefile that you must edit. Note that the Makefile edits this
X + * file (config.X) to produce config.h. If you are looking at
X + * config.h, you're in the wrong file.
X + *
X + * Don't change the funny-looking lines with !!'s in them; see the
X + * Makefile!
X + */
X +
X + /*
X ** library directory for hash table(s) / default hash table name
X ***************
X *** 6,9
X */
X ! #define LIBDIR "/usr/local/lib"
X ! #define DEFHASH "ispell.hash"
X
X
X --- 20,23 -----
X */
X ! #define LIBDIR "!!LIBDIR!!"
X ! #define DEFHASH "!!DEFHASH!!"
X
X ***************
X *** 9,11
X
X ! #ifdef SYSV
X #define index strchr
X
X --- 23,25 -----
X
X ! #ifdef USG
X #define index strchr
X ***************
X *** 17,19
X /* default word list */
X ! #define DEFPDICT "ispell.words"
X
X
X --- 31,33 -----
X /* default word list */
X ! #define DEFPDICT ".ispell_words"
X
X ***************
X *** 20,22
X /* mktemp template for temporary file - MUST contain 6 consecutive X's */
X ! #define TEMPNAME "/usr/tmp/spellXXXXXX"
X
X
X --- 34,36 -----
X /* mktemp template for temporary file - MUST contain 6 consecutive X's */
X ! #define TEMPNAME "/tmp/ispellXXXXXX"
X
X ***************
X *** 23,25
X /* default dictionary file */
X ! #define DEFDICT "dict.191"
X
X
X --- 37,39 -----
X /* default dictionary file */
X ! #define DEFDICT "!!DEFDICT!!"
X
X ***************
X *** 26,28
X /* define LOOK if look(1) command is available */
X ! #define LOOK
X
X
X --- 40,42 -----
X /* define LOOK if look(1) command is available */
X ! #define LOOK "/usr/bin/look -df"
X
X
X
X Index: good.c
X
X *** good.c.old Sun Mar 29 00:10:19 1987
X --- good.c Sun Mar 29 00:10:23 1987
X ***************
X *** 385,386
X }
X case 'G': /* J */
X
X --- 385,387 -----
X }
X + return;
X case 'G': /* J */
X
X
X Index: hash.c
X
X *** hash.c.old Sun Mar 29 00:10:47 1987
X --- hash.c Sun Mar 29 00:10:49 1987
X ***************
X *** 25,27
X h &= 077777;
X ! return (h %= hashsize);
X }
X
X --- 25,27 -----
X h &= 077777;
X ! return (unsigned long) h % hashsize;
X }
X ***************
X *** 27,31
X }
X -
X -
X -
X -
X
X --- 27 -----
X }
X
X
X Index: ispell.1
X
X *** ispell.1.old Sun Mar 29 00:11:04 1987
X --- ispell.1 Sun Mar 29 00:11:10 1987
X ***************
X *** 10,11
X [
X .B \-x
X
X --- 10,13 -----
X [
X + .B \-t
X + |
X .B \-x
X ***************
X *** 12,13
X |
X .B \-d
X
X --- 14,17 -----
X |
X + .B \-S
X + |
X .B \-d
X ***************
X *** 21,22
X [
X .B \-d
X
X --- 25,28 -----
X [
X + .B \-t
X + |
X .B \-d
X ***************
X *** 31,32
X [
X .B \-d
X
X --- 37,40 -----
X [
X + .B \-t
X + |
X .B \-d
X ***************
X *** 74,76
X dictionary. If one of the near misses is the word you want, type the
X ! corresponding number. Finally, if none of these choices is right, you
X can type "R" and you will be prompted for a replacement word.
X
X --- 82,87 -----
X dictionary. If one of the near misses is the word you want, type the
X ! corresponding number.
X ! (If there are more than 10 choices,
X ! you may have to type a carriage return to complete a single-digit number).
X ! Finally, if none of these choices is right, you
X can type "R" and you will be prompted for a replacement word.
X ***************
X *** 92,93
X .B \-a
X is intended to be used from other programs through a pipe. In this
X
X --- 103,105 -----
X .B \-a
X + option
X is intended to be used from other programs through a pipe. In this
X ***************
X *** 95,97
X .I ispell
X ! expects the standard input to consist of single words. Each word is
X read, and a single line is written to the standard output. If the word
X
X --- 107,110 -----
X .I ispell
X ! expects the standard input to consist of lines containing single words.
X ! Each word is
X read, and a single line is written to the standard output. If the word
X ***************
X *** 109,110
X .PP
X The
X
X --- 122,135 -----
X .PP
X + When in the
X + .B \-a
X + mode,
X + .I ispell
X + will also accept lines of single words prefixed with either a '*' or a '@'.
X + A line starting with '*' tells
X + .I ispell
X + to insert the word into the user's dictionary (similar to the I command).
X + A line starting with '@' causes
X + .I ispell
X + to accept this word in the future (similar to the A command).
X + .PP
X The
X ***************
X *** 118,119
X The
X .B \-d
X
X --- 143,168 -----
X The
X + .B \-S
X + option suppresses
X + .IR ispell "'s"
X + normal behavior of sorting the list of possible replacement words.
X + Some people may prefer this, since it somewhat enhances the probability
X + that the correct word will be low-numbered.
X + .PP
X + The
X + .B \-t
X + option selects TeX/LaTeX input mode.
X + In this mode, whenever a backslash ("\e") is found,
X + .I ispell
X + will skip to the next whitespace.
X + Thus, for example, given
X + .RS
X + \echapter {This is a Ckapter}
X + \ecite{SCH86}
X + .RE
X + will find "Ckapter" but will not look for SCH.
X + The
X + .B \-t
X + option does not recognize the TeX comment character "%".
X + .PP
X + The
X .B \-d
X ***************
X *** 226,228
X in such a way as to only support ASCII range text if desired.
X ! .SH DEFAULT FILES
X /usr/public/lib/ispell.hash
X
X --- 275,277 -----
X in such a way as to only support ASCII range text if desired.
X ! .SH FILES
X /usr/public/lib/ispell.hash
X ***************
X *** 278,280
X .br
X ! Enhanced by James Woods, Bob McQueer, Bill Randle, Marc Ries, Rob McMahon,
X ! and Geoff Kuenning.
X
X --- 327,344 -----
X .br
X ! Collected, revised, and enhanced for the Usenet by Walt Buehring.
X ! .br
X ! Further enhanced and debugged by
X ! Don Kark,
X ! Jim Knutson,
X ! Geoff Kuenning,
X ! Dave Mason,
X ! Rob McMahon,
X ! Bob McQueer,
X ! Gary Puckering,
X ! Bill Randle,
X ! Marc Ries,
X ! Rich Salz,
X ! Greg Schaffer,
X ! Perry Smith,
X ! and
X ! James Woods.
X
X
X Index: ispell.c
X
X *** ispell.c.old Sun Mar 29 00:11:41 1987
X --- ispell.c Sun Mar 29 00:11:47 1987
X ***************
X *** 19,20
X * hashed personal dictionary file
X */
X
X --- 19,25 -----
X * hashed personal dictionary file
X + * -S option for unsorted word lists
X + * 1987, Greg Schaffer, added:
X + * -T option (for TeX and LaTeX instead of troff) [later changed to -t]
X + * passes over \ till next whitespace.
X + * does not recognize % (comment)
X */
X ***************
X *** 51,52
X
X givehelp ()
X
X --- 56,59 -----
X
X + static int sortit = 1;
X +
X givehelp ()
X ***************
X *** 90,91
X int xflag = 0;
X
X
X --- 97,99 -----
X int xflag = 0;
X + int tflag = 0;
X
X ***************
X *** 97,100
X {
X ! fprintf (stderr, "Usage: %s [-dfile | -pfile | -wchars | -x] file .....\n",Cmd);
X ! fprintf (stderr, " %s [-dfile | -pfile | -wchars] -l\n",Cmd);
X #ifdef USG
X
X --- 105,108 -----
X {
X ! fprintf (stderr, "Usage: %s [-dfile | -pfile | -wchars | -t | -x | -S] file .....\n",Cmd);
X ! fprintf (stderr, " %s [-dfile | -pfile | -wchars | -t] -l\n",Cmd);
X #ifdef USG
X ***************
X *** 100,102
X #ifdef USG
X ! fprintf (stderr, " %s [-dfile | -pfile | -ffile | -s] -a\n",Cmd);
X #else
X
X --- 108,110 -----
X #ifdef USG
X ! fprintf (stderr, " %s [-dfile | -pfile | -ffile | -t | -s] -a\n",Cmd);
X #else
X ***************
X *** 102,104
X #else
X ! fprintf (stderr, " %s [-dfile | -pfile | -ffile] -a\n",Cmd);
X #endif
X
X --- 110,112 -----
X #else
X ! fprintf (stderr, " %s [-dfile | -pfile | -ffile | -t] -a\n",Cmd);
X #endif
X ***************
X *** 149,150
X switch ((*argv)[1]) {
X case 'a':
X
X --- 157,161 -----
X switch ((*argv)[1]) {
X + case 't':
X + tflag++;
X + break;
X case 'a':
X ***************
X *** 178,179
X #endif
X case 'p':
X
X --- 189,193 -----
X #endif
X + case 'S':
X + sortit = 0;
X + break;
X case 'p':
X ***************
X *** 311,313
X if ((infile = fopen (tempfile, "r")) == NULL) {
X ! fprintf (stderr, "tempoary file disappeared (%s)\r\n", tempfile);
X sleep (2);
X
X --- 325,327 -----
X if ((infile = fopen (tempfile, "r")) == NULL) {
X ! fprintf (stderr, "temporary file disappeared (%s)\r\n", tempfile);
X sleep (2);
X ***************
X *** 360,361
X len = strlen (secondbuf) - 1;
X if (secondbuf [ len ] == '\n')
X
X --- 374,399 -----
X len = strlen (secondbuf) - 1;
X +
X + /* skip over .if */
X + if (strncmp(currentchar,".if t",5) == 0
X + || strncmp(currentchar,".if n",5) == 0) {
X + copyout(¤tchar,5);
X + while (*currentchar && isspace(*currentchar))
X + copyout(¤tchar, 1);
X + }
X +
X + /* skip over .ds XX or .nr XX */
X + if (strncmp(currentchar,".ds ",4) == 0
X + || strncmp(currentchar,".de ",4) == 0
X + || strncmp(currentchar,".nr ",4) == 0) {
X + copyout(¤tchar, 3);
X + while (*currentchar && isspace(*currentchar))
X + copyout(¤tchar, 1);
X + while (*currentchar && !isspace(*currentchar))
X + copyout(¤tchar, 1);
X + if (*currentchar == 0) {
X + if (!lflag) putc ('\n', outfile);
X + continue;
X + }
X + }
X +
X if (secondbuf [ len ] == '\n')
X ***************
X *** 364,366
X /* if this is a formatter command, skip over it */
X ! if (*currentchar == '.') {
X while (*currentchar && !myspace (*currentchar)) {
X
X --- 402,404 -----
X /* if this is a formatter command, skip over it */
X ! if (!tflag && *currentchar == '.') {
X while (*currentchar && !myspace (*currentchar)) {
X ***************
X *** 379,380
X while (*currentchar && !iswordch(*currentchar)) {
X /* formatting escape sequences */
X
X --- 417,433 -----
X while (*currentchar && !iswordch(*currentchar)) {
X + if (tflag) /* TeX or LaTeX stuff */
X + {
X + if (*currentchar == '\\') {
X + /* skip till whitespace */
X + while (*currentchar &&
X + !isspace(*currentchar)) {
X + if (!lflag)
X + putc(*currentchar, outfile);
X + currentchar++;
X + }
X + continue;
X + }
X + }
X + else
X + {
X /* formatting escape sequences */
X ***************
X *** 403,404
X }
X
X
X --- 456,458 -----
X }
X + }
X
X ***************
X *** 420,422
X if (!good (token) && !cflag)
X ! printf ("%s\r\n", token);
X } else {
X
X --- 474,477 -----
X if (!good (token) && !cflag)
X ! if (lflag) printf ("%s\n", token);
X ! else printf ("%s\r\n", token);
X } else {
X ***************
X *** 433,435
X
X ! char possibilities[10][BUFSIZ];
X int pcount;
X
X --- 488,492 -----
X
X ! #define MAXPOSSIBLE 99 /* Max no. of possibilities to generate */
X !
X ! char possibilities[MAXPOSSIBLE][BUFSIZ];
X int pcount;
X ***************
X *** 435,436
X int pcount;
X
X
X --- 492,494 -----
X int pcount;
X + int maxposslen;
X
X ***************
X *** 442,443
X int i;
X char *p;
X
X --- 500,503 -----
X int i;
X + int col_ht;
X + int ncols;
X char *p;
X ***************
X *** 461,466
X
X ! for (i = 0; i < 10; i++) {
X ! if (possibilities[i][0] == 0)
X ! break;
X ! printf ("%d: %s\r\n", i, possibilities[i]);
X }
X
X --- 521,542 -----
X
X ! /*
X ! * Make sure we have enough room on the screen to hold the
X ! * possibilities. Reduce the list if necessary. 80 / (maxposslen + 8)
X ! * is the maximum number of columns that will fit.
X ! */
X ! col_ht = li - 6; /* Height of columns of words */
X ! ncols = 80 / (maxposslen + 8);
X ! if (pcount > ncols * col_ht)
X ! pcount = ncols * col_ht;
X !
X ! #if 0
X ! /*
X ! * Equalize the column sizes. The last column will be short.
X ! */
X ! col_ht = (pcount + ncols - 1) / ncols;
X ! #endif
X !
X ! for (i = 0; i < pcount; i++) {
X ! move (2 + (i % col_ht), (maxposslen + 8) * (i / col_ht));
X ! printf ("%2d: %s", i, possibilities[i]);
X }
X ***************
X *** 467,469
X
X ! move (15, 0);
X printf ("%s\r\n", firstbuf);
X
X --- 543,545 -----
X
X ! move (li - 3, 0);
X printf ("%s\r\n", firstbuf);
X ***************
X *** 516,518
X char buf[200];
X ! move (18, 0);
X putchar ('!');
X
X --- 592,594 -----
X char buf[200];
X ! move (li - 1, 0);
X putchar ('!');
X ***************
X *** 529,531
X case 'r': case 'R':
X ! move (18, 0);
X printf ("Replace with: ");
X
X --- 605,607 -----
X case 'r': case 'R':
X ! move (li - 1, 0);
X printf ("Replace with: ");
X ***************
X *** 541,545
X case '5': case '6': case '7': case '8': case '9':
X ! if (possibilities[c - '0'][0] != 0) {
X ! strcpy (token, possibilities[c - '0']);
X ! inserttoken (secondbuf, begintoken, token, currentchar); erase ();
X return;
X
X --- 617,634 -----
X case '5': case '6': case '7': case '8': case '9':
X ! i = c - '0';
X ! if (pcount > 10
X ! && i > 0 && i <= (pcount - 1) / 10) {
X ! c = getchar () & NOPARITY;
X ! if (c >= '0' && c <= '9')
X ! i = i * 10 + c - '0';
X ! else if (c != '\r' && c != '\n') {
X ! putchar (7);
X ! break;
X ! }
X ! }
X ! if (i < pcount) {
X ! strcpy (token, possibilities[i]);
X ! inserttoken (secondbuf, begintoken,
X ! token, currentchar);
X ! erase ();
X return;
X ***************
X *** 548,549
X break;
X case 'l': case 'L':
X
X --- 637,641 -----
X break;
X + case '\r': /* This makes typing \n after single digits */
X + case '\n': /* ..less obnoxious */
X + break;
X case 'l': case 'L':
X ***************
X *** 551,553
X char buf[100];
X ! move (18, 0);
X printf ("Lookup string ('*' is wildcard): ");
X
X --- 643,645 -----
X char buf[100];
X ! move (li - 1, 0);
X printf ("Lookup string ('*' is wildcard): ");
X ***************
X *** 598,599
X int i;
X
X
X --- 690,692 -----
X int i;
X + extern int strcmp ();
X
X ***************
X *** 599,601
X
X ! for (i = 0; i < 10; i++)
X possibilities[i][0] = 0;
X
X --- 692,694 -----
X
X ! for (i = 0; i < MAXPOSSIBLE; i++)
X possibilities[i][0] = 0;
X ***************
X *** 602,603
X pcount = 0;
X
X
X --- 695,697 -----
X pcount = 0;
X + maxposslen = 0;
X
X ***************
X *** 603,608
X
X ! if (pcount < 10) wrongletter (word);
X ! if (pcount < 10) extraletter (word);
X ! if (pcount < 10) missingletter (word);
X ! if (pcount < 10) transposedletter (word);
X
X
X --- 697,702 -----
X
X ! if (pcount < MAXPOSSIBLE) wrongletter (word);
X ! if (pcount < MAXPOSSIBLE) extraletter (word);
X ! if (pcount < MAXPOSSIBLE) missingletter (word);
X ! if (pcount < MAXPOSSIBLE) transposedletter (word);
X
X ***************
X *** 608,609
X
X }
X
X --- 702,706 -----
X
X + if (sortit && pcount)
X + qsort ((char *) possibilities, pcount,
X + sizeof (possibilities[0]), strcmp);
X }
X ***************
X *** 622,624
X strcpy (possibilities[pcount++], word);
X ! if (pcount >= 10)
X return (-1);
X
X --- 719,724 -----
X strcpy (possibilities[pcount++], word);
X ! i = strlen (word);
X ! if (i > maxposslen)
X ! maxposslen = i;
X ! if (pcount >= MAXPOSSIBLE)
X return (-1);
X ***************
X *** 817,819
X while (gets (buf) != NULL) {
X ! if (good (buf)) {
X if (rootword[0] == 0) {
X
X --- 917,924 -----
X while (gets (buf) != NULL) {
X ! /* *line is like `i', @line is like `a' */
X ! if (buf[0] == '*' || buf[0] == '@') {
X ! treeinsert(buf + 1, buf[0] == '*');
X ! printf("*\n");
X ! treeoutput ();
X ! } else if (good (buf)) {
X if (rootword[0] == 0) {
X ***************
X *** 827,829
X printf ("& ");
X ! for (i = 0; i < 10; i++) {
X if (possibilities[i][0] == 0)
X
X --- 932,934 -----
X printf ("& ");
X ! for (i = 0; i < MAXPOSSIBLE; i++) {
X if (possibilities[i][0] == 0)
X ***************
X *** 886,888
X /* no wild, use look(1) */
X ! sprintf (cmd, "/usr/bin/look -df %s %s", grepstr, WORDS);
X #else
X
X --- 991,993 -----
X /* no wild, use look(1) */
X ! sprintf (cmd, "%s %s %s", LOOK, grepstr, WORDS);
X #else
X
X
X Index: ispell.el
X
X *** ispell.el.old Sun Mar 29 00:12:28 1987
X --- ispell.el Sun Mar 29 00:12:31 1987
X ***************
X *** 7,8
X
X ;;; Depends on the ispell program snarfed from MIT-PREP in early
X
X --- 7,13 -----
X
X + ;;; ispell-region and associate routines added by
X + ;;; Perry Smith
X + ;;; pedz@bobkat
X + ;;; Tue Jan 13 20:18:02 CST 1987
X +
X ;;; Depends on the ispell program snarfed from MIT-PREP in early
X ***************
X *** 35,38
X ;; Make certain characters word constituents
X ! (modify-syntax-entry ?' "w " ispell-syntax-table)
X ! (modify-syntax-entry ?- "w " ispell-syntax-table)
X ;; Get rid on existing word syntax on certain characters
X
X --- 40,43 -----
X ;; Make certain characters word constituents
X ! ;; (modify-syntax-entry ?' "w " ispell-syntax-table)
X ! ;; (modify-syntax-entry ?- "w " ispell-syntax-table)
X ;; Get rid on existing word syntax on certain characters
X ***************
X *** 38,39
X ;; Get rid on existing word syntax on certain characters
X (modify-syntax-entry ?$ ". " ispell-syntax-table)
X
X --- 43,54 -----
X ;; Get rid on existing word syntax on certain characters
X + (modify-syntax-entry ?0 ". " ispell-syntax-table)
X + (modify-syntax-entry ?1 ". " ispell-syntax-table)
X + (modify-syntax-entry ?2 ". " ispell-syntax-table)
X + (modify-syntax-entry ?3 ". " ispell-syntax-table)
X + (modify-syntax-entry ?4 ". " ispell-syntax-table)
X + (modify-syntax-entry ?5 ". " ispell-syntax-table)
X + (modify-syntax-entry ?6 ". " ispell-syntax-table)
X + (modify-syntax-entry ?7 ". " ispell-syntax-table)
X + (modify-syntax-entry ?8 ". " ispell-syntax-table)
X + (modify-syntax-entry ?9 ". " ispell-syntax-table)
X (modify-syntax-entry ?$ ". " ispell-syntax-table)
X ***************
X *** 73,75
X (or quietly (message "Could Not Find %s" (upcase word))))
X ! (t (setq replace (ispell-choose poss))
X (if replace
X
X --- 88,90 -----
X (or quietly (message "Could Not Find %s" (upcase word))))
X ! (t (setq replace (ispell-choose poss word))
X (if replace
X ***************
X *** 76,80
X (progn
X ! (goto-char end)
X ! (delete-region start end)
X ! (insert-string replace)))))
X poss))
X
X --- 91,95 -----
X (progn
X ! (goto-char end)
X ! (delete-region start end)
X ! (insert-string replace)))))
X poss))
X ***************
X *** 82,86
X
X ! (defun ispell-choose (choices)
X ! "Display possible corrections from list CHOICES. Return chosen word or nil
X ! if none chosen."
X (unwind-protect
X
X --- 97,101 -----
X
X ! (defun ispell-choose (choices word)
X ! "Display possible corrections from list CHOICES. Return chosen word
X ! if one is chosen; Return nil to keep word"
X (unwind-protect
X ***************
X *** 89,92
X (words choices)
X ! (pick -1)
X ! (window-min-height 2))
X (overlay-window 3)
X
X --- 104,107 -----
X (words choices)
X ! (window-min-height 2)
X ! char num result)
X (overlay-window 3)
X ***************
X *** 97,99
X (insert "\n"))
X ! (insert "(" (+ count ?a) ") " (car words) " ")
X (setq words (cdr words)
X
X --- 112,114 -----
X (insert "\n"))
X ! (insert "(" (+ count ?1) ") " (car words) " ")
X (setq words (cdr words)
X ***************
X *** 101,110
X (select-window (next-window))
X ! (while (eq pick -1)
X ! (message "Enter letter to replace word; Space to flush")
X ! (let* ((char (read-char))
X ! (num (1+ (- (upcase char) ?A))))
X ! (cond ((= char ? ) (setq pick 0))
X ! ((or (<= num 0) (> num count)) (ding))
X ! (t (setq pick num)))))
X ! (and (> pick 0) (nth (1- pick) choices))))
X ;; Protected forms...
X
X --- 116,134 -----
X (select-window (next-window))
X ! (while (eq t
X ! (setq result
X ! (progn
X ! (message "Enter letter to replace word; Space to flush")
X ! (setq char (upcase (read-char)))
X ! (setq num (- char ?1))
X ! (cond ((= char ? ) nil)
X ! ((= char ?I)
X ! (ispell-check (concat "*" word))
X ! nil)
X ! ((= char ?A)
X ! (ispell-check (concat "@" word))
X ! nil)
X ! ((= char ?R) (read-string "Replacement: " nil))
X ! ((and (>= num 0) (< num count)) (nth num choices))
X ! (t (ding) t))))))
X ! result))
X ;; Protected forms...
X ***************
X *** 191
X
X
X --- 215,273 -----
X
X + (defvar ispell-filter-hook "/bin/cat"
X + "Filter to pass a region through before sending it to ispell.
X + Typically this is set to cat, deroff, detex, etc.")
X + (make-variable-buffer-local 'ispell-filter-hook)
X +
X + (defvar ispell-filter-hook-args nil
X + "Arguments to pass to ispell-filter-hook")
X + (make-variable-buffer-local 'ispell-filter-hook-args)
X +
X + ; This routine has certain limitations brought about by the filter
X + ; hook. For example, deroff will take ``\fBcat\fR'' and spit out
X + ; ``cat''. This is hard to search for since word-search-forward will
X + ; not match at all and search-forward for ``cat'' will match
X + ; ``concatinate'' if it happens to occur before. I attempt to
X + ; minimize these problems by always searching for each word in the
X + ; original buffer even if it is not misspelled. This slows things
X + ; down.
X +
X + (defun ispell-region (start end)
X + "Check a region for spelling errors interactively. The variable
X + which should be buffer or mode specific ispell-filter-hook is called
X + to filter out text processing commands."
X + (interactive "r")
X + (let ((this-buf (current-buffer))
X + (spell-buf (get-buffer-create "ispell-temp"))
X + (current-syntax (syntax-table))
X + word poss replace word-start word-end)
X + (unwind-protect
X + (save-excursion
X + (set-buffer spell-buf)
X + (erase-buffer)
X + (set-buffer this-buf)
X + (if ispell-filter-hook-args
X + (call-process-region start end ispell-filter-hook nil
X + spell-buf nil ispell-filter-hook-args)
X + (call-process-region start end ispell-filter-hook nil
X + spell-buf nil))
X + (goto-char start)
X + (set-buffer spell-buf)
X + (set-syntax-table ispell-syntax-table)
X + (goto-char (point-min))
X + (while (progn
X + (message "Looking for a misspelled word")
X + (re-search-forward "\\W*\\(\\w+\\)" nil t))
X + (setq word (buffer-substring (setq word-start (match-beginning 1))
X + (setq word-end (match-end 1))))
X + (setq poss (ispell-check word))
X + (set-buffer this-buf)
X + (or (search-forward word nil t)
X + (error "Can not find %s in original text" word))
X + (if (not (or (eq poss t) (stringp poss))) ;bad word
X + (progn
X + (sit-for 0)
X + (setq replace (ispell-choose poss word))
X + (if replace
X + (replace-match replace))))
X + (set-buffer spell-buf)))
X + (set-syntax-table current-syntax))))
X
X
X Index: ispell.h
X
X *** ispell.h.old Sun Mar 29 00:12:45 1987
X --- ispell.h Sun Mar 29 00:12:49 1987
X ***************
X *** 2,5
X
X - #define LIBDIR "/tmp2/lib"
X -
X struct dent {
X
X --- 2,3 -----
X
X struct dent {
X
X
X Index: lookup.c
X
X *** lookup.c.old Sun Mar 29 00:12:59 1987
X --- lookup.c Sun Mar 29 00:13:02 1987
X ***************
X *** 13,14
X
X struct dent *hashtbl;
X
X --- 13,15 -----
X
X + struct dent *treelookup();
X struct dent *hashtbl;
X
X
X Index: term.c
X
X *** term.c.old Sun Mar 29 00:13:10 1987
X --- term.c Sun Mar 29 00:13:13 1987
X ***************
X *** 94,95
X int onstop();
X
X
X --- 94,96 -----
X int onstop();
X + extern short ospeed;
X
X ***************
X *** 119,120
X killchar = sbuf.sg_kill;
X
X
X --- 120,122 -----
X killchar = sbuf.sg_kill;
X + ospeed = sbuf.sg_ospeed;
X
X
X
X Index: tree.c
X
X *** tree.c.old Sun Mar 29 00:13:27 1987
X --- tree.c Sun Mar 29 00:13:32 1987
X ***************
X *** 146,210
X dp = treeinsert (buf, 1);
X ! while (h != NULL) {
X ! switch (*h++) {
X ! case 'D':
X ! case 'd':
X ! dp->d_flag = 1;
X ! break;
X ! case 'G':
X ! case 'g':
X ! dp->g_flag = 1;
X ! break;
X ! case 'H':
X ! case 'h':
X ! dp->h_flag = 1;
X ! break;
X ! case 'J':
X ! case 'j':
X ! dp->j_flag = 1;
X ! break;
X ! case 'M':
X ! case 'm':
X ! dp->m_flag = 1;
X ! break;
X ! case 'N':
X ! case 'n':
X ! dp->n_flag = 1;
X ! break;
X ! case 'P':
X ! case 'p':
X ! dp->p_flag = 1;
X ! break;
X ! case 'R':
X ! case 'r':
X ! dp->r_flag = 1;
X ! break;
X ! case 'S':
X ! case 's':
X ! dp->s_flag = 1;
X ! break;
X ! case 'T':
X ! case 't':
X ! dp->t_flag = 1;
X ! break;
X ! case 'V':
X ! case 'v':
X ! dp->v_flag = 1;
X ! break;
X ! case 'X':
X ! case 'x':
X ! dp->x_flag = 1;
X ! break;
X ! case 'Y':
X ! case 'y':
X ! dp->y_flag = 1;
X ! break;
X ! case 'Z':
X ! case 'z':
X ! dp->z_flag = 1;
X ! break;
X ! default:
X ! fprintf (stderr,
X ! "Illegal flag in personal dictionary - %c (word %s)\n",
X ! h[-1], buf);
X ! break;
X }
X
X --- 146,215 -----
X dp = treeinsert (buf, 1);
X ! if (h != NULL) {
X ! while (*h != '\0' && *h != '\n') {
X ! switch (*h++) {
X ! case 'D':
X ! case 'd':
X ! dp->d_flag = 1;
X ! break;
X ! case 'G':
X ! case 'g':
X ! dp->g_flag = 1;
X ! break;
X ! case 'H':
X ! case 'h':
X ! dp->h_flag = 1;
X ! break;
X ! case 'J':
X ! case 'j':
X ! dp->j_flag = 1;
X ! break;
X ! case 'M':
X ! case 'm':
X ! dp->m_flag = 1;
X ! break;
X ! case 'N':
X ! case 'n':
X ! dp->n_flag = 1;
X ! break;
X ! case 'P':
X ! case 'p':
X ! dp->p_flag = 1;
X ! break;
X ! case 'R':
X ! case 'r':
X ! dp->r_flag = 1;
X ! break;
X ! case 'S':
X ! case 's':
X ! dp->s_flag = 1;
X ! break;
X ! case 'T':
X ! case 't':
X ! dp->t_flag = 1;
X ! break;
X ! case 'V':
X ! case 'v':
X ! dp->v_flag = 1;
X ! break;
X ! case 'X':
X ! case 'x':
X ! dp->x_flag = 1;
X ! break;
X ! case 'Y':
X ! case 'y':
X ! dp->y_flag = 1;
X ! break;
X ! case 'Z':
X ! case 'z':
X ! dp->z_flag = 1;
X ! break;
X ! default:
X ! fprintf (stderr,
X ! "Illegal flag in personal dictionary - %c (word %s)\n",
X ! h[-1], buf);
X ! break;
X ! }
X ! /* Accept old-format dicts with extra slashes */
X ! if (*h == '/')
X ! h++;
X }
X ***************
X *** 210,214
X }
X - /* Exit loop if no more flags */
X - if (*h++ != '/')
X - break;
X }
X
X --- 215,216 -----
X }
X }
X ***************
X *** 312,314
X }
X ! newwords = 1;
X return tinsert (nword, (struct dent *) NULL, keep);
X
X --- 314,316 -----
X }
X ! newwords |= keep;
X return tinsert (nword, (struct dent *) NULL, keep);
X ***************
X *** 421,422
X toutput1 ();
X
X
X --- 423,425 -----
X toutput1 ();
X + newwords = 0;
X
X ***************
X *** 445,446
X
X static
X
X --- 448,451 -----
X
X + static int hasslash;
X +
X static
X ***************
X *** 449,450
X {
X fprintf (dictf, "%s", cent->word);
X
X --- 454,457 -----
X {
X +
X + hasslash = 0;
X fprintf (dictf, "%s", cent->word);
X ***************
X *** 451,453
X if (cent->d_flag)
X ! fprintf (dictf, "/D");
X if (cent->g_flag)
X
X --- 458,460 -----
X if (cent->d_flag)
X ! flagout ('D');
X if (cent->g_flag)
X ***************
X *** 453,455
X if (cent->g_flag)
X ! fprintf (dictf, "/G");
X if (cent->h_flag)
X
X --- 460,462 -----
X if (cent->g_flag)
X ! flagout ('G');
X if (cent->h_flag)
X ***************
X *** 455,457
X if (cent->h_flag)
X ! fprintf (dictf, "/H");
X if (cent->j_flag)
X
X --- 462,464 -----
X if (cent->h_flag)
X ! flagout ('H');
X if (cent->j_flag)
X ***************
X *** 457,459
X if (cent->j_flag)
X ! fprintf (dictf, "/J");
X if (cent->m_flag)
X
X --- 464,466 -----
X if (cent->j_flag)
X ! flagout ('J');
X if (cent->m_flag)
X ***************
X *** 459,461
X if (cent->m_flag)
X ! fprintf (dictf, "/M");
X if (cent->n_flag)
X
X --- 466,468 -----
X if (cent->m_flag)
X ! flagout ('M');
X if (cent->n_flag)
X ***************
X *** 461,463
X if (cent->n_flag)
X ! fprintf (dictf, "/N");
X if (cent->p_flag)
X
X --- 468,470 -----
X if (cent->n_flag)
X ! flagout ('N');
X if (cent->p_flag)
X ***************
X *** 463,465
X if (cent->p_flag)
X ! fprintf (dictf, "/P");
X if (cent->r_flag)
X
X --- 470,472 -----
X if (cent->p_flag)
X ! flagout ('P');
X if (cent->r_flag)
X ***************
X *** 465,467
X if (cent->r_flag)
X ! fprintf (dictf, "/R");
X if (cent->s_flag)
X
X --- 472,474 -----
X if (cent->r_flag)
X ! flagout ('R');
X if (cent->s_flag)
X ***************
X *** 467,469
X if (cent->s_flag)
X ! fprintf (dictf, "/S");
X if (cent->t_flag)
X
X --- 474,476 -----
X if (cent->s_flag)
X ! flagout ('S');
X if (cent->t_flag)
X ***************
X *** 469,471
X if (cent->t_flag)
X ! fprintf (dictf, "/T");
X if (cent->v_flag)
X
X --- 476,478 -----
X if (cent->t_flag)
X ! flagout ('T');
X if (cent->v_flag)
X ***************
X *** 471,473
X if (cent->v_flag)
X ! fprintf (dictf, "/V");
X if (cent->x_flag)
X
X --- 478,480 -----
X if (cent->v_flag)
X ! flagout ('V');
X if (cent->x_flag)
X ***************
X *** 473,475
X if (cent->x_flag)
X ! fprintf (dictf, "/X");
X if (cent->y_flag)
X
X --- 480,482 -----
X if (cent->x_flag)
X ! flagout ('X');
X if (cent->y_flag)
X ***************
X *** 475,477
X if (cent->y_flag)
X ! fprintf (dictf, "/Y");
X if (cent->z_flag)
X
X --- 482,484 -----
X if (cent->y_flag)
X ! flagout ('Y');
X if (cent->z_flag)
X ***************
X *** 477,479
X if (cent->z_flag)
X ! fprintf (dictf, "/Z");
X fprintf (dictf, "\n");
X
X --- 484,486 -----
X if (cent->z_flag)
X ! flagout ('Z');
X fprintf (dictf, "\n");
X ***************
X *** 479,480
X fprintf (dictf, "\n");
X }
X
X --- 486,496 -----
X fprintf (dictf, "\n");
X + }
X +
X + static
X + flagout (flag)
X + {
X + if (!hasslash)
X + putc ('/', dictf);
X + hasslash = 1;
X + putc (flag, dictf);
X }
SHAR_EOF
if test 37715 -ne "`wc -c < 'Patch1'`"
then
echo shar: error transmitting "'Patch1'" '(should have been 37715 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'icombine.c'" '(2738 characters)'
if test -f 'icombine.c'
then
echo shar: will not over-write existing file "'icombine.c'"
else
sed 's/^X //' << \SHAR_EOF > 'icombine.c'
X /*
X icombine: combine multiple ispell dictionary entries into a single
X entry with the options of all entries
X
X Author: Gary Puckering
X Cognos, Inc.
X
X Written: January 29, 1987
X
X Notes: Input lines consist of a word followed optionally by
X by one or more flags. e.g CREATE/V/N/S
X
X No editing on flags is performed.
X The input line is upshifted.
X An improper flag, like /XN will be output as /X/N.
X Flags are output in alphabetical order.
X Non-letter appearing before the first "/" are retained,
X those after are dropped.
X */
X
X #include <stdio.h>
X #include <ctype.h>
X
X #define MAXFLAGS 26 /* letters A-Z */
X #define MAXLINE 255 /* maximum line size */
X
X #define TRUE 1
X #define FALSE 0
X typedef int bool;
X
X bool flagtbl[MAXFLAGS]; /* array of flag options */
X
X char line[MAXLINE]; /* current line */
X char lastword[MAXLINE]; /* previous word */
X char word[MAXLINE]; /* current word */
X char flags[MAXLINE]; /* current flags */
X int expand = 0; /* if NZ, expand instead of combining */
X
X extern char *strcpy ();
X
X
X char *getline()
X {
X char *rvalue;
X char *p;
X
X if (rvalue=gets(line))
X { p = line;
X while (*p) { if (islower(*p)) *p=toupper(*p); p++; }
X }
X return(rvalue);
X }
X
X main(argc,argv)
X int argc;
X char *argv[];
X {
X
X if (argc > 1 && strcmp (argv[1], "-e") == 0)
X expand = 1;
X if (getline())
X {
X parse(line,lastword,flags);
X getflags(flags);
X }
X else
X return 0;
X
X while (getline())
X {
X parse(line,word,flags);
X if (strcmp(word,lastword)!=0) /* different word */
X {
X putword();
X strcpy(lastword,word);
X }
X getflags(flags);
X }
X putword();
X return 0;
X }
X
X putword()
X {
X printf("%s",lastword);
X putflags();
X }
X
X parse(ln,wrd,flgs)
X char ln[];
X char wrd[];
X char flgs[];
X {
X register char *p, *q;
X
X /* copy line up to first "/" or to end */
X for (p=ln,q=wrd; *p && *p != '/'; p++,q++) *q = *p;
X *q = NULL;
X
X strcpy(flgs,p); /* copy from "/" to end */
X }
X
X getflags(flgs)
X char *flgs;
X {
X register char *p;
X
X for (p=flgs; *p; p++)
X if (*p != '/')
X {
X if (islower (*p))
X *p = toupper (*p);
X if (isupper(*p))
X flagtbl[(*p)-'A'] = TRUE;
X }
X }
X
X putflags()
X {
X register int i;
X int slashout = 0;
X
X if (expand)
X putchar ('\n');
X
X for (i=0; i<MAXFLAGS; i++)
X if (flagtbl[i])
X {
X if (expand)
X printf("%s/%c\n", lastword, i + 'A');
X else
X {
X if (!slashout)
X putchar('/');
X slashout = 1;
X putchar(i+'A');
X }
X flagtbl[i]=FALSE;
X }
X if (!expand)
X putchar('\n');
X }
SHAR_EOF
if test 2738 -ne "`wc -c < 'icombine.c'`"
then
echo shar: error transmitting "'icombine.c'" '(should have been 2738 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'munchlist.X'" '(5582 characters)'
if test -f 'munchlist.X'
then
echo shar: will not over-write existing file "'munchlist.X'"
else
sed 's/^X //' << \SHAR_EOF > 'munchlist.X'
X : Use /bin/sh
X #
X # Given a list of words for ispell, generate a reduced list
X # in which all possible suffixes have been collapsed. The reduced
X # list will match the same list as the original.
X #
X # Usage:
X #
X # munchlist [ -d hashfile ] [ -e ] [ -w chars ] [ file ] ...
X #
X # Options:
X #
X # -d hashfile
X # Remove any words that are covered by 'hashfile'. The
X # default is the default ispell dictionary. The words
X # will be removed only if all suffixes are covered by
X # the hash file. A hashfile of /dev/null should be
X # specified when the main dictionary is being munched.
X # -e Economical algorithm. This will use much less temporary
X # disk space, at the expense of time. Useful with large files
X # (such as complete dictionaries).
X # -w Passed on to ispell (specify chars that are part of a word)
X #
X # The given input files are merged, then processed by 'ispell -c'
X # to generate possible suffix lists; these are then combined
X # and reduced. The final result is written to standard output.
X #
X # For portability to older systems, I have avoided getopt.
X #
X # Geoff Kuenning
X # 2/28/87
X #
X LIBDIR=!!LIBDIR!!
X COMBINE=${LIBDIR}/icombine
X EXPAND1=${LIBDIR}/expand1.sed
X EXPAND2=${LIBDIR}/expand2.sed
X TDIR=${TMPDIR:-/usr/tmp}
X TMP=${TDIR}/munch$$
X
X cheap=no
X dictopt=
X wchars=
X while [ $# != 0 ]
X do
X case "$1" in
X -d)
X case "$2" in
X /dev/null)
X dictopt=NONE
X ;;
X *)
X dictopt="-d $2"
X ;;
X esac
X shift
X ;;
X -e)
X cheap=yes
X ;;
X -w)
X wchars="-w $2"
X shift
X ;;
X *)
X break
X esac
X shift
X done
X trap "/bin/rm -f ${TMP}*; exit 1" 1 2 15
X #
X # Collect all the input (cat), convert to uppercase (tr), expand all
X # the suffix options (two sed's), and preserve (sorted) for later
X # joining in ${TMP}a.
X #
X if [ $# -eq 0 ]
X then
X tr '[a-z]' '[A-Z]' \
X | sed -f $EXPAND1 | sed -f $EXPAND2 | sort -u > ${TMP}a
X else
X cat "$@" | tr '[a-z]' '[A-Z]' \
X | sed -f $EXPAND1 | sed -f $EXPAND2 | sort -u > ${TMP}a
X fi
X #
X # Unless an explicitly null dictionary was specified, remove all
X # expanded words that are covered by the dictionary. This produces
X # the final list of expanded words that this dictionary must cover.
X # Leave the list in ${TMP}b.
X #
X if [ "X$dictopt" = "XNONE" ]
X then
X ln ${TMP}a ${TMP}b
X else
X ispell -l $dictopt -p /dev/null < ${TMP}a > ${TMP}b
X fi
X #
X # Munch the input to generate roots and suffixes (ispell -c). We are
X # only interested in words that have at least one suffix (egrep /); the
X # next step will pick up the rest. Some of the roots are illegal. We
X # use join to restrict the output to those root words that are found
X # in the original dictionary.
X #
X # Note: one disadvantage of this pipeline is that for a large file,
X # the join and icombine may be sitting around for a long time while ispell
X # and sort run. You can get rid of this by splitting the pipe, at
X # the expense of more temp file space.
X #
X if [ $cheap = yes ]
X then
X ispell $wchars -c -d /dev/null -p /dev/null < ${TMP}b \
X | egrep / | sort -u -t/ +0 -1 +1 \
X | join -t/ - ${TMP}a | $COMBINE > ${TMP}c
X else
X ispell $wchars -c -d /dev/null -p /dev/null < ${TMP}b \
X | egrep / | sort -u -t/ +0 -1 +1 \
X | join -t/ - ${TMP}a > ${TMP}c
X fi
X #
X # There is now one slight problem: the suffix flags X, J, and Z
X # are simply the addition of an "S" to the suffixes N, G, and R,
X # respectively. This produces redundant entries in the output file;
X # for example, ABBREVIATE/N/X and ABBREVIATION/S. We must get rid
X # of the unnecessary duplicates. The candidates are those words that
X # have only an "S" flag (egrep). We strip off the "S" (sed), and
X # generate a list of roots that might have made these words (ispell -c).
X # Of these roots, we select those that have the N, G, or R flags,
X # replacing each with the plural equivalent X, J, or Z (sed -n).
X # Using join once again, we select those that have legal roots
X # and put them in ${TMP}d.
X #
X if [ $cheap = yes ]
X then
X egrep '^[^/]*/S$' ${TMP}c | sed 's@/S$@@' \
X | ispell $wchars -c -d /dev/null -p /dev/null \
X | sed -n -e '/\/N/s/N$/X/p' -e '/\/G/s/G$/J/p' -e '/\/R/s/R$/Z/p' \
X | sort -u -t/ +0 -1 +1 \
X | join -t/ - ${TMP}a \
X | $COMBINE > ${TMP}d
X else
X egrep '^[^/]*/S$' ${TMP}c | sed 's@/S$@@' \
X | ispell $wchars -c -d /dev/null -p /dev/null \
X | sed -n -e '/\/N/s/N$/X/p' -e '/\/G/s/G$/J/p' -e '/\/R/s/R$/Z/p' \
X | sort -u -t/ +0 -1 +1 \
X | join -t/ - ${TMP}a > ${TMP}d
X fi
X /bin/rm -f ${TMP}a
X #
X # Now we have to eliminate the stuff covered by ${TMP}d from ${TMP}c.
X # First, we re-expand the suffixes we just made (sed -f pair), and let
X # ispell re-create the /S version (ispell -c). We select the /S versions
X # only (egrep), sort them (sort) for comm, and use comm to delete these
X # from ${TMP}c. The output of comm (i.e., the trimmed version of
X # ${TMP}c) is combined with our special-suffixes file ${TMP}d (sort again)
X # and reduced in size (icombine) to produce a final list of all words
X # that have at least one suffix.
X #
X sed -f $EXPAND1 < ${TMP}d | sed -f $EXPAND2 \
X | ispell $wchars -c -d /dev/null -p /dev/null \
X | egrep '\/S$' | sort -u -t/ +0 -1 +1 | comm -13 - ${TMP}c \
X | sort -u -t/ +0 -1 +1 - ${TMP}d \
X | $COMBINE > ${TMP}e
X /bin/rm -f ${TMP}[cd]
X #
X # Now a slick trick. Use ispell to select those (root) words from the original
X # list (${TMP}b) that are not covered by the suffix list (${TMP}e). Then we
X # merge these with the suffix list and sort it to produce the final output.
X #
X ispell $wchars -d /dev/null -p ${TMP}e -l < ${TMP}b \
X | sort -u -t/ +0 -1 +1 - ${TMP}e
X /bin/rm -f ${TMP}*
SHAR_EOF
if test 5582 -ne "`wc -c < 'munchlist.X'`"
then
echo shar: error transmitting "'munchlist.X'" '(should have been 5582 characters)'
fi
chmod +x 'munchlist.X'
fi # end of overwriting check
# End of shell archive
exit 0
--
Geoff Kuenning
{hplabs,ihnp4}!trwrb!desint!geoff
Re: Patch #1 to the "enhanced" ispell
Author: geoff
Date: Wed, 01 Apr 1987 08:40
Date: Wed, 01 Apr 1987 08:40
20 lines
1354 bytes
1354 bytes
Sigh. I should know better than to post when I'm tired.
I'm sorry about all the trouble you probably had with Patch #1. I forgot to
mention a CRITICAL little detail: I changed some file names. Before
applying the patch, you must mv three files:
mv config.h config.X
mv munchlist.sh munchlist.X
mv ispell.man ispell.1
Also, on BSD systems you must edit buildhash.c to interchange the includes
of stat.h and param.h. The next patch will also include a fix for this.
Thanks to Ken Yap for identifying the problem.
Finally, I neglected to mention that 'munchlist' is now much faster, thanks
to Gary Puckering's handy 'icombine' program.
--
Geoff Kuenning
{hplabs,ihnp4}!trwrb!desint!geoff
Thread Navigation
This is a paginated view of messages in the thread with full content displayed inline.
Messages are displayed in chronological order, with the original post highlighted in green.
Use pagination controls to navigate through all messages in large threads.
Back to All Threads