;ELC ;;; compiled by roland@churchy.gnu.ai.mit.edu on Mon May 29 16:59:55 1995 ;;; from file /gd/gnu/emacs/19.0/lisp/ispell4.el ;;; emacs version 19.28.92.2. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "`/gd/gnu/emacs/19.0/lisp/ispell4.el' was compiled for Emacs 19")) #@56 Non-nil means use the `-r' option when running `look'. (defvar ispell-have-new-look t (#$ . 488)) #@73 Non-nil enables experimental TeX parser in Ispell for TeX-mode buffers. (defvar ispell-enable-tex-parser nil (#$ . 592)) #@28 The process running Ispell (defvar ispell-process nil (#$ . 719)) #@74 An integer: where in `*ispell*' buffer to find next message from Ispell. (defvar ispell-next-message nil (#$ . 791)) #@29 Command for running Ispell. (defvar ispell-command "ispell" (#$ . 914)) #@236 *String (or list of strings) to pass to Ispell as command arguments. You can specify your private dictionary via the -p option. The -S option is always passed to Ispell as the last parameter, and need not be mentioned here. (defvar ispell-command-options nil (#$ . -993)) #@28 *Command for running look. (defvar ispell-look-command "look" (#$ . -1282)) #@72 A list of markers reflecting the output of the Ispell `:file' command. (defvar ispell-bad-words nil (#$ . 1364)) (byte-code "! B! B!  B‡" [boundp ispell-recently-accepted nil current-load-list ispell-window-configuration ispell-dump-needed] 2) (defalias 'ispell-flush-bad-words #[nil "@!@‰A‰" [ispell-bad-words markerp nil ispell-recently-accepted] 4]) #@113 Kill the Ispell process. Any changes in your private dictionary that have not already been dumped will be lost. (defalias 'kill-ispell #[nil "! " [ispell-process delete-process nil ispell-flush-bad-words] 2 (#$ . 1773) nil]) (byte-code "##" [put ispell-startup-error error-conditions (ispell-startup-error error) error-message "Problem starting ispell - see buffer *ispell*"] 4) (defalias 'start-ispell #[nil "!!\f!)ȏ\n!\n!!\n!\n!qp!dZf=`\n!=R \"\n!dZ;ebp!@Uv@\"A@!)e|*" [message "Starting ispell ..." get-buffer "*ispell*" buf kill-buffer err (byte-code "\f<C\"%" [apply start-process "ispell" "*ispell*" ispell-command append ispell-command-options ("-S") ispell-process] 8) ((file-error (byte-code "\"" [signal ispell-startup-error nil] 3))) process-kill-without-query ispell-process buffer-disable-undo process-buffer accept-process-output nil last-char bury-buffer 1 61 process-status run kill-ispell signal ispell-startup-error read greeting error "Bad ispell version: wanted 1, got %d"] 4]) (defalias 'ispell-sync #[(intr) "\f!= \f!!qp!dZf=<!dZ)b)" [ispell-process process-status run start-ispell intr interrupt-process nil last-char process-buffer bury-buffer 1 61 accept-process-output] 3]) (defalias 'ispell-cmd #[(&rest strings) "! !qp! e) @\"A \" !!)" [ispell-sync t process-buffer ispell-process bury-buffer erase-buffer ispell-next-message strings process-send-string "\n" accept-process-output nil] 4]) (defalias 'ispell-dump #[nil " !" [ispell-dump-needed nil ispell-cmd ":dump"] 2]) (defalias 'ispell-insert #[(word) "\n\" \n\fBʼn" [ispell-cmd ":insert " word ispell-bad-words ispell-recently-accepted t ispell-dump-needed] 3]) (defalias 'ispell-accept #[(word) "\n\" \n\fB" [ispell-cmd ":accept " word ispell-bad-words ispell-recently-accepted] 3]) (defalias 'ispell-next-message #[nil " !qp! b`!`}`ebp!*" [process-buffer ispell-process bury-buffer ispell-next-message forward-sexp 1 read] 3]) (defalias 'ispell-tex-buffer-p #[nil ">" [major-mode (plain-tex-mode latex-mode slitex-mode)] 2]) (byte-code "!\n!\fB \" # # # # # # # #" [boundp ispell-menu-map make-sparse-keymap "Spell" current-load-list defalias define-key [ispell-complete-word-interior-frag] ("Complete Interior Fragment" . ispell-complete-word-interior-frag) [ispell-complete-word] ("Complete Word" . ispell-complete-word) [reload-ispell] ("Reload Dictionary" . reload-ispell) [ispell-next] ("Continue Check" . ispell-next) [ispell-message] ("Check Message" . ispell-message) [ispell-word] ("Check Word" . ispell-word) [ispell-region] ("Check Region" . ispell-region) [ispell-buffer] ("Check Buffer" . ispell)] 4) #@902 Run Ispell over current buffer's visited file. First the file is scanned for misspelled words, then Ispell enters a loop with the following commands for every misspelled word: DIGIT Near miss selector. If the misspelled word is close to some words in the dictionary, they are offered as near misses. r Replace. Replace the word with a string you type. Each word of your new string is also checked. i Insert. Insert this word in your private dictionary (by default, `$HOME/ispell.words'). a Accept. Accept this word for the rest of this editing session, but don't put it in your private dictionary. l Lookup. Look for a word in the dictionary by fast binary search, or search for a regular expression in the dictionary using grep. SPACE Accept the word this time, but complain if it is seen again. q, \[keyboard-quit] Leave the command loop. You can come back later with \[ispell-next]. (defalias 'ispell #[(&optional buf start end) "\n\f p !!* ! q\f ώD\f\"V! ed#i !i\"!i !~ ~!!\n$!+! ȉ$% %\nU%\nW %\\ȓ$B$%$B$)+)@!)!Ӈ! " [start 0 end buf get-buffer error "Can't find buffer" transient-mark-mode nil mark-active run-hooks deactivate-mark-hook buffer-file-name delete-temp filename ((byte-code " Ï" [delete-temp nil (delete-file filename) ((file-error))] 3)) find-file-name-handler make-temp-name "/usr/tmp/ispell" t write-region buffer-modified-p y-or-n-p format "Save file %s? " save-buffer message "Ispell scanning file..." ispell-enable-tex-parser ispell-tex-buffer-p ispell-cmd ":tex" ":generic" ":file %s %d %d" "Parsing ispell output ..." ispell-flush-bad-words bad-words pos ispell-next-message make-marker 1 ispell-bad-words markerp "No misspellings." "Ispell parsing done." ispell-next] 7 (#$ . 4677) nil]) (defalias (quote ispell-buffer) (quote ispell)) #@105 Resume command loop for most recent Ispell command. Return value is t unless exit is due to typing `q'. (defalias 'ispell-next #[nil "Žč) " [nil ispell-window-configuration ((byte-code " ! !L @!&!!L @=6!L @=F!L!ʇ" [ispell-dehighlight ispell-window-configuration set-window-configuration ispell-bad-words error "Ispell has not yet been run" markerp message substitute-command-keys "Type \\[ispell-next] to continue" nil "No more misspellings (but checker was interrupted)" t "Ispell done" "Bad ispell internal list"] 3)) ispell-quit (byte-code " @!$ !! \" A )ɇ" [nil next markerp ispell-bad-words switch-to-buffer marker-buffer push-mark ispell-point "at saved position." t] 3) ispell-dump] 2 (#$ . 6623) nil]) #@169 Check the spelling of the word under the cursor. See the command `ispell' for more information. With a prefix argument, resume handling of the previous Ispell command. (defalias 'ispell-word #[(&optional resume) " ď" [resume ispell-next err (byte-code ")" [((ispell-dehighlight)) ispell-quit (byte-code " " [((byte-code "`\"" [ispell-point "at point."] 3)) ispell-dump] 1)] 2) ((ispell-startup-error (byte-code "!! # " [y-or-n-p "Problem starting ispell, use old-style spell instead? " load-library "spell" define-key esc-map "$" spell-word] 4)))] 3 (#$ . 7425) "P"]) #@56 Check the spelling for all of the words in the region. (defalias 'ispell-region #[(start &optional end) "p \n#" [ispell start end] 4 (#$ . 8037) "r"]) (defalias 'ispell-letterp #[(c) "YXYXY" [c 65 90 97 122 128] 2]) (defalias 'ispell-letter-or-quotep #[(c) "%YX%YX%U%Y" [c 65 90 97 122 39 128] 2]) (defalias 'ispell-find-word-start #[nil "`f!o`Zf! `Zf!) w" [ispell-letterp 1 backward-char ispell-letter-or-quotep "'" nil] 3]) (defalias 'ispell-find-word-end #[nil "`f! ux" [ispell-letter-or-quotep nil "'"] 2]) (defalias 'ispell-next-word #[nil "m?`f!?u" [ispell-letterp nil] 2]) (defalias 'ispell-point #[(start message) "  b   \nW \nW b \f` \f{  !y \"! !  =[ \"x f :r \f $x \") \fb `!q ) \n\f+" [make-marker nil end rescan wend start ispell-find-word-start point-marker ispell-find-word-end word ispell-still-bad message format "Ispell checking %s" ispell-cmd ispell-next-message t "%s: ok" ispell-command-loop error "unknown ispell response %s" ispell-next-word get-buffer "*ispell choices*" buf erase-buffer] 6]) (defalias 'ispell-still-bad #[(word) " \f@\"=\fA\n +" [ispell-recently-accepted t case-fold-search ret words string-match word 0 nil] 4]) (defalias 'ispell-show-choices #[(word message first-line) "  =!   !! 9͎!!Z!)q!e\"e\" ױc??WW_\\8#\"c\"GZ\")*\\o)c\\f)-" [selected-window selwin next-window resize get-buffer-create "*ispell choices*" buf nil w ispell-window-configuration current-window-configuration display-buffer buffer-disable-undo ((select-window selwin)) select-window enlarge-window 6 window-height bury-buffer set-window-point set-window-start erase-buffer first-line "\n" "SPC skip; A accept; I insert; DIGIT select; R replace; L lookup; Q quit\n" message 0 i 3 j n choice format "%d %s" str insert-char 32 20 1] 5]) (defalias 'ispell-command-loop #[(word start end message) " QQ \f\"\f \n#! YaXaZ 8a \f#Up\" 8U UU \f!#U!U!U!&@&A)U!!!!* +" [t nil first-line rescan flag message "No near misses for '" word "'" "Near misses for '" ispell-highlight start end ispell-show-choices "Ispell command: " undo-boundary read-char replacement c 48 57 ispell-replace 113 throw ispell-quit 3 current-input-mode keyboard-quit 32 114 read-string "Replacement: " 105 ispell-insert 97 ispell-accept 108 ispell-do-look val 63 "Type 'C-h d ispell' to the emacs main loop for more help" sit-for 2 "Bad ispell command"] 6]) (defalias 'ispell-do-look #[(bad-word) "\f!\"!\nqed|\f4\f\n &=\f\n %eby`d|ebedUce`{ Bye`|J\n! \" !,B" [nil words buf regex ispell-have-new-look read-string "Lookup: " "Lookup (regex): " "^" get-buffer-create "*ispell look*" call-process ispell-look-command "-r" 10 kill-buffer format "Lookup '%s'" reverse] 7]) (defalias 'ispell-replace #[(start end new) "b c`\n|" [start new end] 2]) #@49 Tell Ispell to re-read your private dictionary. (defalias 'reload-ispell #[nil "!" [ispell-cmd ":reload"] 2 (#$ . 11409) nil]) (defalias 'batch-make-ispell #[nil "!!\f * !!ed#" [byte-compile-file "ispell.el" find-file "ispell.texinfo" default-directory "/tmp" old-dir texinfo-format-buffer Info-validate get-buffer " *problems in info file*" kill-emacs 1 write-region "ispell.info"] 4]) #@43 *Non-nil means to highlight ispell words. (defvar ispell-highlight t (#$ . -11830)) (byte-code "! B‡" [boundp ispell-overlay nil current-load-list] 2) (defalias 'ispell-dehighlight #[nil " !‰" [ispell-overlay delete-overlay nil] 2]) (defalias 'ispell-highlight #[(start end) "' '\n!\f \"\n!ɂ#\n\f p$" [ispell-highlight window-system ispell-overlay make-overlay start end overlay-put face internal-find-face ispell region move-overlay] 5]) #@186 *If non-nil then spelling dictionary as string for `ispell-complete-word'. Overrides default dictionary file such as "/usr/dict/words" or GNU look's "${prefix}/lib/ispell/ispell.words" (defvar ispell-look-dictionary nil (#$ . -12318)) #@442 *t if GNU look -r can give different results with and without trialing `.*'. Example: `look -dfr "^ya" foo' returns nothing, while `look -dfr "^ya.*" foo' returns `yacc', where `foo' is a dictionary file containing the three lines y y's yacc Both commands should return `yacc'. If `ispell-complete-word' erroneously states that no completions exist for a string, then setting this variable to t will help find those completions. (defvar ispell-gnu-look-still-broken-p nil (#$ . -12560)) (byte-code "! B! B!  B!#!7\n B!#" [boundp ispell-lookup-completions-alist nil current-load-list ispell-lookup-last-word ispell-lookup-last-interior-p make-variable-buffer-local put permanent-local t ispell-lookup-last-bow] 4) #@296 Complete word using letters at point to word beginning using `look'. With optional argument INTERIOR-FRAG, word fragment at point is assumed to be an interior word fragment in which case `ispell-have-new-look' should be t. See also `ispell-look-dictionary' and `ispell-gnu-look-still-broken-p'. (defalias 'ispell-complete-word #[(&optional interior-frag) " P!x`) `{\n+\nQ5\n4Q?ЂA\nM f?fP\n\")?\nИPv`)`{!!\n\"\"\n =c!!\n\" !ИQ\n\")\n \"#!!!И  `|\"++!)!." [interior-frag ispell-have-new-look error "Sorry, `ispell-have-new-look' is nil. " "You also will need GNU Ispell's `look'." t completion-ignore-case "a-zA-Z'" nil bow string "^.*" ".*" "^" ispell-gnu-look-still-broken-p regexp "" prefix ispell-lookup-last-interior-p ispell-lookup-last-bow continuing-an-interior-frag-p ispell-lookup-last-word case-fold-search string-match new-unique-string-p completion " " -1 "Perfect match already" "No word fragment at point" ispell-lookup-build-list ispell-lookup-completions-alist try-completion message "Perfect match." "Can't find completion for \"%s\"" beep "$" search-backward replace-match "Proposed unique substring. Repeat for completions list." "Making completion list..." all-completions list "*Completions*" display-completion-list "Making completion list...done"] 5 (#$ . 13342) "P"]) #@200 Runs `ispell-complete-word' with a non-nil INTERIOR-FRAG. A completion list is built for word fragment at point which is assumed to be an interior word fragment. `ispell-have-new-look' should be t. (defalias 'ispell-complete-word-interior-frag #[nil "!" [ispell-complete-word t] 2 (#$ . 14856) nil]) (defalias 'ispell-lookup-build-list #[(string regexp) "!!q ;7'\f &W &WK\f&W&ebedUxe`{Bye`|] !\"*" [message "Building list..." get-buffer-create " *ispell look*" erase-buffer ispell-look-dictionary ispell-have-new-look call-process ispell-look-command nil t "-fr" regexp "-f" string list "Building list...done" mapcar] 8]) (defalias 'ispell-non-empty-string #[(string) "\n\f‡!" [string "" "\\'\\`" regexp-quote] 2]) #@73 *Regular expression to match lines cited from one message into another. (defvar ispell-message-cite-regexp "^ \\|^ " (#$ . -15690)) #@194 *End of text which will be checked in ispell-message. If it is a string, limit at first occurence of that regular expression. Otherwise, it must be a function which is called to get the limit. (defvar ispell-message-text-end (byte-code "#Q" ["^\\(" mapconcat identity ("%!PS-Adobe-2.0" "begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM" "#! /bin/sh" "diff -c .*\n\\*\\*\\* .*\n--- " "[-=]+\\s cut here") "\\|" "\\)"] 5) (#$ . -15831)) #@68 *Ispell-message will check no more than this number of characters. (defvar ispell-message-limit 8000 (#$ . -16268)) #@449 Check the spelling of a mail message or news post. Don't check spelling of message headers (except subject) or included messages. To spell-check whenever a message is sent, include this line in .emacs: (setq news-inews-hook (setq mail-send-hook 'ispell-message)) Or you can bind the function to C-c i in gnus or mail with: (setq mail-mode-hook (setq news-reply-mode-hook (function (lambda () (local-set-key "\C-ci" 'ispell-message))))) (defalias 'ispell-message #[nil " eb #y*!(m(y!> !!R ! `հך{u!wQ!!Q!!! e!\\d\"d\"!\"#攂d\" )^^'G\\(`)eb)#!`Z! `\" +`'Wi iP!4`'W4y`'W`0Q(#Ny`'VY'b\n0Z`\" +." [nil case-fold-search old-case-fold-search non-internal-message search-forward mail-header-separator t 1 looking-at "[a-zA-Z-]+:\\| \\| " featurep supercite "\\(" sc-cite-regexp "\\)" "\\|" ispell-non-empty-string sc-reference-tag-string sc "In [a-zA-Z.]+ you write:" "In <[^,;&+=]+> [^,;&+=]+ writes:" " *> *" major-mode news-reply-mode "In article <" mail-yank-prefix ispell-message-cite-regexp boundp vm-included-text-prefix "[^,;&+=]+ writes:" mh-ins-buf-prefix cite-regexp continue ispell-message-limit ispell-message-text-end char-or-string-p re-search-forward end 0 limit search-limit message-begin "^Subject:[ ]*" "re\\>" ispell-region "\n[ ]" 2 "^[ ]*$\\|" start "^\\("] 7 (#$ . 16391) nil]) (provide (quote ispell))