-;;;;;;;;;;;;;;;;;;;;;;;;;;; -*- 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 <sk@thp.uni-koeln.de>
-;;; 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 <k.stevens@ieee.org>
+;; 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-comments-and-strings
+;; 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 <sk@thp.uni-koeln.de>
+;; 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.")
(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 "egrep"
"Name of the grep command for search processes.")
"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'.")
"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 '(choice file
+ (const :tag "default" nil))
+ :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.
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)
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,
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))
(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]
(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)))))
;;; **********************************************************************
;;; **********************************************************************
-;;; 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.")
"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
;;; 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
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.
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.")
(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.
(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)
(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
(setq replace (ispell-command-loop
(car (cdr (cdr poss)))
(car (cdr (cdr (cdr poss))))
- (car poss)
- start end)))
+ (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)
"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.
(error "No word found to check!"))
(setq start (match-beginning 0)
end (point)
- word (buffer-substring start end))
+ word (buffer-substring-no-properties start end))
(list word start end)))
(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))
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 (highlighted
- (oldwin)
- (textbuf (current-buffer)))
+ (let ((textbuf (current-buffer))
+ (count ?0)
+ (line 2)
+ (max-lines (- (window-height) 4)) ; assure 4 context lines.
+ (choices miss)
+ (window-min-height (min window-min-height
+ ispell-choices-win-default-height))
+ (command-characters '( ? ?i ?a ?A ?r ?R ?? ?x ?X ?q ?l ?u ?m ))
+ (skipped 0)
+ (window (selected-window))
+ (dedicated (window-dedicated-p (selected-window)))
+ 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 (concat "-- %b -- word: " word))
+ (erase-buffer)
+ (if guess
+ (progn
+ (insert "Affix rules generate and capitalize "
+ "this word as shown below:\n\t")
+ (while guess
+ (if (> (+ 4 (current-column) (length (car guess)))
+ (window-width))
+ (progn
+ (insert "\n\t")
+ (setq line (1+ line))))
+ (insert (car guess) " ")
+ (setq guess (cdr guess)))
+ (insert "\nUse option `i' if this is a correct composition"
+ " from the derivative root.\n")
+ (setq line (+ line (if choices 3 2)))))
+ (while (and choices
+ (< (if (> (+ 7 (current-column) (length (car choices))
+ (if (> count ?~) 3 0))
+ (window-width))
+ (progn
+ (insert "\n")
+ (setq line (1+ line)))
+ line)
+ max-lines))
+ ;; not so good if there are over 20 or 30 options, but then, if
+ ;; there are that many you don't want to scan them all anyway...
+ (while (memq count command-characters) ; skip 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)))
+
+ ;; 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 (= 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
- (let ((count ?0)
- (line 2)
- (max-lines (- (window-height) 4)) ; assure 4 context lines.
- (choices miss)
- (window-min-height (min window-min-height
- ispell-choices-win-default-height))
- (command-characters '( ? ?i ?a ?A ?r ?R ?? ?x ?X ?q ?l ?u ?m ))
- (skipped 0)
- char num result)
- (save-excursion
- (set-buffer (get-buffer-create ispell-choices-buffer))
- (setq mode-line-format "-- %b --")
- (erase-buffer)
- (if guess
- (progn
- (insert "Affix rules generate and capitalize "
- "this word as shown below:\n\t")
- (while guess
- (if (> (+ 4 (current-column) (length (car guess)))
- (window-width))
- (progn
- (insert "\n\t")
- (setq line (1+ line))))
- (insert (car guess) " ")
- (setq guess (cdr guess)))
- (insert "\nUse option `i' if this is a correct composition"
- " from the derivative root.\n")
- (setq line (+ line (if choices 3 2)))))
- (while (and choices
- (< (if (> (+ 7 (current-column) (length (car choices))
- (if (> count ?~) 3 0))
- (window-width))
- (progn
- (insert "\n")
- (setq line (1+ line)))
- line)
- max-lines))
- ;; not so good if there are over 20 or 30 options, but then, if
- ;; there are that many you don't want to scan them all anyway...
- (while (memq count command-characters) ; skip 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)))
-
- (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))
-
- ;; This is the window that holds the buffer.
- (setq oldwin (next-window))
-
- ;; Select it.
- (select-window oldwin)
- ;; Put point at the end of the word.
- (goto-char end)
-
- ;; Highlight the word.
+ (progn
(if ispell-highlight-p
- (progn
- (ispell-highlight-spelling-error start end t)
- (setq highlighted t)))
-
+ (ispell-highlight-spelling-error start end t))
+ ;; Loop until a valid choice is made.
(while
(eq
t
result
(progn
(undo-boundary)
- (message (concat "C-h or ? for more options; SPC to leave "
- "unchanged, Character to replace word"))
+ (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)
(setq num (- char ?0 skipped)))
(cond
- ((= char ? ) nil) ; accept word this time only
+ ((= 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!
;; Quit and preserve point.
((= char ?X)
(ispell-pdict-save ispell-silently-savep)
- (message
+ (message "%s"
(substitute-command-keys
(concat "Spell-checking suspended;"
" use C-u \\[ispell-word] to resume")))
(setq ispell-quit (or (not ispell-checking-message)
(point))
ispell-pdict-modified-p nil))
- t)) ; continue if they don't quit.
+ t)) ; continue if they don't quit.
((= char ?l)
(let ((new-word (read-string
"Lookup string (`*' is wildcard): "
(erase-buffer)
(setq count ?0
skipped 0
- mode-line-format "-- %b --"
+ mode-line-format (concat
+ "-- %b -- word: "
+ new-word)
miss (lookup-words new-word)
choices miss)
(while (and choices ; adjust choices window.
count (1+ count)))
(setq count (- count ?0 skipped)))
(select-window (previous-window))
- (if (/= new-line line)
- (progn
+ (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))
- (shrink-window (- line new-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
t)
(t (ding) t))))))
result)
- ;; Unhighlight the word we highlighted.
- (and highlighted ispell-highlight-p
- (save-window-excursion
- (select-window oldwin)
- (ispell-highlight-spelling-error start end nil))))))
+ ;; protected
+ (if ispell-highlight-p ; unhighlight
+ (save-window-excursion
+ (select-window textwin)
+ (ispell-highlight-spelling-error start end)))
+ (set-window-dedicated-p window dedicated))))
;;;###autoload
(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)))))
;;; 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.
(inhibit-quit t) ; inhibit interrupt processing here.
(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
(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)
(delete-overlay ispell-overlay)))
-;;; Choose a highlight function at load time.
-(defun ispell-highlight-spelling-error (start end highlight)
+(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)
+ ((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)
"Create a window covering the top HEIGHT lines of the current window.
Ensure that the line above point is still visible but otherwise avoid
(if (string-match "19\.9.*Lucid" (emacs-version))
(setq height (1+ height)))
(split-window nil height)
+ ;; The lower of the two windows is the logical successor
+ ;; of the original window, so move the dedicated flag to there.
+ ;; The new upper window should not be dedicated.
+ (set-window-dedicated-p (next-window)
+ (window-dedicated-p (selected-window)))
+ (set-window-dedicated-p (selected-window) nil)
(set-window-start (next-window) top))))
;; 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)))))
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)
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.
(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
(setq ispell-dictionary dict))
(if (null arg) ; set local dictionary
(setq ispell-local-dictionary dict)))
- (error "Illegal dictionary: %s" dict))
+ (error "Invalid Ispell dictionary: %s" dict))
(ispell-kill-ispell t)
(message "(Next %sIspell command will use %s dictionary)"
(cond ((equal ispell-local-dictionary ispell-dictionary)
(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)
(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))
(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.
(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)
(concat "Ispell misalignment: word "
"`%s' point %d; please retry")
(car poss) word-start))
+ (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))
+ (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))))
+ (car poss) word-start word-end))))
(cond
((and replace (listp replace))
;; REPLACEMENT WORD entered. Recheck line
(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))))
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)))))
(message "Spell-checking done"))))
+;;;###autoload
+(defun ispell-comments-and-strings ()
+ "Check comments and strings in the current buffer for spelling errors."
+ (interactive)
+ (goto-char (point-min))
+ (let (state done)
+ (while (not done)
+ (setq done t)
+ (setq state (parse-partial-sexp (point) (point-max)
+ nil nil state 'syntax-table))
+ (when (or (nth 3 state) (nth 4 state))
+ (let ((start (point)))
+ (setq state (parse-partial-sexp start (point-max)
+ nil nil state 'syntax-table))
+ (when (or (nth 3 state) (nth 4 state))
+ (error "Unterminated string or comment."))
+ (save-excursion
+ (setq done (not (ispell-region start (point))))))))))
+
;;;###autoload
(defun ispell-buffer ()
(interactive)
(ispell-complete-word t))
+
;;; **********************************************************************
;;; Ispell Minor Mode
;;; **********************************************************************
(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.
(ispell-word nil t))
(call-interactively (key-binding (this-command-keys)))))
+
;;; **********************************************************************
;;; Ispell Message
;;; **********************************************************************
(mapconcat (function identity)
'(
;; Matches postscript files.
- "^%!PS-Adobe-[23].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)
((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.
(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))))
(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
;; 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!")
+ (t (message "Invalid Ispell Parsing argument!")
(sit-for 2))))))))
(setq end (save-excursion (end-of-line) (point)))
(if (re-search-forward " *\\([^ \"]+\\)" end t)
(setq ispell-local-dictionary
- (buffer-substring (match-beginning 1) (match-end 1)))))
+ (buffer-substring-no-properties (match-beginning 1)
+ (match-end 1)))))
(goto-char (point-min))
(while (search-forward ispell-pdict-keyword nil t)
(setq end (save-excursion (end-of-line) (point)))
(if (re-search-forward " *\\([^ \"]+\\)" end t)
(setq ispell-local-pdict
- (buffer-substring (match-beginning 1) (match-end 1)))))))
+ (buffer-substring-no-properties (match-beginning 1)
+ (match-end 1)))))))
;; Reload if new personal dictionary defined.
(if (and ispell-local-pdict
(not (equal ispell-local-pdict ispell-personal-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")))))))
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)
;;; Local Variables:
;;; mode: emacs-lisp
;;; comment-column: 40
-;;; ispell-local-dictionary: "english"
+;;; ispell-local-dictionary: "american"
;;; End: