1 ;;; ispell.el --- this is the GNU EMACS interface to GNU ISPELL version 4.
3 ;;Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc.
7 ;;This file is part of GNU Emacs.
9 ;;GNU Emacs is free software; you can redistribute it and/or modify
10 ;;it under the terms of the GNU General Public License as published by
11 ;;the Free Software Foundation; either version 2, or (at your option)
14 ;;GNU Emacs is distributed in the hope that it will be useful,
15 ;;but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;;MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;;GNU General Public License for more details.
19 ;;You should have received a copy of the GNU General Public License
20 ;;along with GNU Emacs; see the file COPYING. If not, write to
21 ;;the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 ;; This package provides a graceful interface to ispell, the GNU
30 (defvar ispell-have-new-look t
31 "Non-nil means use the `-r' option when running `look'.")
33 (defvar ispell-enable-tex-parser nil
34 "Non-nil enables experimental TeX parser in Ispell for TeX-mode buffers.")
36 (defvar ispell-process nil "The process running Ispell")
37 (defvar ispell-next-message nil
38 "An integer: where in `*ispell*' buffer to find next message from Ispell.")
40 (defvar ispell-command "ispell"
41 "Command for running Ispell.")
42 (defvar ispell-command-options nil
43 "*String (or list of strings) to pass to Ispell as command arguments.
44 You can use this to specify the name of your private dictionary.
45 The -S option is always passed to Ispell as the last parameter,
46 and need not be mentioned here.")
48 ;Each marker in this list points to the start of a word that
49 ;ispell thought was bad last time it did the :file command.
50 ;Notice that if the user accepts or inserts a word into his
51 ;private dictionary, then some "good" words will be on the list.
52 ;We would like to deal with this by looking up the words again just before
53 ;presenting them to the user, but that is too slow on machines
54 ;without the select system call. Therefore, see the variable
55 ;ispell-recently-accepted.
56 (defvar ispell-bad-words nil
57 "A list of markers reflecting the output of the Ispell `:file' command.")
59 ;list of words that the user has accepted, but that might still
60 ;be on the bad-words list
61 (defvar ispell-recently-accepted nil)
63 ;; Non-nil means we have started showing an alternatives window.
64 ;; This is the window config from before then.
65 (defvar ispell-window-configuration nil)
67 ;t when :dump command needed
68 (defvar ispell-dump-needed nil)
70 (defun ispell-flush-bad-words ()
71 (while ispell-bad-words
72 (if (markerp (car ispell-bad-words))
73 (set-marker (car ispell-bad-words) nil))
74 (setq ispell-bad-words (cdr ispell-bad-words)))
75 (setq ispell-recently-accepted nil))
78 "Kill the Ispell process.
79 Any changes in your private dictionary
80 that have not already been dumped will be lost."
83 (delete-process ispell-process))
84 (setq ispell-process nil)
85 (ispell-flush-bad-words))
87 (put 'ispell-startup-error 'error-conditions
88 '(ispell-startup-error error))
89 (put 'ispell-startup-error 'error-message
90 "Problem starting ispell - see buffer *ispell*")
92 ;; Start an ispell subprocess; check the version; and display the greeting.
94 (defun start-ispell ()
95 (message "Starting ispell ...")
96 (let ((buf (get-buffer "*ispell*")))
101 (apply 'start-process "ispell" "*ispell*" ispell-command
102 (append (if (listp ispell-command-options)
103 ispell-command-options
104 (list ispell-command-options))
106 (file-error (signal 'ispell-startup-error nil)))
107 (process-kill-without-query ispell-process)
108 (buffer-disable-undo (process-buffer ispell-process))
109 (accept-process-output ispell-process)
112 (set-buffer (process-buffer ispell-process))
113 (bury-buffer (current-buffer))
114 (setq last-char (- (point-max) 1))
115 (while (not (eq (char-after last-char) ?=))
116 (cond ((not (eq (process-status ispell-process) 'run))
118 (signal 'ispell-startup-error nil)))
119 (accept-process-output ispell-process)
120 (setq last-char (- (point-max) 1)))
121 (goto-char (point-min))
122 (let ((greeting (read (current-buffer))))
123 (if (not (= (car greeting) 1))
124 (error "Bad ispell version: wanted 1, got %d" (car greeting)))
125 (message (car (cdr greeting))))
126 (delete-region (point-min) last-char))))
128 ;; Make sure ispell is ready for a command.
129 ;; Leaves buffer set to *ispell*, point at '='.
131 (defun ispell-sync (intr)
132 (if (or (null ispell-process)
133 (not (eq (process-status ispell-process) 'run)))
136 (interrupt-process ispell-process))
138 (set-buffer (process-buffer ispell-process))
139 (bury-buffer (current-buffer))
140 (setq last-char (- (point-max) 1))
141 (while (not (eq (char-after last-char) ?=))
142 (accept-process-output ispell-process)
143 (setq last-char (- (point-max) 1)))
144 (goto-char last-char)))
146 ;; Send a command to ispell. Choices are:
148 ;; WORD Check spelling of WORD. Result is
152 ;; list of strings near misses
154 ;; :file FILENAME scan the named file, and print the file offsets of
155 ;; any misspelled words
157 ;; :insert WORD put word in private dictionary
159 ;; :accept WORD don't complain about word any more this session
161 ;; :dump write out the current private dictionary, if necessary.
163 ;; :reload reread `~/ispell.words'
167 ;; :generic set type of parser to use when scanning whole files
169 (defun ispell-cmd (&rest strings)
172 (set-buffer (process-buffer ispell-process))
173 (bury-buffer (current-buffer))
175 (setq ispell-next-message (point-min))
177 (process-send-string ispell-process (car strings))
178 (setq strings (cdr strings)))
179 (process-send-string ispell-process "\n")
180 (accept-process-output ispell-process)
183 (defun ispell-dump ()
184 (cond (ispell-dump-needed
185 (setq ispell-dump-needed nil)
186 (ispell-cmd ":dump"))))
188 (defun ispell-insert (word)
189 (ispell-cmd ":insert " word)
191 (setq ispell-recently-accepted (cons word ispell-recently-accepted)))
192 (setq ispell-dump-needed t))
194 (defun ispell-accept (word)
195 (ispell-cmd ":accept " word)
197 (setq ispell-recently-accepted (cons word ispell-recently-accepted))))
199 ;; Return the next message sent by the Ispell subprocess.
201 (defun ispell-next-message ()
203 (set-buffer (process-buffer ispell-process))
204 (bury-buffer (current-buffer))
206 (goto-char ispell-next-message)
207 (narrow-to-region (point)
208 (progn (forward-sexp 1) (point)))
209 (setq ispell-next-message (point))
210 (goto-char (point-min))
211 (read (current-buffer)))))
213 (defun ispell-tex-buffer-p ()
214 (memq major-mode '(plain-TeX-mode LaTeX-mode)))
216 (defvar ispell-menu-map (make-sparse-keymap "Spell"))
217 (defalias 'ispell-menu-map ispell-menu-map)
219 (define-key ispell-menu-map [reload-ispell]
220 '("Reload Dictionary" . reload-ispell))
222 (define-key ispell-menu-map [ispell-next]
223 '("Continue Check" . ispell-next))
225 (define-key ispell-menu-map [ispell-message]
226 '("Check Message" . ispell-message))
228 (define-key ispell-menu-map [ispell-region]
229 '("Check Region" . ispell-region))
231 (define-key ispell-menu-map [ispell-buffer]
232 '("Check Buffer" . ispell))
234 (define-key ispell-menu-map [ispell-word]
235 '("Check Word" . ispell-word))
238 (defun ispell (&optional buf start end)
239 "Run Ispell over current buffer's visited file.
240 First the file is scanned for misspelled words, then Ispell
241 enters a loop with the following commands for every misspelled word:
243 DIGIT Near miss selector. If the misspelled word is close to
244 some words in the dictionary, they are offered as near misses.
245 r Replace. Replace the word with a string you type. Each word
246 of your new string is also checked.
247 i Insert. Insert this word in your private dictionary (kept in
248 `$HOME/ispell.words').
249 a Accept. Accept this word for the rest of this editing session,
250 but don't put it in your private dictionary.
251 l Lookup. Look for a word in the dictionary by fast binary
252 search, or search for a regular expression in the dictionary
254 SPACE Accept the word this time, but complain if it is seen again.
255 q, \\[keyboard-quit] Leave the command loop. You can come back later with \\[ispell-next]."
263 (setq buf (current-buffer)))
264 (setq buf (get-buffer buf))
266 (error "Can't find buffer"))
267 ;; Deactivate the mark, because we'll do it anyway if we change something,
268 ;; and a region highlight while in the Ispell loop is distracting.
272 (let ((filename buffer-file-name)
276 (cond ((null filename)
277 (setq filename (make-temp-name "/usr/tmp/ispell"))
279 (write-region (point-min) (point-max) filename))
280 ((and (buffer-modified-p buf)
281 (y-or-n-p (format "Save file %s? " filename)))
283 (message "Ispell scanning file...")
284 (if (and ispell-enable-tex-parser
285 (ispell-tex-buffer-p))
287 (ispell-cmd ":generic"))
288 (ispell-cmd (format ":file %s %d %d" filename start end)))
291 (delete-file filename)
293 (message "Parsing ispell output ...")
294 (ispell-flush-bad-words)
296 (while (numberp (setq pos (ispell-next-message)))
297 ;;ispell may check the words on the line following the end
298 ;;of the region - therefore, don't record anything out of range
301 (setq bad-words (cons (set-marker (make-marker) (+ pos 1))
303 (setq bad-words (cons pos bad-words))
304 (setq ispell-bad-words (nreverse bad-words))))
305 (cond ((not (markerp (car ispell-bad-words)))
306 (setq ispell-bad-words nil)
307 (message "No misspellings."))
309 (message "Ispell parsing done.")
313 (defalias 'ispell-buffer 'ispell)
315 (defun ispell-next ()
316 "Resume command loop for most recent Ispell command."
318 (setq ispell-window-configuration nil)
321 ;; There used to be a save-excursion here,
322 ;; but that was annoying: it's better if point doesn't move
325 (while (markerp (setq next (car ispell-bad-words)))
326 (switch-to-buffer (marker-buffer next))
328 (ispell-point next "at saved position.")
329 (setq ispell-bad-words (cdr ispell-bad-words))
330 (set-marker next nil))))
331 (if ispell-window-configuration
332 (set-window-configuration ispell-window-configuration))
333 (cond ((null ispell-bad-words)
334 (error "Ispell has not yet been run."))
335 ((markerp (car ispell-bad-words))
336 (message (substitute-command-keys
337 "Type \\[ispell-next] to continue.")))
338 ((eq (car ispell-bad-words) nil)
339 (setq ispell-bad-words nil)
340 (message "No more misspellings (but checker was interrupted.)"))
341 ((eq (car ispell-bad-words) t)
342 (setq ispell-bad-words nil)
343 (message "Ispell done."))
345 (setq ispell-bad-words nil)
346 (message "Bad ispell internal list"))))
350 (defun ispell-word (&optional resume)
351 "Check the spelling of the word under the cursor.
352 See the command `ispell' for more information.
353 With a prefix argument, resume handling of the previous Ispell command."
359 (save-window-excursion
360 (ispell-point (point) "at point."))
362 (ispell-startup-error
363 (cond ((y-or-n-p "Problem starting ispell, use old-style spell instead? ")
364 (load-library "spell")
365 (define-key esc-map "$" 'spell-word)
368 (define-key esc-map "$" 'ispell-word)
371 (defun ispell-region (start &optional end)
372 "Check the spelling for all of the words in the region."
374 (ispell (current-buffer) start end))
376 (defun ispell-letterp (c)
378 (or (and (>= c ?A) (<= c ?Z))
379 (and (>= c ?a) (<= c ?z))
382 (defun ispell-letter-or-quotep (c)
384 (or (and (>= c ?A) (<= c ?Z))
385 (and (>= c ?a) (<= c ?z))
389 (defun ispell-find-word-start ()
390 ;;backward to a letter
391 (if (not (ispell-letterp (char-after (point))))
392 (while (and (not (bobp))
393 (not (ispell-letterp (char-after (- (point) 1)))))
395 ;;backward to beginning of word
396 (while (ispell-letter-or-quotep (char-after (- (point) 1)))
398 (skip-chars-forward "'"))
400 (defun ispell-find-word-end ()
401 (while (ispell-letter-or-quotep (char-after (point)))
403 (skip-chars-backward "'"))
405 (defun ispell-next-word ()
406 (while (and (not (eobp))
407 (not (ispell-letterp (char-after (point)))))
410 ;if end is nil, then do one word at start
411 ;otherwise, do all words from the beginning of the word where
412 ;start points, to the end of the word where end points
413 (defun ispell-point (start message)
414 (let ((wend (make-marker))
417 ;; There used to be a save-excursion here,
418 ;; but that was annoying: it's better if point doesn't move
421 (ispell-find-word-start) ;find correct word start
422 (setq start (point-marker))
423 (ispell-find-word-end) ;now find correct end
424 (setq end (point-marker))
425 ;; Do nothing if we don't find a word.
429 (ispell-find-word-end) ;find end of current word
430 ;could be before 'end' if
431 ;user typed replacement
432 ;that is more than one word
433 (set-marker wend (point))
435 (setq word (buffer-substring start wend))
436 (cond ((ispell-still-bad word)
437 ;;; This just causes confusion. -- rms.
438 ;;; (goto-char start)
440 (message (format "Ispell checking %s" word))
442 (let ((message (ispell-next-message)))
443 (cond ((eq message t)
444 (message "%s: ok" word))
448 (ispell-command-loop word start wend message)))
450 (error "unknown ispell response %s" message))))))
454 (set-marker start (point))))))
455 ;;clear the choices buffer; otherwise it's hard for the user to tell
456 ;;when we get back to the command loop
457 (let ((buf (get-buffer "*ispell choices*")))
461 (set-marker start nil)
463 (set-marker wend nil)))
465 (defun ispell-still-bad (word)
466 (let ((words ispell-recently-accepted)
468 (case-fold-search t))
470 (cond ((eq (string-match (car words) word) 0)
473 (setq words (cdr words)))
476 (defun ispell-show-choices (word message first-line)
477 ;;if there is only one window on the frame, make the ispell
478 ;;messages winow be small. otherwise just use the other window
479 (let* ((selwin (selected-window))
480 (resize (eq selwin (next-window)))
481 (buf (get-buffer-create "*ispell choices*"))
483 (or ispell-window-configuration
484 (setq ispell-window-configuration (current-window-configuration)))
485 (setq w (display-buffer buf))
486 (buffer-disable-undo buf)
491 (enlarge-window (- 6 (window-height w))))
492 (select-window selwin)))
496 (set-window-point w (point-min))
497 (set-window-start w (point-min))
499 (insert first-line "\n")
501 "SPC skip; A accept; I insert; DIGIT select; R replace; \
503 (cond ((not (null message))
508 (let* ((n (+ (* j 3) i))
509 (choice (nth n message)))
511 (let ((str (format "%d %s" n choice)))
513 (insert-char ? (- 20 (length str)))))))
516 (setq i (+ i 1)))))))))
518 (defun ispell-command-loop (word start end message)
523 (setq first-line (concat "No near misses for '" word "'"))
524 (setq first-line (concat "Near misses for '" word "'")))
526 (ispell-show-choices word message first-line)
527 (message "Ispell command: ")
529 (let ((c (downcase (read-char)))
531 (cond ((and (>= c ?0)
533 (setq replacement (nth (- c ?0) message)))
534 (ispell-replace start end replacement)
541 (ispell-replace start end (read-string "Replacement: "))
551 (let ((val (ispell-do-look word)))
552 (setq first-line (car val))
553 (setq message (cdr val))))
556 "Type 'C-h d ispell' to the emacs main loop for more help")
559 (message "Bad ispell command")
563 (defun ispell-do-look (bad-word)
564 (let (regex buf words)
565 (cond ((null ispell-have-new-look)
566 (setq regex (read-string "Lookup: ")))
568 (setq regex (read-string "Lookup (regex): " "^"))))
569 (setq buf (get-buffer-create "*ispell look*"))
572 (delete-region (point-min) (point-max))
573 (if ispell-have-new-look
574 (call-process "look" nil buf nil "-r" regex)
575 (call-process "look" nil buf nil regex))
576 (goto-char (point-min))
578 (delete-region (point) (point-max))
579 (goto-char (point-min))
580 (while (not (= (point-min) (point-max)))
582 (setq words (cons (buffer-substring (point-min) (point)) words))
584 (delete-region (point-min) (point)))
586 (cons (format "Lookup '%s'" regex)
589 (defun ispell-replace (start end new)
592 (delete-region (point) end))
594 (defun reload-ispell ()
595 "Tell Ispell to re-read your private dictionary."
597 (ispell-cmd ":reload"))
599 (defun batch-make-ispell ()
600 (byte-compile-file "ispell.el")
601 (find-file "ispell.texinfo")
602 (let ((old-dir default-directory)
603 (default-directory "/tmp"))
604 (texinfo-format-buffer))
606 (if (get-buffer " *problems in info file*")
608 (write-region (point-min) (point-max) "ispell.info"))
610 (defun ispell-message ()
611 "Check the spelling for an outgoing mail message."
614 (beginning-of-buffer)
615 (search-forward mail-header-separator nil t)
616 (ispell (current-buffer) (point))))
620 ;;; ispell.el ends here