From 39a561e69e2e371e10b3b5d55b158fb013f8fd7c Mon Sep 17 00:00:00 2001 From: Stefan Monnier Date: Tue, 13 May 2003 22:51:58 +0000 Subject: [PATCH] Version 3.4 --- lisp/textmodes/ispell.el | 545 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 375 insertions(+), 170 deletions(-) diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el index 512df0a9944..9788eb18ec8 100644 --- a/lisp/textmodes/ispell.el +++ b/lisp/textmodes/ispell.el @@ -1,13 +1,15 @@ ;;; ispell.el --- Interface to International Ispell Versions 3.1 and 3.2 -;; Copyright (C) 1994, 1995, 1997, 1998, 1999 Free Software Foundation, Inc. +;; Copyright (C) 1994, 1995, 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc. -;; Authors : Ken Stevens -;; Stevens Mod Date: Mon 29 Nov 11:38:34 PST 1999 -;; Stevens Revision: 3.3 +;; Author: Ken Stevens +;; Maintainer: +;; Stevens Mod Date: Fri Aug 4 09:41:50 PDT 2000 +;; Stevens Revision: 3.4 ;; Status : Release with 3.1.12+ and 3.2.0+ ispell. ;; Bug Reports : ispell-el-bugs@itcorp.com ;; Web Site : http://kdstevens.com/~stevens/ispell-page.html +;; Keywords: unix wp ;; This file is part of GNU Emacs. @@ -127,6 +129,17 @@ ;; Modifications made in latest versions: +;; Revision 3.4 2000/8/4 09:41:50 kss +;; Support new color display functions. +;; Fixed misalignment offset bug when replacing a string after a shift made. +;; Set to standard Author/Maintainer heading, +;; ensure localwords lists are separated from the text by newline. (Dave Love) +;; Added dictionary definition for Italian (William Deakin) +;; HTML region skipping greatly improved. (Chuck D. Phillips) +;; improved menus. Fixed regexp matching http/email addresses. +;; one arg always for xemacs sleep-for (gunnar Evermann) +;; support for synchronous processes (Eli Zaretskii) + ;; Revision 3.3 1999/11/29 11:38:34 kss ;; Only word replacements entered in from the keyboard are rechecked. ;; This fixes a bug in tex parsing and misalignment. @@ -183,6 +196,9 @@ "User variables for emacs ispell interface." :group 'applications))) +(if (not (fboundp 'buffer-substring-no-properties)) + (defun buffer-substring-no-properties (start end) + (buffer-substring start end))) ;;;###autoload (defconst xemacsp (string-match "Lucid\\|XEmacs" emacs-version) @@ -196,6 +212,11 @@ (defconst version20p (string-match "20\\.[0-9]+\\.[0-9]+" emacs-version) "Non nil if using emacs version 20.") +(and (not version18p) + (not (boundp 'epoch::version)) + (defalias 'ispell 'ispell-buffer) + (defalias 'ispell-check-version 'check-ispell-version)) + ;;; ********************************************************************** ;;; The following variables should be set according to personal preference @@ -358,7 +379,7 @@ The following values are supported: there for a couple of seconds. t Pop up a new buffer and display a short help message there for a couple of seconds. - electric Pop up a new buffer and display a long help message there. + electric Pop up a new buffer and display a long help message there. User can browse and then exit the help mode." :type '(choice (const electric) (const :tag "off" nil) (const :tag "on" t)) :group 'ispell) @@ -429,6 +450,17 @@ for language-specific arguments." :group 'ispell) + +(defcustom ispell-skip-html 'use-mode-name + "*Indicates whether ispell should skip spell checking of SGML markup. +If t, always skip SGML markup; if nil, never skip; if non-t and non-nil, +guess whether SGML markup should be skipped according to the name of the +buffer's major mode." + :type '(choice (const :tag "always" t) (const :tag "never" nil) + (const :tag "use-mode-name" use-mode-name)) + :group 'ispell) + + ;;; Define definitions here only for personal dictionaries. ;;;###autoload (defcustom ispell-local-dictionary-alist nil @@ -446,7 +478,7 @@ See `ispell-dictionary-alist'." (choice :tag "Extended character mode" (const "~tex") (const "~plaintex") (const "~nroff") (const "~list") - (const "~latin1") (const "~latin3") + (const "~latin1") (const "~latin3") (const :tag "default" nil)) (choice :tag "Character set" (const iso-8859-1) @@ -465,7 +497,7 @@ See `ispell-dictionary-alist'." "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("american" ; Yankee English "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) - ("brasiliano" ; Brazilian mode + ("brasileiro" ; Brazilian mode "[A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[^A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[']" nil ("-d" "brasileiro") nil iso-8859-1) @@ -474,11 +506,11 @@ See `ispell-dictionary-alist'." ("castellano" ; Spanish mode "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" - "[---]" nil ("-B" "-d" "castellano") "~tex" iso-8859-1) + "[-]" nil ("-B" "-d" "castellano") "~tex" iso-8859-1) ("castellano8" ; 8 bit Spanish mode "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" - "[---]" nil ("-B" "-d" "castellano") "~latin1" iso-8859-1))) + "[-]" nil ("-B" "-d" "castellano") "~latin1" iso-8859-1))) ;;; Second part of dictionary, shortened for loaddefs.el @@ -518,7 +550,7 @@ See `ispell-dictionary-alist'." ("francais" ; Francais.aff "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" - "[---']" t nil "~list" iso-8859-1))) + "[-']" t nil "~list" iso-8859-1))) ;;; Fourth part of dictionary, shortened for loaddefs.el @@ -528,7 +560,11 @@ See `ispell-dictionary-alist'." '(("francais-tex" ; Francais.aff "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" - "[---'^`\"]" t nil "~tex" iso-8859-1) + "[-'^`\"]" t nil "~tex" iso-8859-1) + ("italiano" ; Italian.aff + "[A-Z\300\301\310\311\314\315\322\323\331\332a-z\340\341\350\351\354\355\363\371\372]" + "[^A-Z\300\301\310\311\314\315\322\323\331\332a-z\340\341\350\351\354\355\363\371\372]" + "[-]" nil ("-B" "-d" "italian") "~tex" iso-8859-1) ("nederlands" ; Nederlands.aff "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" @@ -550,7 +586,7 @@ See `ispell-dictionary-alist'." ("norsk7-tex" ; 7 bit Norwegian TeX mode "[A-Za-z{}\\'^`]" "[^A-Za-z{}\\'^`]" "[\"]" nil ("-d" "norsk") "~plaintex" iso-8859-1) - ("polish" ; polish mode + ("polish" ; polish mode "[A-Za-z\241\243\246\254\257\261\263\266\274\277\306\312\321\323\346\352\361\363]" "[^A-Za-z\241\243\246\254\257\261\263\266\274\277\306\312\321\323\346\352\361\363]" "" nil ( "-d" "polish") nil iso-8859-2))) @@ -637,7 +673,7 @@ LANGUAGE.aff file \(e.g., english.aff\)." (choice :tag "Extended character mode" (const "~tex") (const "~plaintex") (const "~nroff") (const "~list") - (const "~latin1") (const "~latin3") + (const "~latin1") (const "~latin3") (const :tag "default" nil)) (choice :tag "Character set" (const iso-8859-1) @@ -652,9 +688,13 @@ LANGUAGE.aff file \(e.g., english.aff\)." ispell-dictionary-alist-3 ispell-dictionary-alist-4 ispell-dictionary-alist-5 ispell-dictionary-alist-6)) -;;; The preparation of the menu bar menu must be autoloaded -;;; because otherwise this file gets autoloaded every time Emacs starts -;;; so that it can set up the menus and determine keyboard equivalents. + + + +;;; ********************************************************************** +;;; The following are used by ispell, and should not be changed. +;;; ********************************************************************** + ;;; The version must be 3.1 or greater for this version of ispell.el @@ -664,7 +704,7 @@ LANGUAGE.aff file \(e.g., english.aff\)." (defvar ispell-offset -1 "Offset that maps protocol differences between ispell 3.1 versions.") -(defconst ispell-version "ispell.el 3.3 -- Mon 29 Nov 11:38:34 PST 1999") +(defconst ispell-version "ispell.el 3.4 -- Fri Aug 4 09:41:50 PDT 2000") (defun check-ispell-version (&optional interactivep) @@ -731,6 +771,12 @@ Otherwise returns the library path if defined." result)) + +;;; The preparation of the menu bar menu must be autoloaded +;;; because otherwise this file gets autoloaded every time Emacs starts +;;; so that it can set up the menus and determine keyboard equivalents. + + ;;;###autoload (defvar ispell-menu-map nil "Key map for ispell menu.") ;;; redo menu when loading ispell to get dictionary modifications @@ -773,8 +819,10 @@ and added as a submenu of the \"Edit\" menu.") (cond ((not (stringp name)) (define-key ispell-menu-map (vector 'default) (cons "Select Default Dict" - (list 'lambda () '(interactive) - (list 'ispell-change-dictionary "default"))))) + (cons "Dictionary for which Ispell was configured" + (list 'lambda () '(interactive) + (list + 'ispell-change-dictionary "default")))))) ((or (not path) ; load all if library dir not defined (file-exists-p (concat path "/" name ".hash")) (file-exists-p (concat path "/" name ".has")) @@ -782,7 +830,7 @@ and added as a submenu of the \"Edit\" menu.") (or (file-exists-p(concat path "/" load-dict ".hash")) (file-exists-p(concat path "/" load-dict ".has"))))) (define-key ispell-menu-map (vector (intern name)) - (cons (concat "Select " (capitalize name)) + (cons (concat "Select " (capitalize name) " Dict") (list 'lambda () '(interactive) (list 'ispell-change-dictionary name))))))))) @@ -792,39 +840,61 @@ and added as a submenu of the \"Edit\" menu.") (if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-change-dictionary] - '("Change Dictionary" . ispell-change-dictionary)) + '(menu-item "Change Dictionary..." ispell-change-dictionary + :help "Supply explicit path to dictionary")) (define-key ispell-menu-map [ispell-kill-ispell] - '("Kill Process" . ispell-kill-ispell)) + '(menu-item "Kill Process" ispell-kill-ispell + :enable (and ispell-process + (eq (ispell-process-status) 'run)) + :help "Terminate Ispell subprocess")) (define-key ispell-menu-map [ispell-pdict-save] - '("Save Dictionary" . (lambda ()(interactive) (ispell-pdict-save t t)))) + '(menu-item "Save Dictionary" + (lambda () (interactive) (ispell-pdict-save t t)) + :help "Save personal dictionary")) + (define-key ispell-menu-map [ispell-help] + ;; use (x-popup-menu last-nonmenu-event(list "" ispell-help-list)) ? + '(menu-item "Help" + (lambda () (interactive) (describe-function 'ispell-help)) + :help "Show standard Ispell keybindings and commands")) (define-key ispell-menu-map [ispell-complete-word] - '("Complete Word" . ispell-complete-word)) + '(menu-item "Complete Word" ispell-complete-word + :help "Complete word at cursor using dictionary")) (define-key ispell-menu-map [ispell-complete-word-interior-frag] - '("Complete Word Frag" . ispell-complete-word-interior-frag)))) + '(menu-item "Complete Word Fragment" ispell-complete-word-interior-frag + :help "Complete word fragment at cursor")))) ;;;###autoload (if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-continue] - '("Continue Check" . ispell-continue)) + '(menu-item "Continue Spell-Checking" ispell-continue + :enable (and (boundp 'ispell-region-end) + (marker-position ispell-region-end) + (equal (marker-buffer ispell-region-end) + (current-buffer))) + :help "Continue spell checking last region")) (define-key ispell-menu-map [ispell-word] - '("Check Word" . ispell-word)) + '(menu-item "Spell-Check Word" ispell-word + :help "Spell-check word at cursor")) (define-key ispell-menu-map [ispell-comments-and-strings] - '("Check Comments" . ispell-comments-and-strings)) - (define-key ispell-menu-map [ispell-region] - '("Check Region" . ispell-region)) - (define-key ispell-menu-map [ispell-buffer] - '("Check Buffer" . ispell-buffer)))) + '(menu-item "Spell-Check Comments" ispell-comments-and-strings + :help "Spell-check only comments and strings")))) + ;;;###autoload (if ispell-menu-map-needed (progn + (define-key ispell-menu-map [ispell-region] + '(menu-item "Spell-Check Region" ispell-region + :enable mark-active + :help "Spell-check text in marked region")) (define-key ispell-menu-map [ispell-message] - '("Check Message" . ispell-message)) - (define-key ispell-menu-map [ispell-help] - ;; use (x-popup-menu last-nonmenu-event(list "" ispell-help-list)) ? - '("Help" . (lambda () (interactive) (describe-function 'ispell-help)))) - (put 'ispell-region 'menu-enable 'mark-active) + '(menu-item "Spell-Check Message" ispell-message + :help "Skip headers and included message text")) + (define-key ispell-menu-map [ispell-buffer] + '(menu-item "Spell-Check Buffer" ispell-buffer + :help "Check spelling of selected buffer")) + ;;(put 'ispell-region 'menu-enable 'mark-active) (fset 'ispell-menu-map (symbol-value 'ispell-menu-map)))) ;;; XEmacs versions 19 & 20 @@ -888,8 +958,6 @@ and added as a submenu of the \"Edit\" menu.") ;;; ********************************************************************** -;;; The following are used by ispell, and should not be changed. -;;; ********************************************************************** ;;; This variable contains the current dictionary being used if the ispell @@ -934,6 +1002,15 @@ Protects against bogus binding of `enable-multibyte-characters' in XEmacs." (defvar ispell-process nil "The process object for Ispell.") +(defvar ispell-async-processp (and (fboundp 'kill-process) + (fboundp 'process-send-string) + (fboundp 'accept-process-output) + ;;(fboundp 'start-process) + ;;(fboundp 'set-process-filter) + ;;(fboundp 'process-kill-without-query) + ) + "Non-nil means that the OS supports asynchronous processes.") + (defvar ispell-pdict-modified-p nil "Non-nil means personal dictionary has modifications to be saved.") @@ -942,14 +1019,23 @@ Protects against bogus binding of `enable-multibyte-characters' in XEmacs." ;;; When numeric, contains cursor location in buffer, and cursor remains there. (defvar ispell-quit nil) +(defvar ispell-process-directory nil + "The directory where `ispell-process' was started.") + (defvar ispell-filter nil "Output filter from piped calls to Ispell.") (defvar ispell-filter-continue nil "Control variable for Ispell filter function.") -(defvar ispell-process-directory nil - "The directory where `ispell-process' was started.") +(defvar ispell-output-buffer nil + "Buffer used for reading output of a synchronous Ispell subprocess.") + +(defvar ispell-session-buffer nil + "Buffer used for passing input to a synchronous Ispell subprocess.") + +(defvar ispell-cmd-args nil + "Command-line arguments to pass to a synchronous Ispell subprocess.") (defvar ispell-query-replace-marker (make-marker) "Marker for `query-replace' processing.") @@ -999,15 +1085,16 @@ The last occurring definition in the buffer will be used.") (ispell-parsing-keyword forward-line) ("^---*BEGIN PGP [A-Z ]*--*" . "^---*END PGP [A-Z ]*--*") ("^---* \\(Start of \\)?[Ff]orwarded [Mm]essage" . "^---* End of [Ff]orwarded [Mm]essage") - ;; matches e-mail addresses, file names, http addresses, etc. - ("\\(/\\|\\(\\(\\w\\|-\\)+[.:@]\\)\\)\\(\\w\\|-\\)*\\([.:/@]+\\(\\w\\|-\\|~\\)+\\)+") + ;; Matches e-mail addresses, file names, http addresses, etc. The `-+' + ;; pattern necessary for performance reasons when `-' part of word syntax. + ("\\(-+\\|\\(/\\|\\(\\(\\w\\|[-_]\\)+[.:@]\\)\\)\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_]\\|~\\)+\\)+\\)") ;; This is a pretty complex regexp. It can be simplified to the following: - ;; "\\(\\w\\|-\\)*\\([.:/@]+\\(\\w\\|-\\|~\\)+\\)+" + ;; "\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_]\\|~\\)+\\)+" ;; but some valid text will be skipped, e.g. "his/her". This could be ;; fixed up (at the expense of a moderately more complex regexp) ;; by not allowing "/" to be the character which triggers the ;; identification of the computer name, e.g.: - ;; "\\(\\w\\|-\\)+[.:@]\\(\\w\\|-\\)*\\([.:/@]+\\(\\w\\|-\\|~\\)+\\)+" + ;; "\\(\\w\\|[-_]\\)+[.:@]\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_]\\|~\\)+\\)+" ) "Alist expressing beginning and end of regions not to spell check. The alist key must be a regular expression. @@ -1048,15 +1135,6 @@ Delete or add any regions you want to be automatically selected for skipping in latex mode.") -(defcustom ispell-skip-sgml 'use-mode-name - "*Indicates whether ispell should skip spell checking of SGML markup. -If t, always skip SGML markup; if nil, never skip; if non-t and non-nil, -guess whether SGML markup should be skipped according to the name of the -buffer's major mode." - :type '(choice (const :tag "always" t) (const :tag "never" nil) - (const :tag "use-mode-name" use-mode-name)) - :group 'ispell) - (defvar ispell-local-pdict ispell-personal-dictionary "A buffer local variable containing the current personal dictionary. If non-nil, the value must be a string, which is a file name. @@ -1095,18 +1173,108 @@ You can set this variable in hooks in your init file -- eg: -(and (not version18p) - (not (boundp 'epoch::version)) - (defalias 'ispell 'ispell-buffer) - (defalias 'ispell-check-version 'check-ispell-version)) +;;;###autoload +(define-key esc-map "$" 'ispell-word) -(if (not (fboundp 'buffer-substring-no-properties)) - (defun buffer-substring-no-properties (start end) - (buffer-substring start end))) +(defun ispell-accept-output (&optional timeout-secs timeout-msecs) + "Wait for output from ispell process, or TIMEOUT-SECS and TIMEOUT-MSECS. +If asynchronous subprocesses are not supported, call `ispell-filter' and +pass it the output of the last ispell invocation." + (if ispell-async-processp + (accept-process-output ispell-process timeout-secs timeout-msecs) + (if (null ispell-process) + (error "No Ispell process to read output from!") + (let ((buf ispell-output-buffer) + ispell-output) + (if (not (bufferp buf)) + (setq ispell-filter nil) + (save-excursion + (set-buffer buf) + (setq ispell-output (buffer-substring-no-properties + (point-min) (point-max)))) + (ispell-filter t ispell-output) + (save-excursion + (set-buffer buf) + (erase-buffer))))))) + + +(defun ispell-send-string (string) + "Send the string STRING to the Ispell process." + (if ispell-async-processp + (process-send-string ispell-process string) + ;; Asynchronous subprocesses aren't supported on this losing system. + ;; We keep all the directives passed to Ispell during the entire + ;; session in a buffer, and pass them anew each time we invoke + ;; Ispell to process another chunk of text. (Yes, I know this is a + ;; terrible kludge, and it's a bit slow, but it does get the work done.) + (let ((cmd (aref string 0)) + ;; The following commands are not passed to Ispell until + ;; we have a *reall* reason to invoke it. + (cmds-to-defer '(?* ?@ ?~ ?+ ?- ?! ?%)) + (default-major-mode 'fundamental-mode) + (session-buf ispell-session-buffer) + (output-buf ispell-output-buffer) + (ispell-args ispell-cmd-args) + (defdir ispell-process-directory) + prev-pos) + (save-excursion + (set-buffer session-buf) + (setq prev-pos (point)) + (setq default-directory defdir) + (insert string) + (if (not (memq cmd cmds-to-defer)) + (let (coding-system-for-read coding-system-for-write status) + (if (or xemacsp + (and (boundp 'enable-multibyte-characters) + enable-multibyte-characters)) + (setq coding-system-for-read (ispell-get-coding-system) + coding-system-for-write (ispell-get-coding-system))) + (set-buffer output-buf) + (erase-buffer) + (set-buffer session-buf) + (setq status + (apply 'call-process-region (point-min) (point-max) + ispell-program-name nil + output-buf nil + "-a" "-m" ispell-args)) + (set-buffer output-buf) + (goto-char (point-min)) + (save-match-data + (if (not (looking-at "@(#) ")) + (error "Ispell error: %s" + (buffer-substring-no-properties + (point) (progn (end-of-line) (point))))) + ;; If STRING is "^Z\n", we just started Ispell and need + ;; to retain its version ID line in the output buffer. + ;; Otherwise, remove the ID line, as it will confuse + ;; `ispell-filter'. + (or (string= string "\032\n") + (progn + (forward-line) + (delete-region (point-min) (point)))) + ;; If STRING begins with ^ or any normal character, we need + ;; to remove the last line from the session buffer, since it + ;; was just spell-checked, and we don't want to check it again. + ;; The same goes for the # command, since Ispell already saved + ;; the personal dictionary. + (set-buffer session-buf) + (delete-region prev-pos (point)) + ;; Ispell run synchronously saves the personal dictionary + ;; after each successful command. So we can remove any + ;; lines in the session buffer that insert words into the + ;; dictionary. + (if (memq status '(0 nil)) + (let ((more-lines t)) + (goto-char (point-min)) + (while more-lines + (if (looking-at "^\\*") + (let ((start (point))) + (forward-line) + (delete-region start (point))) + (setq more-lines (= 0 (forward-line)))))))))))))) + -;;;###autoload -(define-key esc-map "$" 'ispell-word) ;;;###autoload (defun ispell-word (&optional following quietly continue) @@ -1156,13 +1324,13 @@ quit spell session exited." (or quietly (message "Checking spelling of %s..." (funcall ispell-format-word word))) - (process-send-string ispell-process "%\n") ;put in verbose mode - (process-send-string ispell-process (concat "^" word "\n")) + (ispell-send-string "%\n") ; put in verbose mode + (ispell-send-string (concat "^" word "\n")) ;; wait until ispell has processed word (while (progn - (accept-process-output ispell-process) + (ispell-accept-output) (not (string= "" (car ispell-filter))))) - ;;(process-send-string ispell-process "!\n") ;back to terse mode. + ;;(ispell-send-string "!\n") ;back to terse mode. (setq ispell-filter (cdr ispell-filter)) ; remove extra \n (if (and ispell-filter (listp ispell-filter)) (if (> (length ispell-filter) 1) @@ -1296,7 +1464,7 @@ If so, ask if it needs to be saved." (if (or ispell-pdict-modified-p force-save) (if (or no-query (y-or-n-p "Personal dictionary modified. Save? ")) (progn - (process-send-string ispell-process "#\n") ; save dictionary + (ispell-send-string "#\n") ; save dictionary (message "Personal dictionary saved.")))) ;; unassert variable, even if not saved to avoid questioning. (setq ispell-pdict-modified-p nil)) @@ -1372,7 +1540,7 @@ Global `ispell-quit' set to start location to continue spell session." ;; ensure word is visible (if (not (pos-visible-in-window-p end)) (sit-for 0)) - + ;; allow temporary split of dedicated windows... (if dedicated (progn @@ -1418,11 +1586,11 @@ Global `ispell-quit' set to start location to continue spell session." (cond ((= char ? ) nil) ; accept word this time only ((= char ?i) ; accept and insert word into pers dict - (process-send-string ispell-process (concat "*" word "\n")) + (ispell-send-string (concat "*" word "\n")) (setq ispell-pdict-modified-p '(t)) ; dictionary modified! nil) ((or (= char ?a) (= char ?A)) ; accept word without insert - (process-send-string ispell-process (concat "@" word "\n")) + (ispell-send-string (concat "@" word "\n")) (if (null ispell-pdict-modified-p) (setq ispell-pdict-modified-p (list ispell-pdict-modified-p))) @@ -1518,14 +1686,12 @@ Global `ispell-quit' set to start location to continue spell session." 'block)) t) ; reselect from new choices ((= char ?u) ; insert lowercase into dictionary - (process-send-string ispell-process - (concat "*" (downcase word) "\n")) + (ispell-send-string (concat "*" (downcase word) "\n")) (setq ispell-pdict-modified-p '(t)) ; dictionary modified! nil) ((= char ?m) ; type in what to insert - (process-send-string - ispell-process (concat "*" (read-string "Insert: " word) - "\n")) + (ispell-send-string + (concat "*" (read-string "Insert: " word) "\n")) (setq ispell-pdict-modified-p '(t)) (cons word nil)) ((and (>= num 0) (< num count)) @@ -1641,7 +1807,7 @@ SPC: Accept word this time. (if (equal ispell-help-in-bufferp 'electric) (progn (require 'ehelp) - (with-electric-help + (with-electric-help (function (lambda () ;;This shouldn't be necessary: with-electric-help needs ;; an optional argument telling it about the smallest @@ -1859,7 +2025,9 @@ The variable `ispell-highlight-face' selects the face to use for highlighting." (xemacsp (ispell-highlight-spelling-error-xemacs start end highlight)) ((and (not version18p) - (featurep 'faces) window-system) + (featurep 'faces) + (or (and (fboundp 'display-color-p) (display-color-p)) + window-system)) (ispell-highlight-spelling-error-overlay start end highlight)) (t (ispell-highlight-spelling-error-generic start end highlight refresh)))) @@ -1942,11 +2110,52 @@ Optional third arg SHIFT is an offset to apply based on previous corrections." (nreverse miss-list) (nreverse guess-list))))))) +(defun ispell-process-status () + "Return the status of the Ispell process. +When asynchronous processes are not supported, `run' is always returned." + (if ispell-async-processp + (process-status ispell-process) + (and ispell-process 'run))) + + +(defun ispell-start-process () + "Start the ispell process, with support for no asynchronous processes. +Keeps argument list for future ispell invocations for no async support." + (let (args) + ;; Local dictionary becomes the global dictionary in use. + (if ispell-local-dictionary + (setq ispell-dictionary ispell-local-dictionary)) + (setq args (ispell-get-ispell-args)) + (if ispell-dictionary ; use specified dictionary + (setq args + (append (list "-d" ispell-dictionary) args))) + (if ispell-personal-dictionary ; use specified pers dict + (setq args + (append args + (list "-p" + (expand-file-name ispell-personal-dictionary))))) + (setq args (append args ispell-extra-args)) + + (if ispell-async-processp + (let ((process-connection-type ispell-use-ptys-p)) + (apply 'start-process + "ispell" nil ispell-program-name + "-a" ; accept single input lines + "-m" ; make root/affix combos not in dict + args)) + (setq ispell-cmd-args args + ispell-output-buffer (generate-new-buffer " *ispell-output*") + ispell-session-buffer (generate-new-buffer " *ispell-session*")) + (ispell-send-string "\032\n") ; so Ispell prints version and exits + t))) + + + (defun ispell-init-process () "Check status of Ispell process and start if necessary." (if (and ispell-process - (eq (process-status ispell-process) 'run) - ;; If we're using a personal dictionary, assure + (eq (ispell-process-status) 'run) + ;; If we're using a personal dictionary, ensure ;; we're in the same default directory! (or (not ispell-personal-dictionary) (equal ispell-process-directory default-directory))) @@ -1956,32 +2165,12 @@ Optional third arg SHIFT is an offset to apply based on previous corrections." (message "Starting new Ispell process...") (sit-for 0) (check-ispell-version) - (setq ispell-process - (let ((process-connection-type ispell-use-ptys-p)) - (apply 'start-process - "ispell" nil ispell-program-name - "-a" ; accept single input lines - "-m" ; make root/affix combos not in dict - (let (args) - ;; Local dictionary becomes the global dictionary in use. - (if ispell-local-dictionary - (setq ispell-dictionary ispell-local-dictionary)) - (setq args (ispell-get-ispell-args)) - (if ispell-dictionary ; use specified dictionary - (setq args - (append (list "-d" ispell-dictionary) args))) - (if ispell-personal-dictionary ; use specified pers dict - (setq args - (append args - (list "-p" - (expand-file-name - ispell-personal-dictionary))))) - (setq args (append args ispell-extra-args)) - args))) + (setq ispell-process-directory default-directory + ispell-process (ispell-start-process) ispell-filter nil - ispell-filter-continue nil - ispell-process-directory default-directory) - (set-process-filter ispell-process 'ispell-filter) + ispell-filter-continue nil) + (if ispell-async-processp + (set-process-filter ispell-process 'ispell-filter)) ;; protect against bogus binding of `enable-multibyte-characters' in XEmacs (if (and (or xemacsp (and (boundp 'enable-multibyte-characters) @@ -1991,10 +2180,10 @@ Optional third arg SHIFT is an offset to apply based on previous corrections." (ispell-get-coding-system))) ;; Get version ID line (if (not version18p) - (accept-process-output ispell-process 3) - (accept-process-output ispell-process)) + (ispell-accept-output 3) + (ispell-accept-output)) ;; get more output if filter empty? - (if (null ispell-filter) (accept-process-output ispell-process 3)) + (if (null ispell-filter) (ispell-accept-output 3)) (cond ((null ispell-filter) (error "%s did not output version line" ispell-program-name)) ((and @@ -2002,8 +2191,8 @@ Optional third arg SHIFT is an offset to apply based on previous corrections." (if (string-match "warning: " (car ispell-filter)) (progn (if (not version18p) - (accept-process-output ispell-process 3) ; was warn msg. - (accept-process-output ispell-process)) + (ispell-accept-output 3) ; was warn msg. + (ispell-accept-output)) (stringp (car ispell-filter))) (null (cdr ispell-filter))) (string-match "^@(#) " (car ispell-filter))) @@ -2015,14 +2204,14 @@ Optional third arg SHIFT is an offset to apply based on previous corrections." ;; But first wait to see if some more output is going to arrive. ;; Otherwise we get cool errors like "Can't open ". (sleep-for 1) - (accept-process-output ispell-process 3) + (ispell-accept-output 3) (error "%s" (mapconcat 'identity ispell-filter "\n")))) (setq ispell-filter nil) ; Discard version ID line (let ((extended-char-mode (ispell-get-extended-character-mode))) (if extended-char-mode ; ~ extended character mode - (process-send-string ispell-process - (concat extended-char-mode "\n")))) - (process-kill-without-query ispell-process))) + (ispell-send-string (concat extended-char-mode "\n")))) + (if ispell-async-processp + (process-kill-without-query ispell-process)))) ;;;###autoload (defun ispell-kill-ispell (&optional no-error) @@ -2030,18 +2219,26 @@ Optional third arg SHIFT is an offset to apply based on previous corrections." With NO-ERROR, just return non-nil if there was no Ispell running." (interactive) (if (not (and ispell-process - (eq (process-status ispell-process) 'run))) + (eq (ispell-process-status) 'run))) (or no-error (error "There is no ispell process running!")) - (process-send-eof ispell-process) - (if (eq (process-status ispell-process) 'run) - (accept-process-output ispell-process 1)) - (if (eq (process-status ispell-process) 'run) - (kill-process ispell-process)) - (while (not (or (eq (process-status ispell-process) 'exit) - (eq (process-status ispell-process) 'signal))) - (if version20p (sleep-for 0.25) - (sleep-for 0 250))) + (if ispell-async-processp + (progn + (process-send-eof ispell-process) + (if (eq (ispell-process-status) 'run) + (ispell-accept-output 1)) + (if (eq (ispell-process-status) 'run) + (kill-process ispell-process)) + (while (not (or (eq (ispell-process-status) 'exit) + (eq (ispell-process-status) 'signal))) + (if (or xemacsp version20p) (sleep-for 0.25) + (sleep-for 0 250)))) + ;; synchronous processes + (ispell-send-string "\n") ; make sure side effects occurred. + (kill-buffer ispell-output-buffer) + (kill-buffer ispell-session-buffer) + (setq ispell-output-buffer nil + ispell-session-buffer nil)) (setq ispell-process nil) (message "Ispell process killed") nil)) @@ -2210,13 +2407,13 @@ Return nil if spell session is quit, "\\|" skip-regexp))) (if ispell-skip-tib (setq skip-regexp (concat ispell-tib-ref-beginning "\\|" skip-regexp))) - (if ispell-skip-sgml - (setq skip-regexp (concat "" "\\|" - "<[cC][oO][dD][eE]>" "\\|" - "<[vV][eE][rR][bB]>" "\\|" - ;; "<[tT][tT]>" "\\|" + (if ispell-skip-html + (setq skip-regexp (concat "<[cC][oO][dD][eE]\\>[^>]*>" "\\|" + "<[sS][cC][rR][iI][pP][tT]\\>[^>]*>" "\\|" + "<[aA][pP][pP][lL][eE][tT]\\>[^>]*>" "\\|" + "<[vV][eE][rR][bB]\\>[^>]*>" "\\|" + ;; "<[tT][tT]\\>[^>]*>" "\\|" "<[tT][tT]/" "\\|" - "" key)) - (search-forward-regexp ".$" ispell-region-end t)) - ((and ispell-skip-sgml (string-match "" ispell-region-end t)) - ((and ispell-skip-sgml (string-match "<[cC][oO][dD][eE]>" key)) + ((and ispell-skip-html (string-match "<[cC][oO][dD][eE]\\>[^>]*>" key)) (search-forward-regexp "" ispell-region-end t)) - ((and ispell-skip-sgml (string-match "<[vV][eE][rR][bB]>" key)) + ((and ispell-skip-html + (string-match "<[sS][cC][rR][iI][pP][tT]\\>[^>]*>" key)) + (search-forward-regexp "" ispell-region-end t)) + ((and ispell-skip-html + (string-match "<[aA][pP][pP][lL][eE][tT]\\>[^>]*>" key)) + (search-forward-regexp "" ispell-region-end t)) + ((and ispell-skip-html (string-match "<[vV][eE][rR][bB]\\>[^>]*>" key)) (search-forward-regexp "" ispell-region-end t)) - ;;((and ispell-skip-sgml (string-match "<[tT][tT]>" key)) - ;; (search-forward-regexp "" ispell-region-end t)) - ((and ispell-skip-sgml (string-match "<[tT][tT]/" key)) - (search-forward "/" ispell-region-end t)) - ((and ispell-skip-sgml (string-match "<" key)) - (search-forward-regexp "[/>]" ispell-region-end t)) - ((and ispell-skip-sgml (string-match "&" key)) - (search-forward ";" ispell-region-end t)) + ;;((and ispell-skip-html (string-match "<[tT][tT]\\>[^>]*>" key)) + ;; (search-forward-regexp "" ispell-region-end t)) + ((and ispell-skip-html (string-match "<[tT][tT]/" key)) + (search-forward "/" ispell-region-end t)) + ((and ispell-skip-html (string-match "<" key)) + (search-forward ">" ispell-region-end t)) + ((and ispell-skip-html (string-match "&" key)) + (search-forward-regexp "[; \t\n]" ispell-region-end t)) ;; markings from alist (t (while alist @@ -2335,7 +2536,7 @@ otherwise, the current line is skipped." (cond ; LOOK AT THIS LINE AND SKIP OR PROCESS ((eolp) ; END OF LINE, just go to next line. (forward-line)) - ;;((looking-at "[---#@*+!%~^]") ; SKIP SPECIAL ISPELL CHARACTERS + ;;((looking-at "[-#@*+!%~^]") ; SKIP SPECIAL ISPELL CHARACTERS ;; (forward-char 1)) ; not needed as quoted below. ((or (re-search-forward ispell-casechars end t) ; TEXT EXISTS (re-search-forward "[][()${}]" end t)) ; or MATH COMMANDS @@ -2346,6 +2547,11 @@ otherwise, the current line is skipped." string)) +;;; Avoid error messages when compiling for these dynamic variables. +(eval-when-compile + (defvar start) + (defvar end)) + (defun ispell-process-line (string shift) "Sends a LINE of text to ispell and processes the result. This will modify the buffer for spelling errors. @@ -2356,9 +2562,9 @@ Returns the sum shift due to changes in word replacements." (if (not (numberp shift)) (setq shift 0)) ;; send string to spell process and get input. - (process-send-string ispell-process string) + (ispell-send-string string) (while (progn - (accept-process-output ispell-process) + (ispell-accept-output) ;; Last item of output contains a blank line. (not (string= "" (car ispell-filter))))) ;; parse all inputs from the stream one word at a time. @@ -2386,7 +2592,6 @@ Returns the sum shift due to changes in word replacements." (ispell-horiz-scroll) (goto-char word-start) (ispell-horiz-scroll) - ;; Alignment cannot be tracked and this error will occur when ;; `query-replace' makes multiple corrections on the starting line. (if (/= (+ word-len (point)) @@ -2426,7 +2631,7 @@ Returns the sum shift due to changes in word replacements." (set-marker line-end (point)) (setq ispell-filter nil recheck-region t))) - + ;; insert correction if needed (cond ((or (null replace) @@ -2458,6 +2663,7 @@ Returns the sum shift due to changes in word replacements." (let ((region-end (copy-marker ispell-region-end))) (setq recheck-region ispell-filter ispell-filter nil ; save filter + shift 0 ; already accounted shift (ispell-region word-start (+ word-start (length replace-word)) @@ -2655,7 +2861,7 @@ Standard ispell choices are then available." (defun ispell-minor-mode (&optional arg) "Toggle Ispell minor mode. With prefix arg, turn Ispell minor mode on iff arg is positive. - + In Ispell minor mode, pressing SPC or RET warns you if the previous word is incorrectly spelled. @@ -2666,7 +2872,7 @@ them into the running ispell process, type \\[ispell-word] SPC." (not (or (and (null arg) ispell-minor-mode) (<= (prefix-numeric-value arg) 0)))) (force-mode-line-update)) - + (defun ispell-minor-check () "Check previous word then continue with the normal binding of this key. Don't check previous word when character before point is a space or newline. @@ -2677,8 +2883,8 @@ Don't read buffer-local settings or word lists." (last-char (char-after (1- (point))))) (command-execute (key-binding (this-command-keys))) (if (not (or (eq last-char ?\ ) (eq last-char ?\n) - (and ispell-skip-sgml (eq last-char ?>)) - (and ispell-skip-sgml (eq last-char ?\;)))) + (and ispell-skip-html (eq last-char ?>)) + (and ispell-skip-html (eq last-char ?\;)))) (ispell-word nil t)))) @@ -2852,7 +3058,7 @@ You can bind this to the key C-c i in GNUS or mail by adding to Overrides the default parsing mode. Includes Latex/Nroff modes and extended character mode." ;; (ispell-init-process) must already be called. - (process-send-string ispell-process "!\n") ; Put process in terse mode. + (ispell-send-string "!\n") ; Put process in terse mode. ;; We assume all major modes with "tex-mode" in them should use latex parsing ;; When exclusively checking comments, set to raw text mode (nroff). (if (and (not (eq 'exclusive ispell-check-comments)) @@ -2861,19 +3067,19 @@ Includes Latex/Nroff modes and extended character mode." (symbol-name major-mode))) (eq ispell-parser 'tex))) (progn - (process-send-string ispell-process "+\n") ; set ispell mode to tex + (ispell-send-string "+\n") ; set ispell mode to tex (if (not (eq ispell-parser 'tex)) (set (make-local-variable 'ispell-parser) 'tex))) - (process-send-string ispell-process "-\n")) ; set mode to normal (nroff) + (ispell-send-string "-\n")) ; set mode to normal (nroff) ;; If needed, test for SGML & HTML modes and set a buffer local nil/t value. - (if (and ispell-skip-sgml (not (eq ispell-skip-sgml t))) - (set (make-local-variable 'ispell-skip-sgml) + (if (and ispell-skip-html (not (eq ispell-skip-html t))) + (set (make-local-variable 'ispell-skip-html) (not (null (string-match "sgml\\|html" (downcase (symbol-name major-mode))))))) ;; Set default extended character mode for given buffer, if any. (let ((extended-char-mode (ispell-get-extended-character-mode))) (if extended-char-mode - (process-send-string ispell-process (concat extended-char-mode "\n")))) + (ispell-send-string (concat extended-char-mode "\n")))) ;; Set buffer-local parsing mode and extended character mode, if specified. (save-excursion (goto-char (point-max)) @@ -2888,11 +3094,11 @@ Includes Latex/Nroff modes and extended character mode." (match-beginning 1) (match-end 1)))) (cond ((and (string-match "latex-mode" string) (not (eq 'exclusive ispell-check-comments))) - (process-send-string ispell-process "+\n~tex\n")) + (ispell-send-string "+\n~tex\n")) ((string-match "nroff-mode" string) - (process-send-string ispell-process "-\n~nroff\n")) + (ispell-send-string "-\n~nroff\n")) ((string-match "~" string) ; Set extended character mode. - (process-send-string ispell-process (concat string "\n"))) + (ispell-send-string (concat string "\n"))) (t (message "Invalid Ispell Parsing argument!") (sit-for 2)))))))) @@ -2965,8 +3171,7 @@ Both should not be used to define a buffer-local dictionary." ;; Error handling needs to be added between ispell and emacs. (if (and (< 1 (length string)) (equal 0 (string-match ispell-casechars string))) - (process-send-string ispell-process - (concat "@" string "\n")))))))) + (ispell-send-string (concat "@" string "\n")))))))) ;;; returns optionally adjusted region-end-point. @@ -2978,10 +3183,11 @@ Both should not be used to define a buffer-local dictionary." (save-excursion (goto-char (point-min)) (let ((old-case-fold-search case-fold-search) - line-okay search done string) + line-okay search done found) (while (not done) (setq case-fold-search nil search (search-forward ispell-words-keyword nil 'move) + found (or found search) line-okay (< (+ (length word) 1 ; 1 for space after word.. (progn (end-of-line) (current-column))) 80) @@ -2993,16 +3199,15 @@ Both should not be used to define a buffer-local dictionary." (if (null search) (progn (open-line 1) - (setq string (concat comment-start " " - ispell-words-keyword)) - (insert string) - (if (and comment-end (not (equal "" comment-end))) + (unless found (newline)) + (insert (concat comment-start " " ispell-words-keyword)) + (if (> (length comment-end) 0) (save-excursion - (open-line 1) - (forward-line 1) + (newline) (insert comment-end))))) (insert (concat " " word)))))))) +(add-to-list 'debug-ignored-errors "^No word found to check!$") (provide 'ispell) -- 2.11.4.GIT