|
2
|
1 ;;; ispell.el --- spell checking using Ispell
|
|
|
2
|
|
|
3 ;; Copyright (C) 1994, 1995 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 ;; Authors : Ken Stevens <k.stevens@ieee.org>
|
|
|
6 ;; Last Modified On: Tue Jun 13 12:05:28 EDT 1995
|
|
|
7 ;; Update Revision : 2.37
|
|
|
8 ;; Syntax : emacs-lisp
|
|
|
9 ;; Status : Release with 3.1.12+ ispell.
|
|
|
10 ;; Version : International Ispell Version 3.1 by Geoff Kuenning.
|
|
|
11 ;; Bug Reports : ispell-el-bugs@itcorp.com
|
|
|
12
|
|
|
13 ;; Note: version numbers and time stamp are not updated
|
|
|
14 ;; when this file is edited for release with GNU emacs.
|
|
|
15
|
|
|
16 ;; This file is part of XEmacs.
|
|
|
17
|
|
|
18 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
19 ;; under the terms of the GNU General Public License as published by
|
|
|
20 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
21 ;; any later version.
|
|
|
22
|
|
|
23 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
24 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
25 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
26 ;; General Public License for more details.
|
|
|
27
|
|
|
28 ;; You should have received a copy of the GNU General Public License
|
|
|
29 ;; along with XEmacs; see the file COPYING. If not, write to the Free
|
|
|
30 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
|
31 ;; 02111-1307, USA.
|
|
|
32
|
|
0
|
33 ;;; Commentary:
|
|
2
|
34
|
|
|
35 ;; INSTRUCTIONS
|
|
|
36 ;;
|
|
|
37 ;; This code contains a section of user-settable variables that you should
|
|
|
38 ;; inspect prior to installation. Look past the end of the history list.
|
|
|
39 ;; Set them up for your locale and the preferences of the majority of the
|
|
|
40 ;; users. Otherwise the users may need to set a number of variables
|
|
|
41 ;; themselves.
|
|
|
42 ;; You particularly may want to change the default dictionary for your
|
|
|
43 ;; country and language.
|
|
|
44 ;;
|
|
|
45 ;;
|
|
|
46 ;; To fully install this, add this file to your Emacs Lisp directory and
|
|
|
47 ;; compile it with M-X byte-compile-file. Then add the following to the
|
|
|
48 ;; appropriate init file:
|
|
|
49 ;;
|
|
|
50 ;; (autoload 'ispell-word "ispell"
|
|
|
51 ;; "Check the spelling of word in buffer." t)
|
|
|
52 ;; (global-set-key "\e$" 'ispell-word)
|
|
|
53 ;; (autoload 'ispell-region "ispell"
|
|
|
54 ;; "Check the spelling of region." t)
|
|
|
55 ;; (autoload 'ispell-buffer "ispell"
|
|
|
56 ;; "Check the spelling of buffer." t)
|
|
|
57 ;; (autoload 'ispell-complete-word "ispell"
|
|
|
58 ;; "Look up current word in dictionary and try to complete it." t)
|
|
|
59 ;; (autoload 'ispell-change-dictionary "ispell"
|
|
|
60 ;; "Change ispell dictionary." t)
|
|
|
61 ;; (autoload 'ispell-message "ispell"
|
|
|
62 ;; "Check spelling of mail message or news post.")
|
|
|
63 ;;
|
|
|
64 ;; Depending on the mail system you use, you may want to include these:
|
|
|
65 ;;
|
|
|
66 ;; (add-hook 'news-inews-hook 'ispell-message)
|
|
|
67 ;; (add-hook 'mail-send-hook 'ispell-message)
|
|
|
68 ;; (add-hook 'mh-before-send-letter-hook 'ispell-message)
|
|
|
69 ;;
|
|
|
70 ;;
|
|
|
71 ;; Ispell has a TeX parser and a nroff parser (the default).
|
|
|
72 ;; The parsing is controlled by the variable ispell-parser. Currently
|
|
|
73 ;; it is just a "toggle" between TeX and nroff, but if more parsers are
|
|
|
74 ;; added it will be updated. See the variable description for more info.
|
|
|
75 ;;
|
|
|
76 ;;
|
|
|
77 ;; TABLE OF CONTENTS
|
|
|
78 ;;
|
|
|
79 ;; ispell-word
|
|
|
80 ;; ispell-region
|
|
|
81 ;; ispell-buffer
|
|
|
82 ;; ispell-message
|
|
|
83 ;; ispell-continue
|
|
|
84 ;; ispell-complete-word
|
|
|
85 ;; ispell-complete-word-interior-frag
|
|
|
86 ;; ispell-change-dictionary
|
|
|
87 ;; ispell-kill-ispell
|
|
|
88 ;; ispell-pdict-save
|
|
|
89 ;;
|
|
|
90 ;;
|
|
|
91 ;; Commands in ispell-region:
|
|
|
92 ;; Character replacement: Replace word with choice. May query-replace.
|
|
|
93 ;; ' ': Accept word this time.
|
|
|
94 ;; 'i': Accept word and insert into private dictionary.
|
|
|
95 ;; 'a': Accept word for this session.
|
|
|
96 ;; 'A': Accept word and place in buffer-local dictionary.
|
|
|
97 ;; 'r': Replace word with typed-in value. Rechecked.
|
|
|
98 ;; 'R': Replace word with typed-in value. Query-replaced in buffer. Rechecked.
|
|
|
99 ;; '?': Show these commands
|
|
|
100 ;; 'x': Exit spelling buffer. Move cursor to original point.
|
|
|
101 ;; 'X': Exit spelling buffer. Leave cursor at the current point.
|
|
|
102 ;; 'q': Quit spelling session (Kills ispell process).
|
|
|
103 ;; 'l': Look up typed-in replacement in alternate dictionary. Wildcards okay.
|
|
|
104 ;; 'u': Like 'i', but the word is lower-cased first.
|
|
|
105 ;; 'm': Like 'i', but allows one to include dictionary completion info.
|
|
|
106 ;; 'C-l': redraws screen
|
|
|
107 ;; 'C-r': recursive edit
|
|
|
108 ;; 'C-z': suspend emacs or iconify frame
|
|
|
109 ;;
|
|
|
110 ;; Buffer-Local features:
|
|
|
111 ;; There are a number of buffer-local features that can be used to customize
|
|
|
112 ;; ispell for the current buffer. This includes language dictionaries,
|
|
|
113 ;; personal dictionaries, parsing, and local word spellings. Each of these
|
|
|
114 ;; local customizations are done either through local variables, or by
|
|
|
115 ;; including the keyword and argument(s) at the end of the buffer (usually
|
|
|
116 ;; prefixed by the comment characters). See the end of this file for
|
|
|
117 ;; examples. The local keywords and variables are:
|
|
|
118 ;;
|
|
|
119 ;; ispell-dictionary-keyword language-dictionary
|
|
|
120 ;; uses local variable ispell-local-dictionary
|
|
|
121 ;; ispell-pdict-keyword personal-dictionary
|
|
|
122 ;; uses local variable ispell-local-pdict
|
|
|
123 ;; ispell-parsing-keyword mode-arg extended-char-arg
|
|
|
124 ;; ispell-words-keyword any number of local word spellings
|
|
|
125 ;;
|
|
|
126 ;;
|
|
|
127 ;; BUGS:
|
|
|
128 ;; Highlighting in version 19 still doesn't work on tty's.
|
|
|
129 ;; On some versions of emacs, growing the minibuffer fails.
|
|
|
130 ;;
|
|
|
131 ;; HISTORY
|
|
|
132 ;;
|
|
|
133 ;; Revision 2.38 1996/5/30 ethanb@phys.washington.edu
|
|
|
134 ;; Update ispell-message for gnus 5 (news-inews-hook => message-send-hook;
|
|
|
135 ;; different header for quoted message).
|
|
|
136 ;;
|
|
|
137 ;; Revision 2.37 1995/6/13 12:05:28 stevens
|
|
|
138 ;; Removed autoload from ispell-dictionary-alist. *choices* mode-line shows
|
|
|
139 ;; misspelled word. Block skip for pgp & forwarded messages added.
|
|
|
140 ;; RMS: the autoload changes had problems and I removed them.
|
|
|
141 ;;
|
|
|
142 ;; Revision 2.36 1995/2/6 17:39:38 stevens
|
|
|
143 ;; Properly adjust screen with different ispell-choices-win-default-height
|
|
|
144 ;; settings. Skips SGML entity references.
|
|
|
145 ;;
|
|
|
146 ;; Revision 2.35 1995/1/13 14:16:46 stevens
|
|
|
147 ;; Skips SGML tags, ispell-change-dictionary fix for add-hook, assure personal
|
|
|
148 ;; dictionary is saved when called from the menu
|
|
|
149 ;;
|
|
|
150 ;; Revision 2.34 1994/12/08 13:17:41 stevens
|
|
|
151 ;; Interaction corrected to function with all 3.1 ispell versions.
|
|
|
152 ;;
|
|
|
153 ;; Revision 2.33 1994/11/24 02:31:20 stevens
|
|
|
154 ;; Repaired bug introduced in 2.32 that corrupts buffers when correcting.
|
|
|
155 ;; Improved buffer scrolling. Nondestructive buffer selections allowed.
|
|
|
156 ;;
|
|
|
157 ;; Revision 2.32 1994/10/31 21:10:08 geoff
|
|
|
158 ;; Many revisions accepted from RMS/FSF. I think (though I don't know) that
|
|
|
159 ;; this represents an 'official' version.
|
|
|
160 ;;
|
|
|
161 ;; Revision 2.31 1994/5/31 10:18:17 stevens
|
|
|
162 ;; Repaired comments. buffer-local commands executed in `ispell-word' now.
|
|
|
163 ;; German dictionary described for extended character mode. Dict messages.
|
|
|
164 ;;
|
|
|
165 ;; Revision 2.30 1994/5/20 22:18:36 stevens
|
|
|
166 ;; Continue ispell from ispell-word, C-z functionality fixed.
|
|
|
167 ;;
|
|
|
168 ;; Revision 2.29 1994/5/12 09:44:33 stevens
|
|
|
169 ;; Restored ispell-use-ptys-p, ispell-message aborts sends with interrupt.
|
|
|
170 ;; defined fn ispell
|
|
|
171 ;;
|
|
|
172 ;; Revision 2.28 1994/4/28 16:24:40 stevens
|
|
|
173 ;; Window checking when ispell-message put on gnus-inews-article-hook jwz.
|
|
|
174 ;; prefixed ispell- to highlight functions and horiz-scroll fn.
|
|
|
175 ;; Try and respect case of word in ispell-complete-word.
|
|
|
176 ;; Ignore non-char events. Ispell-use-ptys-p commented out. Lucid menu.
|
|
|
177 ;; Better interrupt handling. ispell-message improvements from Ethan.
|
|
|
178 ;;
|
|
|
179 ;; Revision 2.27
|
|
|
180 ;; version 18 explicit C-g handling disabled as it didn't work. Added
|
|
|
181 ;; ispell-extra-args for ispell customization (jwz)
|
|
|
182 ;;
|
|
|
183 ;; Revision 2.26 1994/2/15 16:11:14 stevens
|
|
|
184 ;; name changes for copyright assignment. Added word-frags in complete-word.
|
|
|
185 ;; Horizontal scroll (John Conover). Query-replace matches words now. bugs.
|
|
|
186 ;;
|
|
|
187 ;; Revision 2.25
|
|
|
188 ;; minor mods, upgraded ispell-message
|
|
|
189 ;;
|
|
|
190 ;; Revision 2.24
|
|
|
191 ;; query-replace more robust, messages, defaults, ispell-change-dict.
|
|
|
192 ;;
|
|
|
193 ;; Revision 2.23 1993/11/22 23:47:03 stevens
|
|
|
194 ;; ispell-message, Fixed highlighting, added menu-bar, fixed ispell-help, ...
|
|
|
195 ;;
|
|
|
196 ;; Revision 2.22
|
|
|
197 ;; Added 'u' command. Fixed default in ispell-local-dictionary.
|
|
|
198 ;; fixed affix rules display. Tib skipping more robust. Contributions by
|
|
|
199 ;; Per Abraham (parser selection), Denis Howe, and Eberhard Mattes.
|
|
|
200 ;;
|
|
|
201 ;; Revision 2.21 1993/06/30 14:09:04 stevens
|
|
|
202 ;; minor bugs. (nroff word skipping fixed)
|
|
|
203 ;;
|
|
|
204 ;; Revision 2.20 1993/06/30 14:09:04 stevens
|
|
|
205 ;;
|
|
|
206 ;; Debugging and contributions by: Boris Aronov, Rik Faith, Chris Moore,
|
|
|
207 ;; Kevin Rodgers, Malcolm Davis.
|
|
|
208 ;; Particular thanks to Michael Lipp, Jamie Zawinski, Phil Queinnec
|
|
|
209 ;; and John Heidemann for suggestions and code.
|
|
|
210 ;; Major update including many tweaks.
|
|
|
211 ;; Many changes were integrations of suggestions.
|
|
|
212 ;; lookup-words rehacked to use call-process (Jamie).
|
|
|
213 ;; ispell-complete-word rehacked to be compatible with the rest of the
|
|
|
214 ;; system for word searching and to include multiple wildcards,
|
|
|
215 ;; and it's own dictionary.
|
|
|
216 ;; query-replace capability added. New options 'X', 'R', and 'A'.
|
|
|
217 ;; buffer-local modes for dictionary, word-spelling, and formatter-parsing.
|
|
|
218 ;; Many random bugs, like commented comments being skipped, fix to
|
|
|
219 ;; keep-choices-win, fix for math mode, added pipe mode choice,
|
|
|
220 ;; fixed 'q' command, ispell-word checks previous word and leave cursor
|
|
|
221 ;; in same location. Fixed tib code which could drop spelling regions.
|
|
|
222 ;; Cleaned up setq calls for efficiency. Gave more context on window overlays.
|
|
|
223 ;; Assure context on ispell-command-loop. Window lossage in look cmd fixed.
|
|
|
224 ;; Due to pervasive opinion, common-lisp package syntax removed. Display
|
|
|
225 ;; problem when not highlighting.
|
|
|
226 ;;
|
|
|
227 ;; Revision 2.19 1992/01/10 10:54:08 geoff
|
|
|
228 ;; Make another attempt at fixing the "Bogus, dude" problem. This one is
|
|
|
229 ;; less elegant, but has the advantage of working.
|
|
|
230 ;;
|
|
|
231 ;; Revision 2.18 1992/01/07 10:04:52 geoff
|
|
|
232 ;; Fix the "Bogus, Dude" problem in ispell-word.
|
|
|
233 ;;
|
|
|
234 ;; Revision 2.17 1991/09/12 00:01:42 geoff
|
|
|
235 ;; Add some changes to make ispell-complete-word work better, though
|
|
|
236 ;; still not perfectly.
|
|
|
237 ;;
|
|
|
238 ;; Revision 2.16 91/09/04 18:00:52 geoff
|
|
|
239 ;; More updates from Sebastian, to make the multiple-dictionary support
|
|
|
240 ;; more flexible.
|
|
|
241 ;;
|
|
|
242 ;; Revision 2.15 91/09/04 17:30:02 geoff
|
|
|
243 ;; Sebastian Kremer's tib support
|
|
|
244 ;;
|
|
|
245 ;; Revision 2.14 91/09/04 16:19:37 geoff
|
|
|
246 ;; Don't do set-window-start if the move-to-window-line moved us
|
|
|
247 ;; downward, rather than upward. This prevents getting the buffer all
|
|
|
248 ;; confused. Also, don't use the "not-modified" function to clear the
|
|
|
249 ;; modification flag; instead use set-buffer-modified-p. This prevents
|
|
|
250 ;; extra messages from flashing.
|
|
|
251 ;;
|
|
|
252 ;; Revision 2.13 91/09/04 14:35:41 geoff
|
|
|
253 ;; Fix a spelling error in a comment. Add code to handshake with the
|
|
|
254 ;; ispell process before sending anything to it.
|
|
|
255 ;;
|
|
|
256 ;; Revision 2.12 91/09/03 20:14:21 geoff
|
|
|
257 ;; Add Sebastian Kremer's multiple-language support.
|
|
|
258 ;;
|
|
|
259 ;;
|
|
|
260 ;; Walt Buehring
|
|
|
261 ;; Texas Instruments - Computer Science Center
|
|
|
262 ;; ARPA: Buehring%TI-CSL@CSNet-Relay
|
|
|
263 ;; UUCP: {smu, texsun, im4u, rice} ! ti-csl ! buehring
|
|
|
264 ;;
|
|
|
265 ;; ispell-region and associated routines added by
|
|
|
266 ;; Perry Smith
|
|
|
267 ;; pedz@bobkat
|
|
|
268 ;; Tue Jan 13 20:18:02 CST 1987
|
|
|
269 ;;
|
|
|
270 ;; extensively modified by Mark Davies and Andrew Vignaux
|
|
|
271 ;; {mark,andrew}@vuwcomp
|
|
|
272 ;; Sun May 10 11:45:04 NZST 1987
|
|
|
273 ;;
|
|
|
274 ;; Ken Stevens ARPA: k.stevens@ieee.org
|
|
|
275 ;; Tue Jan 3 16:59:07 PST 1989
|
|
|
276 ;; This file has overgone a major overhaul to be compatible with ispell
|
|
|
277 ;; version 2.1. Most of the functions have been totally rewritten, and
|
|
|
278 ;; many user-accessible variables have been added. The syntax table has
|
|
|
279 ;; been removed since it didn't work properly anyway, and a filter is
|
|
|
280 ;; used rather than a buffer. Regular expressions are used based on
|
|
|
281 ;; ispell's internal definition of characters (see ispell(4)).
|
|
|
282 ;; Some new updates:
|
|
|
283 ;; - Updated to version 3.0 to include terse processing.
|
|
|
284 ;; - Added a variable for the look command.
|
|
|
285 ;; - Fixed a bug in ispell-word when cursor is far away from the word
|
|
|
286 ;; that is to be checked.
|
|
|
287 ;; - Ispell places the incorrect word or guess in the minibuffer now.
|
|
|
288 ;; - fixed a bug with 'l' option when multiple windows are on the screen.
|
|
|
289 ;; - lookup-words just didn't work with the process filter. Fixed.
|
|
|
290 ;; - Rewrote the process filter to make it cleaner and more robust
|
|
|
291 ;; in the event of a continued line not being completed.
|
|
|
292 ;; - Made ispell-init-process more robust in handling errors.
|
|
|
293 ;; - Fixed bug in continuation location after a region has been modified by
|
|
|
294 ;; correcting a misspelling.
|
|
|
295 ;; Mon 17 Sept 1990
|
|
|
296 ;;
|
|
|
297 ;; Sebastian Kremer <sk@thp.uni-koeln.de>
|
|
|
298 ;; Wed Aug 7 14:02:17 MET DST 1991
|
|
|
299 ;; - Ported ispell-complete-word from Ispell 2 to Ispell 3.
|
|
|
300 ;; - Added ispell-kill-ispell command.
|
|
|
301 ;; - Added ispell-dictionary and ispell-dictionary-alist variables to
|
|
|
302 ;; support other than default language. See their docstrings and
|
|
|
303 ;; command ispell-change-dictionary.
|
|
|
304 ;; - (ispelled it :-)
|
|
|
305 ;; - Added ispell-skip-tib variable to support the tib bibliography
|
|
|
306 ;; program.
|
|
0
|
307
|
|
|
308
|
|
2
|
309 ;; **********************************************************************
|
|
|
310 ;; The following variables should be set according to personal preference
|
|
|
311 ;; and location of binaries:
|
|
|
312 ;; **********************************************************************
|
|
0
|
313
|
|
2
|
314 ;; ******* THIS FILE IS WRITTEN FOR ISPELL VERSION 3.1
|
|
0
|
315
|
|
|
316 ;;; Code:
|
|
|
317
|
|
120
|
318 (defgroup ispell nil
|
|
|
319 "Spell checking using ispell"
|
|
|
320 :group 'processes)
|
|
|
321
|
|
0
|
322
|
|
120
|
323 (defcustom ispell-highlight-p t
|
|
|
324 "*Highlight spelling errors when non-nil."
|
|
|
325 :type 'boolean
|
|
|
326 :group 'ispell)
|
|
|
327
|
|
|
328 (defcustom ispell-highlight-face 'highlight
|
|
0
|
329 "*The face used for Ispell highlighting. For Emacses with overlays.
|
|
|
330 Possible values are `highlight', `modeline', `secondary-selection',
|
|
|
331 `region', and `underline'.
|
|
|
332 This variable can be set by the user to whatever face they desire.
|
|
|
333 It's most convenient if the cursor color and highlight color are
|
|
120
|
334 slightly different."
|
|
|
335 :type 'face
|
|
|
336 :group 'ispell)
|
|
0
|
337
|
|
120
|
338 (defcustom ispell-check-comments t
|
|
|
339 "*If nil, don't check spelling of comments."
|
|
|
340 :type 'boolean
|
|
|
341 :group 'ispell)
|
|
|
342
|
|
|
343 (defcustom ispell-query-replace-choices nil
|
|
0
|
344 "*Corrections made throughout region when non-nil.
|
|
120
|
345 Uses `query-replace' (\\[query-replace]) for corrections."
|
|
|
346 :type 'boolean
|
|
|
347 :group 'ispell)
|
|
0
|
348
|
|
120
|
349 (defcustom ispell-skip-tib nil
|
|
0
|
350 "*Does not spell check `tib' bibliography references when non-nil.
|
|
|
351 Skips any text between strings matching regular expressions
|
|
|
352 `ispell-tib-ref-beginning' and `ispell-tib-ref-end'.
|
|
|
353
|
|
|
354 TeX users beware: Any field starting with [. will skip until a .] -- even
|
|
|
355 your whole buffer -- unless you set `ispell-skip-tib' to nil. That includes
|
|
120
|
356 a [.5mm] type of number...."
|
|
|
357 :type 'boolean
|
|
|
358 :group 'ispell)
|
|
0
|
359
|
|
|
360 (defvar ispell-tib-ref-beginning "[[<]\\."
|
|
|
361 "Regexp matching the beginning of a Tib reference.")
|
|
|
362
|
|
|
363 (defvar ispell-tib-ref-end "\\.[]>]"
|
|
|
364 "Regexp matching the end of a Tib reference.")
|
|
|
365
|
|
120
|
366 (defcustom ispell-keep-choices-win t
|
|
0
|
367 "*When not nil, the `*Choices*' window remains for spelling session.
|
|
120
|
368 This minimizes redisplay thrashing."
|
|
|
369 :type 'boolean
|
|
|
370 :group 'ispell)
|
|
0
|
371
|
|
120
|
372 (defcustom ispell-choices-win-default-height 2
|
|
0
|
373 "*The default size of the `*Choices*' window, including status line.
|
|
120
|
374 Must be greater than 1."
|
|
|
375 :type 'integer
|
|
|
376 :group 'ispell)
|
|
0
|
377
|
|
120
|
378 (defcustom ispell-program-name "ispell"
|
|
|
379 "Program invoked by \\[ispell-word] and \\[ispell-region] commands."
|
|
|
380 :type 'string
|
|
|
381 :group 'ispell)
|
|
0
|
382
|
|
120
|
383 (defcustom ispell-alternate-dictionary
|
|
0
|
384 (cond ((file-exists-p "/usr/dict/web2") "/usr/dict/web2")
|
|
|
385 ((file-exists-p "/usr/share/dict/web2") "/usr/share/dict/web2")
|
|
|
386 ((file-exists-p "/usr/dict/words") "/usr/dict/words")
|
|
|
387 ((file-exists-p "/usr/lib/dict/words") "/usr/lib/dict/words")
|
|
|
388 ((file-exists-p "/usr/share/dict/words") "/usr/share/dict/words")
|
|
|
389 ((file-exists-p "/sys/dict") "/sys/dict")
|
|
|
390 (t "/usr/dict/words"))
|
|
120
|
391 "*Alternate dictionary for spelling help."
|
|
|
392 :type 'file
|
|
|
393 :group 'ispell)
|
|
0
|
394
|
|
120
|
395 (defcustom ispell-complete-word-dict ispell-alternate-dictionary
|
|
|
396 "*Dictionary used for word completion."
|
|
|
397 :type 'file
|
|
|
398 :group 'ispell)
|
|
0
|
399
|
|
|
400 (defvar ispell-grep-command "egrep"
|
|
|
401 "Name of the grep command for search processes.")
|
|
|
402
|
|
|
403 (defvar ispell-grep-options "-i"
|
|
|
404 "String of options to use when running the program in `ispell-grep-command'.
|
|
|
405 Should probably be \"-i\" or \"-e\".
|
|
|
406 Some machines (like the NeXT) don't support \"-i\"")
|
|
|
407
|
|
|
408 (defvar ispell-look-command "look"
|
|
|
409 "Name of the look command for search processes.
|
|
|
410 This must be an absolute file name.")
|
|
|
411
|
|
120
|
412 (defcustom ispell-look-p `(file-exists-p ispell-look-command)
|
|
0
|
413 "*Non-nil means use `look' rather than `grep'.
|
|
120
|
414 Default is based on whether `look' seems to be available."
|
|
|
415 :type 'boolean
|
|
|
416 :group 'ispell)
|
|
0
|
417
|
|
120
|
418 (defcustom ispell-have-new-look nil
|
|
|
419 "*Non-nil means use the `-r' option (regexp) when running `look'."
|
|
|
420 :type 'boolean
|
|
|
421 :group 'ispell)
|
|
0
|
422
|
|
|
423 (defvar ispell-look-options (if ispell-have-new-look "-dfr" "-df")
|
|
|
424 "String of command options for `ispell-look-command'.")
|
|
|
425
|
|
|
426 (defvar ispell-use-ptys-p nil
|
|
|
427 "When non-nil, Emacs uses ptys to communicate with Ispell.
|
|
|
428 When nil, Emacs uses pipes.")
|
|
|
429
|
|
120
|
430 (defcustom ispell-following-word nil
|
|
0
|
431 "*Non-nil means `ispell-word' checks the word around or after point.
|
|
120
|
432 Otherwise `ispell-word' checks the preceding word."
|
|
|
433 :type 'boolean
|
|
|
434 :group 'ispell)
|
|
0
|
435
|
|
120
|
436 (defcustom ispell-help-in-bufferp nil
|
|
0
|
437 "*Non-nil means display interactive keymap help in a buffer.
|
|
120
|
438 Otherwise use the minibuffer."
|
|
|
439 :type 'boolean
|
|
|
440 :group 'ispell)
|
|
0
|
441
|
|
120
|
442 (defcustom ispell-quietly nil
|
|
|
443 "*Non-nil means suppress messages in `ispell-word'."
|
|
|
444 :type 'boolean
|
|
|
445 :group 'ispell)
|
|
0
|
446
|
|
120
|
447 (defcustom ispell-format-word (function upcase)
|
|
0
|
448 "*Formatting function for displaying word being spell checked.
|
|
120
|
449 The function must take one string argument and return a string."
|
|
|
450 :type 'function
|
|
|
451 :group 'ispell)
|
|
0
|
452
|
|
|
453 ;;;###autoload
|
|
120
|
454 (defcustom ispell-personal-dictionary nil
|
|
0
|
455 "*File name of your personal spelling dictionary, or nil.
|
|
|
456 If nil, the default personal dictionary, \"~/.ispell_DICTNAME\" is used,
|
|
120
|
457 where DICTNAME is the name of your default dictionary."
|
|
|
458 :type 'file
|
|
|
459 :group 'ispell)
|
|
0
|
460
|
|
120
|
461 (defcustom ispell-silently-savep nil
|
|
|
462 "*When non-nil, save the personal dictionary without confirmation."
|
|
|
463 :type 'boolean
|
|
|
464 :group 'ispell)
|
|
0
|
465
|
|
|
466 ;;; This variable contains the current dictionary being used if the ispell
|
|
|
467 ;;; process is running. Otherwise it contains the global default.
|
|
|
468 (defvar ispell-dictionary nil
|
|
|
469 "If non-nil, a dictionary to use instead of the default one.
|
|
|
470 This is passed to the ispell process using the `-d' switch and is
|
|
|
471 used as key in `ispell-dictionary-alist' (which see).
|
|
|
472
|
|
|
473 You should set this variable before your first use of Emacs spell-checking
|
|
|
474 commands in the Emacs session, or else use the \\[ispell-change-dictionary]
|
|
|
475 command to change it. Otherwise, this variable only takes effect in a newly
|
|
|
476 started Ispell process.")
|
|
|
477
|
|
120
|
478 (defcustom ispell-extra-args nil
|
|
0
|
479 "*If non-nil, a list of extra switches to pass to the Ispell program.
|
|
|
480 For example, '(\"-W\" \"3\") to cause it to accept all 1-3 character
|
|
|
481 words as correct. See also `ispell-dictionary-alist', which may be used
|
|
120
|
482 for language-specific arguments."
|
|
|
483 :type '(repeat string)
|
|
|
484 :group 'ispell)
|
|
0
|
485
|
|
2
|
486 ;;; The preparation of the menu bar menu must be autoloaded
|
|
|
487 ;;; because otherwise this file gets autoloaded every time Emacs starts
|
|
|
488 ;;; so that it can set up the menus and determine keyboard equivalents.
|
|
|
489
|
|
0
|
490 ;;;###autoload
|
|
|
491 (defvar ispell-dictionary-alist-1 ; sk 9-Aug-1991 18:28
|
|
|
492 '((nil ; default (english.aff)
|
|
|
493 "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil)
|
|
|
494 ("english" ; make english explicitly selectable
|
|
|
495 "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil)
|
|
|
496 ("british" ; british version
|
|
|
497 "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil)
|
|
|
498 ("deutsch" ; deutsch.aff
|
|
|
499 "[a-zA-Z\"]" "[^a-zA-Z\"]" "[']" t ("-C") "~tex")
|
|
|
500 ("deutsch8"
|
|
|
501 "[a-zA-Z\304\326\334\344\366\337\374]"
|
|
|
502 "[^a-zA-Z\304\326\334\344\366\337\374]"
|
|
|
503 "[']" t ("-C" "-d" "deutsch") "~latin1")
|
|
|
504 ("nederlands" ; nederlands.aff
|
|
|
505 "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]"
|
|
|
506 "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]"
|
|
|
507 "[']" t ("-C") nil)
|
|
|
508 ("nederlands8" ; dutch8.aff
|
|
|
509 "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]"
|
|
|
510 "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]"
|
|
|
511 "[']" t ("-C") nil)))
|
|
|
512
|
|
|
513 ;;;###autoload
|
|
|
514 (defvar ispell-dictionary-alist-2
|
|
|
515 '(("svenska" ;7 bit swedish mode
|
|
|
516 "[A-Za-z}{|\\133\\135\\\\]" "[^A-Za-z}{|\\133\\135\\\\]"
|
|
|
517 "[']" nil ("-C") nil)
|
|
|
518 ("svenska8" ;8 bit swedish mode
|
|
|
519 "[A-Za-z\345\344\366\305\304\366]" "[^A-Za-z\345\344\366\305\304\366]"
|
|
|
520 "[']" nil ("-C" "-d" "svenska") "~list") ; Add `"-T" "list"' instead?
|
|
126
|
521 ("norsk" ;8 bit norwegian mode
|
|
|
522 "[A-Za-z\351\346\370\345\311\306\330\305]" "[^A-Za-z\351\346\370\345\311\306\330\305]"
|
|
|
523 "[']" nil ("-C" "-d" "norsk") "~list")
|
|
0
|
524 ("francais7"
|
|
|
525 "[A-Za-z]" "[^A-Za-z]" "[`'^---]" t nil nil)
|
|
|
526 ("francais" ; francais.aff
|
|
|
527 "[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]"
|
|
|
528 "[^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]"
|
|
|
529 "[---']" t nil "~list")
|
|
|
530 ("francais-tex" ; francais.aff
|
|
|
531 "[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\\]"
|
|
|
532 "[^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\\]"
|
|
|
533 "[---'^`\"]" t nil "~tex")
|
|
120
|
534 ("italiano" ; italiano.aff
|
|
|
535 "[A-Za-z\300\310\311\314\315\316\322\331\332\340\350\351\354\355\356\362\371\372]"
|
|
|
536 "[^A-Za-z\300\310\311\314\315\316\322\331\332\340\350\351\354\355\356\362\371\372]"
|
|
|
537 "[']" t ("-d" "italiano") "~list")
|
|
0
|
538 ("dansk" ; dansk.aff
|
|
|
539 "[A-Z\306\330\305a-z\346\370\345]" "[^A-Z\306\330\305a-z\346\370\345]"
|
|
|
540 "" nil ("-C") nil)
|
|
|
541 ))
|
|
|
542
|
|
|
543
|
|
|
544 ;;; ispell-dictionary-alist is set up from two subvariables above
|
|
|
545 ;;; to avoid having very long lines in loaddefs.el.
|
|
|
546 ;;;###autoload
|
|
|
547 (defvar ispell-dictionary-alist
|
|
|
548 (append ispell-dictionary-alist-1 ispell-dictionary-alist-2)
|
|
|
549 "An alist of dictionaries and their associated parameters.
|
|
|
550
|
|
|
551 Each element of this list is also a list:
|
|
|
552
|
|
|
553 \(DICTIONARY-NAME CASECHARS NOT-CASECHARS OTHERCHARS MANY-OTHERCHARS-P
|
|
|
554 ISPELL-ARGS EXTENDED-CHARACTER-MODE\)
|
|
|
555
|
|
|
556 DICTIONARY-NAME is a possible value of variable `ispell-dictionary', nil
|
|
|
557 means the default dictionary.
|
|
|
558
|
|
|
559 CASECHARS is a regular expression of valid characters that comprise a
|
|
|
560 word.
|
|
|
561
|
|
|
562 NOT-CASECHARS is the opposite regexp of CASECHARS.
|
|
|
563
|
|
|
564 OTHERCHARS is a regular expression of other characters that are valid
|
|
|
565 in word constructs. Otherchars cannot be adjacent to each other in a
|
|
|
566 word, nor can they begin or end a word. This implies we can't check
|
|
|
567 \"Stevens'\" as a correct possessive and other correct formations.
|
|
|
568
|
|
|
569 Hint: regexp syntax requires the hyphen to be declared first here.
|
|
|
570
|
|
|
571 MANY-OTHERCHARS-P is non-nil if many otherchars are to be allowed in a
|
|
|
572 word instead of only one.
|
|
|
573
|
|
|
574 ISPELL-ARGS is a list of additional arguments passed to the ispell
|
|
|
575 subprocess.
|
|
|
576
|
|
|
577 EXTENDED-CHARACTER-MODE should be used when dictionaries are used which
|
|
|
578 have been configured in an Ispell affix file. (For example, umlauts
|
|
|
579 can be encoded as \\\"a, a\\\", \"a, ...) Defaults are ~tex and ~nroff
|
|
|
580 in English. This has the same effect as the command-line `-T' option.
|
|
|
581 The buffer Major Mode controls Ispell's parsing in tex or nroff mode,
|
|
|
582 but the dictionary can control the extended character mode.
|
|
|
583 Both defaults can be overruled in a buffer-local fashion. See
|
|
|
584 `ispell-parsing-keyword' for details on this.
|
|
|
585
|
|
|
586 Note that the CASECHARS and OTHERCHARS slots of the alist should
|
|
|
587 contain the same character set as casechars and otherchars in the
|
|
|
588 language.aff file \(e.g., english.aff\).")
|
|
|
589
|
|
|
590 ;;;###autoload
|
|
|
591 (defvar ispell-menu-map nil "Key map for ispell menu")
|
|
|
592
|
|
|
593 ;;;###autoload
|
|
2
|
594 (defvar ispell-menu-xemacs nil "Spelling menu for XEmacs.")
|
|
0
|
595
|
|
2
|
596 ;;; Break out XEmacs menu and split into several calls to avoid having
|
|
0
|
597 ;;; long lines in loaddefs.el. Detect need off following constant.
|
|
|
598
|
|
|
599 ;;;###autoload
|
|
2
|
600 (defconst ispell-menu-map-needed ; make sure this is not XEmacs
|
|
0
|
601 (and (not ispell-menu-map)
|
|
|
602 (string-lessp "19" emacs-version)
|
|
|
603 ;; make sure this isn't XEmacs
|
|
|
604 (not (string-match "XEmacs" emacs-version))))
|
|
|
605
|
|
|
606
|
|
2
|
607 ;;; Set up dictionary
|
|
0
|
608 ;;;###autoload
|
|
|
609 (if ispell-menu-map-needed
|
|
|
610 (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist)))
|
|
|
611 name)
|
|
|
612 (setq ispell-menu-map (make-sparse-keymap "Spell"))
|
|
|
613 ;; add the dictionaries to the bottom of the list.
|
|
|
614 (while dicts
|
|
|
615 (setq name (car (car dicts))
|
|
|
616 dicts (cdr dicts))
|
|
|
617 (if (stringp name)
|
|
|
618 (define-key ispell-menu-map (vector (intern name))
|
|
|
619 (cons (concat "Select " (capitalize name))
|
|
|
620 (list 'lambda () '(interactive)
|
|
|
621 (list 'ispell-change-dictionary name))))))))
|
|
|
622
|
|
|
623 ;;; define commands in menu in opposite order you want them to appear.
|
|
|
624 ;;;###autoload
|
|
|
625 (if ispell-menu-map-needed
|
|
|
626 (progn
|
|
|
627 (define-key ispell-menu-map [ispell-change-dictionary]
|
|
|
628 '("Change Dictionary" . ispell-change-dictionary))
|
|
|
629 (define-key ispell-menu-map [ispell-kill-ispell]
|
|
|
630 '("Kill Process" . ispell-kill-ispell))
|
|
|
631 (define-key ispell-menu-map [ispell-pdict-save]
|
|
|
632 '("Save Dictionary" . (lambda () (interactive) (ispell-pdict-save t t))))
|
|
|
633 (define-key ispell-menu-map [ispell-complete-word]
|
|
|
634 '("Complete Word" . ispell-complete-word))
|
|
|
635 (define-key ispell-menu-map [ispell-complete-word-interior-frag]
|
|
|
636 '("Complete Word Frag" . ispell-complete-word-interior-frag))))
|
|
|
637
|
|
|
638 ;;;###autoload
|
|
|
639 (if ispell-menu-map-needed
|
|
|
640 (progn
|
|
|
641 (define-key ispell-menu-map [ispell-continue]
|
|
|
642 '("Continue Check" . ispell-continue))
|
|
|
643 (define-key ispell-menu-map [ispell-word]
|
|
|
644 '("Check Word" . ispell-word))
|
|
|
645 (define-key ispell-menu-map [ispell-region]
|
|
|
646 '("Check Region" . ispell-region))
|
|
|
647 (define-key ispell-menu-map [ispell-buffer]
|
|
|
648 '("Check Buffer" . ispell-buffer))))
|
|
|
649
|
|
|
650 ;;;###autoload
|
|
|
651 (if ispell-menu-map-needed
|
|
|
652 (progn
|
|
|
653 (define-key ispell-menu-map [ispell-message]
|
|
|
654 '("Check Message" . ispell-message))
|
|
|
655 (define-key ispell-menu-map [ispell-help]
|
|
|
656 ;; use (x-popup-menu last-nonmenu-event(list "" ispell-help-list)) ?
|
|
|
657 '("Help" . (lambda () (interactive) (describe-function 'ispell-help))))
|
|
|
658 (put 'ispell-region 'menu-enable 'mark-active)
|
|
|
659 (fset 'ispell-menu-map (symbol-value 'ispell-menu-map))))
|
|
|
660
|
|
|
661 ;;; XEmacs version 19
|
|
|
662 (if (and (string-lessp "19" emacs-version)
|
|
|
663 (string-match "Lucid" emacs-version)
|
|
124
|
664 (not (and (boundp 'infodock-version) infodock-version))
|
|
|
665 (featurep 'menubar)
|
|
|
666 (or current-menubar default-menubar))
|
|
0
|
667 (let ((dicts (cons (cons "default" nil) ispell-dictionary-alist))
|
|
|
668 (current-menubar (or current-menubar default-menubar))
|
|
|
669 (menu
|
|
|
670 '(["Help" (describe-function 'ispell-help) t]
|
|
|
671 ;;["Help" (popup-menu ispell-help-list) t]
|
|
|
672 ["Check Message" ispell-message t]
|
|
|
673 ["Check Buffer" ispell-buffer t]
|
|
|
674 ["Check Word" ispell-word t]
|
|
|
675 ["Check Region" ispell-region (or (not zmacs-regions) (mark))]
|
|
|
676 ["Continue Check" ispell-continue t]
|
|
|
677 ["Complete Word Frag"ispell-complete-word-interior-frag t]
|
|
|
678 ["Complete Word" ispell-complete-word t]
|
|
|
679 ["Kill Process" ispell-kill-ispell t]
|
|
|
680 "-"
|
|
|
681 ["Save Dictionary" (ispell-pdict-save t t) t]
|
|
|
682 ["Change Dictionary" ispell-change-dictionary t]))
|
|
|
683 name)
|
|
|
684 (while dicts
|
|
|
685 (setq name (car (car dicts))
|
|
|
686 dicts (cdr dicts))
|
|
|
687 (if (stringp name)
|
|
|
688 (setq menu (append menu
|
|
|
689 (list
|
|
|
690 (vector (concat "Select " (capitalize name))
|
|
|
691 (list 'ispell-change-dictionary name)
|
|
|
692 t))))))
|
|
2
|
693 (setq ispell-menu-xemacs menu)
|
|
0
|
694 (if current-menubar
|
|
|
695 (progn
|
|
|
696 (delete-menu-item '("Edit" "Spell")) ; in case already defined
|
|
2
|
697 (add-menu '("Edit") "Spell" ispell-menu-xemacs)))))
|
|
0
|
698
|
|
|
699
|
|
|
700 ;;; **********************************************************************
|
|
|
701 ;;; The following are used by ispell, and should not be changed.
|
|
|
702 ;;; **********************************************************************
|
|
|
703
|
|
|
704
|
|
|
705 ;;; The version must be 3.1 or greater for this version of ispell.el
|
|
|
706 ;;; There is an incompatibility between version 3.1.12 and lower versions.
|
|
|
707 (defconst ispell-required-version '("3.1." 12)
|
|
|
708 "Ispell versions with which this version of ispell.el is known to work.")
|
|
|
709 (defvar ispell-offset 1
|
|
|
710 "Offset that maps protocol differences between ispell 3.1 versions.")
|
|
|
711
|
|
|
712 (defun ispell-get-casechars ()
|
|
|
713 (nth 1 (assoc ispell-dictionary ispell-dictionary-alist)))
|
|
|
714 (defun ispell-get-not-casechars ()
|
|
|
715 (nth 2 (assoc ispell-dictionary ispell-dictionary-alist)))
|
|
|
716 (defun ispell-get-otherchars ()
|
|
|
717 (nth 3 (assoc ispell-dictionary ispell-dictionary-alist)))
|
|
|
718 (defun ispell-get-many-otherchars-p ()
|
|
|
719 (nth 4 (assoc ispell-dictionary ispell-dictionary-alist)))
|
|
|
720 (defun ispell-get-ispell-args ()
|
|
|
721 (nth 5 (assoc ispell-dictionary ispell-dictionary-alist)))
|
|
|
722 (defun ispell-get-extended-character-mode ()
|
|
|
723 (nth 6 (assoc ispell-dictionary ispell-dictionary-alist)))
|
|
|
724
|
|
|
725 (defvar ispell-process nil
|
|
|
726 "The process object for Ispell.")
|
|
|
727
|
|
|
728 (defvar ispell-pdict-modified-p nil
|
|
|
729 "Non-nil means personal dictionary has modifications to be saved.")
|
|
|
730
|
|
|
731 ;;; If you want to save the dictionary when quitting, must do so explicitly.
|
|
|
732 ;;; When non-nil, the spell session is terminated.
|
|
|
733 ;;; When numeric, contains cursor location in buffer, and cursor remains there.
|
|
|
734 (defvar ispell-quit nil)
|
|
|
735
|
|
|
736 (defvar ispell-filter nil
|
|
|
737 "Output filter from piped calls to Ispell.")
|
|
|
738
|
|
|
739 (defvar ispell-filter-continue nil
|
|
|
740 "Control variable for Ispell filter function.")
|
|
|
741
|
|
|
742 (defvar ispell-process-directory nil
|
|
|
743 "The directory where `ispell-process' was started.")
|
|
|
744
|
|
|
745 (defvar ispell-query-replace-marker (make-marker)
|
|
|
746 "Marker for `query-replace' processing.")
|
|
|
747
|
|
|
748 (defvar ispell-checking-message nil
|
|
|
749 "Non-nil when we're checking a mail message")
|
|
|
750
|
|
|
751 (defconst ispell-choices-buffer "*Choices*")
|
|
|
752
|
|
|
753 (defvar ispell-overlay nil "Overlay variable for Ispell highlighting.")
|
|
|
754
|
|
|
755 ;;; *** Buffer Local Definitions ***
|
|
|
756
|
|
|
757 ;;; This is the local dictionary to use. When nil the default dictionary will
|
|
|
758 ;;; be used. Do not redefine default value or it will override the global!
|
|
|
759 (defvar ispell-local-dictionary nil
|
|
|
760 "If non-nil, a dictionary to use for Ispell commands in this buffer.
|
|
|
761 The value must be a string dictionary name in `ispell-dictionary-alist'.
|
|
|
762 This variable becomes buffer-local when set in any fashion.
|
|
|
763
|
|
|
764 Setting ispell-local-dictionary to a value has the same effect as
|
|
|
765 calling \\[ispell-change-dictionary] with that value. This variable
|
|
|
766 is automatically set when defined in the file with either
|
|
|
767 `ispell-dictionary-keyword' or the Local Variable syntax.")
|
|
|
768
|
|
|
769 (make-variable-buffer-local 'ispell-local-dictionary)
|
|
|
770
|
|
|
771 ;; Use default directory, unless locally set.
|
|
|
772 (set-default 'ispell-local-dictionary nil)
|
|
|
773
|
|
|
774 (defconst ispell-words-keyword "LocalWords: "
|
|
|
775 "The keyword for local oddly-spelled words to accept.
|
|
|
776 The keyword will be followed by any number of local word spellings.
|
|
|
777 There can be multiple of these keywords in the file.")
|
|
|
778
|
|
|
779 (defconst ispell-dictionary-keyword "Local IspellDict: "
|
|
|
780 "The keyword for local dictionary definitions.
|
|
|
781 There should be only one dictionary keyword definition per file, and it
|
|
|
782 should be followed by a correct dictionary name in `ispell-dictionary-alist'.")
|
|
|
783
|
|
|
784 (defconst ispell-parsing-keyword "Local IspellParsing: "
|
|
|
785 "The keyword for overriding default Ispell parsing.
|
|
|
786 Determined by the buffer's major mode and extended-character mode as well as
|
|
|
787 the default dictionary.
|
|
|
788
|
|
|
789 The above keyword string should be followed by `latex-mode' or
|
|
|
790 `nroff-mode' to put the current buffer into the desired parsing mode.
|
|
|
791
|
|
|
792 Extended character mode can be changed for this buffer by placing
|
|
|
793 a `~' followed by an extended-character mode -- such as `~.tex'.")
|
|
|
794
|
|
|
795 (defvar ispell-skip-sgml nil
|
|
|
796 "Skips spell checking of SGML tags and entity references when non-nil.
|
|
|
797 This variable is set when major-mode is sgml-mode or html-mode.")
|
|
|
798
|
|
|
799 ;;;###autoload
|
|
|
800 (defvar ispell-local-pdict ispell-personal-dictionary
|
|
|
801 "A buffer local variable containing the current personal dictionary.
|
|
|
802 If non-nil, the value must be a string, which is a file name.
|
|
|
803
|
|
|
804 If you specify a personal dictionary for the current buffer which is
|
|
|
805 different from the current personal dictionary, the effect is similar
|
|
|
806 to calling \\[ispell-change-dictionary]. This variable is automatically
|
|
|
807 set when defined in the file with either `ispell-pdict-keyword' or the
|
|
|
808 local variable syntax.")
|
|
|
809
|
|
|
810 (make-variable-buffer-local 'ispell-local-pdict)
|
|
|
811
|
|
|
812 (defconst ispell-pdict-keyword "Local IspellPersDict: "
|
|
|
813 "The keyword for defining buffer local dictionaries.")
|
|
|
814
|
|
|
815 (defvar ispell-buffer-local-name nil
|
|
|
816 "Contains the buffer name if local word definitions were used.
|
|
|
817 Ispell is then restarted because the local words could conflict.")
|
|
|
818
|
|
|
819 (defvar ispell-parser 'use-mode-name
|
|
|
820 "*Indicates whether ispell should parse the current buffer as TeX Code.
|
|
|
821 Special value `use-mode-name' tries to guess using the name of major-mode.
|
|
|
822 Default parser is 'nroff.
|
|
|
823 Currently the only other valid parser is 'tex.
|
|
|
824
|
|
|
825 You can set this variable in hooks in your init file -- eg:
|
|
|
826
|
|
|
827 (add-hook 'tex-mode-hook (function (lambda () (setq ispell-parser 'tex))))")
|
|
|
828
|
|
|
829 (defvar ispell-region-end (make-marker)
|
|
|
830 "Marker that allows spelling continuations.")
|
|
|
831
|
|
|
832 (defvar ispell-check-only nil
|
|
|
833 "If non-nil, `ispell-word' does not try to correct the word.")
|
|
|
834
|
|
|
835
|
|
|
836 ;;; **********************************************************************
|
|
|
837 ;;; **********************************************************************
|
|
|
838
|
|
|
839
|
|
|
840 (and (string-lessp "19" emacs-version)
|
|
|
841 (not (boundp 'epoch::version))
|
|
|
842 (defalias 'ispell 'ispell-buffer))
|
|
|
843
|
|
78
|
844
|
|
|
845 ;; XEmacs: \M-$ for whatever reason, drives `make autoloads' bonkers
|
|
|
846
|
|
0
|
847 ;;;###autoload
|
|
78
|
848 (define-key global-map [(meta ?\$)] 'ispell-word)
|
|
0
|
849
|
|
|
850 ;;;###autoload
|
|
|
851 (defun ispell-word (&optional following quietly continue)
|
|
|
852 "Check spelling of word under or before the cursor.
|
|
|
853 If the word is not found in dictionary, display possible corrections
|
|
|
854 in a window allowing you to choose one.
|
|
|
855
|
|
|
856 With a prefix argument (or if CONTINUE is non-nil),
|
|
|
857 resume interrupted spell-checking of a buffer or region.
|
|
|
858
|
|
|
859 If optional argument FOLLOWING is non-nil or if `ispell-following-word'
|
|
|
860 is non-nil when called interactively, then the following word
|
|
|
861 \(rather than preceding\) is checked when the cursor is not over a word.
|
|
|
862 When the optional argument QUIETLY is non-nil or `ispell-quietly' is non-nil
|
|
|
863 when called interactively, non-corrective messages are suppressed.
|
|
|
864
|
|
|
865 Word syntax described by `ispell-dictionary-alist' (which see).
|
|
|
866
|
|
|
867 This will check or reload the dictionary. Use \\[ispell-change-dictionary]
|
|
|
868 or \\[ispell-region] to update the Ispell process."
|
|
|
869 (interactive (list nil nil current-prefix-arg))
|
|
|
870 (if continue
|
|
|
871 (ispell-continue)
|
|
|
872 (if (interactive-p)
|
|
|
873 (setq following ispell-following-word
|
|
|
874 quietly ispell-quietly))
|
|
|
875 (ispell-accept-buffer-local-defs) ; use the correct dictionary
|
|
|
876 (let ((cursor-location (point)) ; retain cursor location
|
|
|
877 (word (ispell-get-word following))
|
|
|
878 start end poss replace)
|
|
|
879 ;; destructure return word info list.
|
|
|
880 (setq start (car (cdr word))
|
|
|
881 end (car (cdr (cdr word)))
|
|
|
882 word (car word))
|
|
|
883
|
|
|
884 ;; now check spelling of word.
|
|
|
885 (or quietly
|
|
|
886 (message "Checking spelling of %s..."
|
|
|
887 (funcall ispell-format-word word)))
|
|
|
888 (process-send-string ispell-process "%\n") ;put in verbose mode
|
|
|
889 (process-send-string ispell-process (concat "^" word "\n"))
|
|
|
890 ;; wait until ispell has processed word
|
|
|
891 (while (progn
|
|
|
892 (accept-process-output ispell-process)
|
|
|
893 (not (string= "" (car ispell-filter)))))
|
|
|
894 ;;(process-send-string ispell-process "!\n") ;back to terse mode.
|
|
|
895 (setq ispell-filter (cdr ispell-filter))
|
|
|
896 (if (listp ispell-filter)
|
|
|
897 (setq poss (ispell-parse-output (car ispell-filter))))
|
|
|
898 (cond ((eq poss t)
|
|
|
899 (or quietly
|
|
|
900 (message "%s is correct" (funcall ispell-format-word word))))
|
|
|
901 ((stringp poss)
|
|
|
902 (or quietly
|
|
|
903 (message "%s is correct because of root %s"
|
|
|
904 (funcall ispell-format-word word)
|
|
|
905 (funcall ispell-format-word poss))))
|
|
|
906 ((null poss) (message "Error in ispell process"))
|
|
|
907 (ispell-check-only ; called from ispell minor mode.
|
|
|
908 (beep))
|
|
|
909 (t ; prompt for correct word.
|
|
|
910 (save-window-excursion
|
|
|
911 (setq replace (ispell-command-loop
|
|
|
912 (car (cdr (cdr poss)))
|
|
|
913 (car (cdr (cdr (cdr poss))))
|
|
|
914 (car poss) start end)))
|
|
|
915 (cond ((equal 0 replace)
|
|
|
916 (ispell-add-per-file-word-list (car poss)))
|
|
|
917 (replace
|
|
|
918 (setq word (if (atom replace) replace (car replace))
|
|
|
919 cursor-location (+ (- (length word) (- end start))
|
|
|
920 cursor-location))
|
|
|
921 (if (not (equal word (car poss)))
|
|
|
922 (progn
|
|
|
923 (delete-region start end)
|
|
|
924 (insert word)))
|
|
|
925 (if (not (atom replace)) ; recheck spelling of replacement
|
|
|
926 (progn
|
|
|
927 (goto-char cursor-location)
|
|
|
928 (ispell-word following quietly)))))
|
|
|
929 (if (get-buffer ispell-choices-buffer)
|
|
|
930 (kill-buffer ispell-choices-buffer))))
|
|
|
931 (goto-char cursor-location) ; return to original location
|
|
|
932 (ispell-pdict-save ispell-silently-savep)
|
|
|
933 (if ispell-quit (setq ispell-quit nil)))))
|
|
|
934
|
|
|
935
|
|
|
936 (defun ispell-get-word (following &optional extra-otherchars)
|
|
|
937 "Return the word for spell-checking according to ispell syntax.
|
|
|
938 If optional argument FOLLOWING is non-nil or if `ispell-following-word'
|
|
|
939 is non-nil when called interactively, then the following word
|
|
|
940 \(rather than preceding\) is checked when the cursor is not over a word.
|
|
|
941 Optional second argument contains otherchars that can be included in word
|
|
|
942 many times.
|
|
|
943
|
|
|
944 Word syntax described by `ispell-dictionary-alist' (which see)."
|
|
|
945 (let* ((ispell-casechars (ispell-get-casechars))
|
|
|
946 (ispell-not-casechars (ispell-get-not-casechars))
|
|
|
947 (ispell-otherchars (ispell-get-otherchars))
|
|
|
948 (ispell-many-otherchars-p (ispell-get-many-otherchars-p))
|
|
|
949 (word-regexp (concat ispell-casechars
|
|
|
950 "+\\("
|
|
|
951 ispell-otherchars
|
|
|
952 "?"
|
|
|
953 (if extra-otherchars
|
|
|
954 (concat extra-otherchars "?"))
|
|
|
955 ispell-casechars
|
|
|
956 "+\\)"
|
|
|
957 (if (or ispell-many-otherchars-p
|
|
|
958 extra-otherchars)
|
|
|
959 "*" "?")))
|
|
|
960 did-it-once
|
|
|
961 start end word)
|
|
|
962 ;; find the word
|
|
|
963 (if (not (looking-at ispell-casechars))
|
|
|
964 (if following
|
|
|
965 (re-search-forward ispell-casechars (point-max) t)
|
|
|
966 (re-search-backward ispell-casechars (point-min) t)))
|
|
|
967 ;; move to front of word
|
|
|
968 (re-search-backward ispell-not-casechars (point-min) 'start)
|
|
|
969 (while (and (or (looking-at ispell-otherchars)
|
|
|
970 (and extra-otherchars (looking-at extra-otherchars)))
|
|
|
971 (not (bobp))
|
|
|
972 (or (not did-it-once)
|
|
|
973 ispell-many-otherchars-p))
|
|
|
974 (if (and extra-otherchars (looking-at extra-otherchars))
|
|
|
975 (progn
|
|
|
976 (backward-char 1)
|
|
|
977 (if (looking-at ispell-casechars)
|
|
|
978 (re-search-backward ispell-not-casechars (point-min) 'move)))
|
|
|
979 (setq did-it-once t)
|
|
|
980 (backward-char 1)
|
|
|
981 (if (looking-at ispell-casechars)
|
|
|
982 (re-search-backward ispell-not-casechars (point-min) 'move)
|
|
|
983 (backward-char -1))))
|
|
|
984 ;; Now mark the word and save to string.
|
|
|
985 (or (re-search-forward word-regexp (point-max) t)
|
|
|
986 (error "No word found to check!"))
|
|
|
987 (setq start (match-beginning 0)
|
|
|
988 end (point)
|
|
|
989 word (buffer-substring start end))
|
|
|
990 (list word start end)))
|
|
|
991
|
|
|
992
|
|
|
993 ;;; Global ispell-pdict-modified-p is set by ispell-command-loop and
|
|
|
994 ;;; tracks changes in the dictionary. The global may either be
|
|
|
995 ;;; a value or a list, whose value is the state of whether the
|
|
|
996 ;;; dictionary needs to be saved.
|
|
|
997
|
|
|
998 (defun ispell-pdict-save (&optional no-query force-save)
|
|
|
999 "Check to see if the personal dictionary has been modified.
|
|
|
1000 If so, ask if it needs to be saved."
|
|
|
1001 (interactive (list ispell-silently-savep t))
|
|
|
1002 (if (and ispell-pdict-modified-p (listp ispell-pdict-modified-p))
|
|
|
1003 (setq ispell-pdict-modified-p (car ispell-pdict-modified-p)))
|
|
|
1004 (if (or ispell-pdict-modified-p force-save)
|
|
|
1005 (if (or no-query (y-or-n-p "Personal dictionary modified. Save? "))
|
|
|
1006 (progn
|
|
|
1007 (process-send-string ispell-process "#\n")
|
|
|
1008 (message "Personal dictionary saved."))))
|
|
|
1009 ;; unassert variable, even if not saved to avoid questioning.
|
|
|
1010 (setq ispell-pdict-modified-p nil))
|
|
|
1011
|
|
|
1012
|
|
|
1013 (defun ispell-command-loop (miss guess word start end)
|
|
|
1014 "Display possible corrections from list MISS.
|
|
|
1015 GUESS lists possibly valid affix construction of WORD.
|
|
|
1016 Returns nil to keep word.
|
|
|
1017 Returns 0 to insert locally into buffer-local dictionary.
|
|
|
1018 Returns string for new chosen word.
|
|
|
1019 Returns list for new replacement word (will be rechecked).
|
|
|
1020 Highlights the word, which is assumed to run from START to END.
|
|
|
1021 Global `ispell-pdict-modified-p' becomes a list where the only value
|
|
|
1022 indicates whether the dictionary has been modified when option `a' or `i' is
|
|
|
1023 used."
|
|
|
1024 (let ((textbuf (current-buffer))
|
|
|
1025 (count ?0)
|
|
|
1026 (line 2)
|
|
|
1027 (max-lines (- (window-height) 4)) ; assure 4 context lines.
|
|
|
1028 (choices miss)
|
|
|
1029 (window-min-height (min window-min-height
|
|
|
1030 ispell-choices-win-default-height))
|
|
|
1031 (command-characters '( ? ?i ?a ?A ?r ?R ?? ?x ?X ?q ?l ?u ?m ))
|
|
|
1032 (skipped 0)
|
|
|
1033 char num result textwin highlighted)
|
|
|
1034
|
|
|
1035 ;; setup the *Choices* buffer with valid data.
|
|
|
1036 (save-excursion
|
|
|
1037 (set-buffer (get-buffer-create ispell-choices-buffer))
|
|
|
1038 (setq mode-line-format (concat "-- %b -- word: " word))
|
|
|
1039 ;; XEmacs: turn off the modeline
|
|
|
1040 (and (fboundp 'set-specifier)
|
|
|
1041 (set-specifier has-modeline-p (cons (current-buffer) nil)))
|
|
|
1042 (erase-buffer)
|
|
|
1043 (if guess
|
|
|
1044 (progn
|
|
|
1045 (insert "Affix rules generate and capitalize "
|
|
|
1046 "this word as shown below:\n\t")
|
|
|
1047 (while guess
|
|
|
1048 (if (> (+ 4 (current-column) (length (car guess)))
|
|
|
1049 (window-width))
|
|
|
1050 (progn
|
|
|
1051 (insert "\n\t")
|
|
|
1052 (setq line (1+ line))))
|
|
|
1053 (insert (car guess) " ")
|
|
|
1054 (setq guess (cdr guess)))
|
|
|
1055 (insert "\nUse option `i' if this is a correct composition"
|
|
|
1056 " from the derivative root.\n")
|
|
|
1057 (setq line (+ line (if choices 3 2)))))
|
|
|
1058 (while (and choices
|
|
|
1059 (< (if (> (+ 7 (current-column) (length (car choices))
|
|
|
1060 (if (> count ?~) 3 0))
|
|
|
1061 (window-width))
|
|
|
1062 (progn
|
|
|
1063 (insert "\n")
|
|
|
1064 (setq line (1+ line)))
|
|
|
1065 line)
|
|
|
1066 max-lines))
|
|
|
1067 ;; not so good if there are over 20 or 30 options, but then, if
|
|
|
1068 ;; there are that many you don't want to scan them all anyway...
|
|
161
|
1069 (when (integerp count)
|
|
|
1070 (setq count (int-char count)))
|
|
0
|
1071 (while (memq count command-characters) ; skip command characters.
|
|
161
|
1072 (setq count (int-char (1+ count))
|
|
0
|
1073 skipped (1+ skipped)))
|
|
|
1074 (insert "(" count ") " (car choices) " ")
|
|
|
1075 (setq choices (cdr choices)
|
|
|
1076 count (1+ count)))
|
|
161
|
1077 (setq count (int-char (- count ?0 skipped))))
|
|
0
|
1078
|
|
|
1079 ;; Assure word is visible
|
|
|
1080 (if (not (pos-visible-in-window-p end))
|
|
|
1081 (sit-for 0))
|
|
|
1082 ;; Display choices for misspelled word.
|
|
|
1083 (let ((choices-window (get-buffer-window ispell-choices-buffer)))
|
|
|
1084 (if choices-window
|
|
|
1085 (if (= line (window-height choices-window))
|
|
|
1086 (select-window choices-window)
|
|
|
1087 ;; *Choices* window changed size. Adjust the choices window
|
|
|
1088 ;; without scrolling the spelled window when possible
|
|
|
1089 (let ((window-line (- line (window-height choices-window)))
|
|
|
1090 (visible (progn (forward-line -1) (point))))
|
|
|
1091 (if (< line ispell-choices-win-default-height)
|
|
|
1092 (setq window-line (+ window-line
|
|
|
1093 (- ispell-choices-win-default-height
|
|
|
1094 line))))
|
|
|
1095 (move-to-window-line 0)
|
|
|
1096 (forward-line window-line)
|
|
|
1097 (set-window-start (selected-window)
|
|
|
1098 (if (> (point) visible) visible (point)))
|
|
|
1099 (goto-char end)
|
|
|
1100 (select-window (previous-window)) ; *Choices* window
|
|
|
1101 (enlarge-window window-line)))
|
|
|
1102 ;; Overlay *Choices* window when it isn't showing
|
|
|
1103 (ispell-overlay-window (max line ispell-choices-win-default-height)))
|
|
|
1104 (switch-to-buffer ispell-choices-buffer)
|
|
|
1105 (goto-char (point-min)))
|
|
|
1106
|
|
|
1107 (select-window (setq textwin (next-window)))
|
|
|
1108
|
|
|
1109 ;; highlight word, protecting current buffer status
|
|
|
1110 (unwind-protect
|
|
|
1111 (progn
|
|
|
1112 (if ispell-highlight-p
|
|
|
1113 (ispell-highlight-spelling-error start end t))
|
|
|
1114 ;; Loop until a valid choice is made.
|
|
|
1115 (while
|
|
|
1116 (eq
|
|
|
1117 t
|
|
|
1118 (setq
|
|
|
1119 result
|
|
|
1120 (progn
|
|
|
1121 (undo-boundary)
|
|
|
1122 (message (concat "C-h or ? for more options; SPC to leave "
|
|
|
1123 "unchanged, Character to replace word"))
|
|
|
1124 (let ((inhibit-quit t))
|
|
|
1125 (setq char (if (fboundp 'read-char-exclusive)
|
|
|
1126 (read-char-exclusive)
|
|
|
1127 (read-char))
|
|
|
1128 skipped 0)
|
|
161
|
1129 (if (or quit-flag (eq char ?\C-g)) ; C-g is like typing X
|
|
0
|
1130 (setq char ?X
|
|
|
1131 quit-flag nil)))
|
|
|
1132 ;; Adjust num to array offset skipping command characters.
|
|
|
1133 (let ((com-chars command-characters))
|
|
|
1134 (while com-chars
|
|
|
1135 (if (and (> (car com-chars) ?0) (< (car com-chars) char))
|
|
|
1136 (setq skipped (1+ skipped)))
|
|
|
1137 (setq com-chars (cdr com-chars)))
|
|
|
1138 (setq num (- char ?0 skipped)))
|
|
|
1139
|
|
|
1140 (cond
|
|
161
|
1141 ((eq char ? ) nil) ; accept word this time only
|
|
|
1142 ((eq char ?i) ; accept and insert word into pers dict
|
|
0
|
1143 (process-send-string ispell-process (concat "*" word "\n"))
|
|
|
1144 (setq ispell-pdict-modified-p '(t)) ; dictionary modified!
|
|
|
1145 nil)
|
|
161
|
1146 ((or (eq char ?a) (eq char ?A)) ; accept word without insert
|
|
0
|
1147 (process-send-string ispell-process (concat "@" word "\n"))
|
|
|
1148 (if (null ispell-pdict-modified-p)
|
|
|
1149 (setq ispell-pdict-modified-p
|
|
|
1150 (list ispell-pdict-modified-p)))
|
|
161
|
1151 (if (eq char ?A) 0)) ; return 0 for ispell-add buffer-local
|
|
|
1152 ((or (eq char ?r) (eq char ?R)) ; type in replacement
|
|
|
1153 (if (or (eq char ?R) ispell-query-replace-choices)
|
|
0
|
1154 (list (read-string "Query-replacement for: " word) t)
|
|
|
1155 (cons (read-string "Replacement for: " word) nil)))
|
|
161
|
1156 ((or (eq char ??)
|
|
0
|
1157 ;; XEmacs change: help-char may not be an int.
|
|
|
1158 (eq char (event-to-character
|
|
|
1159 (character-to-event help-char)))
|
|
161
|
1160 (eq char ?\C-h))
|
|
0
|
1161 (ispell-help)
|
|
|
1162 t)
|
|
|
1163 ;; Quit and move point back.
|
|
161
|
1164 ((eq char ?x)
|
|
0
|
1165 (ispell-pdict-save ispell-silently-savep)
|
|
|
1166 (message "Exited spell-checking")
|
|
|
1167 (setq ispell-quit t)
|
|
|
1168 nil)
|
|
|
1169 ;; Quit and preserve point.
|
|
161
|
1170 ((eq char ?X)
|
|
0
|
1171 (ispell-pdict-save ispell-silently-savep)
|
|
2
|
1172 (message "%s"
|
|
0
|
1173 (substitute-command-keys
|
|
|
1174 (concat "Spell-checking suspended;"
|
|
|
1175 " use C-u \\[ispell-word] to resume")))
|
|
|
1176 (setq ispell-quit (max (point-min)
|
|
|
1177 (- (point) (length word))))
|
|
|
1178 nil)
|
|
161
|
1179 ((eq char ?q)
|
|
0
|
1180 (if (y-or-n-p "Really kill Ispell process? ")
|
|
|
1181 (progn
|
|
|
1182 (ispell-kill-ispell t) ; terminate process.
|
|
|
1183 (setq ispell-quit (or (not ispell-checking-message)
|
|
|
1184 (point))
|
|
|
1185 ispell-pdict-modified-p nil))
|
|
|
1186 t)) ; continue if they don't quit.
|
|
161
|
1187 ((eq char ?l)
|
|
0
|
1188 (let ((new-word (read-string
|
|
|
1189 "Lookup string (`*' is wildcard): "
|
|
|
1190 word))
|
|
|
1191 (new-line 2))
|
|
|
1192 (if new-word
|
|
|
1193 (progn
|
|
|
1194 (save-excursion
|
|
|
1195 (set-buffer (get-buffer-create
|
|
|
1196 ispell-choices-buffer))
|
|
|
1197 (erase-buffer)
|
|
|
1198 (setq count ?0
|
|
|
1199 skipped 0
|
|
|
1200 mode-line-format (concat
|
|
|
1201 "-- %b -- word: "
|
|
|
1202 new-word)
|
|
|
1203 miss (lookup-words new-word)
|
|
|
1204 choices miss)
|
|
|
1205 (while (and choices ; adjust choices window.
|
|
|
1206 (< (if (> (+ 7 (current-column)
|
|
|
1207 (length (car choices))
|
|
|
1208 (if (> count ?~) 3 0))
|
|
|
1209 (window-width))
|
|
|
1210 (progn
|
|
|
1211 (insert "\n")
|
|
|
1212 (setq new-line
|
|
|
1213 (1+ new-line)))
|
|
|
1214 new-line)
|
|
|
1215 max-lines))
|
|
|
1216 (while (memq count command-characters)
|
|
161
|
1217 (setq count (int-char (1+ count))
|
|
0
|
1218 skipped (1+ skipped)))
|
|
|
1219 (insert "(" count ") " (car choices) " ")
|
|
|
1220 (setq choices (cdr choices)
|
|
|
1221 count (1+ count)))
|
|
|
1222 (setq count (- count ?0 skipped)))
|
|
|
1223 (select-window (previous-window))
|
|
|
1224 (if (and (/= new-line line)
|
|
|
1225 (> (max line new-line)
|
|
|
1226 ispell-choices-win-default-height))
|
|
|
1227 (let* ((minh ispell-choices-win-default-height)
|
|
|
1228 (gr-bl (if (< line minh) ; blanks
|
|
|
1229 (- minh line)
|
|
|
1230 0))
|
|
|
1231 (shr-bl (if (< new-line minh) ; blanks
|
|
|
1232 (- minh new-line)
|
|
|
1233 0)))
|
|
|
1234 (if (> new-line line)
|
|
|
1235 (enlarge-window (- new-line line gr-bl))
|
|
|
1236 (shrink-window (- line new-line shr-bl)))
|
|
|
1237 (setq line new-line)))
|
|
|
1238 (select-window (next-window)))))
|
|
|
1239 t) ; reselect from new choices
|
|
161
|
1240 ((eq char ?u)
|
|
0
|
1241 (process-send-string ispell-process
|
|
|
1242 (concat "*" (downcase word) "\n"))
|
|
|
1243 (setq ispell-pdict-modified-p '(t)) ; dictionary modified!
|
|
|
1244 nil)
|
|
161
|
1245 ((eq char ?m) ; type in what to insert
|
|
0
|
1246 (process-send-string
|
|
|
1247 ispell-process (concat "*" (read-string "Insert: " word)
|
|
|
1248 "\n"))
|
|
|
1249 (setq ispell-pdict-modified-p '(t))
|
|
|
1250 (cons word nil))
|
|
|
1251 ((and (>= num 0) (< num count))
|
|
|
1252 (if ispell-query-replace-choices ; Query replace flag
|
|
|
1253 (list (nth num miss) 'query-replace)
|
|
|
1254 (nth num miss)))
|
|
161
|
1255 ((eq char ?\C-l)
|
|
0
|
1256 (redraw-display) t)
|
|
161
|
1257 ((eq char ?\C-r)
|
|
0
|
1258 (save-window-excursion (recursive-edit)) t)
|
|
161
|
1259 ((eq char ?\C-z)
|
|
0
|
1260 (funcall (key-binding "\C-z"))
|
|
|
1261 t)
|
|
|
1262 (t (ding) t))))))
|
|
|
1263 result)
|
|
|
1264 ;; protected
|
|
|
1265 (if ispell-highlight-p ; unhighlight
|
|
|
1266 (save-window-excursion
|
|
|
1267 (select-window textwin)
|
|
|
1268 (ispell-highlight-spelling-error start end))))))
|
|
|
1269
|
|
|
1270
|
|
|
1271 ;;;###autoload
|
|
|
1272 (defun ispell-help ()
|
|
|
1273 "Display a list of the options available when a misspelling is encountered.
|
|
|
1274
|
|
|
1275 Selections are:
|
|
|
1276
|
|
|
1277 DIGIT: Replace the word with a digit offered in the *Choices* buffer.
|
|
|
1278 SPC: Accept word this time.
|
|
|
1279 `i': Accept word and insert into private dictionary.
|
|
|
1280 `a': Accept word for this session.
|
|
|
1281 `A': Accept word and place in `buffer-local dictionary'.
|
|
|
1282 `r': Replace word with typed-in value. Rechecked.
|
|
|
1283 `R': Replace word with typed-in value. Query-replaced in buffer. Rechecked.
|
|
|
1284 `?': Show these commands.
|
|
|
1285 `x': Exit spelling buffer. Move cursor to original point.
|
|
|
1286 `X': Exit spelling buffer. Leaves cursor at the current point, and permits
|
|
|
1287 the aborted check to be completed later.
|
|
|
1288 `q': Quit spelling session (Kills ispell process).
|
|
|
1289 `l': Look up typed-in replacement in alternate dictionary. Wildcards okay.
|
|
|
1290 `u': Like `i', but the word is lower-cased first.
|
|
|
1291 `m': Like `i', but allows one to include dictionary completion information.
|
|
|
1292 `C-l': redraws screen
|
|
|
1293 `C-r': recursive edit
|
|
|
1294 `C-z': suspend emacs or iconify frame"
|
|
|
1295
|
|
|
1296 (let ((help-1 (concat "[r/R]eplace word; [a/A]ccept for this session; "
|
|
|
1297 "[i]nsert into private dictionary"))
|
|
|
1298 (help-2 (concat "[l]ook a word up in alternate dictionary; "
|
|
|
1299 "e[x/X]it; [q]uit session"))
|
|
|
1300 (help-3 (concat "[u]ncapitalized insert into dictionary. "
|
|
|
1301 "Type 'C-h d ispell-help' for more help")))
|
|
|
1302 (save-window-excursion
|
|
|
1303 (if ispell-help-in-bufferp
|
|
|
1304 (progn
|
|
|
1305 (ispell-overlay-window 4)
|
|
|
1306 (switch-to-buffer (get-buffer-create "*Ispell Help*"))
|
|
|
1307 (insert (concat help-1 "\n" help-2 "\n" help-3))
|
|
|
1308 (sit-for 5)
|
|
|
1309 (kill-buffer "*Ispell Help*"))
|
|
|
1310 (select-window (minibuffer-window))
|
|
|
1311 ;;(enlarge-window 2)
|
|
|
1312 (erase-buffer)
|
|
|
1313 (cond ((and (< emacs-minor-version 12)
|
|
|
1314 (string-match "Lucid" emacs-version))
|
|
|
1315 (message help-3)
|
|
|
1316 (enlarge-window 1)
|
|
|
1317 (message help-2)
|
|
|
1318 (enlarge-window 1)
|
|
|
1319 (message help-1)
|
|
|
1320 (goto-char (point-min)))
|
|
|
1321 (t
|
|
|
1322 (if (string-lessp "19" emacs-version)
|
|
|
1323 (message nil))
|
|
|
1324 (enlarge-window 2)
|
|
2
|
1325 ;; Make sure we display the minibuffer
|
|
|
1326 ;; in this window, not some other.
|
|
100
|
1327 (if (fboundp 'set-minibuffer-window)
|
|
|
1328 (set-minibuffer-window (selected-window)))
|
|
0
|
1329 (insert (concat help-1 "\n" help-2 "\n" help-3))))
|
|
|
1330 (sit-for 5)
|
|
|
1331 (erase-buffer)))))
|
|
|
1332
|
|
|
1333
|
|
|
1334 (defun lookup-words (word &optional lookup-dict)
|
|
|
1335 "Look up word in word-list dictionary.
|
|
|
1336 A `*' serves as a wild card. If no wild cards, `look' is used if it exists.
|
|
|
1337 Otherwise the variable `ispell-grep-command' contains the command used to
|
|
|
1338 search for the words (usually egrep).
|
|
|
1339
|
|
|
1340 Optional second argument contains the dictionary to use; the default is
|
|
|
1341 `ispell-alternate-dictionary'."
|
|
|
1342 ;; We don't use the filter for this function, rather the result is written
|
|
|
1343 ;; into a buffer. Hence there is no need to save the filter values.
|
|
|
1344 (if (null lookup-dict)
|
|
|
1345 (setq lookup-dict ispell-alternate-dictionary))
|
|
|
1346
|
|
|
1347 (let* ((process-connection-type ispell-use-ptys-p)
|
|
|
1348 (wild-p (string-match "\\*" word))
|
|
|
1349 (look-p (and ispell-look-p ; Only use look for an exact match.
|
|
|
1350 (or ispell-have-new-look (not wild-p))))
|
|
|
1351 (ispell-grep-buffer (get-buffer-create "*Ispell-Temp*")) ; result buf
|
|
|
1352 (prog (if look-p ispell-look-command ispell-grep-command))
|
|
|
1353 (args (if look-p ispell-look-options ispell-grep-options))
|
|
|
1354 status results loc)
|
|
|
1355 (unwind-protect
|
|
|
1356 (save-window-excursion
|
|
|
1357 (message "Starting \"%s\" process..." (file-name-nondirectory prog))
|
|
|
1358 (set-buffer ispell-grep-buffer)
|
|
|
1359 (if look-p
|
|
|
1360 nil
|
|
|
1361 ;; convert * to .*
|
|
|
1362 (insert "^" word "$")
|
|
|
1363 (while (search-backward "*" nil t) (insert "."))
|
|
|
1364 (setq word (buffer-string))
|
|
|
1365 (erase-buffer))
|
|
|
1366 (setq status (call-process prog nil t nil args word lookup-dict))
|
|
|
1367 ;; grep returns status 1 and no output when word not found, which
|
|
|
1368 ;; is a perfectly normal thing.
|
|
|
1369 (if (stringp status)
|
|
|
1370 (setq results (cons (format "error: %s exited with signal %s"
|
|
|
1371 (file-name-nondirectory prog) status)
|
|
|
1372 results))
|
|
|
1373 ;; else collect words into `results' in FIFO order
|
|
|
1374 (goto-char (point-max))
|
|
|
1375 ;; assure we've ended with \n
|
|
|
1376 (or (bobp) (= (preceding-char) ?\n) (insert ?\n))
|
|
|
1377 (while (not (bobp))
|
|
|
1378 (setq loc (point))
|
|
|
1379 (forward-line -1)
|
|
|
1380 (setq results (cons (buffer-substring (point) (1- loc))
|
|
|
1381 results)))))
|
|
|
1382 ;; protected
|
|
|
1383 (kill-buffer ispell-grep-buffer)
|
|
|
1384 (if (and results (string-match ".+: " (car results)))
|
|
|
1385 (error "%s error: %s" ispell-grep-command (car results))))
|
|
|
1386 results))
|
|
|
1387
|
|
|
1388
|
|
|
1389 ;;; "ispell-filter" is a list of output lines from the generating function.
|
|
|
1390 ;;; Each full line (ending with \n) is a separate item on the list.
|
|
|
1391 ;;; "output" can contain multiple lines, part of a line, or both.
|
|
|
1392 ;;; "start" and "end" are used to keep bounds on lines when "output" contains
|
|
|
1393 ;;; multiple lines.
|
|
|
1394 ;;; "ispell-filter-continue" is true when we have received only part of a
|
|
|
1395 ;;; line as output from a generating function ("output" did not end with \n)
|
|
2
|
1396 ;;; THIS FUNCTION WILL FAIL IF THE PROCESS OUTPUT DOESN'T END WITH \n!
|
|
0
|
1397 ;;; This is the case when a process dies or fails. The default behavior
|
|
|
1398 ;;; in this case treats the next input received as fresh input.
|
|
|
1399
|
|
|
1400 (defun ispell-filter (process output)
|
|
|
1401 "Output filter function for ispell, grep, and look."
|
|
|
1402 (let ((start 0)
|
|
|
1403 (continue t)
|
|
|
1404 end)
|
|
|
1405 (while continue
|
|
|
1406 (setq end (string-match "\n" output start)) ; get text up to the newline.
|
|
|
1407 ;; If we get out of sync and ispell-filter-continue is asserted when we
|
|
|
1408 ;; are not continuing, treat the next item as a separate list. When
|
|
|
1409 ;; ispell-filter-continue is asserted, ispell-filter *should* always be a
|
|
|
1410 ;; list!
|
|
|
1411
|
|
|
1412 ;; Continue with same line (item)?
|
|
|
1413 (if (and ispell-filter-continue ispell-filter (listp ispell-filter))
|
|
|
1414 ;; Yes. Add it to the prev item
|
|
|
1415 (setcar ispell-filter
|
|
|
1416 (concat (car ispell-filter) (substring output start end)))
|
|
|
1417 ;; No. This is a new line and item.
|
|
|
1418 (setq ispell-filter
|
|
|
1419 (cons (substring output start end) ispell-filter)))
|
|
|
1420 (if (null end)
|
|
|
1421 ;; We've completed reading the output, but didn't finish the line.
|
|
|
1422 (setq ispell-filter-continue t continue nil)
|
|
|
1423 ;; skip over newline, this line complete.
|
|
|
1424 (setq ispell-filter-continue nil end (1+ end))
|
|
|
1425 (if (= end (length output)) ; No more lines in output
|
|
|
1426 (setq continue nil) ; so we can exit the filter.
|
|
|
1427 (setq start end)))))) ; else move start to next line of input
|
|
|
1428
|
|
|
1429
|
|
|
1430 ;;; This function destroys the mark location if it is in the word being
|
|
|
1431 ;;; highlighted.
|
|
|
1432 (defun ispell-highlight-spelling-error-generic (start end &optional highlight)
|
|
|
1433 "Highlight the word from START to END with a kludge using `inverse-video'.
|
|
|
1434 When the optional third arg HIGHLIGHT is set, the word is highlighted;
|
|
|
1435 otherwise it is displayed normally."
|
|
|
1436 (let ((modified (buffer-modified-p)) ; don't allow this fn to modify buffer
|
|
|
1437 (buffer-read-only nil) ; Allow highlighting read-only buffers.
|
|
|
1438 (text (buffer-substring start end)) ; Save highlight region
|
|
|
1439 (inhibit-quit t) ; inhibit interrupt processing here.
|
|
|
1440 (buffer-undo-list t)) ; don't clutter the undo list.
|
|
|
1441 (delete-region start end)
|
|
|
1442 (insert-char ? (- end start)) ; mimimize amount of redisplay
|
|
|
1443 (sit-for 0) ; update display
|
|
|
1444 (if highlight (setq inverse-video (not inverse-video))) ; toggle video
|
|
|
1445 (delete-region start end) ; delete whitespace
|
|
|
1446 (insert text) ; insert text in inverse video.
|
|
|
1447 (sit-for 0) ; update display showing inverse video.
|
|
|
1448 (if highlight (setq inverse-video (not inverse-video))) ; toggle video
|
|
|
1449 (set-buffer-modified-p modified))) ; don't modify if flag not set.
|
|
|
1450
|
|
|
1451
|
|
|
1452 (defun ispell-highlight-spelling-error-lucid (start end &optional highlight)
|
|
|
1453 "Highlight the word from START to END using `isearch-highlight'.
|
|
|
1454 When the optional third arg HIGHLIGHT is set, the word is highlighted,
|
|
|
1455 otherwise it is displayed normally."
|
|
|
1456 (if highlight
|
|
|
1457 (isearch-highlight start end)
|
|
|
1458 (isearch-dehighlight t))
|
|
|
1459 ;;(sit-for 0)
|
|
|
1460 )
|
|
|
1461
|
|
|
1462
|
|
|
1463 (defun ispell-highlight-spelling-error-overlay (start end &optional highlight)
|
|
|
1464 "Highlight the word from START to END using overlays.
|
|
|
1465 When the optional third arg HIGHLIGHT is set, the word is highlighted
|
|
|
1466 otherwise it is displayed normally.
|
|
|
1467
|
|
|
1468 The variable `ispell-highlight-face' selects the face to use for highlighting."
|
|
|
1469 (if highlight
|
|
|
1470 (progn
|
|
|
1471 (setq ispell-overlay (make-overlay start end))
|
|
|
1472 (overlay-put ispell-overlay 'face ispell-highlight-face))
|
|
|
1473 (delete-overlay ispell-overlay)))
|
|
|
1474
|
|
|
1475
|
|
|
1476 (defun ispell-highlight-spelling-error (start end &optional highlight)
|
|
|
1477 (cond
|
|
|
1478 ((string-match "Lucid" emacs-version)
|
|
|
1479 (ispell-highlight-spelling-error-lucid start end highlight))
|
|
|
1480 ((and (string-lessp "19" emacs-version)
|
|
|
1481 (featurep 'faces) window-system)
|
|
|
1482 (ispell-highlight-spelling-error-overlay start end highlight))
|
|
|
1483 (t (ispell-highlight-spelling-error-generic start end highlight))))
|
|
|
1484
|
|
|
1485
|
|
|
1486 (defun ispell-overlay-window (height)
|
|
|
1487 "Create a window covering the top HEIGHT lines of the current window.
|
|
|
1488 Ensure that the line above point is still visible but otherwise avoid
|
|
|
1489 scrolling the current window. Leave the new window selected."
|
|
|
1490 (save-excursion
|
|
|
1491 (let ((oldot (save-excursion (forward-line -1) (point)))
|
|
|
1492 (top (save-excursion (move-to-window-line height) (point))))
|
|
|
1493 ;; If line above old point (line starting at olddot) would be
|
|
|
1494 ;; hidden by new window, scroll it to just below new win
|
|
|
1495 ;; otherwise set top line of other win so it doesn't scroll.
|
|
|
1496 (if (< oldot top) (setq top oldot))
|
|
|
1497 ;; NB: Lemacs 19.9 bug: If a window of size N (N includes the mode
|
|
|
1498 ;; line) is demanded, the last line is not visible.
|
|
|
1499 ;; At least this happens on AIX 3.2, lemacs w/ Motif, font 9x15.
|
|
|
1500 ;; So we increment the height for this case.
|
|
|
1501 (if (string-match "19\.9.*Lucid" (emacs-version))
|
|
|
1502 (setq height (1+ height)))
|
|
|
1503 (split-window nil height)
|
|
|
1504 (set-window-start (next-window) top))))
|
|
|
1505
|
|
|
1506
|
|
|
1507 ;;; Should we add a compound word match return value?
|
|
|
1508 (defun ispell-parse-output (output)
|
|
|
1509 "Parse the OUTPUT string from Ispell and return:
|
|
|
1510 1: t for an exact match.
|
|
|
1511 2: A string containing the root word for a match via suffix removal.
|
|
|
1512 3: A list of possible correct spellings of the format:
|
|
|
1513 '(\"ORIGINAL-WORD\" OFFSET MISS-LIST GUESS-LIST)
|
|
|
1514 ORIGINAL-WORD is a string of the possibly misspelled word.
|
|
|
1515 OFFSET is an integer giving the line offset of the word.
|
|
|
1516 MISS-LIST and GUESS-LIST are possibly null lists of guesses and misses."
|
|
|
1517 (cond
|
|
|
1518 ((string= output "") t) ; for startup with pipes...
|
|
|
1519 ((string= output "*") t) ; exact match
|
|
|
1520 ((string= output "-") t) ; compound word match
|
|
|
1521 ((string= (substring output 0 1) "+") ; found cuz of root word
|
|
|
1522 (substring output 2)) ; return root word
|
|
|
1523 (t ; need to process &, ?, and #'s
|
|
|
1524 (let ((type (substring output 0 1)) ; &, ?, or #
|
|
|
1525 (original-word (substring output 2 (string-match " " output 2)))
|
|
|
1526 (cur-count 0) ; contains number of misses + guesses
|
|
|
1527 count miss-list guess-list offset)
|
|
|
1528 (setq output (substring output (match-end 0))) ; skip over misspelling
|
|
|
1529 (if (string= type "#")
|
|
|
1530 (setq count 0) ; no misses for type #
|
|
|
1531 (setq count (string-to-int output) ; get number of misses.
|
|
|
1532 output (substring output (1+ (string-match " " output 1)))))
|
|
|
1533 (setq offset (string-to-int output))
|
|
|
1534 (if (string= type "#") ; No miss or guess list.
|
|
|
1535 (setq output nil)
|
|
|
1536 (setq output (substring output (1+ (string-match " " output 1)))))
|
|
|
1537 (while output
|
|
|
1538 (let ((end (string-match ", \\|\\($\\)" output))) ; end of miss/guess.
|
|
|
1539 (setq cur-count (1+ cur-count))
|
|
|
1540 (if (> cur-count count)
|
|
|
1541 (setq guess-list (cons (substring output 0 end) guess-list))
|
|
|
1542 (setq miss-list (cons (substring output 0 end) miss-list)))
|
|
|
1543 (if (match-end 1) ; True only when at end of line.
|
|
|
1544 (setq output nil) ; no more misses or guesses
|
|
|
1545 (setq output (substring output (+ end 2))))))
|
|
|
1546 (list original-word offset miss-list guess-list)))))
|
|
|
1547
|
|
|
1548
|
|
|
1549 (defun check-ispell-version ()
|
|
|
1550 ;; This is a little wasteful as we actually launch ispell twice: once
|
|
|
1551 ;; to make sure it's the right version, and once for real. But people
|
|
|
1552 ;; get confused by version mismatches *all* the time (and I've got the
|
|
|
1553 ;; email to prove it) so I think this is worthwhile. And the -v[ersion]
|
|
|
1554 ;; option is the only way I can think of to do this that works with
|
|
|
1555 ;; all versions, since versions earlier than 3.0.09 didn't identify
|
|
|
1556 ;; themselves on startup.
|
|
|
1557 (save-excursion
|
|
|
1558 (let ((case-fold-search t)
|
|
|
1559 ;; avoid bugs when syntax of `.' changes in various default modes
|
|
|
1560 (default-major-mode 'fundamental-mode)
|
|
|
1561 status)
|
|
|
1562 (set-buffer (get-buffer-create " *ispell-tmp*"))
|
|
|
1563 (erase-buffer)
|
|
|
1564 (setq status (call-process ispell-program-name nil t nil "-v"))
|
|
|
1565 (goto-char (point-min))
|
|
|
1566 (if (not (memq status '(0 nil)))
|
|
|
1567 (error "%s exited with %s %s" ispell-program-name
|
|
|
1568 (if (stringp status) "signal" "code") status))
|
|
|
1569 (if (not (re-search-forward
|
|
|
1570 (concat "\\b\\("
|
|
|
1571 (regexp-quote (car ispell-required-version))
|
|
|
1572 "\\)\\([0-9]*\\)\\b")
|
|
|
1573 nil t))
|
|
|
1574 (error
|
|
|
1575 "%s version %s* is required: try renaming ispell4.el to ispell.el"
|
|
|
1576 ispell-program-name (car ispell-required-version))
|
|
|
1577 ;; check that it is the correct version.
|
|
|
1578 (if (< (car (read-from-string (buffer-substring
|
|
|
1579 (match-beginning 2) (match-end 2))))
|
|
|
1580 (car (cdr ispell-required-version)))
|
|
|
1581 (setq ispell-offset 0)))
|
|
|
1582 (kill-buffer (current-buffer)))))
|
|
|
1583
|
|
|
1584
|
|
|
1585 (defun ispell-init-process ()
|
|
|
1586 "Check status of Ispell process and start if necessary."
|
|
|
1587 (if (and ispell-process
|
|
|
1588 (eq (process-status ispell-process) 'run)
|
|
|
1589 ;; If we're using a personal dictionary, assure
|
|
|
1590 ;; we're in the same default directory!
|
|
|
1591 (or (not ispell-personal-dictionary)
|
|
|
1592 (equal ispell-process-directory default-directory)))
|
|
|
1593 (setq ispell-filter nil ispell-filter-continue nil)
|
|
|
1594 ;; may need to restart to select new personal dictionary.
|
|
|
1595 (ispell-kill-ispell t)
|
|
|
1596 (message "Starting new Ispell process...")
|
|
|
1597 (sit-for 0)
|
|
|
1598 (check-ispell-version)
|
|
|
1599 (setq ispell-process
|
|
|
1600 (let ((process-connection-type ispell-use-ptys-p))
|
|
|
1601 (apply 'start-process
|
|
|
1602 "ispell" nil ispell-program-name
|
|
|
1603 "-a" ; accept single input lines
|
|
|
1604 "-m" ; make root/affix combos not in dict
|
|
|
1605 (let (args)
|
|
|
1606 ;; Local dictionary becomes the global dictionary in use.
|
|
|
1607 (if ispell-local-dictionary
|
|
|
1608 (setq ispell-dictionary ispell-local-dictionary))
|
|
|
1609 (setq args (ispell-get-ispell-args))
|
|
|
1610 (if ispell-dictionary ; use specified dictionary
|
|
|
1611 (setq args
|
|
|
1612 (append (list "-d" ispell-dictionary) args)))
|
|
|
1613 (if ispell-personal-dictionary ; use specified pers dict
|
|
|
1614 (setq args
|
|
|
1615 (append args
|
|
|
1616 (list "-p"
|
|
|
1617 (expand-file-name
|
|
|
1618 ispell-personal-dictionary)))))
|
|
|
1619 (setq args (append args ispell-extra-args))
|
|
|
1620 args)))
|
|
|
1621 ispell-filter nil
|
|
|
1622 ispell-filter-continue nil
|
|
|
1623 ispell-process-directory default-directory)
|
|
|
1624 (set-process-filter ispell-process 'ispell-filter)
|
|
|
1625 (accept-process-output ispell-process) ; Get version ID line
|
|
|
1626 (cond ((null ispell-filter)
|
|
|
1627 (error "%s did not output version line" ispell-program-name))
|
|
|
1628 ((and
|
|
|
1629 (stringp (car ispell-filter))
|
|
|
1630 (if (string-match "warning: " (car ispell-filter))
|
|
|
1631 (progn
|
|
|
1632 (accept-process-output ispell-process 5) ; 1st was warn msg.
|
|
|
1633 (stringp (car ispell-filter)))
|
|
|
1634 (null (cdr ispell-filter)))
|
|
|
1635 (string-match "^@(#) " (car ispell-filter)))
|
|
|
1636 ;; got the version line as expected (we already know it's the right
|
|
|
1637 ;; version, so don't bother checking again.)
|
|
|
1638 nil)
|
|
|
1639 (t
|
|
|
1640 ;; Otherwise, it must be an error message. Show the user.
|
|
|
1641 ;; But first wait to see if some more output is going to arrive.
|
|
|
1642 ;; Otherwise we get cool errors like "Can't open ".
|
|
|
1643 (sleep-for 1)
|
|
|
1644 (accept-process-output)
|
|
|
1645 (error "%s" (mapconcat 'identity ispell-filter "\n"))))
|
|
|
1646 (setq ispell-filter nil) ; Discard version ID line
|
|
|
1647 (let ((extended-char-mode (ispell-get-extended-character-mode)))
|
|
|
1648 (if extended-char-mode
|
|
|
1649 (process-send-string ispell-process
|
|
|
1650 (concat extended-char-mode "\n"))))
|
|
|
1651 (process-kill-without-query ispell-process)))
|
|
|
1652
|
|
|
1653 ;;;###autoload
|
|
|
1654 (defun ispell-kill-ispell (&optional no-error)
|
|
|
1655 "Kill current Ispell process (so that you may start a fresh one).
|
|
|
1656 With NO-ERROR, just return non-nil if there was no Ispell running."
|
|
|
1657 (interactive)
|
|
|
1658 (if (not (and ispell-process
|
|
|
1659 (eq (process-status ispell-process) 'run)))
|
|
|
1660 (or no-error
|
|
|
1661 (error "There is no ispell process running!"))
|
|
|
1662 (kill-process ispell-process)
|
|
|
1663 (setq ispell-process nil)
|
|
|
1664 (message "Ispell process killed")
|
|
|
1665 nil))
|
|
|
1666
|
|
|
1667
|
|
|
1668 ;;; ispell-change-dictionary is set in some people's hooks. Maybe this should
|
|
|
1669 ;;; call ispell-init-process rather than wait for a spell checking command?
|
|
|
1670
|
|
|
1671 ;;;###autoload
|
|
|
1672 (defun ispell-change-dictionary (dict &optional arg)
|
|
|
1673 "Change `ispell-dictionary' (q.v.) and kill old Ispell process.
|
|
|
1674 A new one will be started as soon as necessary.
|
|
|
1675
|
|
|
1676 By just answering RET you can find out what the current dictionary is.
|
|
|
1677
|
|
|
1678 With prefix argument, set the default directory."
|
|
|
1679 (interactive
|
|
|
1680 (list (completing-read
|
|
|
1681 "Use new dictionary (RET for current, SPC to complete): "
|
|
|
1682 (cons (cons "default" nil) ispell-dictionary-alist) nil t)
|
|
|
1683 current-prefix-arg))
|
|
|
1684 (if (equal dict "default") (setq dict nil))
|
|
|
1685 ;; This relies on completing-read's bug of returning "" for no match
|
|
|
1686 (cond ((equal dict "")
|
|
|
1687 (message "Using %s dictionary"
|
|
|
1688 (or ispell-local-dictionary ispell-dictionary "default")))
|
|
|
1689 ((and (equal dict ispell-dictionary)
|
|
|
1690 (or (null ispell-local-dictionary)
|
|
|
1691 (equal dict ispell-local-dictionary)))
|
|
|
1692 ;; Specified dictionary is the default already. No-op
|
|
|
1693 (and (interactive-p)
|
|
|
1694 (message "No change, using %s dictionary" (or dict "default"))))
|
|
|
1695 (t ; reset dictionary!
|
|
|
1696 (if (assoc dict ispell-dictionary-alist)
|
|
|
1697 (progn
|
|
|
1698 (if (or arg (null dict)) ; set default dictionary
|
|
|
1699 (setq ispell-dictionary dict))
|
|
|
1700 (if (null arg) ; set local dictionary
|
|
|
1701 (setq ispell-local-dictionary dict)))
|
|
|
1702 (error "Illegal dictionary: %s" dict))
|
|
|
1703 (ispell-kill-ispell t)
|
|
|
1704 (message "(Next %sIspell command will use %s dictionary)"
|
|
|
1705 (cond ((equal ispell-local-dictionary ispell-dictionary)
|
|
|
1706 "")
|
|
|
1707 (arg "global ")
|
|
|
1708 (t "local "))
|
|
|
1709 (or (if (or (equal ispell-local-dictionary ispell-dictionary)
|
|
|
1710 (null arg))
|
|
|
1711 ispell-local-dictionary
|
|
|
1712 ispell-dictionary)
|
|
|
1713 "default")))))
|
|
|
1714
|
|
|
1715
|
|
|
1716 ;;; Spelling of comments are checked when ispell-check-comments is non-nil.
|
|
|
1717
|
|
|
1718 ;;;###autoload
|
|
|
1719 (defun ispell-region (reg-start reg-end)
|
|
|
1720 "Interactively check a region for spelling errors."
|
|
|
1721 (interactive "r") ; Don't flag errors on read-only bufs.
|
|
|
1722 (ispell-accept-buffer-local-defs) ; set up dictionary, local words, etc.
|
|
|
1723 (unwind-protect
|
|
|
1724 (save-excursion
|
|
|
1725 (message "Spell checking %s using %s dictionary..."
|
|
|
1726 (if (and (= reg-start (point-min)) (= reg-end (point-max)))
|
|
|
1727 (buffer-name) "region")
|
|
|
1728 (or ispell-dictionary "default"))
|
|
|
1729 ;; Returns cursor to original location.
|
|
|
1730 (save-window-excursion
|
|
|
1731 (goto-char reg-start)
|
|
|
1732 (let ((transient-mark-mode nil)
|
|
|
1733 ref-type)
|
|
|
1734 (while (and (not ispell-quit) (< (point) reg-end))
|
|
|
1735 (let ((start (point))
|
|
|
1736 (offset-change 0)
|
|
|
1737 (end (save-excursion (end-of-line) (min (point) reg-end)))
|
|
|
1738 (ispell-casechars (ispell-get-casechars))
|
|
|
1739 string)
|
|
|
1740 (cond ; LOOK AT THIS LINE AND SKIP OR PROCESS
|
|
|
1741 ((eolp) ; END OF LINE, just go to next line.
|
|
|
1742 (forward-char 1))
|
|
|
1743 ((and (null ispell-check-comments) ; SKIPPING COMMENTS
|
|
|
1744 comment-start ; skip comments that start on the line.
|
|
|
1745 (search-forward comment-start end t)) ; or found here.
|
|
|
1746 (if (= (- (point) start) (length comment-start))
|
|
|
1747 ;; comment starts the line. Skip entire line or region
|
|
|
1748 (if (string= "" comment-end) ; skip to next line
|
|
|
1749 (beginning-of-line 2) ; or jump to comment end.
|
|
|
1750 (search-forward comment-end reg-end 'limit))
|
|
|
1751 ;; Comment later in line. Check spelling before comment.
|
|
|
1752 (let ((limit (- (point) (length comment-start))))
|
|
|
1753 (goto-char (1- limit))
|
|
|
1754 (if (looking-at "\\\\") ; "quoted" comment, don't skip
|
|
|
1755 ;; quoted comment. Skip over comment-start
|
|
|
1756 (if (= start (1- limit))
|
|
|
1757 (setq limit (+ limit (length comment-start)))
|
|
|
1758 (setq limit (1- limit))))
|
|
|
1759 (goto-char start)
|
|
|
1760 ;; Only check when "casechars" or math before comment
|
|
|
1761 (if (or (re-search-forward ispell-casechars limit t)
|
|
|
1762 (re-search-forward "[][()$]" limit t))
|
|
|
1763 (setq string
|
|
|
1764 (concat "^" (buffer-substring start limit)
|
|
|
1765 "\n")
|
|
|
1766 offset-change (- offset-change ispell-offset)))
|
|
|
1767 (goto-char limit))))
|
|
|
1768 ((looking-at "[---#@*+!%~^]") ; SKIP SPECIAL ISPELL CHARACTERS
|
|
|
1769 (forward-char 1))
|
|
|
1770 ((or (and ispell-skip-tib ; SKIP TIB REFERENCES OR SGML MARKUP
|
|
|
1771 (re-search-forward ispell-tib-ref-beginning end t)
|
|
|
1772 (setq ref-type 'tib))
|
|
|
1773 (and ispell-skip-sgml
|
|
2
|
1774 (re-search-forward "[<&]" end t)
|
|
0
|
1775 (setq ref-type 'sgml)))
|
|
|
1776 (if (or (and (eq 'tib ref-type) ; tib tag is 2 chars.
|
|
|
1777 (= (- (point) 2) start))
|
|
|
1778 (and (eq 'sgml ref-type) ; sgml skips 1 char.
|
|
|
1779 (= (- (point) 1) start)))
|
|
|
1780 ;; Skip to end of reference, not necessarily on this line
|
|
|
1781 ;; Return an error if tib/sgml reference not found
|
|
|
1782 (if (or
|
|
|
1783 (and
|
|
|
1784 (eq 'tib ref-type)
|
|
|
1785 (not
|
|
|
1786 (re-search-forward ispell-tib-ref-end reg-end t)))
|
|
|
1787 (and (eq 'sgml ref-type)
|
|
2
|
1788 (not (re-search-forward "[>;]" reg-end t))))
|
|
0
|
1789 (progn
|
|
|
1790 (ispell-pdict-save ispell-silently-savep)
|
|
|
1791 (ding)
|
|
|
1792 (message
|
|
|
1793 (concat
|
|
|
1794 "Open tib or SGML command. Fix buffer or set "
|
|
|
1795 (if (eq 'tib ref-type)
|
|
|
1796 "ispell-skip-tib"
|
|
|
1797 "ispell-skip-sgml")
|
|
|
1798 " to nil"))
|
|
|
1799 ;; keep cursor at error location
|
|
|
1800 (setq ispell-quit (- (point) 2))))
|
|
|
1801 ;; Check spelling between reference and start of the line.
|
|
|
1802 (let ((limit (- (point) (if (eq 'tib ref-type) 2 1))))
|
|
|
1803 (goto-char start)
|
|
|
1804 (if (or (re-search-forward ispell-casechars limit t)
|
|
|
1805 (re-search-forward "[][()$]" limit t))
|
|
|
1806 (setq string
|
|
|
1807 (concat "^" (buffer-substring start limit)
|
|
|
1808 "\n")
|
|
|
1809 offset-change (- offset-change ispell-offset)))
|
|
|
1810 (goto-char limit))))
|
|
|
1811 ((or (re-search-forward ispell-casechars end t) ; TEXT EXISTS
|
|
|
1812 (re-search-forward "[][()$]" end t)) ; or MATH COMMANDS
|
|
|
1813 (setq string (concat "^" (buffer-substring start end) "\n")
|
|
|
1814 offset-change (- offset-change ispell-offset))
|
|
|
1815 (goto-char end))
|
|
|
1816 (t (beginning-of-line 2))) ; EMPTY LINE, skip it.
|
|
|
1817
|
|
|
1818 (setq end (point)) ; "end" tracks end of region to check.
|
|
|
1819
|
|
|
1820 (if string ; there is something to spell!
|
|
|
1821 (let (poss)
|
|
|
1822 ;; send string to spell process and get input.
|
|
|
1823 (process-send-string ispell-process string)
|
|
|
1824 (while (progn
|
|
|
1825 (accept-process-output ispell-process)
|
|
|
1826 ;; Last item of output contains a blank line.
|
|
|
1827 (not (string= "" (car ispell-filter)))))
|
|
|
1828 ;; parse all inputs from the stream one word at a time.
|
|
|
1829 ;; Place in FIFO order and remove the blank item.
|
|
|
1830 (setq ispell-filter (nreverse (cdr ispell-filter)))
|
|
|
1831 (while (and (not ispell-quit) ispell-filter)
|
|
|
1832 (setq poss (ispell-parse-output (car ispell-filter)))
|
|
|
1833 (if (listp poss) ; spelling error occurred.
|
|
|
1834 (let* ((word-start (+ start offset-change
|
|
|
1835 (car (cdr poss))))
|
|
|
1836 (word-end (+ word-start
|
|
|
1837 (length (car poss))))
|
|
|
1838 replace)
|
|
|
1839 (goto-char word-start)
|
|
|
1840 ;; Adjust the horizontal scroll & point
|
|
|
1841 (ispell-horiz-scroll)
|
|
|
1842 (goto-char word-end)
|
|
|
1843 (ispell-horiz-scroll)
|
|
|
1844 (goto-char word-start)
|
|
|
1845 (ispell-horiz-scroll)
|
|
|
1846 (if (/= word-end
|
|
|
1847 (progn
|
|
|
1848 (search-forward (car poss) word-end t)
|
|
|
1849 (point)))
|
|
|
1850 ;; This occurs due to filter pipe problems
|
|
|
1851 (error
|
|
|
1852 (concat "Ispell misalignment: word "
|
|
|
1853 "`%s' point %d; please retry")
|
|
|
1854 (car poss) word-start))
|
|
2
|
1855 (if (not (pos-visible-in-window-p))
|
|
|
1856 (sit-for 0))
|
|
0
|
1857 (if ispell-keep-choices-win
|
|
|
1858 (setq replace
|
|
|
1859 (ispell-command-loop
|
|
|
1860 (car (cdr (cdr poss)))
|
|
|
1861 (car (cdr (cdr (cdr poss))))
|
|
|
1862 (car poss) word-start word-end))
|
|
|
1863 (save-window-excursion
|
|
|
1864 (setq replace
|
|
|
1865 (ispell-command-loop
|
|
|
1866 (car (cdr (cdr poss)))
|
|
|
1867 (car (cdr (cdr (cdr poss))))
|
|
|
1868 (car poss) word-start word-end))))
|
|
|
1869 (cond
|
|
|
1870 ((and replace (listp replace))
|
|
|
1871 ;; REPLACEMENT WORD entered. Recheck line
|
|
|
1872 ;; starting with the replacement word.
|
|
|
1873 (setq ispell-filter nil
|
|
|
1874 string (buffer-substring word-start
|
|
|
1875 word-end))
|
|
|
1876 (let ((change (- (length (car replace))
|
|
|
1877 (length (car poss)))))
|
|
|
1878 ;; adjust regions
|
|
|
1879 (setq reg-end (+ reg-end change)
|
|
|
1880 offset-change (+ offset-change
|
|
|
1881 change)))
|
|
|
1882 (if (not (equal (car replace) (car poss)))
|
|
|
1883 (progn
|
|
|
1884 (delete-region word-start word-end)
|
|
|
1885 (insert (car replace))))
|
|
|
1886 ;; I only need to recheck typed-in replacements
|
|
|
1887 (if (not (eq 'query-replace
|
|
|
1888 (car (cdr replace))))
|
|
|
1889 (backward-char (length (car replace))))
|
|
|
1890 (setq end (point)) ; reposition for recheck
|
|
|
1891 ;; when second arg exists, query-replace, saving regions
|
|
|
1892 (if (car (cdr replace))
|
|
|
1893 (unwind-protect
|
|
|
1894 (save-window-excursion
|
|
|
1895 (set-marker
|
|
|
1896 ispell-query-replace-marker reg-end)
|
|
|
1897 ;; Assume case-replace &
|
|
|
1898 ;; case-fold-search correct?
|
|
|
1899 (query-replace string (car replace)
|
|
|
1900 t))
|
|
|
1901 (setq reg-end
|
|
|
1902 (marker-position
|
|
|
1903 ispell-query-replace-marker))
|
|
|
1904 (set-marker ispell-query-replace-marker
|
|
|
1905 nil))))
|
|
|
1906 ((or (null replace)
|
|
|
1907 (equal 0 replace)) ; ACCEPT/INSERT
|
|
|
1908 (if (equal 0 replace) ; BUFFER-LOCAL DICT ADD
|
|
|
1909 (setq reg-end
|
|
|
1910 (ispell-add-per-file-word-list
|
|
|
1911 (car poss) reg-end)))
|
|
|
1912 ;; This avoids pointing out the word that was
|
|
|
1913 ;; just accepted (via 'i' or 'a') if it follows
|
|
|
1914 ;; on the same line.
|
|
|
1915 ;; Redo check following the accepted word.
|
|
|
1916 (if (and ispell-pdict-modified-p
|
|
|
1917 (listp ispell-pdict-modified-p))
|
|
|
1918 ;; Word accepted. Recheck line.
|
|
|
1919 (setq ispell-pdict-modified-p ; update flag
|
|
|
1920 (car ispell-pdict-modified-p)
|
|
|
1921 ispell-filter nil ; discontinue check
|
|
|
1922 end word-start))) ; reposition loc.
|
|
|
1923 (replace ; STRING REPLACEMENT for this word.
|
|
|
1924 (delete-region word-start word-end)
|
|
|
1925 (insert replace)
|
|
|
1926 (let ((change (- (length replace)
|
|
|
1927 (length (car poss)))))
|
|
|
1928 (setq reg-end (+ reg-end change)
|
|
|
1929 offset-change (+ offset-change change)
|
|
|
1930 end (+ end change)))))
|
|
|
1931 (if (not ispell-quit)
|
|
2
|
1932 (message "Continuing spelling check using %s dictionary..."
|
|
|
1933 (or ispell-dictionary "default")))
|
|
0
|
1934 (sit-for 0)))
|
|
|
1935 ;; finished with line!
|
|
|
1936 (setq ispell-filter (cdr ispell-filter)))))
|
|
|
1937 (goto-char end)))))
|
|
|
1938 (not ispell-quit))
|
|
|
1939 ;; protected
|
|
|
1940 (if (get-buffer ispell-choices-buffer)
|
|
|
1941 (kill-buffer ispell-choices-buffer))
|
|
|
1942 (if ispell-quit
|
|
|
1943 (progn
|
|
|
1944 ;; preserve or clear the region for ispell-continue.
|
|
|
1945 (if (not (numberp ispell-quit))
|
|
|
1946 (set-marker ispell-region-end nil)
|
|
|
1947 ;; Enable ispell-continue.
|
|
|
1948 (set-marker ispell-region-end reg-end)
|
|
|
1949 (goto-char ispell-quit))
|
|
|
1950 ;; Check for aborting
|
|
|
1951 (if (and ispell-checking-message (numberp ispell-quit))
|
|
|
1952 (progn
|
|
|
1953 (setq ispell-quit nil)
|
|
|
1954 (error "Message send aborted.")))
|
|
|
1955 (setq ispell-quit nil))
|
|
|
1956 (set-marker ispell-region-end nil)
|
|
|
1957 ;; Only save if successful exit.
|
|
|
1958 (ispell-pdict-save ispell-silently-savep)
|
|
|
1959 (message "Spell-checking done"))))
|
|
|
1960
|
|
|
1961
|
|
|
1962
|
|
|
1963 ;;;###autoload
|
|
|
1964 (defun ispell-buffer ()
|
|
|
1965 "Check the current buffer for spelling errors interactively."
|
|
|
1966 (interactive)
|
|
|
1967 (ispell-region (point-min) (point-max)))
|
|
|
1968
|
|
|
1969
|
|
|
1970 ;;;###autoload
|
|
|
1971 (defun ispell-continue ()
|
|
|
1972 (interactive)
|
|
|
1973 "Continue a spelling session after making some changes."
|
|
|
1974 (if (not (marker-position ispell-region-end))
|
|
|
1975 (message "No session to continue. Use 'X' command when checking!")
|
|
|
1976 (if (not (equal (marker-buffer ispell-region-end) (current-buffer)))
|
|
|
1977 (message "Must continue ispell from buffer %s"
|
|
|
1978 (buffer-name (marker-buffer ispell-region-end)))
|
|
|
1979 (ispell-region (point) (marker-position ispell-region-end)))))
|
|
|
1980
|
|
|
1981
|
|
|
1982 ;;; Horizontal scrolling
|
|
|
1983 (defun ispell-horiz-scroll ()
|
|
|
1984 "Places point within the horizontal visibility of its window area."
|
|
|
1985 (if truncate-lines ; display truncating lines?
|
|
|
1986 ;; See if display needs to be scrolled.
|
|
|
1987 (let ((column (- (current-column) (max (window-hscroll) 1))))
|
|
|
1988 (if (and (< column 0) (> (window-hscroll) 0))
|
|
|
1989 (scroll-right (max (- column) 10))
|
|
|
1990 (if (>= column (- (window-width) 2))
|
|
|
1991 (scroll-left (max (- column (window-width) -3) 10)))))))
|
|
|
1992
|
|
|
1993
|
|
|
1994 ;;; Interactive word completion.
|
|
|
1995 ;;; Forces "previous-word" processing. Do we want to make this selectable?
|
|
|
1996
|
|
|
1997 ;;;###autoload
|
|
|
1998 (defun ispell-complete-word (&optional interior-frag)
|
|
|
1999 "Look up word before or under point in dictionary (see lookup-words command)
|
|
|
2000 and try to complete it. If optional INTERIOR-FRAG is non-nil then the word
|
|
|
2001 may be a character sequence inside of a word.
|
|
|
2002
|
|
|
2003 Standard ispell choices are then available."
|
|
|
2004 (interactive "P")
|
|
|
2005 (let ((cursor-location (point))
|
|
|
2006 case-fold-search
|
|
|
2007 (word (ispell-get-word nil "\\*")) ; force "previous-word" processing.
|
|
|
2008 start end possibilities replacement)
|
|
|
2009 (setq start (car (cdr word))
|
|
|
2010 end (car (cdr (cdr word)))
|
|
|
2011 word (car word)
|
|
|
2012 possibilities
|
|
|
2013 (or (string= word "") ; Will give you every word
|
|
|
2014 (lookup-words (concat (if interior-frag "*") word "*")
|
|
|
2015 ispell-complete-word-dict)))
|
|
|
2016 (cond ((eq possibilities t)
|
|
|
2017 (message "No word to complete"))
|
|
|
2018 ((null possibilities)
|
|
|
2019 (message "No match for \"%s\"" word))
|
|
|
2020 (t ; There is a modification...
|
|
|
2021 (cond ; Try and respect case of word.
|
|
|
2022 ((string-match "^[^A-Z]+$" word)
|
|
|
2023 (setq possibilities (mapcar 'downcase possibilities)))
|
|
|
2024 ((string-match "^[^a-z]+$" word)
|
|
|
2025 (setq possibilities (mapcar 'upcase possibilities)))
|
|
|
2026 ((string-match "^[A-Z]" word)
|
|
|
2027 (setq possibilities (mapcar 'capitalize possibilities))))
|
|
|
2028 (save-window-excursion
|
|
|
2029 (setq replacement
|
|
|
2030 (ispell-command-loop possibilities nil word start end)))
|
|
|
2031 (cond
|
|
|
2032 ((equal 0 replacement) ; BUFFER-LOCAL ADDITION
|
|
|
2033 (ispell-add-per-file-word-list word))
|
|
|
2034 (replacement ; REPLACEMENT WORD
|
|
|
2035 (delete-region start end)
|
|
|
2036 (setq word (if (atom replacement) replacement (car replacement))
|
|
|
2037 cursor-location (+ (- (length word) (- end start))
|
|
|
2038 cursor-location))
|
|
|
2039 (insert word)
|
|
|
2040 (if (not (atom replacement)) ; recheck spelling of replacement.
|
|
|
2041 (progn
|
|
|
2042 (goto-char cursor-location)
|
|
|
2043 (ispell-word nil t)))))
|
|
|
2044 (if (get-buffer ispell-choices-buffer)
|
|
|
2045 (kill-buffer ispell-choices-buffer))))
|
|
|
2046 (ispell-pdict-save ispell-silently-savep)
|
|
|
2047 (goto-char cursor-location)))
|
|
|
2048
|
|
|
2049
|
|
|
2050 ;;;###autoload
|
|
|
2051 (defun ispell-complete-word-interior-frag ()
|
|
|
2052 "Completes word matching character sequence inside a word."
|
|
|
2053 (interactive)
|
|
|
2054 (ispell-complete-word t))
|
|
|
2055
|
|
|
2056
|
|
|
2057 ;;; **********************************************************************
|
|
|
2058 ;;; Ispell Minor Mode
|
|
|
2059 ;;; **********************************************************************
|
|
|
2060
|
|
|
2061 (defvar ispell-minor-mode nil
|
|
|
2062 "Non-nil if Ispell minor mode is enabled.")
|
|
|
2063 ;; Variable indicating that ispell minor mode is active.
|
|
|
2064 (make-variable-buffer-local 'ispell-minor-mode)
|
|
|
2065
|
|
|
2066 (or (assq 'ispell-minor-mode minor-mode-alist)
|
|
|
2067 (setq minor-mode-alist
|
|
|
2068 (cons '(ispell-minor-mode " Spell") minor-mode-alist)))
|
|
|
2069
|
|
|
2070 (defvar ispell-minor-keymap
|
|
|
2071 (let ((map (make-sparse-keymap)))
|
|
|
2072 (define-key map " " 'ispell-minor-check)
|
|
|
2073 (define-key map "\r" 'ispell-minor-check)
|
|
|
2074 map)
|
|
|
2075 "Keymap used for Ispell minor mode.")
|
|
|
2076
|
|
|
2077 (or (not (boundp 'minor-mode-map-alist))
|
|
|
2078 (assoc 'ispell-minor-mode minor-mode-map-alist)
|
|
|
2079 (setq minor-mode-map-alist
|
|
|
2080 (cons (cons 'ispell-minor-mode ispell-minor-keymap)
|
|
|
2081 minor-mode-map-alist)))
|
|
|
2082
|
|
|
2083 ;;;###autoload
|
|
|
2084 (defun ispell-minor-mode (&optional arg)
|
|
|
2085 "Toggle Ispell minor mode.
|
|
|
2086 With prefix arg, turn Ispell minor mode on iff arg is positive.
|
|
|
2087
|
|
|
2088 In Ispell minor mode, pressing SPC or RET
|
|
|
2089 warns you if the previous word is incorrectly spelled."
|
|
|
2090 (interactive "P")
|
|
|
2091 (setq ispell-minor-mode
|
|
|
2092 (not (or (and (null arg) ispell-minor-mode)
|
|
|
2093 (<= (prefix-numeric-value arg) 0))))
|
|
|
2094 (redraw-modeline))
|
|
|
2095
|
|
|
2096 (defun ispell-minor-check ()
|
|
|
2097 ;; Check previous word then continue with the normal binding of this key.
|
|
|
2098 (interactive "*")
|
|
|
2099 (let ((ispell-minor-mode nil)
|
|
|
2100 (ispell-check-only t))
|
|
|
2101 (save-restriction
|
|
|
2102 (narrow-to-region (point-min) (point))
|
|
|
2103 (ispell-word nil t))
|
|
|
2104 (call-interactively (key-binding (this-command-keys)))))
|
|
|
2105
|
|
|
2106
|
|
|
2107 ;;; **********************************************************************
|
|
|
2108 ;;; Ispell Message
|
|
|
2109 ;;; **********************************************************************
|
|
|
2110 ;;; Original from D. Quinlan, E. Bradford, A. Albert, and M. Ernst
|
|
|
2111
|
|
|
2112
|
|
|
2113 (defvar ispell-message-text-end
|
|
|
2114 (mapconcat (function identity)
|
|
|
2115 '(
|
|
|
2116 ;; Matches postscript files.
|
|
|
2117 "^%!PS-Adobe-[123].0"
|
|
|
2118 ;; Matches uuencoded text
|
|
|
2119 "^begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM"
|
|
|
2120 ;; Matches shell files (esp. auto-decoding)
|
|
|
2121 "^#! /bin/[ck]?sh"
|
|
|
2122 ;; Matches context difference listing
|
|
|
2123 "\\(diff -c .*\\)?\n\\*\\*\\* .*\n--- .*\n\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*"
|
|
2
|
2124 ;; Matches reporter.el bug report
|
|
|
2125 "^current state:\n==============\n"
|
|
0
|
2126 ;; Matches "----------------- cut here"
|
|
2
|
2127 ;; and "------- Start of forwarded message"
|
|
|
2128 "^[-=_]+\\s ?\\(cut here\\|Start of forwarded message\\)")
|
|
0
|
2129 "\\|")
|
|
|
2130 "*End of text which will be checked in ispell-message.
|
|
|
2131 If it is a string, limit at first occurrence of that regular expression.
|
|
|
2132 Otherwise, it must be a function which is called to get the limit.")
|
|
|
2133
|
|
|
2134
|
|
|
2135 (defvar ispell-message-start-skip
|
|
|
2136 (mapconcat (function identity)
|
|
|
2137 '(
|
|
|
2138 ;; Matches forwarded messages
|
|
|
2139 "^---* Forwarded Message"
|
|
|
2140 ;; Matches PGP Public Key block
|
|
|
2141 "^---*BEGIN PGP [A-Z ]*--*"
|
|
|
2142 )
|
|
|
2143 "\\|")
|
|
|
2144 "Spelling is skipped inside these start/end groups by ispell-message.
|
|
|
2145 Assumed that blocks are not mutually inclusive.")
|
|
|
2146
|
|
|
2147
|
|
|
2148 (defvar ispell-message-end-skip
|
|
|
2149 (mapconcat (function identity)
|
|
|
2150 '(
|
|
|
2151 ;; Matches forwarded messages
|
|
|
2152 "^--- End of Forwarded Message"
|
|
|
2153 ;; Matches PGP Public Key block
|
|
|
2154 "^---*END PGP [A-Z ]*--*"
|
|
|
2155 )
|
|
|
2156 "\\|")
|
|
|
2157 "Spelling is skipped inside these start/end groups by ispell-message.
|
|
|
2158 Assumed that blocks are not mutually inclusive.")
|
|
|
2159
|
|
|
2160
|
|
|
2161 ;;;###autoload
|
|
|
2162 (defun ispell-message ()
|
|
|
2163 "Check the spelling of a mail message or news post.
|
|
|
2164 Don't check spelling of message headers except the Subject field.
|
|
|
2165 Don't check included messages.
|
|
|
2166
|
|
2
|
2167 To abort spell checking of a message region and send the message anyway,
|
|
0
|
2168 use the `x' or `q' command. (Any subsequent regions will be checked.)
|
|
|
2169 The `X' command aborts the message send so that you can edit the buffer.
|
|
|
2170
|
|
|
2171 To spell-check whenever a message is sent, include the appropriate lines
|
|
|
2172 in your .emacs file:
|
|
2
|
2173 (add-hook 'message-send-hook 'ispell-message)
|
|
0
|
2174 (add-hook 'mail-send-hook 'ispell-message)
|
|
|
2175 (add-hook 'mh-before-send-letter-hook 'ispell-message)
|
|
|
2176
|
|
|
2177 You can bind this to the key C-c i in GNUS or mail by adding to
|
|
|
2178 `news-reply-mode-hook' or `mail-mode-hook' the following lambda expression:
|
|
|
2179 (function (lambda () (local-set-key \"\\C-ci\" 'ispell-message)))"
|
|
|
2180 (interactive)
|
|
|
2181 (save-excursion
|
|
|
2182 (goto-char (point-min))
|
|
|
2183 (let* ((internal-messagep (save-excursion
|
|
|
2184 (re-search-forward
|
|
|
2185 (concat "^"
|
|
|
2186 (regexp-quote mail-header-separator)
|
|
|
2187 "$")
|
|
|
2188 nil t)))
|
|
|
2189 (limit (copy-marker
|
|
|
2190 (cond
|
|
|
2191 ((not ispell-message-text-end) (point-max))
|
|
|
2192 ((char-or-string-p ispell-message-text-end)
|
|
|
2193 (if (re-search-forward ispell-message-text-end nil t)
|
|
|
2194 (match-beginning 0)
|
|
|
2195 (point-max)))
|
|
|
2196 (t (min (point-max) (funcall ispell-message-text-end))))))
|
|
|
2197 (cite-regexp ;Prefix of inserted text
|
|
|
2198 (cond
|
|
|
2199 ((featurep 'supercite) ; sc 3.0
|
|
|
2200 (concat "\\(" (sc-cite-regexp) "\\)" "\\|"
|
|
|
2201 (ispell-non-empty-string sc-reference-tag-string)))
|
|
|
2202 ((featurep 'sc) ; sc 2.3
|
|
|
2203 (concat "\\(" sc-cite-regexp "\\)" "\\|"
|
|
|
2204 (ispell-non-empty-string sc-reference-tag-string)))
|
|
2
|
2205 ((equal major-mode 'news-reply-mode) ;GNUS 4 & below
|
|
0
|
2206 (concat "In article <" "\\|"
|
|
|
2207 (if mail-yank-prefix
|
|
|
2208 (ispell-non-empty-string mail-yank-prefix)
|
|
|
2209 "^ \\|^\t")))
|
|
2
|
2210 ((equal major-mode 'message-mode) ;GNUS 5
|
|
|
2211 (concat ".*@.* writes:$" "\\|"
|
|
|
2212 (if mail-yank-prefix
|
|
|
2213 (ispell-non-empty-string mail-yank-prefix)
|
|
|
2214 "^ \\|^\t")))
|
|
0
|
2215 ((equal major-mode 'mh-letter-mode) ; mh mail message
|
|
|
2216 (ispell-non-empty-string mh-ins-buf-prefix))
|
|
|
2217 ((not internal-messagep) ; Assume n sent us this message.
|
|
|
2218 (concat "In [a-zA-Z.]+ you write:" "\\|"
|
|
|
2219 "In <[^,;&+=]+> [^,;&+=]+ writes:" "\\|"
|
|
|
2220 " *> *"))
|
|
|
2221 ((boundp 'vm-included-text-prefix) ; VM mail message
|
|
|
2222 (concat "[^,;&+=]+ writes:" "\\|"
|
|
|
2223 (ispell-non-empty-string vm-included-text-prefix)))
|
|
|
2224 (mail-yank-prefix ; vanilla mail message.
|
|
|
2225 (ispell-non-empty-string mail-yank-prefix))
|
|
|
2226 (t "^ \\|^\t")))
|
|
|
2227 (cite-regexp-start (concat "^[ \t]*$\\|" cite-regexp))
|
|
|
2228 (cite-regexp-end (concat "^\\(" cite-regexp "\\)"))
|
|
|
2229 (old-case-fold-search case-fold-search)
|
|
|
2230 (case-fold-search t)
|
|
|
2231 (ispell-checking-message t))
|
|
|
2232 (goto-char (point-min))
|
|
|
2233 ;; Skip header fields except Subject: without Re:'s
|
|
|
2234 ;;(search-forward mail-header-separator nil t)
|
|
|
2235 (while (if internal-messagep
|
|
|
2236 (< (point) internal-messagep)
|
|
|
2237 (and (looking-at "[a-zA-Z---]+:\\|\t\\| ")
|
|
|
2238 (not (eobp))))
|
|
|
2239 (if (looking-at "Subject: *") ; Spell check new subject fields
|
|
|
2240 (progn
|
|
|
2241 (goto-char (match-end 0))
|
|
|
2242 (if (and (not (looking-at ".*Re\\>"))
|
|
|
2243 (not (looking-at "\\[")))
|
|
|
2244 (let ((case-fold-search old-case-fold-search))
|
|
|
2245 (ispell-region (point)
|
|
|
2246 (progn
|
|
|
2247 (end-of-line)
|
|
|
2248 (while (looking-at "\n[ \t]")
|
|
|
2249 (end-of-line 2))
|
|
|
2250 (point)))))))
|
|
|
2251 (forward-line 1))
|
|
|
2252 (setq case-fold-search nil)
|
|
|
2253 ;; Skip mail header, particularly for non-english languages.
|
|
|
2254 (if (looking-at (concat (regexp-quote mail-header-separator) "$"))
|
|
|
2255 (forward-line 1))
|
|
|
2256 (while (< (point) limit)
|
|
|
2257 ;; Skip across text cited from other messages.
|
|
|
2258 (while (and (looking-at cite-regexp-start)
|
|
|
2259 (< (point) limit)
|
|
|
2260 (zerop (forward-line 1))))
|
|
|
2261
|
|
|
2262 (if (< (point) limit)
|
|
|
2263 (let* ((start (point))
|
|
|
2264 ;; Check the next batch of lines that *aren't* cited.
|
|
|
2265 (end-c (and (re-search-forward cite-regexp-end limit 'end)
|
|
|
2266 (match-beginning 0)))
|
|
|
2267 ;; Skip a block of included text.
|
|
|
2268 (end-fwd (and (goto-char start)
|
|
|
2269 (re-search-forward ispell-message-start-skip
|
|
|
2270 limit 'end)
|
|
|
2271 (progn (beginning-of-line)
|
|
|
2272 (point))))
|
|
|
2273 (end (or (and end-c end-fwd (min end-c end-fwd))
|
|
|
2274 end-c end-fwd
|
|
2
|
2275 ;; default to limit of text.
|
|
0
|
2276 (marker-position limit))))
|
|
|
2277 (goto-char start)
|
|
|
2278 (ispell-region start end)
|
|
|
2279 (if (and end-fwd (= end end-fwd))
|
|
|
2280 (progn
|
|
|
2281 (goto-char end)
|
|
|
2282 (re-search-forward ispell-message-end-skip limit 'end))
|
|
|
2283 (goto-char end)))))
|
|
|
2284 (set-marker limit nil))))
|
|
|
2285
|
|
|
2286
|
|
|
2287 (defun ispell-non-empty-string (string)
|
|
|
2288 (if (or (not string) (string-equal string ""))
|
|
|
2289 "\\'\\`" ; An unmatchable string if string is null.
|
|
|
2290 (regexp-quote string)))
|
|
|
2291
|
|
|
2292
|
|
|
2293 ;;; **********************************************************************
|
|
|
2294 ;;; Buffer Local Functions
|
|
|
2295 ;;; **********************************************************************
|
|
|
2296
|
|
|
2297
|
|
|
2298 (defun ispell-accept-buffer-local-defs ()
|
|
|
2299 "Load all buffer-local information, restarting ispell when necessary."
|
|
|
2300 (ispell-buffer-local-dict) ; May kill ispell-process.
|
|
|
2301 (ispell-buffer-local-words) ; Will initialize ispell-process.
|
|
|
2302 (ispell-buffer-local-parsing))
|
|
|
2303
|
|
|
2304
|
|
|
2305 (defun ispell-buffer-local-parsing ()
|
|
|
2306 "Place Ispell into parsing mode for this buffer.
|
|
|
2307 Overrides the default parsing mode.
|
|
|
2308 Includes latex/nroff modes and extended character mode."
|
|
|
2309 ;; (ispell-init-process) must already be called.
|
|
|
2310 (process-send-string ispell-process "!\n") ; Put process in terse mode.
|
|
|
2311 ;; We assume all major modes with "tex-mode" in them should use latex parsing
|
|
|
2312 (if (or (and (eq ispell-parser 'use-mode-name)
|
|
|
2313 (string-match "[Tt][Ee][Xx]-mode" (symbol-name major-mode)))
|
|
|
2314 (eq ispell-parser 'tex))
|
|
|
2315 (process-send-string ispell-process "+\n") ; set ispell mode to tex
|
|
|
2316 (process-send-string ispell-process "-\n")) ; set mode to normal (nroff)
|
|
|
2317 ;; Hard-wire test for SGML & HTML mode.
|
|
|
2318 (setq ispell-skip-sgml (memq major-mode '(sgml-mode html-mode)))
|
|
|
2319 ;; Set default extended character mode for given buffer, if any.
|
|
|
2320 (let ((extended-char-mode (ispell-get-extended-character-mode)))
|
|
|
2321 (if extended-char-mode
|
|
|
2322 (process-send-string ispell-process (concat extended-char-mode "\n"))))
|
|
|
2323 ;; Set buffer-local parsing mode and extended character mode, if specified.
|
|
|
2324 (save-excursion
|
|
|
2325 (goto-char (point-min))
|
|
|
2326 ;; Uses last valid definition
|
|
|
2327 (while (search-forward ispell-parsing-keyword nil t)
|
|
|
2328 (let ((end (save-excursion (end-of-line) (point)))
|
|
|
2329 (case-fold-search t)
|
|
|
2330 string)
|
|
|
2331 (while (re-search-forward " *\\([^ \"]+\\)" end t)
|
|
|
2332 ;; space separated definitions.
|
|
|
2333 (setq string (buffer-substring (match-beginning 1) (match-end 1)))
|
|
|
2334 (cond ((string-match "latex-mode" string)
|
|
|
2335 (process-send-string ispell-process "+\n~tex\n"))
|
|
|
2336 ((string-match "nroff-mode" string)
|
|
|
2337 (process-send-string ispell-process "-\n~nroff"))
|
|
|
2338 ((string-match "~" string) ; Set extended character mode.
|
|
|
2339 (process-send-string ispell-process (concat string "\n")))
|
|
|
2340 (t (message "Illegal Ispell Parsing argument!")
|
|
|
2341 (sit-for 2))))))))
|
|
|
2342
|
|
|
2343
|
|
|
2344 ;;; Can kill the current ispell process
|
|
|
2345
|
|
|
2346 (defun ispell-buffer-local-dict ()
|
|
|
2347 "Initializes local dictionary.
|
|
|
2348 When a dictionary is defined in the buffer (see variable
|
|
|
2349 `ispell-dictionary-keyword'), it will override the local setting
|
|
|
2350 from \\[ispell-change-dictionary].
|
|
|
2351 Both should not be used to define a buffer-local dictionary."
|
|
|
2352 (save-excursion
|
|
|
2353 (goto-char (point-min))
|
|
|
2354 (let (end)
|
|
|
2355 ;; Override the local variable definition.
|
|
|
2356 ;; Uses last valid definition.
|
|
|
2357 (while (search-forward ispell-dictionary-keyword nil t)
|
|
|
2358 (setq end (save-excursion (end-of-line) (point)))
|
|
|
2359 (if (re-search-forward " *\\([^ \"]+\\)" end t)
|
|
|
2360 (setq ispell-local-dictionary
|
|
|
2361 (buffer-substring (match-beginning 1) (match-end 1)))))
|
|
|
2362 (goto-char (point-min))
|
|
|
2363 (while (search-forward ispell-pdict-keyword nil t)
|
|
|
2364 (setq end (save-excursion (end-of-line) (point)))
|
|
|
2365 (if (re-search-forward " *\\([^ \"]+\\)" end t)
|
|
|
2366 (setq ispell-local-pdict
|
|
|
2367 (buffer-substring (match-beginning 1) (match-end 1)))))))
|
|
|
2368 ;; Reload if new personal dictionary defined.
|
|
|
2369 (if (and ispell-local-pdict
|
|
|
2370 (not (equal ispell-local-pdict ispell-personal-dictionary)))
|
|
|
2371 (progn
|
|
|
2372 (ispell-kill-ispell t)
|
|
|
2373 (setq ispell-personal-dictionary ispell-local-pdict)))
|
|
|
2374 ;; Reload if new dictionary defined.
|
|
|
2375 (if (and ispell-local-dictionary
|
|
|
2376 (not (equal ispell-local-dictionary ispell-dictionary)))
|
|
|
2377 (ispell-change-dictionary ispell-local-dictionary)))
|
|
|
2378
|
|
|
2379
|
|
|
2380 (defun ispell-buffer-local-words ()
|
|
|
2381 "Loads the buffer-local dictionary in the current buffer."
|
|
|
2382 (if (and ispell-buffer-local-name
|
|
|
2383 (not (equal ispell-buffer-local-name (buffer-name))))
|
|
|
2384 (progn
|
|
|
2385 (ispell-kill-ispell t)
|
|
|
2386 (setq ispell-buffer-local-name nil)))
|
|
|
2387 (ispell-init-process)
|
|
|
2388 (save-excursion
|
|
|
2389 (goto-char (point-min))
|
|
|
2390 (while (search-forward ispell-words-keyword nil t)
|
|
|
2391 (or ispell-buffer-local-name
|
|
|
2392 (setq ispell-buffer-local-name (buffer-name)))
|
|
|
2393 (let ((end (save-excursion (end-of-line) (point)))
|
|
|
2394 string)
|
|
|
2395 ;; buffer-local words separated by a space, and can contain
|
|
|
2396 ;; any character other than a space.
|
|
|
2397 (while (re-search-forward " *\\([^ ]+\\)" end t)
|
|
|
2398 (setq string (buffer-substring (match-beginning 1) (match-end 1)))
|
|
|
2399 (process-send-string ispell-process (concat "@" string "\n")))))))
|
|
|
2400
|
|
|
2401
|
|
|
2402 ;;; returns optionally adjusted region-end-point.
|
|
|
2403
|
|
|
2404 (defun ispell-add-per-file-word-list (word &optional reg-end)
|
|
|
2405 "Adds new word to the per-file word list."
|
|
|
2406 (or ispell-buffer-local-name
|
|
|
2407 (setq ispell-buffer-local-name (buffer-name)))
|
|
|
2408 (if (null reg-end)
|
|
|
2409 (setq reg-end 0))
|
|
|
2410 (save-excursion
|
|
|
2411 (goto-char (point-min))
|
|
|
2412 (let (case-fold-search line-okay search done string)
|
|
|
2413 (while (not done)
|
|
|
2414 (setq search (search-forward ispell-words-keyword nil 'move)
|
|
|
2415 line-okay (< (+ (length word) 1 ; 1 for space after word..
|
|
|
2416 (progn (end-of-line) (current-column)))
|
|
|
2417 80))
|
|
|
2418 (if (or (and search line-okay)
|
|
|
2419 (null search))
|
|
|
2420 (progn
|
|
|
2421 (setq done t)
|
|
|
2422 (if (null search)
|
|
|
2423 (progn
|
|
|
2424 (open-line 1)
|
|
|
2425 (setq string (concat comment-start " "
|
|
|
2426 ispell-words-keyword))
|
|
|
2427 ;; in case the keyword is in the middle of the file....
|
|
|
2428 (if (> reg-end (point))
|
|
|
2429 (setq reg-end (+ reg-end (length string))))
|
|
|
2430 (insert string)
|
|
|
2431 (if (and comment-end (not (equal "" comment-end)))
|
|
|
2432 (save-excursion
|
|
|
2433 (open-line 1)
|
|
|
2434 (forward-line 1)
|
|
|
2435 (insert comment-end)))))
|
|
|
2436 (if (> reg-end (point))
|
|
|
2437 (setq reg-end (+ 1 reg-end (length word))))
|
|
|
2438 (insert (concat " " word)))))))
|
|
|
2439 reg-end)
|
|
|
2440
|
|
|
2441
|
|
|
2442 (defconst ispell-version "2.37 -- Tue Jun 13 12:05:28 EDT 1995")
|
|
|
2443
|
|
|
2444 (provide 'ispell)
|
|
|
2445
|
|
|
2446
|
|
|
2447 ;;; LOCAL VARIABLES AND BUFFER-LOCAL VALUE EXAMPLES.
|
|
|
2448
|
|
|
2449 ;;; Local Variable options:
|
|
|
2450 ;;; mode: name(-mode)
|
|
|
2451 ;;; eval: expression
|
|
|
2452 ;;; local-variable: value
|
|
|
2453
|
|
|
2454 ;;; The following sets the buffer local dictionary to english!
|
|
|
2455
|
|
|
2456 ;;; Local Variables:
|
|
|
2457 ;;; mode: emacs-lisp
|
|
|
2458 ;;; comment-column: 40
|
|
|
2459 ;;; ispell-local-dictionary: "english"
|
|
|
2460 ;;; End:
|
|
|
2461
|
|
|
2462
|
|
|
2463 ;;; MORE EXAMPLES OF ISPELL BUFFER-LOCAL VALUES
|
|
|
2464
|
|
|
2465 ;;; The following places this file in nroff parsing and extended char modes.
|
|
|
2466 ;;; Local IspellParsing: nroff-mode ~nroff
|
|
|
2467 ;;; Change IspellDict to IspellDict: to enable the following line.
|
|
|
2468 ;;; Local IspellDict english
|
|
|
2469 ;;; Change IspellPersDict to IspellPersDict: to enable the following line.
|
|
|
2470 ;;; Local IspellPersDict ~/.ispell_lisp
|
|
|
2471 ;;; The following were automatically generated by ispell using the 'A' command:
|
|
|
2472 ; LocalWords: ispell ispell-highlight-p ispell-check-comments query-replace
|
|
|
2473 ; LocalWords: ispell-query-replace-choices ispell-skip-tib non-nil tib
|
|
|
2474 ; LocalWords: regexps ispell-tib-ref-beginning ispell-tib-ref-end
|
|
|
2475
|
|
|
2476 ;; ispell.el ends here
|
