X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/a8928dd22f52c72f3c6ff2878b5b2e1d52ca271a..1907b8e60e7d5814898a310736ac64f3d79acfff:/lisp/textmodes/ispell.el diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el index d9d2825acb..5107345166 100644 --- a/lisp/textmodes/ispell.el +++ b/lisp/textmodes/ispell.el @@ -1,315 +1,361 @@ -;;;;;;;;;;;;;;;;;;;;;;;;;;; -*- Mode: emacs-lisp -*- ;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; GNU EMACS interface for International Ispell Version 3.1 by Geoff Kuenning. -;;; -;;; -;;; Copyright (C) 1994 Free Software Foundation, Inc. -;;; -;;; -;;; Authors : Ken Stevens et. al. -;;; Syntax : emacs-lisp -;;; Status : Release with 3.1.05 ispell. -;;; Version : International Ispell Version 3.1 by Geoff Kuenning. -;;; Bug Reports : ispell-el-bugs@itcorp.com -;;; -;;; This file is part of GNU Emacs. -;;; -;;; GNU Emacs is free software; you can redistribute it and/or modify -;;; it under the terms of the GNU General Public License as published by -;;; the Free Software Foundation; either version 2, or (at your option) -;;; any later version. -;;; -;;; GNU Emacs is distributed in the hope that it will be useful, -;;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;;; GNU General Public License for more details. -;;; -;;; You should have received a copy of the GNU General Public License -;;; along with GNU Emacs; see the file COPYING. If not, write to -;;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. -;;; -;;; Commentary: -;;; -;;; INSTRUCTIONS -;;; -;;; This code contains a section of user-settable variables that you should -;;; inspect prior to installation. Look past the end of the history list. -;;; Set them up for your locale and the preferences of the majority of the -;;; users. Otherwise the users may need to set a number of variables -;;; themselves. -;;; You particularly may want to change the default dictionary for your -;;; country and language. -;;; -;;; -;;; To fully install this, add this file to your Emacs Lisp directory and -;;; compile it with M-X byte-compile-file. Then add the following to the -;;; appropriate init file: -;;; -;;; (autoload 'ispell-word "ispell" -;;; "Check the spelling of word in buffer." t) -;;; (global-set-key "\e$" 'ispell-word) -;;; (autoload 'ispell-region "ispell" -;;; "Check the spelling of region." t) -;;; (autoload 'ispell-buffer "ispell" -;;; "Check the spelling of buffer." t) -;;; (autoload 'ispell-complete-word "ispell" -;;; "Look up current word in dictionary and try to complete it." t) -;;; (autoload 'ispell-change-dictionary "ispell" -;;; "Change ispell dictionary." t) -;;; (autoload 'ispell-message "ispell" -;;; "Check spelling of mail message or news post.") -;;; -;;; Depending on the mail system you use, you may want to include these: -;;; -;;; (add-hook 'news-inews-hook 'ispell-message) -;;; (add-hook 'mail-send-hook 'ispell-message) -;;; (add-hook 'mh-before-send-letter-hook 'ispell-message) -;;; -;;; -;;; Ispell has a TeX parser and a nroff parser (the default). -;;; The parsing is controlled by the variable ispell-parser. Currently -;;; it is just a "toggle" between TeX and nroff, but if more parsers are -;;; added it will be updated. See the variable description for more info. -;;; -;;; -;;; TABLE OF CONTENTS -;;; -;;; ispell-word -;;; ispell-region -;;; ispell-buffer -;;; ispell-message -;;; ispell-continue -;;; ispell-complete-word -;;; ispell-complete-word-interior-frag -;;; ispell-change-dictionary -;;; ispell-kill-ispell -;;; ispell-pdict-save -;;; -;;; -;;; Commands in ispell-region: -;;; Character replacement: Replace word with choice. May query-replace. -;;; ' ': Accept word this time. -;;; 'i': Accept word and insert into private dictionary. -;;; 'a': Accept word for this session. -;;; 'A': Accept word and place in buffer-local dictionary. -;;; 'r': Replace word with typed-in value. Rechecked. -;;; 'R': Replace word with typed-in value. Query-replaced in buffer. Rechecked. -;;; '?': Show these commands -;;; 'x': Exit spelling buffer. Move cursor to original point. -;;; 'X': Exit spelling buffer. Leave cursor at the current point. -;;; 'q': Quit spelling session (Kills ispell process). -;;; 'l': Look up typed-in replacement in alternate dictionary. Wildcards okay. -;;; 'u': Like 'i', but the word is lower-cased first. -;;; 'm': Like 'i', but allows one to include dictionary completion info. -;;; 'C-l': redraws screen -;;; 'C-r': recursive edit -;;; 'C-z': suspend emacs or iconify frame -;;; -;;; Buffer-Local features: -;;; There are a number of buffer-local features that can be used to customize -;;; ispell for the current buffer. This includes language dictionaries, -;;; personal dictionaries, parsing, and local word spellings. Each of these -;;; local customizations are done either through local variables, or by -;;; including the keyword and argument(s) at the end of the buffer (usually -;;; prefixed by the comment characters). See the end of this file for -;;; examples. The local keywords and variables are: -;;; -;;; ispell-dictionary-keyword language-dictionary -;;; uses local variable ispell-local-dictionary -;;; ispell-pdict-keyword personal-dictionary -;;; uses local variable ispell-local-pdict -;;; ispell-parsing-keyword mode-arg extended-char-arg -;;; ispell-words-keyword any number of local word spellings -;;; -;;; -;;; BUGS: -;;; Highlighting in version 19 still doesn't work on tty's. -;;; On some versions of emacs, growing the minibuffer fails. -;;; -;;; HISTORY -;;; -;;; Revision 2.30 1994/5/20 15:58:52 stevens -;;; Continue ispell from ispell-word, C-z functionality fixed. -;;; -;;; Revision 2.29 1994/5/12 09:44:33 stevens -;;; Restored ispell-use-ptys-p, ispell-message aborts sends with interrupt. -;;; defined fn ispell -;;; -;;; Revision 2.28 1994/4/28 16:24:40 stevens -;;; Window checking when ispell-message put on gnus-inews-article-hook jwz. -;;; prefixed ispell- to highlight functions and horiz-scroll fn. -;;; Try and respect case of word in ispell-complete-word. -;;; Ignore non-char events. Ispell-use-ptys-p commented out. Lucid menu. -;;; Better interrupt handling. ispell-message improvements from Ethan. -;;; -;;; Revision 2.27 -;;; version 18 explicit C-g handling disabled as it didn't work. Added -;;; ispell-extra-args for ispell customization (jwz) -;;; -;;; Revision 2.26 1994/2/15 16:11:14 stevens -;;; name changes for copyright assignment. Added word-frags in complete-word. -;;; Horizontal scroll (John Conover). Query-replace matches words now. bugs. -;;; -;;; Revision 2.25 -;;; minor mods, upgraded ispell-message -;;; -;;; Revision 2.24 -;;; query-replace more robust, messages, defaults, ispell-change-dict. -;;; -;;; Revision 2.23 1993/11/22 23:47:03 stevens -;;; ispell-message, Fixed highlighting, added menu-bar, fixed ispell-help, ... -;;; -;;; Revision 2.22 -;;; Added 'u' command. Fixed default in ispell-local-dictionary. -;;; fixed affix rules display. Tib skipping more robust. Contributions by -;;; Per Abraham (parser selection), Denis Howe, and Eberhard Mattes. -;;; -;;; Revision 2.21 1993/06/30 14:09:04 stevens -;;; minor bugs. (nroff word skipping fixed) -;;; -;;; Revision 2.20 1993/06/30 14:09:04 stevens -;;; -;;; Debugging and contributions by: Boris Aronov, Rik Faith, Chris Moore, -;;; Kevin Rodgers, Malcolm Davis. -;;; Particular thanks to Michael Lipp, Jamie Zawinski, Phil Queinnec -;;; and John Heidemann for suggestions and code. -;;; Major update including many tweaks. -;;; Many changes were integrations of suggestions. -;;; lookup-words rehacked to use call-process (Jamie). -;;; ispell-complete-word rehacked to be compatible with the rest of the -;;; system for word searching and to include multiple wildcards, -;;; and it's own dictionary. -;;; query-replace capability added. New options 'X', 'R', and 'A'. -;;; buffer-local modes for dictionary, word-spelling, and formatter-parsing. -;;; Many random bugs, like commented comments being skipped, fix to -;;; keep-choices-win, fix for math mode, added pipe mode choice, -;;; fixed 'q' command, ispell-word checks previous word and leave cursor -;;; in same location. Fixed tib code which could drop spelling regions. -;;; Cleaned up setq calls for efficiency. Gave more context on window overlays. -;;; Assure context on ispell-command-loop. Window lossage in look cmd fixed. -;;; Due to pervasive opinion, common-lisp package syntax removed. Display -;;; problem when not highlighting. -;;; -;;; Revision 2.19 1992/01/10 10:54:08 geoff -;;; Make another attempt at fixing the "Bogus, dude" problem. This one is -;;; less elegant, but has the advantage of working. -;;; -;;; Revision 2.18 1992/01/07 10:04:52 geoff -;;; Fix the "Bogus, Dude" problem in ispell-word. -;;; -;;; Revision 2.17 1991/09/12 00:01:42 geoff -;;; Add some changes to make ispell-complete-word work better, though -;;; still not perfectly. -;;; -;;; Revision 2.16 91/09/04 18:00:52 geoff -;;; More updates from Sebastian, to make the multiple-dictionary support -;;; more flexible. -;;; -;;; Revision 2.15 91/09/04 17:30:02 geoff -;;; Sebastian Kremer's tib support -;;; -;;; Revision 2.14 91/09/04 16:19:37 geoff -;;; Don't do set-window-start if the move-to-window-line moved us -;;; downward, rather than upward. This prevents getting the buffer all -;;; confused. Also, don't use the "not-modified" function to clear the -;;; modification flag; instead use set-buffer-modified-p. This prevents -;;; extra messages from flashing. -;;; -;;; Revision 2.13 91/09/04 14:35:41 geoff -;;; Fix a spelling error in a comment. Add code to handshake with the -;;; ispell process before sending anything to it. -;;; -;;; Revision 2.12 91/09/03 20:14:21 geoff -;;; Add Sebastian Kremer's multiple-language support. -;;; -;;; -;;; Walt Buehring -;;; Texas Instruments - Computer Science Center -;;; ARPA: Buehring%TI-CSL@CSNet-Relay -;;; UUCP: {smu, texsun, im4u, rice} ! ti-csl ! buehring -;;; -;;; ispell-region and associated routines added by -;;; Perry Smith -;;; pedz@bobkat -;;; Tue Jan 13 20:18:02 CST 1987 -;;; -;;; extensively modified by Mark Davies and Andrew Vignaux -;;; {mark,andrew}@vuwcomp -;;; Sun May 10 11:45:04 NZST 1987 -;;; -;;; Ken Stevens ARPA: k.stevens@ieee.org -;;; Tue Jan 3 16:59:07 PST 1989 -;;; This file has overgone a major overhaul to be compatible with ispell -;;; version 2.1. Most of the functions have been totally rewritten, and -;;; many user-accessible variables have been added. The syntax table has -;;; been removed since it didn't work properly anyway, and a filter is -;;; used rather than a buffer. Regular expressions are used based on -;;; ispell's internal definition of characters (see ispell(4)). -;;; Some new updates: -;;; - Updated to version 3.0 to include terse processing. -;;; - Added a variable for the look command. -;;; - Fixed a bug in ispell-word when cursor is far away from the word -;;; that is to be checked. -;;; - Ispell places the incorrect word or guess in the minibuffer now. -;;; - fixed a bug with 'l' option when multiple windows are on the screen. -;;; - lookup-words just didn't work with the process filter. Fixed. -;;; - Rewrote the process filter to make it cleaner and more robust -;;; in the event of a continued line not being completed. -;;; - Made ispell-init-process more robust in handling errors. -;;; - Fixed bug in continuation location after a region has been modified by -;;; correcting a misspelling. -;;; Mon 17 Sept 1990 -;;; -;;; Sebastian Kremer -;;; Wed Aug 7 14:02:17 MET DST 1991 -;;; - Ported ispell-complete-word from Ispell 2 to Ispell 3. -;;; - Added ispell-kill-ispell command. -;;; - Added ispell-dictionary and ispell-dictionary-alist variables to -;;; support other than default language. See their docstrings and -;;; command ispell-change-dictionary. -;;; - (ispelled it :-) -;;; - Added ispell-skip-tib variable to support the tib bibliography -;;; program. -;;; -;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; ispell.el --- spell checking using Ispell +;; Copyright (C) 1994, 1995, 1997 Free Software Foundation, Inc. +;; Authors : Ken Stevens +;; Last Modified On: Tue Jun 13 12:05:28 EDT 1995 +;; Update Revision : 2.37 +;; Syntax : emacs-lisp +;; Status : Release with 3.1.12+ ispell. +;; Version : International Ispell Version 3.1 by Geoff Kuenning. +;; Bug Reports : ispell-el-bugs@itcorp.com -;;; ********************************************************************** -;;; The following variables should be set according to personal preference -;;; and location of binaries: -;;; ********************************************************************** +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2, or (at your option) +;; any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs; see the file COPYING. If not, write to the +;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. + +;; Note: version numbers and time stamp are not updated +;; when this file is edited for release with GNU Emacs. + +;;; Commentary: + +;; INSTRUCTIONS +;; +;; This code contains a section of user-settable variables that you should +;; inspect prior to installation. Look past the end of the history list. +;; Set them up for your locale and the preferences of the majority of the +;; users. Otherwise the users may need to set a number of variables +;; themselves. +;; You particularly may want to change the default dictionary for your +;; country and language. +;; +;; +;; To fully install this, add this file to your Emacs Lisp directory and +;; compile it with M-X byte-compile-file. Then add the following to the +;; appropriate init file: +;; +;; (autoload 'ispell-word "ispell" +;; "Check the spelling of word in buffer." t) +;; (global-set-key "\e$" 'ispell-word) +;; (autoload 'ispell-region "ispell" +;; "Check the spelling of region." t) +;; (autoload 'ispell-buffer "ispell" +;; "Check the spelling of buffer." t) +;; (autoload 'ispell-complete-word "ispell" +;; "Look up current word in dictionary and try to complete it." t) +;; (autoload 'ispell-change-dictionary "ispell" +;; "Change ispell dictionary." t) +;; (autoload 'ispell-message "ispell" +;; "Check spelling of mail message or news post.") +;; +;; Depending on the mail system you use, you may want to include these: +;; +;; (add-hook 'news-inews-hook 'ispell-message) +;; (add-hook 'mail-send-hook 'ispell-message) +;; (add-hook 'mh-before-send-letter-hook 'ispell-message) +;; +;; +;; Ispell has a TeX parser and a nroff parser (the default). +;; The parsing is controlled by the variable ispell-parser. Currently +;; it is just a "toggle" between TeX and nroff, but if more parsers are +;; added it will be updated. See the variable description for more info. +;; +;; +;; TABLE OF CONTENTS +;; +;; ispell-word +;; ispell-region +;; ispell-buffer +;; ispell-message +;; ispell-continue +;; ispell-complete-word +;; ispell-complete-word-interior-frag +;; ispell-change-dictionary +;; ispell-kill-ispell +;; ispell-pdict-save +;; +;; +;; Commands in ispell-region: +;; Character replacement: Replace word with choice. May query-replace. +;; ' ': Accept word this time. +;; 'i': Accept word and insert into private dictionary. +;; 'a': Accept word for this session. +;; 'A': Accept word and place in buffer-local dictionary. +;; 'r': Replace word with typed-in value. Rechecked. +;; 'R': Replace word with typed-in value. Query-replaced in buffer. Rechecked. +;; '?': Show these commands +;; 'x': Exit spelling buffer. Move cursor to original point. +;; 'X': Exit spelling buffer. Leave cursor at the current point. +;; 'q': Quit spelling session (Kills ispell process). +;; 'l': Look up typed-in replacement in alternate dictionary. Wildcards okay. +;; 'u': Like 'i', but the word is lower-cased first. +;; 'm': Like 'i', but allows one to include dictionary completion info. +;; 'C-l': redraws screen +;; 'C-r': recursive edit +;; 'C-z': suspend emacs or iconify frame +;; +;; Buffer-Local features: +;; There are a number of buffer-local features that can be used to customize +;; ispell for the current buffer. This includes language dictionaries, +;; personal dictionaries, parsing, and local word spellings. Each of these +;; local customizations are done either through local variables, or by +;; including the keyword and argument(s) at the end of the buffer (usually +;; prefixed by the comment characters). See the end of this file for +;; examples. The local keywords and variables are: +;; +;; ispell-dictionary-keyword language-dictionary +;; uses local variable ispell-local-dictionary +;; ispell-pdict-keyword personal-dictionary +;; uses local variable ispell-local-pdict +;; ispell-parsing-keyword mode-arg extended-char-arg +;; ispell-words-keyword any number of local word spellings +;; +;; +;; BUGS: +;; Highlighting in version 19 still doesn't work on tty's. +;; On some versions of emacs, growing the minibuffer fails. +;; +;; HISTORY +;; +;; Revision 2.38 1996/5/30 ethanb@phys.washington.edu +;; Update ispell-message for gnus 5 (news-inews-hook => message-send-hook; +;; different header for quoted message). +;; +;; Revision 2.37 1995/6/13 12:05:28 stevens +;; Removed autoload from ispell-dictionary-alist. *choices* mode-line shows +;; misspelled word. Block skip for pgp & forwarded messages added. +;; RMS: the autoload changes had problems and I removed them. +;; +;; Revision 2.36 1995/2/6 17:39:38 stevens +;; Properly adjust screen with different ispell-choices-win-default-height +;; settings. Skips SGML entity references. +;; +;; Revision 2.35 1995/1/13 14:16:46 stevens +;; Skips SGML tags, ispell-change-dictionary fix for add-hook, assure personal +;; dictionary is saved when called from the menu +;; +;; Revision 2.34 1994/12/08 13:17:41 stevens +;; Interaction corrected to function with all 3.1 ispell versions. +;; +;; Revision 2.33 1994/11/24 02:31:20 stevens +;; Repaired bug introduced in 2.32 that corrupts buffers when correcting. +;; Improved buffer scrolling. Nondestructive buffer selections allowed. +;; +;; Revision 2.32 1994/10/31 21:10:08 geoff +;; Many revisions accepted from RMS/FSF. I think (though I don't know) that +;; this represents an 'official' version. +;; +;; Revision 2.31 1994/5/31 10:18:17 stevens +;; Repaired comments. buffer-local commands executed in `ispell-word' now. +;; German dictionary described for extended character mode. Dict messages. +;; +;; Revision 2.30 1994/5/20 22:18:36 stevens +;; Continue ispell from ispell-word, C-z functionality fixed. +;; +;; Revision 2.29 1994/5/12 09:44:33 stevens +;; Restored ispell-use-ptys-p, ispell-message aborts sends with interrupt. +;; defined fn ispell +;; +;; Revision 2.28 1994/4/28 16:24:40 stevens +;; Window checking when ispell-message put on gnus-inews-article-hook jwz. +;; prefixed ispell- to highlight functions and horiz-scroll fn. +;; Try and respect case of word in ispell-complete-word. +;; Ignore non-char events. Ispell-use-ptys-p commented out. Lucid menu. +;; Better interrupt handling. ispell-message improvements from Ethan. +;; +;; Revision 2.27 +;; version 18 explicit C-g handling disabled as it didn't work. Added +;; ispell-extra-args for ispell customization (jwz) +;; +;; Revision 2.26 1994/2/15 16:11:14 stevens +;; name changes for copyright assignment. Added word-frags in complete-word. +;; Horizontal scroll (John Conover). Query-replace matches words now. bugs. +;; +;; Revision 2.25 +;; minor mods, upgraded ispell-message +;; +;; Revision 2.24 +;; query-replace more robust, messages, defaults, ispell-change-dict. +;; +;; Revision 2.23 1993/11/22 23:47:03 stevens +;; ispell-message, Fixed highlighting, added menu-bar, fixed ispell-help, ... +;; +;; Revision 2.22 +;; Added 'u' command. Fixed default in ispell-local-dictionary. +;; fixed affix rules display. Tib skipping more robust. Contributions by +;; Per Abraham (parser selection), Denis Howe, and Eberhard Mattes. +;; +;; Revision 2.21 1993/06/30 14:09:04 stevens +;; minor bugs. (nroff word skipping fixed) +;; +;; Revision 2.20 1993/06/30 14:09:04 stevens +;; +;; Debugging and contributions by: Boris Aronov, Rik Faith, Chris Moore, +;; Kevin Rodgers, Malcolm Davis. +;; Particular thanks to Michael Lipp, Jamie Zawinski, Phil Queinnec +;; and John Heidemann for suggestions and code. +;; Major update including many tweaks. +;; Many changes were integrations of suggestions. +;; lookup-words rehacked to use call-process (Jamie). +;; ispell-complete-word rehacked to be compatible with the rest of the +;; system for word searching and to include multiple wildcards, +;; and its own dictionary. +;; query-replace capability added. New options 'X', 'R', and 'A'. +;; buffer-local modes for dictionary, word-spelling, and formatter-parsing. +;; Many random bugs, like commented comments being skipped, fix to +;; keep-choices-win, fix for math mode, added pipe mode choice, +;; fixed 'q' command, ispell-word checks previous word and leave cursor +;; in same location. Fixed tib code which could drop spelling regions. +;; Cleaned up setq calls for efficiency. Gave more context on window overlays. +;; Assure context on ispell-command-loop. Window lossage in look cmd fixed. +;; Due to pervasive opinion, common-lisp package syntax removed. Display +;; problem when not highlighting. +;; +;; Revision 2.19 1992/01/10 10:54:08 geoff +;; Make another attempt at fixing the "Bogus, dude" problem. This one is +;; less elegant, but has the advantage of working. +;; +;; Revision 2.18 1992/01/07 10:04:52 geoff +;; Fix the "Bogus, Dude" problem in ispell-word. +;; +;; Revision 2.17 1991/09/12 00:01:42 geoff +;; Add some changes to make ispell-complete-word work better, though +;; still not perfectly. +;; +;; Revision 2.16 91/09/04 18:00:52 geoff +;; More updates from Sebastian, to make the multiple-dictionary support +;; more flexible. +;; +;; Revision 2.15 91/09/04 17:30:02 geoff +;; Sebastian Kremer's tib support +;; +;; Revision 2.14 91/09/04 16:19:37 geoff +;; Don't do set-window-start if the move-to-window-line moved us +;; downward, rather than upward. This prevents getting the buffer all +;; confused. Also, don't use the "not-modified" function to clear the +;; modification flag; instead use set-buffer-modified-p. This prevents +;; extra messages from flashing. +;; +;; Revision 2.13 91/09/04 14:35:41 geoff +;; Fix a spelling error in a comment. Add code to handshake with the +;; ispell process before sending anything to it. +;; +;; Revision 2.12 91/09/03 20:14:21 geoff +;; Add Sebastian Kremer's multiple-language support. +;; +;; +;; Walt Buehring +;; Texas Instruments - Computer Science Center +;; ARPA: Buehring%TI-CSL@CSNet-Relay +;; UUCP: {smu, texsun, im4u, rice} ! ti-csl ! buehring +;; +;; ispell-region and associated routines added by +;; Perry Smith +;; pedz@bobkat +;; Tue Jan 13 20:18:02 CST 1987 +;; +;; extensively modified by Mark Davies and Andrew Vignaux +;; {mark,andrew}@vuwcomp +;; Sun May 10 11:45:04 NZST 1987 +;; +;; Ken Stevens ARPA: k.stevens@ieee.org +;; Tue Jan 3 16:59:07 PST 1989 +;; This file has overgone a major overhaul to be compatible with ispell +;; version 2.1. Most of the functions have been totally rewritten, and +;; many user-accessible variables have been added. The syntax table has +;; been removed since it didn't work properly anyway, and a filter is +;; used rather than a buffer. Regular expressions are used based on +;; ispell's internal definition of characters (see ispell(4)). +;; Some new updates: +;; - Updated to version 3.0 to include terse processing. +;; - Added a variable for the look command. +;; - Fixed a bug in ispell-word when cursor is far away from the word +;; that is to be checked. +;; - Ispell places the incorrect word or guess in the minibuffer now. +;; - fixed a bug with 'l' option when multiple windows are on the screen. +;; - lookup-words just didn't work with the process filter. Fixed. +;; - Rewrote the process filter to make it cleaner and more robust +;; in the event of a continued line not being completed. +;; - Made ispell-init-process more robust in handling errors. +;; - Fixed bug in continuation location after a region has been modified by +;; correcting a misspelling. +;; Mon 17 Sept 1990 +;; +;; Sebastian Kremer +;; Wed Aug 7 14:02:17 MET DST 1991 +;; - Ported ispell-complete-word from Ispell 2 to Ispell 3. +;; - Added ispell-kill-ispell command. +;; - Added ispell-dictionary and ispell-dictionary-alist variables to +;; support other than default language. See their docstrings and +;; command ispell-change-dictionary. +;; - (ispelled it :-) +;; - Added ispell-skip-tib variable to support the tib bibliography +;; program. + + +;; ********************************************************************** +;; The following variables should be set according to personal preference +;; and location of binaries: +;; ********************************************************************** + +;; ******* THIS FILE IS WRITTEN FOR ISPELL VERSION 3.1 -;;; ******* THIS FILE IS WRITTEN FOR ISPELL VERSION 3.1 ;;; Code: -(defvar ispell-highlight-p t - "*Highlight spelling errors when non-nil.") +(defgroup ispell nil + "Spell checking using ispell" + :group 'processes) + -(defvar ispell-highlight-face 'highlight +(defcustom ispell-highlight-p t + "*Highlight spelling errors when non-nil." + :type 'boolean + :group 'ispell) + +(defcustom ispell-highlight-face 'highlight "*The face used for Ispell highlighting. For Emacses with overlays. Possible values are `highlight', `modeline', `secondary-selection', `region', and `underline'. This variable can be set by the user to whatever face they desire. It's most convenient if the cursor color and highlight color are -slightly different.") +slightly different." + :type 'face + :group 'ispell) -(defvar ispell-check-comments nil - "*Spelling of comments checked when non-nil.") +(defcustom ispell-check-comments t + "*If nil, don't check spelling of comments." + :type 'boolean + :group 'ispell) -(defvar ispell-query-replace-choices nil +(defcustom ispell-query-replace-choices nil "*Corrections made throughout region when non-nil. -Uses `query-replace' (\\[query-replace]) for corrections.") +Uses `query-replace' (\\[query-replace]) for corrections." + :type 'boolean + :group 'ispell) -(defvar ispell-skip-tib nil +(defcustom ispell-skip-tib nil "*Does not spell check `tib' bibliography references when non-nil. Skips any text between strings matching regular expressions `ispell-tib-ref-beginning' and `ispell-tib-ref-end'. TeX users beware: Any field starting with [. will skip until a .] -- even your whole buffer -- unless you set `ispell-skip-tib' to nil. That includes -a [.5mm] type of number....") +a [.5mm] type of number...." + :type 'boolean + :group 'ispell) (defvar ispell-tib-ref-beginning "[[<]\\." "Regexp matching the beginning of a Tib reference.") @@ -317,29 +363,41 @@ a [.5mm] type of number....") (defvar ispell-tib-ref-end "\\.[]>]" "Regexp matching the end of a Tib reference.") -(defvar ispell-keep-choices-win t +(defcustom ispell-keep-choices-win t "*When not nil, the `*Choices*' window remains for spelling session. -This minimizes redisplay thrashing.") +This minimizes redisplay thrashing." + :type 'boolean + :group 'ispell) -(defvar ispell-choices-win-default-height 2 +(defcustom ispell-choices-win-default-height 2 "*The default size of the `*Choices*' window, including status line. -Must be greater than 1.") +Must be greater than 1." + :type 'integer + :group 'ispell) -(defvar ispell-program-name "ispell" - "Program invoked by \\[ispell-word] and \\[ispell-region] commands.") +(defcustom ispell-program-name "ispell" + "Program invoked by \\[ispell-word] and \\[ispell-region] commands." + :type 'string + :group 'ispell) -(defvar ispell-alternate-dictionary +(defcustom ispell-alternate-dictionary (cond ((file-exists-p "/usr/dict/web2") "/usr/dict/web2") + ((file-exists-p "/usr/share/dict/web2") "/usr/share/dict/web2") ((file-exists-p "/usr/dict/words") "/usr/dict/words") ((file-exists-p "/usr/lib/dict/words") "/usr/lib/dict/words") + ((file-exists-p "/usr/share/dict/words") "/usr/share/dict/words") ((file-exists-p "/sys/dict") "/sys/dict") (t "/usr/dict/words")) - "*Alternate dictionary for spelling help.") + "*Alternate dictionary for spelling help." + :type 'file + :group 'ispell) -(defvar ispell-complete-word-dict ispell-alternate-dictionary - "*Dictionary used for word completion.") +(defcustom ispell-complete-word-dict ispell-alternate-dictionary + "*Dictionary used for word completion." + :type 'file + :group 'ispell) -(defvar ispell-grep-command "/usr/bin/egrep" +(defvar ispell-grep-command "egrep" "Name of the grep command for search processes.") (defvar ispell-grep-options "-i" @@ -347,16 +405,20 @@ Must be greater than 1.") Should probably be \"-i\" or \"-e\". Some machines (like the NeXT) don't support \"-i\"") -(defvar ispell-look-command "/usr/bin/look" +(defvar ispell-look-command "look" "Name of the look command for search processes. This must be an absolute file name.") -(defvar ispell-look-p (file-exists-p ispell-look-command) - "*Non-nil means use `look; rather than `grep'. -Default is based on whether `look' seems to be available.") +(defcustom ispell-look-p (file-exists-p ispell-look-command) + "*Non-nil means use `look' rather than `grep'. +Default is based on whether `look' seems to be available." + :type 'boolean + :group 'ispell) -(defvar ispell-have-new-look nil - "*Non-nil means use the `-r' option (regexp) when running `look'.") +(defcustom ispell-have-new-look nil + "*Non-nil means use the `-r' option (regexp) when running `look'." + :type 'boolean + :group 'ispell) (defvar ispell-look-options (if ispell-have-new-look "-dfr" "-df") "String of command options for `ispell-look-command'.") @@ -365,27 +427,41 @@ Default is based on whether `look' seems to be available.") "When non-nil, Emacs uses ptys to communicate with Ispell. When nil, Emacs uses pipes.") -(defvar ispell-following-word nil +(defcustom ispell-following-word nil "*Non-nil means `ispell-word' checks the word around or after point. -Otherwise `ispell-word' checks the preceding word.") +Otherwise `ispell-word' checks the preceding word." + :type 'boolean + :group 'ispell) -(defvar ispell-help-in-bufferp nil +(defcustom ispell-help-in-bufferp nil "*Non-nil means display interactive keymap help in a buffer. -Otherwise use the minibuffer.") +Otherwise use the minibuffer." + :type 'boolean + :group 'ispell) -(defvar ispell-quietly nil - "*Non-nil means suppress messages in `ispell-word'.") +(defcustom ispell-quietly nil + "*Non-nil means suppress messages in `ispell-word'." + :type 'boolean + :group 'ispell) -(defvar ispell-format-word (function upcase) +(defcustom ispell-format-word (function upcase) "*Formatting function for displaying word being spell checked. -The function must take one string argument and return a string.") - -(defvar ispell-personal-dictionary nil - "*File name of your personal spelling dictionary. -If nil, default dictionary `~/.ispell_words' is used.") +The function must take one string argument and return a string." + :type 'function + :group 'ispell) -(defvar ispell-silently-savep nil - "*When non-nil, save the personal dictionary without confirmation.") +;;;###autoload +(defcustom ispell-personal-dictionary nil + "*File name of your personal spelling dictionary, or nil. +If nil, the default personal dictionary, \"~/.ispell_DICTNAME\" is used, +where DICTNAME is the name of your default dictionary." + :type 'file + :group 'ispell) + +(defcustom ispell-silently-savep nil + "*When non-nil, save the personal dictionary without confirmation." + :type 'boolean + :group 'ispell) ;;; This variable contains the current dictionary being used if the ispell ;;; process is running. Otherwise it contains the global default. @@ -395,53 +471,74 @@ This is passed to the ispell process using the `-d' switch and is used as key in `ispell-dictionary-alist' (which see). You should set this variable before your first use of Emacs spell-checking -commands in the Emacs session, or else use the \\[ispell-change-dictionary] command to -change it. Otherwise, this variable only takes effect in a newly +commands in the Emacs session, or else use the \\[ispell-change-dictionary] +command to change it. Otherwise, this variable only takes effect in a newly started Ispell process.") -(defvar ispell-extra-args nil +(defcustom ispell-extra-args nil "*If non-nil, a list of extra switches to pass to the Ispell program. For example, '(\"-W\" \"3\") to cause it to accept all 1-3 character words as correct. See also `ispell-dictionary-alist', which may be used -for language-specific arguments.") +for language-specific arguments." + :type '(repeat string) + :group 'ispell) + +;;; The preparation of the menu bar menu must be autoloaded +;;; because otherwise this file gets autoloaded every time Emacs starts +;;; so that it can set up the menus and determine keyboard equivalents. ;;;###autoload (defvar ispell-dictionary-alist-1 ; sk 9-Aug-1991 18:28 '((nil ; default (english.aff) "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil) - ("english" ; make english explicitly selectable + ("english" ; make English explicitly selectable "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil) + ("british" ; British version + "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil) + ("american" ; American version + "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "american") nil) ("deutsch" ; deutsch.aff - "[a-zA-Z\"]" "[^a-zA-Z\"]" "[---']" t ("-C") nil) + "[a-zA-Z\"]" "[^a-zA-Z\"]" "[']" t ("-C") "~tex") ("deutsch8" "[a-zA-Z\304\326\334\344\366\337\374]" "[^a-zA-Z\304\326\334\344\366\337\374]" - "[---']" t ("-C" "-d" "deutsch") "~latin1") + "[']" t ("-C" "-d" "deutsch") "~latin1" iso-latin-1) + ("nederlands" ; nederlands.aff + "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" + "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" + "[']" t ("-C") nil iso-latin-1) ("nederlands8" ; dutch8.aff "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" - "[---']" t ("-C") nil))) + "[']" t ("-C") nil iso-latin-1))) ;;;###autoload (defvar ispell-dictionary-alist-2 '(("svenska" ;7 bit swedish mode "[A-Za-z}{|\\133\\135\\\\]" "[^A-Za-z}{|\\133\\135\\\\]" - "[---']" nil ("-C") nil) + "[']" nil ("-C") nil) ("svenska8" ;8 bit swedish mode "[A-Za-z\345\344\366\305\304\366]" "[^A-Za-z\345\344\366\305\304\366]" - "[---']" nil ("-C" "-d" "svenska") "~list") ; Add `"-T" "list"' instead? - ("francais" - "[A-Za-z]" "[^A-Za-z]" "[`'^-]" t nil nil) - ("francais8" "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\346\347\350\351\352\353\356\357\364\371\373\374]" - "[^A-Za-z\300\302\304\306\307\310\311\312\313\316\317\324\326\331\333\334\340\342\344\346\347\350\351\352\353\356\357\364\366\371\373\374]" "[---']" - t nil "~list") + "[']" nil ("-C" "-d" "svenska") "~list" ; Add `"-T" "list"' instead? + iso-latin-1) + ("francais7" + "[A-Za-z]" "[^A-Za-z]" "[`'^---]" t nil nil) + ("francais" ; francais.aff + "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" + "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" + "[---']" t nil "~list" iso-latin-1) + ("francais-tex" ; francais.aff + "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" + "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" + "[---'^`\"]" t nil "~tex" iso-latin-1) ("dansk" ; dansk.aff "[A-Z\306\330\305a-z\346\370\345]" "[^A-Z\306\330\305a-z\346\370\345]" - "[---]" nil ("-C") nil) + "[']" nil ("-C") nil iso-latin-1) )) -;; ispell-dictionary-alist is set up from two subvariables above -;; to avoid having very long lines in loaddefs.el. + +;;; ispell-dictionary-alist is set up from two subvariables above +;;; to avoid having very long lines in loaddefs.el. ;;;###autoload (defvar ispell-dictionary-alist (append ispell-dictionary-alist-1 ispell-dictionary-alist-2) @@ -460,21 +557,25 @@ word. NOT-CASECHARS is the opposite regexp of CASECHARS. -OTHERCHARS is a regular expression of other characters that are valid -in word constructs. Otherchars cannot be adjacent to each other in a -word, nor can they begin or end a word. This implies we can't check -\"Stevens'\" as a correct possessive and other correct formations. - +OTHERCHARS are characters in the NOT-CASECHARS set but which can be used to +construct words in some special way. If OTHERCHARS characters follow and +precede characters from CASECHARS, they are parsed as part of a word, +otherwise they become word-breaks. As an example in English, assume the +set ['] (as a regular expression) for OTHERCHARS. Then \"they're\" and +\"Steven's\" are parsed as single words including the \"'\" character, but +\"Stevens'\" does not include the quote character as part of the word. +If you want OTHERCHARS to be empty, use nil. Hint: regexp syntax requires the hyphen to be declared first here. -MANY-OTHERCHARS-P is non-nil if many otherchars are to be allowed in a -word instead of only one. +MANY-OTHERCHARS-P is non-nil when multiple OTHERCHARS are allowed in a word. +Otherwise only a single OTHERCHARS character is allowed to be part of any +single word. ISPELL-ARGS is a list of additional arguments passed to the ispell subprocess. EXTENDED-CHARACTER-MODE should be used when dictionaries are used which -have been configured in Ispell's parse.y. (For example, umlauts +have been configured in an Ispell affix file. (For example, umlauts can be encoded as \\\"a, a\\\", \"a, ...) Defaults are ~tex and ~nroff in English. This has the same effect as the command-line `-T' option. The buffer Major Mode controls Ispell's parsing in tex or nroff mode, @@ -487,20 +588,30 @@ contain the same character set as casechars and otherchars in the language.aff file \(e.g., english.aff\).") ;;;###autoload -(defvar ispell-menu-map nil) +(defvar ispell-menu-map nil "Key map for ispell menu") -;;; Set up the map. ;;;###autoload -(defconst ispell-menu-map-needed - ;; Verify this is not Lucid Emacs. - (and (not ispell-menu-map) (boundp 'system-key-alist))) +(defvar ispell-menu-lucid nil "Spelling menu for Lucid Emacs.") +;;; Break out lucid menu and split into several calls to avoid having +;;; long lines in loaddefs.el. Detect need off following constant. + +;;;###autoload +(defconst ispell-menu-map-needed ; make sure this is not Lucid Emacs + (and (not ispell-menu-map) +;;; This is commented out because it fails in Emacs. +;;; due to the fact that menu-bar is loaded much later than loaddefs. +;;; ;; make sure this isn't Lucid Emacs +;;; (featurep 'menu-bar) + (not (string-match "Lucid" emacs-version)))) + +;;; Set up dictionary ;;;###autoload (if ispell-menu-map-needed (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist))) name) - ;; Can put in defvar when external defines are removed. (setq ispell-menu-map (make-sparse-keymap "Spell")) + ;; add the dictionaries to the bottom of the list. (while dicts (setq name (car (car dicts)) dicts (cdr dicts)) @@ -510,16 +621,16 @@ language.aff file \(e.g., english.aff\).") (list 'lambda () '(interactive) (list 'ispell-change-dictionary name)))))))) +;;; define commands in menu in opposite order you want them to appear. ;;;###autoload (if ispell-menu-map-needed (progn - ;; Define commands in opposite order you want them to appear in menu. (define-key ispell-menu-map [ispell-change-dictionary] '("Change Dictionary" . ispell-change-dictionary)) (define-key ispell-menu-map [ispell-kill-ispell] '("Kill Process" . ispell-kill-ispell)) (define-key ispell-menu-map [ispell-pdict-save] - '("Save Dictionary" . (lambda () (interactive) (ispell-pdict-save t)))) + '("Save Dictionary" . (lambda () (interactive) (ispell-pdict-save t t)))) (define-key ispell-menu-map [ispell-complete-word] '("Complete Word" . ispell-complete-word)) (define-key ispell-menu-map [ispell-complete-word-interior-frag] @@ -543,46 +654,45 @@ language.aff file \(e.g., english.aff\).") (define-key ispell-menu-map [ispell-message] '("Check Message" . ispell-message)) (define-key ispell-menu-map [ispell-help] + ;; use (x-popup-menu last-nonmenu-event(list "" ispell-help-list)) ? '("Help" . (lambda () (interactive) (describe-function 'ispell-help)))) - (put 'ispell-region 'menu-enable 'mark-active))) - -;;;###autoload -(fset 'ispell-menu-map (symbol-value 'ispell-menu-map)) - -(cond - ((and (string-lessp "19" emacs-version) - (string-match "Lucid" emacs-version)) - (let ((dicts (cons (cons "default" nil) ispell-dictionary-alist)) - (current-menubar (or current-menubar default-menubar)) - (menu - '(["Help" (describe-function 'ispell-help) t] - ;;["Help" (popup-menu ispell-help-list) t] - ["Check Message" ispell-message t] - ["Check Buffer" ispell-buffer t] - ["Check Word" ispell-word t] - ["Check Region" ispell-region (or (not zmacs-regions) (mark))] - ["Continue Check" ispell-continue t] - ["Complete Word Frag"ispell-complete-word-interior-frag t] - ["Complete Word" ispell-complete-word t] - ["Kill Process" ispell-kill-ispell t] - "-" - ["Save Dictionary" (ispell-pdict-save t) t] - ["Change Dictionary" ispell-change-dictionary t])) - name) - (while dicts - (setq name (car (car dicts)) - dicts (cdr dicts)) - (if (stringp name) - (setq menu (append menu - (list - (vector (concat "Select " (capitalize name)) - (list 'ispell-change-dictionary name) - t)))))) - (defvar ispell-menu-lucid menu "Lucid's spelling menu.") - (if current-menubar - (progn - (delete-menu-item '("Edit" "Spell")) ; in case already defined - (add-menu '("Edit") "Spell" ispell-menu-lucid)))))) + (put 'ispell-region 'menu-enable 'mark-active) + (fset 'ispell-menu-map (symbol-value 'ispell-menu-map)))) + +;;; Xemacs version 19 +(if (and (string-lessp "19" emacs-version) + (string-match "Lucid" emacs-version)) + (let ((dicts (cons (cons "default" nil) ispell-dictionary-alist)) + (current-menubar (or current-menubar default-menubar)) + (menu + '(["Help" (describe-function 'ispell-help) t] + ;;["Help" (popup-menu ispell-help-list) t] + ["Check Message" ispell-message t] + ["Check Buffer" ispell-buffer t] + ["Check Word" ispell-word t] + ["Check Region" ispell-region (or (not zmacs-regions) (mark))] + ["Continue Check" ispell-continue t] + ["Complete Word Frag"ispell-complete-word-interior-frag t] + ["Complete Word" ispell-complete-word t] + ["Kill Process" ispell-kill-ispell t] + "-" + ["Save Dictionary" (ispell-pdict-save t t) t] + ["Change Dictionary" ispell-change-dictionary t])) + name) + (while dicts + (setq name (car (car dicts)) + dicts (cdr dicts)) + (if (stringp name) + (setq menu (append menu + (list + (vector (concat "Select " (capitalize name)) + (list 'ispell-change-dictionary name) + t)))))) + (setq ispell-menu-lucid menu) + (if current-menubar + (progn + (delete-menu-item '("Edit" "Spell")) ; in case already defined + (add-menu '("Edit") "Spell" ispell-menu-lucid))))) ;;; ********************************************************************** @@ -590,22 +700,37 @@ language.aff file \(e.g., english.aff\).") ;;; ********************************************************************** -;;; This doesn't match the LAST patch number -- this is for 3.1 or 3.0.09 -(defconst ispell-required-versions '("3.1." "3.0.09") +;;; The version must be 3.1 or greater for this version of ispell.el +;;; There is an incompatibility between version 3.1.12 and lower versions. +(defconst ispell-required-version '("3.1." 12) "Ispell versions with which this version of ispell.el is known to work.") +(defvar ispell-offset 1 + "Offset that maps protocol differences between ispell 3.1 versions.") + +(defun ispell-decode-string (str) + (let (coding-system) + (if (and enable-multibyte-characters + (setq coding-system (ispell-get-coding-system))) + (decode-coding-string str coding-system) + str))) (defun ispell-get-casechars () - (nth 1 (assoc ispell-dictionary ispell-dictionary-alist))) + (ispell-decode-string + (nth 1 (assoc ispell-dictionary ispell-dictionary-alist)))) (defun ispell-get-not-casechars () - (nth 2 (assoc ispell-dictionary ispell-dictionary-alist))) + (ispell-decode-string + (nth 2 (assoc ispell-dictionary ispell-dictionary-alist)))) (defun ispell-get-otherchars () - (nth 3 (assoc ispell-dictionary ispell-dictionary-alist))) + (ispell-decode-string + (nth 3 (assoc ispell-dictionary ispell-dictionary-alist)))) (defun ispell-get-many-otherchars-p () (nth 4 (assoc ispell-dictionary ispell-dictionary-alist))) (defun ispell-get-ispell-args () (nth 5 (assoc ispell-dictionary ispell-dictionary-alist))) (defun ispell-get-extended-character-mode () (nth 6 (assoc ispell-dictionary ispell-dictionary-alist))) +(defun ispell-get-coding-system () + (nth 7 (assoc ispell-dictionary ispell-dictionary-alist))) (defvar ispell-process nil "The process object for Ispell.") @@ -614,8 +739,8 @@ language.aff file \(e.g., english.aff\).") "Non-nil means personal dictionary has modifications to be saved.") ;;; If you want to save the dictionary when quitting, must do so explicitly. -;; When non-nil, the spell session is terminated. -;; When numeric, contains cursor location in buffer, and cursor remains there. +;;; When non-nil, the spell session is terminated. +;;; When numeric, contains cursor location in buffer, and cursor remains there. (defvar ispell-quit nil) (defvar ispell-filter nil @@ -643,7 +768,7 @@ language.aff file \(e.g., english.aff\).") ;;; be used. Do not redefine default value or it will override the global! (defvar ispell-local-dictionary nil "If non-nil, a dictionary to use for Ispell commands in this buffer. -The value should be a string, which is a file name. +The value must be a string dictionary name in `ispell-dictionary-alist'. This variable becomes buffer-local when set in any fashion. Setting ispell-local-dictionary to a value has the same effect as @@ -677,6 +802,10 @@ The above keyword string should be followed by `latex-mode' or Extended character mode can be changed for this buffer by placing a `~' followed by an extended-character mode -- such as `~.tex'.") +(defvar ispell-skip-sgml nil + "Skips spell checking of SGML tags and entity references when non-nil. +This variable is set when major-mode is sgml-mode or html-mode.") + (defvar ispell-local-pdict ispell-personal-dictionary "A buffer local variable containing the current personal dictionary. If non-nil, the value must be a string, which is a file name. @@ -704,7 +833,7 @@ Currently the only other valid parser is 'tex. You can set this variable in hooks in your init file -- eg: -\(add-hook 'tex-mode-hook (function (lambda () (setq ispell-parser 'tex))))") +(add-hook 'tex-mode-hook (function (lambda () (setq ispell-parser 'tex))))") (defvar ispell-region-end (make-marker) "Marker that allows spelling continuations.") @@ -712,19 +841,23 @@ You can set this variable in hooks in your init file -- eg: (defvar ispell-check-only nil "If non-nil, `ispell-word' does not try to correct the word.") + ;;; ********************************************************************** ;;; ********************************************************************** -(defalias 'ispell 'ispell-buffer) +(and (string-lessp "19" emacs-version) + (not (boundp 'epoch::version)) + (defalias 'ispell 'ispell-buffer)) -;;;###autoload (define-key global-map "\M-$" 'ispell-word) +;;;###autoload +(define-key global-map "\M-$" 'ispell-word) ;;;###autoload (defun ispell-word (&optional following quietly continue) "Check spelling of word under or before the cursor. If the word is not found in dictionary, display possible corrections -in a window and so you can choose one. +in a window allowing you to choose one. With a prefix argument (or if CONTINUE is non-nil), resume interrupted spell-checking of a buffer or region. @@ -745,7 +878,7 @@ or \\[ispell-region] to update the Ispell process." (if (interactive-p) (setq following ispell-following-word quietly ispell-quietly)) - (ispell-buffer-local-dict) ; use the correct dictionary + (ispell-accept-buffer-local-defs) ; use the correct dictionary (let ((cursor-location (point)) ; retain cursor location (word (ispell-get-word following)) start end poss replace) @@ -758,7 +891,6 @@ or \\[ispell-region] to update the Ispell process." (or quietly (message "Checking spelling of %s..." (funcall ispell-format-word word))) - (ispell-init-process) ; erases ispell output buffer (process-send-string ispell-process "%\n") ;put in verbose mode (process-send-string ispell-process (concat "^" word "\n")) ;; wait until ispell has processed word @@ -781,26 +913,21 @@ or \\[ispell-region] to update the Ispell process." (ispell-check-only ; called from ispell minor mode. (beep)) (t ; prompt for correct word. - (unwind-protect - (progn - (if ispell-highlight-p ;highlight word - (ispell-highlight-spelling-error start end t)) - (save-window-excursion - (setq replace (ispell-command-loop - (car (cdr (cdr poss))) - (car (cdr (cdr (cdr poss)))) - (car poss))))) - ;; protected - (if ispell-highlight-p ; clear highlight - (ispell-highlight-spelling-error start end))) + (save-window-excursion + (setq replace (ispell-command-loop + (car (cdr (cdr poss))) + (car (cdr (cdr (cdr poss)))) + (car poss) start end))) (cond ((equal 0 replace) (ispell-add-per-file-word-list (car poss))) (replace - (delete-region start end) (setq word (if (atom replace) replace (car replace)) cursor-location (+ (- (length word) (- end start)) cursor-location)) - (insert word) + (if (not (equal word (car poss))) + (progn + (delete-region start end) + (insert word))) (if (not (atom replace)) ; recheck spelling of replacement (progn (goto-char cursor-location) @@ -816,7 +943,7 @@ or \\[ispell-region] to update the Ispell process." "Return the word for spell-checking according to ispell syntax. If optional argument FOLLOWING is non-nil or if `ispell-following-word' is non-nil when called interactively, then the following word -\(rather than preceeding\) is checked when the cursor is not over a word. +\(rather than preceding\) is checked when the cursor is not over a word. Optional second argument contains otherchars that can be included in word many times. @@ -882,22 +1009,26 @@ If so, ask if it needs to be saved." (setq ispell-pdict-modified-p (car ispell-pdict-modified-p))) (if (or ispell-pdict-modified-p force-save) (if (or no-query (y-or-n-p "Personal dictionary modified. Save? ")) - (process-send-string ispell-process "#\n"))) + (progn + (process-send-string ispell-process "#\n") + (message "Personal dictionary saved.")))) ;; unassert variable, even if not saved to avoid questioning. (setq ispell-pdict-modified-p nil)) -(defun ispell-command-loop (miss guess word) +(defun ispell-command-loop (miss guess word start end) "Display possible corrections from list MISS. GUESS lists possibly valid affix construction of WORD. Returns nil to keep word. Returns 0 to insert locally into buffer-local dictionary. Returns string for new chosen word. Returns list for new replacement word (will be rechecked). +Highlights the word, which is assumed to run from START to END. Global `ispell-pdict-modified-p' becomes a list where the only value indicates whether the dictionary has been modified when option `a' or `i' is used." - (let ((count ?0) + (let ((textbuf (current-buffer)) + (count ?0) (line 2) (max-lines (- (window-height) 4)) ; assure 4 context lines. (choices miss) @@ -905,10 +1036,12 @@ used." ispell-choices-win-default-height)) (command-characters '( ? ?i ?a ?A ?r ?R ?? ?x ?X ?q ?l ?u ?m )) (skipped 0) - char num result) + char num result textwin highlighted) + + ;; setup the *Choices* buffer with valid data. (save-excursion (set-buffer (get-buffer-create ispell-choices-buffer)) - (setq mode-line-format "-- %b --") + (setq mode-line-format (concat "-- %b -- word: " word)) (erase-buffer) (if guess (progn @@ -944,159 +1077,193 @@ used." count (1+ count))) (setq count (- count ?0 skipped))) + ;; Assure word is visible + (if (not (pos-visible-in-window-p end)) + (sit-for 0)) + ;; Display choices for misspelled word. (let ((choices-window (get-buffer-window ispell-choices-buffer))) (if choices-window - (if (not (equal line (window-height choices-window))) - (progn - (save-excursion - (let ((cur-point (point))) - (move-to-window-line (- line (window-height choices-window))) - (if (<= (point) cur-point) - (set-window-start (selected-window) (point))))) - (select-window (previous-window)) - (enlarge-window (- line (window-height choices-window)))) - (select-window choices-window)) - (ispell-overlay-window (max line - ispell-choices-win-default-height)) - (switch-to-buffer ispell-choices-buffer))) - (goto-char (point-min)) - (select-window (next-window)) - (while - (eq - t - (setq - result - (progn - (undo-boundary) - (message (concat "C-h or ? for more options; SPC to leave " - "unchanged, Character to replace word")) - (let ((inhibit-quit t)) - (setq char (if (fboundp 'read-char-exclusive) - (read-char-exclusive) - (read-char)) - skipped 0) - (if (or quit-flag (= char ?\C-g)) ; C-g is like typing X - (setq char ?X - quit-flag nil))) - ;; Adjust num to array offset skipping command characters. - (let ((com-chars command-characters)) - (while com-chars - (if (and (> (car com-chars) ?0) (< (car com-chars) char)) - (setq skipped (1+ skipped))) - (setq com-chars (cdr com-chars))) - (setq num (- char ?0 skipped))) - - (cond - ((= char ? ) nil) ; accept word this time only - ((= char ?i) ; accept and insert word into pers dict - (process-send-string ispell-process (concat "*" word "\n")) - (setq ispell-pdict-modified-p '(t)) ; dictionary modified! - nil) - ((or (= char ?a) (= char ?A)) ; accept word without insert - (process-send-string ispell-process (concat "@" word "\n")) - (if (null ispell-pdict-modified-p) - (setq ispell-pdict-modified-p - (list ispell-pdict-modified-p))) - (if (= char ?A) 0)) ; return 0 for ispell-add buffer-local - ((or (= char ?r) (= char ?R)) ; type in replacement - (if (or (= char ?R) ispell-query-replace-choices) - (list (read-string "Query-replacement for: " word) t) - (cons (read-string "Replacement for: " word) nil))) - ((or (= char ??) (= char help-char) (= char ?\C-h)) - (ispell-help) - t) - ;; Quit and move point back. - ((= char ?x) - (ispell-pdict-save ispell-silently-savep) - (message "Exited spell-checking") - (setq ispell-quit t) - nil) - ;; Quit and preserve point. - ((= char ?X) - (ispell-pdict-save ispell-silently-savep) - (message - (substitute-command-keys - (concat "Spell-checking suspended;" - " use C-u \\[ispell-word] to resume"))) - (setq ispell-quit (max (point-min) - (- (point) (length word)))) - nil) - ((= char ?q) - (if (y-or-n-p "Really kill Ispell process? ") - (progn - (ispell-kill-ispell t) ; terminate process. - (setq ispell-quit (or (not ispell-checking-message) - (point)) - ispell-pdict-modified-p nil)) - t)) ; continue if they don't quit. - ((= char ?l) - (let ((new-word (read-string - "Lookup string (`*' is wildcard): " - word)) - (new-line 2)) - (if new-word - (progn - (save-excursion - (set-buffer (get-buffer-create - ispell-choices-buffer)) - (erase-buffer) - (setq count ?0 - skipped 0 - mode-line-format "-- %b --" - miss (lookup-words new-word) - choices miss) - (while (and choices ; adjust choices window. - (< (if (> (+ 7 (current-column) - (length (car choices)) - (if (> count ?~) 3 0)) - (window-width)) - (progn - (insert "\n") - (setq new-line - (1+ new-line))) - new-line) - max-lines)) - (while (memq count command-characters) - (setq count (1+ count) - skipped (1+ skipped))) - (insert "(" count ") " (car choices) " ") - (setq choices (cdr choices) - count (1+ count))) - (setq count (- count ?0 skipped))) - (select-window (previous-window)) - (if (/= new-line line) + (if (= line (window-height choices-window)) + (select-window choices-window) + ;; *Choices* window changed size. Adjust the choices window + ;; without scrolling the spelled window when possible + (let ((window-line (- line (window-height choices-window))) + (visible (progn (forward-line -1) (point)))) + (if (< line ispell-choices-win-default-height) + (setq window-line (+ window-line + (- ispell-choices-win-default-height + line)))) + (move-to-window-line 0) + (forward-line window-line) + (set-window-start (selected-window) + (if (> (point) visible) visible (point))) + (goto-char end) + (select-window (previous-window)) ; *Choices* window + (enlarge-window window-line))) + ;; Overlay *Choices* window when it isn't showing + (ispell-overlay-window (max line ispell-choices-win-default-height))) + (switch-to-buffer ispell-choices-buffer) + (goto-char (point-min))) + + (select-window (setq textwin (next-window))) + + ;; highlight word, protecting current buffer status + (unwind-protect + (progn + (if ispell-highlight-p + (ispell-highlight-spelling-error start end t)) + ;; Loop until a valid choice is made. + (while + (eq + t + (setq + result + (progn + (undo-boundary) + (let (message-log-max) + (message (concat "C-h or ? for more options; SPC to leave " + "unchanged, Character to replace word"))) + (let ((inhibit-quit t)) + (setq char (if (fboundp 'read-char-exclusive) + (read-char-exclusive) + (read-char)) + skipped 0) + (if (or quit-flag (= char ?\C-g)) ; C-g is like typing X + (setq char ?X + quit-flag nil))) + ;; Adjust num to array offset skipping command characters. + (let ((com-chars command-characters)) + (while com-chars + (if (and (> (car com-chars) ?0) (< (car com-chars) char)) + (setq skipped (1+ skipped))) + (setq com-chars (cdr com-chars))) + (setq num (- char ?0 skipped))) + + (cond + ((= char ? ) nil) ; accept word this time only + ((= char ?i) ; accept and insert word into pers dict + (process-send-string ispell-process (concat "*" word "\n")) + (setq ispell-pdict-modified-p '(t)) ; dictionary modified! + nil) + ((or (= char ?a) (= char ?A)) ; accept word without insert + (process-send-string ispell-process (concat "@" word "\n")) + (if (null ispell-pdict-modified-p) + (setq ispell-pdict-modified-p + (list ispell-pdict-modified-p))) + (if (= char ?A) 0)) ; return 0 for ispell-add buffer-local + ((or (= char ?r) (= char ?R)) ; type in replacement + (if (or (= char ?R) ispell-query-replace-choices) + (list (read-string "Query-replacement for: " word) t) + (cons (read-string "Replacement for: " word) nil))) + ((or (= char ??) (= char help-char) (= char ?\C-h)) + (ispell-help) + t) + ;; Quit and move point back. + ((= char ?x) + (ispell-pdict-save ispell-silently-savep) + (message "Exited spell-checking") + (setq ispell-quit t) + nil) + ;; Quit and preserve point. + ((= char ?X) + (ispell-pdict-save ispell-silently-savep) + (message "%s" + (substitute-command-keys + (concat "Spell-checking suspended;" + " use C-u \\[ispell-word] to resume"))) + (setq ispell-quit (max (point-min) + (- (point) (length word)))) + nil) + ((= char ?q) + (if (y-or-n-p "Really kill Ispell process? ") + (progn + (ispell-kill-ispell t) ; terminate process. + (setq ispell-quit (or (not ispell-checking-message) + (point)) + ispell-pdict-modified-p nil)) + t)) ; continue if they don't quit. + ((= char ?l) + (let ((new-word (read-string + "Lookup string (`*' is wildcard): " + word)) + (new-line 2)) + (if new-word (progn - (if (> new-line line) - (enlarge-window (- new-line line)) - (shrink-window (- line new-line))) - (setq line new-line))) - (select-window (next-window))))) - t) ; reselect from new choices - ((= char ?u) - (process-send-string ispell-process - (concat "*" (downcase word) "\n")) - (setq ispell-pdict-modified-p '(t)) ; dictionary modified! - nil) - ((= char ?m) ; type in what to insert - (process-send-string - ispell-process (concat "*" (read-string "Insert: " word) - "\n")) - (setq ispell-pdict-modified-p '(t)) - (cons word nil)) - ((and (>= num 0) (< num count)) - (if ispell-query-replace-choices ; Query replace flag - (list (nth num miss) 'query-replace) - (nth num miss))) - ((= char ?\C-l) - (redraw-display) t) - ((= char ?\C-r) - (save-window-excursion (recursive-edit)) t) - ((= char ?\C-z) - (funcall (key-binding "\C-z")) - t) - (t (ding) t)))))) - result)) - + (save-excursion + (set-buffer (get-buffer-create + ispell-choices-buffer)) + (erase-buffer) + (setq count ?0 + skipped 0 + mode-line-format (concat + "-- %b -- word: " + new-word) + miss (lookup-words new-word) + choices miss) + (while (and choices ; adjust choices window. + (< (if (> (+ 7 (current-column) + (length (car choices)) + (if (> count ?~) 3 0)) + (window-width)) + (progn + (insert "\n") + (setq new-line + (1+ new-line))) + new-line) + max-lines)) + (while (memq count command-characters) + (setq count (1+ count) + skipped (1+ skipped))) + (insert "(" count ") " (car choices) " ") + (setq choices (cdr choices) + count (1+ count))) + (setq count (- count ?0 skipped))) + (select-window (previous-window)) + (if (and (/= new-line line) + (> (max line new-line) + ispell-choices-win-default-height)) + (let* ((minh ispell-choices-win-default-height) + (gr-bl (if (< line minh) ; blanks + (- minh line) + 0)) + (shr-bl (if (< new-line minh) ; blanks + (- minh new-line) + 0))) + (if (> new-line line) + (enlarge-window (- new-line line gr-bl)) + (shrink-window (- line new-line shr-bl))) + (setq line new-line))) + (select-window (next-window))))) + t) ; reselect from new choices + ((= char ?u) + (process-send-string ispell-process + (concat "*" (downcase word) "\n")) + (setq ispell-pdict-modified-p '(t)) ; dictionary modified! + nil) + ((= char ?m) ; type in what to insert + (process-send-string + ispell-process (concat "*" (read-string "Insert: " word) + "\n")) + (setq ispell-pdict-modified-p '(t)) + (cons word nil)) + ((and (>= num 0) (< num count)) + (if ispell-query-replace-choices ; Query replace flag + (list (nth num miss) 'query-replace) + (nth num miss))) + ((= char ?\C-l) + (redraw-display) t) + ((= char ?\C-r) + (save-window-excursion (recursive-edit)) t) + ((= char ?\C-z) + (funcall (key-binding "\C-z")) + t) + (t (ding) t)))))) + result) + ;; protected + (if ispell-highlight-p ; unhighlight + (save-window-excursion + (select-window textwin) + (ispell-highlight-spelling-error start end)))))) ;;;###autoload @@ -1152,6 +1319,9 @@ SPC: Accept word this time. (if (string-lessp "19" emacs-version) (message nil)) (enlarge-window 2) + ;; Make sure we display the minibuffer + ;; in this window, not some other. + (set-minibuffer-window (selected-window)) (insert (concat help-1 "\n" help-2 "\n" help-3)))) (sit-for 5) (erase-buffer))))) @@ -1219,7 +1389,7 @@ Optional second argument contains the dictionary to use; the default is ;;; multiple lines. ;;; "ispell-filter-continue" is true when we have received only part of a ;;; line as output from a generating function ("output" did not end with \n) -;;; NOTE THAT THIS FUNCTION WILL FAIL IF THE PROCESS OUTPUT DOESNT END WITH \n! +;;; THIS FUNCTION WILL FAIL IF THE PROCESS OUTPUT DOESN'T END WITH \n! ;;; This is the case when a process dies or fails. The default behavior ;;; in this case treats the next input received as fresh input. @@ -1263,9 +1433,9 @@ otherwise it is displayed normally." (buffer-read-only nil) ; Allow highlighting read-only buffers. (text (buffer-substring start end)) ; Save highlight region (inhibit-quit t) ; inhibit interrupt processing here. - (buffer-undo-list nil)) ; don't clutter the undo list. + (buffer-undo-list t)) ; don't clutter the undo list. (delete-region start end) - (insert-char ? (- end start)) ; mimimize amount of redisplay + (insert-char ? (- end start)) ; minimize amount of redisplay (sit-for 0) ; update display (if highlight (setq inverse-video (not inverse-video))) ; toggle video (delete-region start end) ; delete whitespace @@ -1277,7 +1447,7 @@ otherwise it is displayed normally." (defun ispell-highlight-spelling-error-lucid (start end &optional highlight) "Highlight the word from START to END using `isearch-highlight'. -When the optional third arg HIGHLIGHT is set, the word is highlighted +When the optional third arg HIGHLIGHT is set, the word is highlighted, otherwise it is displayed normally." (if highlight (isearch-highlight start end) @@ -1299,16 +1469,14 @@ The variable `ispell-highlight-face' selects the face to use for highlighting." (delete-overlay ispell-overlay))) -;;; Choose a highlight function at load time. -(fset 'ispell-highlight-spelling-error - (symbol-function - (cond - ((string-match "Lucid" emacs-version) - 'ispell-highlight-spelling-error-lucid) - ((and (string-lessp "19" emacs-version) (featurep 'faces) - window-system) - 'ispell-highlight-spelling-error-overlay) - (t 'ispell-highlight-spelling-error-generic)))) +(defun ispell-highlight-spelling-error (start end &optional highlight) + (cond + ((string-match "Lucid" emacs-version) + (ispell-highlight-spelling-error-lucid start end highlight)) + ((and (string-lessp "19" emacs-version) + (featurep 'faces) window-system) + (ispell-highlight-spelling-error-overlay start end highlight)) + (t (ispell-highlight-spelling-error-generic start end highlight)))) (defun ispell-overlay-window (height) @@ -1328,7 +1496,8 @@ scrolling the current window. Leave the new window selected." ;; So we increment the height for this case. (if (string-match "19\.9.*Lucid" (emacs-version)) (setq height (1+ height))) - (split-window nil height) + (let ((inhibit-frame-unsplittable t)) + (split-window nil height)) (set-window-start (next-window) top)))) @@ -1382,31 +1551,31 @@ scrolling the current window. Leave the new window selected." ;; option is the only way I can think of to do this that works with ;; all versions, since versions earlier than 3.0.09 didn't identify ;; themselves on startup. - ;; (save-excursion - (set-buffer (get-buffer-create " *ispell-tmp*")) - (erase-buffer) - (let ((status (call-process ispell-program-name nil t nil "-v")) - (case-fold-search t)) + (let ((case-fold-search t) + ;; avoid bugs when syntax of `.' changes in various default modes + (default-major-mode 'fundamental-mode) + status) + (set-buffer (get-buffer-create " *ispell-tmp*")) + (erase-buffer) + (setq status (call-process ispell-program-name nil t nil "-v")) (goto-char (point-min)) - (cond ((not (memq status '(0 nil))) - (error "%s exited with %s %s" ispell-program-name - (if (stringp status) "signal" "code") status)) - ((not (re-search-forward - (concat "\\b\\(" - (mapconcat 'regexp-quote - ispell-required-versions - "\\|") - "\\)\\b") - nil t)) - (error "%s version %s is required: try renaming ispell4.el to ispell.el" - ispell-program-name - (car ispell-required-versions) - ;(if (re-search-forward "version \\([0-9][0-9.]+\\)\\b" - ; nil t) - ; (buffer-substring (match-beginning 1) (match-end 1)) - ; "an unknown version") - ))) + (if (not (memq status '(0 nil))) + (error "%s exited with %s %s" ispell-program-name + (if (stringp status) "signal" "code") status)) + (if (not (re-search-forward + (concat "\\b\\(" + (regexp-quote (car ispell-required-version)) + "\\)\\([0-9]*\\)\\b") + nil t)) + (error + "%s version %s* is required: try renaming ispell4.el to ispell.el" + ispell-program-name (car ispell-required-version)) + ;; check that it is the correct version. + (if (< (car (read-from-string (buffer-substring + (match-beginning 2) (match-end 2)))) + (car (cdr ispell-required-version))) + (setq ispell-offset 0))) (kill-buffer (current-buffer))))) @@ -1450,12 +1619,20 @@ scrolling the current window. Leave the new window selected." ispell-filter-continue nil ispell-process-directory default-directory) (set-process-filter ispell-process 'ispell-filter) + (if (and enable-multibyte-characters + ispell-dictionary) + (set-process-coding-system ispell-process (ispell-get-coding-system))) (accept-process-output ispell-process) ; Get version ID line (cond ((null ispell-filter) (error "%s did not output version line" ispell-program-name)) - ((and (null (cdr ispell-filter)) - (stringp (car ispell-filter)) - (string-match "^@(#) " (car ispell-filter))) + ((and + (stringp (car ispell-filter)) + (if (string-match "warning: " (car ispell-filter)) + (progn + (accept-process-output ispell-process 5) ; 1st was warn msg. + (stringp (car ispell-filter))) + (null (cdr ispell-filter))) + (string-match "^@(#) " (car ispell-filter))) ;; got the version line as expected (we already know it's the right ;; version, so don't bother checking again.) nil) @@ -1488,6 +1665,9 @@ With NO-ERROR, just return non-nil if there was no Ispell running." nil)) +;;; ispell-change-dictionary is set in some people's hooks. Maybe this should +;;; call ispell-init-process rather than wait for a spell checking command? + ;;;###autoload (defun ispell-change-dictionary (dict &optional arg) "Change `ispell-dictionary' (q.v.) and kill old Ispell process. @@ -1507,9 +1687,11 @@ With prefix argument, set the default directory." (message "Using %s dictionary" (or ispell-local-dictionary ispell-dictionary "default"))) ((and (equal dict ispell-dictionary) - (equal dict ispell-local-dictionary)) + (or (null ispell-local-dictionary) + (equal dict ispell-local-dictionary))) ;; Specified dictionary is the default already. No-op - (message "No change, using %s dictionary" (or dict "default"))) + (and (interactive-p) + (message "No change, using %s dictionary" (or dict "default")))) (t ; reset dictionary! (if (assoc dict ispell-dictionary-alist) (progn @@ -1540,14 +1722,15 @@ With prefix argument, set the default directory." (ispell-accept-buffer-local-defs) ; set up dictionary, local words, etc. (unwind-protect (save-excursion - (message "Spell checking %s..." + (message "Spell checking %s using %s dictionary..." (if (and (= reg-start (point-min)) (= reg-end (point-max))) - (buffer-name) "region")) -;Eliminated to keep ispell-message displaying each piece: (sit-for 0) - ;; must be top level, not in ispell-command-loop for keeping window. + (buffer-name) "region") + (or ispell-dictionary "default")) + ;; Returns cursor to original location. (save-window-excursion (goto-char reg-start) - (let ((transient-mark-mode nil)) + (let ((transient-mark-mode nil) + ref-type) (while (and (not ispell-quit) (< (point) reg-end)) (let ((start (point)) (offset-change 0) @@ -1557,7 +1740,7 @@ With prefix argument, set the default directory." (cond ; LOOK AT THIS LINE AND SKIP OR PROCESS ((eolp) ; END OF LINE, just go to next line. (forward-char 1)) - ((and (null ispell-check-comments) ; SKIPING COMMENTS + ((and (null ispell-check-comments) ; SKIPPING COMMENTS comment-start ; skip comments that start on the line. (search-forward comment-start end t)) ; or found here. (if (= (- (point) start) (length comment-start)) @@ -1579,37 +1762,56 @@ With prefix argument, set the default directory." (re-search-forward "[][()$]" limit t)) (setq string (concat "^" (buffer-substring start limit) - "\n"))) + "\n") + offset-change (- offset-change ispell-offset))) (goto-char limit)))) - ((and ispell-skip-tib ; SKIP TIB REFERENCES! - (re-search-forward ispell-tib-ref-beginning end t)) - (if (= (- (point) 2) start) ; tib ref is 2 chars. - ;; Skip to end of tib ref, not necessarily on this line. - ;; Return an error if tib ref not found - (if (not(re-search-forward ispell-tib-ref-end reg-end t)) + ((looking-at "[---#@*+!%~^]") ; SKIP SPECIAL ISPELL CHARACTERS + (forward-char 1)) + ((or (and ispell-skip-tib ; SKIP TIB REFERENCES OR SGML MARKUP + (re-search-forward ispell-tib-ref-beginning end t) + (setq ref-type 'tib)) + (and ispell-skip-sgml + (re-search-forward "[<&]" end t) + (setq ref-type 'sgml))) + (if (or (and (eq 'tib ref-type) ; tib tag is 2 chars. + (= (- (point) 2) start)) + (and (eq 'sgml ref-type) ; sgml skips 1 char. + (= (- (point) 1) start))) + ;; Skip to end of reference, not necessarily on this line + ;; Return an error if tib/sgml reference not found + (if (or + (and + (eq 'tib ref-type) + (not + (re-search-forward ispell-tib-ref-end reg-end t))) + (and (eq 'sgml ref-type) + (not (re-search-forward "[>;]" reg-end t)))) (progn (ispell-pdict-save ispell-silently-savep) (ding) (message (concat - "Open tib reference--set `ispell-skip-tib'" - " to nil to avoid this error")) + "Open tib or SGML command. Fix buffer or set " + (if (eq 'tib ref-type) + "ispell-skip-tib" + "ispell-skip-sgml") + " to nil")) ;; keep cursor at error location (setq ispell-quit (- (point) 2)))) - ;; tib ref starts later on line. Check spelling before tib. - (let ((limit (- (point) 2))) + ;; Check spelling between reference and start of the line. + (let ((limit (- (point) (if (eq 'tib ref-type) 2 1)))) (goto-char start) (if (or (re-search-forward ispell-casechars limit t) (re-search-forward "[][()$]" limit t)) (setq string (concat "^" (buffer-substring start limit) - "\n"))) + "\n") + offset-change (- offset-change ispell-offset))) (goto-char limit)))) - ((looking-at "[---#@*+!%~^]") ; SKIP SPECIAL ISPELL CHARACTERS - (forward-char 1)) ((or (re-search-forward ispell-casechars end t) ; TEXT EXISTS (re-search-forward "[][()$]" end t)) ; or MATH COMMANDS - (setq string (concat "^" (buffer-substring start end) "\n")) + (setq string (concat "^" (buffer-substring start end) "\n") + offset-change (- offset-change ispell-offset)) (goto-char end)) (t (beginning-of-line 2))) ; EMPTY LINE, skip it. @@ -1629,8 +1831,20 @@ With prefix argument, set the default directory." (while (and (not ispell-quit) ispell-filter) (setq poss (ispell-parse-output (car ispell-filter))) (if (listp poss) ; spelling error occurred. - (let* ((word-start (+ start offset-change - (car (cdr poss)))) + (let* ((word-start + (if (and enable-multibyte-characters + (ispell-get-coding-system)) + ;; OFFSET returned by ispell + ;; counts non-ASCII chars as + ;; one, so just adding OFFSET + ;; to START will cause an + ;; error. + (save-excursion + (goto-char (+ start offset-change)) + (forward-char (car (cdr poss))) + (point)) + (+ start offset-change + (car (cdr poss))))) (word-end (+ word-start (length (car poss)))) replace) @@ -1650,28 +1864,20 @@ With prefix argument, set the default directory." (concat "Ispell misalignment: word " "`%s' point %d; please retry") (car poss) word-start)) - (unwind-protect - (progn - (if ispell-highlight-p - (ispell-highlight-spelling-error - word-start word-end t)) - (sit-for 0) ; update screen display - (if ispell-keep-choices-win - (setq replace - (ispell-command-loop - (car (cdr (cdr poss))) - (car (cdr (cdr (cdr poss)))) - (car poss))) - (save-window-excursion - (setq replace - (ispell-command-loop - (car (cdr (cdr poss))) - (car (cdr (cdr (cdr poss)))) - (car poss)))))) - ;; protected - (if ispell-highlight-p - (ispell-highlight-spelling-error - word-start word-end))) + (if (not (pos-visible-in-window-p)) + (sit-for 0)) + (if ispell-keep-choices-win + (setq replace + (ispell-command-loop + (car (cdr (cdr poss))) + (car (cdr (cdr (cdr poss)))) + (car poss) word-start word-end)) + (save-window-excursion + (setq replace + (ispell-command-loop + (car (cdr (cdr poss))) + (car (cdr (cdr (cdr poss)))) + (car poss) word-start word-end)))) (cond ((and replace (listp replace)) ;; REPLACEMENT WORD entered. Recheck line @@ -1685,8 +1891,10 @@ With prefix argument, set the default directory." (setq reg-end (+ reg-end change) offset-change (+ offset-change change))) - (delete-region word-start word-end) - (insert (car replace)) + (if (not (equal (car replace) (car poss))) + (progn + (delete-region word-start word-end) + (insert (car replace)))) ;; I only need to recheck typed-in replacements (if (not (eq 'query-replace (car (cdr replace)))) @@ -1733,7 +1941,9 @@ With prefix argument, set the default directory." offset-change (+ offset-change change) end (+ end change))))) (if (not ispell-quit) - (message "Continuing spelling check...")) + (let (message-log-max) + (message "Continuing spelling check using %s dictionary..." + (or ispell-dictionary "default")))) (sit-for 0))) ;; finished with line! (setq ispell-filter (cdr ispell-filter))))) @@ -1828,16 +2038,9 @@ Standard ispell choices are then available." (setq possibilities (mapcar 'upcase possibilities))) ((string-match "^[A-Z]" word) (setq possibilities (mapcar 'capitalize possibilities)))) - (unwind-protect - (progn - (if ispell-highlight-p ; highlight word - (ispell-highlight-spelling-error start end t)) - (save-window-excursion - (setq replacement - (ispell-command-loop possibilities nil word)))) - ;; protected - (if ispell-highlight-p - (ispell-highlight-spelling-error start end))) ; un-highlight + (save-window-excursion + (setq replacement + (ispell-command-loop possibilities nil word start end))) (cond ((equal 0 replacement) ; BUFFER-LOCAL ADDITION (ispell-add-per-file-word-list word)) @@ -1863,6 +2066,7 @@ Standard ispell choices are then available." (interactive) (ispell-complete-word t)) + ;;; ********************************************************************** ;;; Ispell Minor Mode ;;; ********************************************************************** @@ -1900,7 +2104,7 @@ warns you if the previous word is incorrectly spelled." (setq ispell-minor-mode (not (or (and (null arg) ispell-minor-mode) (<= (prefix-numeric-value arg) 0)))) - (set-buffer-modified-p (buffer-modified-p))) + (force-mode-line-update)) (defun ispell-minor-check () ;; Check previous word then continue with the normal binding of this key. @@ -1912,6 +2116,7 @@ warns you if the previous word is incorrectly spelled." (ispell-word nil t)) (call-interactively (key-binding (this-command-keys))))) + ;;; ********************************************************************** ;;; Ispell Message ;;; ********************************************************************** @@ -1922,38 +2127,68 @@ warns you if the previous word is incorrectly spelled." (mapconcat (function identity) '( ;; Matches postscript files. - "^%!PS-Adobe-2.0" + "^%!PS-Adobe-[123].0" ;; Matches uuencoded text "^begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM" ;; Matches shell files (esp. auto-decoding) - "^#! /bin/sh" + "^#! /bin/[ck]?sh" ;; Matches context difference listing "\\(diff -c .*\\)?\n\\*\\*\\* .*\n--- .*\n\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*" + ;; Matches reporter.el bug report + "^current state:\n==============\n" ;; Matches "----------------- cut here" - "^[-=_]+\\s ?cut here") + ;; and "------- Start of forwarded message", + ;; or either one with "- " in front. + "^\\(- \\)?[-=_]+\\s ?\\(cut here\\|\\(Start of \\)?forwarded message\\)") "\\|") "*End of text which will be checked in ispell-message. -If it is a string, limit at first occurence of that regular expression. +If it is a string, limit at first occurrence of that regular expression. Otherwise, it must be a function which is called to get the limit.") +(defvar ispell-message-start-skip + (mapconcat (function identity) + '( + ;; Matches forwarded messages + "^---* Forwarded Message" + ;; Matches PGP Public Key block + "^---*BEGIN PGP [A-Z ]*--*" + ) + "\\|") + "Spelling is skipped inside these start/end groups by ispell-message. +Assumed that blocks are not mutually inclusive.") + + +(defvar ispell-message-end-skip + (mapconcat (function identity) + '( + ;; Matches forwarded messages + "^--- End of Forwarded Message" + ;; Matches PGP Public Key block + "^---*END PGP [A-Z ]*--*" + ) + "\\|") + "Spelling is skipped inside these start/end groups by ispell-message. +Assumed that blocks are not mutually inclusive.") + + ;;;###autoload (defun ispell-message () "Check the spelling of a mail message or news post. Don't check spelling of message headers except the Subject field. Don't check included messages. -To abort spell checking of a message REGION and send the message anyway, -use the `x' or `q' command. (Any subsequent regions will be checked.) +To abort spell checking of a message region and send the message anyway, +use the `x' command. (Any subsequent regions will be checked.) The `X' command aborts the message send so that you can edit the buffer. To spell-check whenever a message is sent, include the appropriate lines in your .emacs file: - (add-hook 'news-inews-hook 'ispell-message) + (add-hook 'message-send-hook 'ispell-message) (add-hook 'mail-send-hook 'ispell-message) (add-hook 'mh-before-send-letter-hook 'ispell-message) -you can bind this to the key C-c i in GNUS or mail by adding to +You can bind this to the key C-c i in GNUS or mail by adding to `news-reply-mode-hook' or `mail-mode-hook' the following lambda expression: (function (lambda () (local-set-key \"\\C-ci\" 'ispell-message)))" (interactive) @@ -1981,11 +2216,16 @@ you can bind this to the key C-c i in GNUS or mail by adding to ((featurep 'sc) ; sc 2.3 (concat "\\(" sc-cite-regexp "\\)" "\\|" (ispell-non-empty-string sc-reference-tag-string))) - ((equal major-mode 'news-reply-mode) ;GNUS + ((equal major-mode 'news-reply-mode) ;GNUS 4 & below (concat "In article <" "\\|" (if mail-yank-prefix (ispell-non-empty-string mail-yank-prefix) "^ \\|^\t"))) + ((equal major-mode 'message-mode) ;GNUS 5 + (concat ".*@.* writes:$" "\\|" + (if mail-yank-prefix + (ispell-non-empty-string mail-yank-prefix) + "^ \\|^\t"))) ((equal major-mode 'mh-letter-mode) ; mh mail message (ispell-non-empty-string mh-ins-buf-prefix)) ((not internal-messagep) ; Assume n sent us this message. @@ -2025,26 +2265,36 @@ you can bind this to the key C-c i in GNUS or mail by adding to (forward-line 1)) (setq case-fold-search nil) ;; Skip mail header, particularly for non-english languages. - (if (looking-at mail-header-separator) + (if (looking-at (concat (regexp-quote mail-header-separator) "$")) (forward-line 1)) (while (< (point) limit) ;; Skip across text cited from other messages. (while (and (looking-at cite-regexp-start) - (< (point) limit)) - (let ((point1 (point))) - (forward-line 1) - ;; If there's no next line, go to the end of this one - ;; so that the loop stops looping. - (if (eq point1 (point)) - (end-of-line)))) + (< (point) limit) + (zerop (forward-line 1)))) + (if (< (point) limit) - ;; Check the next batch of lines that *aren't* cited. - (let ((end (save-excursion - (if (re-search-forward cite-regexp-end limit 'end) - (match-beginning 0) - (marker-position limit))))) - (ispell-region (point) end) - (goto-char end)))) + (let* ((start (point)) + ;; Check the next batch of lines that *aren't* cited. + (end-c (and (re-search-forward cite-regexp-end limit 'end) + (match-beginning 0))) + ;; Skip a block of included text. + (end-fwd (and (goto-char start) + (re-search-forward ispell-message-start-skip + limit 'end) + (progn (beginning-of-line) + (point)))) + (end (or (and end-c end-fwd (min end-c end-fwd)) + end-c end-fwd + ;; default to limit of text. + (marker-position limit)))) + (goto-char start) + (ispell-region start end) + (if (and end-fwd (= end end-fwd)) + (progn + (goto-char end) + (re-search-forward ispell-message-end-skip limit 'end)) + (goto-char end))))) (set-marker limit nil)))) @@ -2078,11 +2328,13 @@ Includes latex/nroff modes and extended character mode." (eq ispell-parser 'tex)) (process-send-string ispell-process "+\n") ; set ispell mode to tex (process-send-string ispell-process "-\n")) ; set mode to normal (nroff) + ;; Hard-wire test for SGML & HTML mode. + (setq ispell-skip-sgml (memq major-mode '(sgml-mode html-mode))) ;; Set default extended character mode for given buffer, if any. (let ((extended-char-mode (ispell-get-extended-character-mode))) (if extended-char-mode (process-send-string ispell-process (concat extended-char-mode "\n")))) - ;; Set buffer-local parsing mode and extended charater mode, if specified. + ;; Set buffer-local parsing mode and extended character mode, if specified. (save-excursion (goto-char (point-min)) ;; Uses last valid definition @@ -2094,9 +2346,9 @@ Includes latex/nroff modes and extended character mode." ;; space separated definitions. (setq string (buffer-substring (match-beginning 1) (match-end 1))) (cond ((string-match "latex-mode" string) - (process-send-string ispell-process "+\n")) + (process-send-string ispell-process "+\n~tex\n")) ((string-match "nroff-mode" string) - (process-send-string ispell-process "-\n")) + (process-send-string ispell-process "-\n~nroff")) ((string-match "~" string) ; Set extended character mode. (process-send-string ispell-process (concat string "\n"))) (t (message "Illegal Ispell Parsing argument!") @@ -2154,8 +2406,8 @@ Both should not be used to define a buffer-local dictionary." (setq ispell-buffer-local-name (buffer-name))) (let ((end (save-excursion (end-of-line) (point))) string) - ;; This used to treat " specially, but that loses for some - ;; people using them to fake accented letters. + ;; buffer-local words separated by a space, and can contain + ;; any character other than a space. (while (re-search-forward " *\\([^ ]+\\)" end t) (setq string (buffer-substring (match-beginning 1) (match-end 1))) (process-send-string ispell-process (concat "@" string "\n"))))))) @@ -2201,7 +2453,7 @@ Both should not be used to define a buffer-local dictionary." reg-end) -(defconst ispell-version "2.30 -- Fri May 20 15:58:52 MDT 1994") +(defconst ispell-version "2.37 -- Tue Jun 13 12:05:28 EDT 1995") (provide 'ispell) @@ -2218,7 +2470,7 @@ Both should not be used to define a buffer-local dictionary." ;;; Local Variables: ;;; mode: emacs-lisp ;;; comment-column: 40 -;;; ispell-local-dictionary: "english" +;;; ispell-local-dictionary: "american" ;;; End: