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