;ELC   
;;; Compiled by rms@psilocin.ai.mit.edu on Wed Jun 24 14:14:22 1998
;;; from file /gd/gnu/emacs/lisp/ispell.el
;;; in Emacs version 20.2.95.4
;;; with bytecomp version 2.46
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`ispell.el' was compiled for Emacs 19.29 or later"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@105 *Highlight spelling errors when non-nil.
When set to `block', assumes a block cursor with TTY displays.
(custom-declare-variable 'ispell-highlight-p ''block '(#$ . -601) :type '(choice (const block) (const nil) (other :tag "on" t)) :group 'ispell)
#@316 *The face used for Ispell highlighting.  For Emacses with overlays.
Possible values are `highlight', `modeline', `secondary-selection',
`region', and `underline'.
This variable can be set by the user to whatever face they desire.
It's most convenient if the cursor color and highlight color are
slightly different.
(custom-declare-variable 'ispell-highlight-face ''highlight '(#$ . -856) :type 'face :group 'ispell)
#@228 *Spelling of comments checked when non-nil.
When set to `exclusive', ONLY comments are checked.  (For code comments).
Warning!  Not checking comments, when a comment start is embedded in strings,
may produce undesired results.
(custom-declare-variable 'ispell-check-comments 't '(#$ . -1279) :type '(choice (const exclusive) (const nil) (other :tag "on" t)) :group 'ispell)
#@108 *Corrections made throughout region when non-nil.
Uses `query-replace' (\[query-replace]) for corrections.
(custom-declare-variable 'ispell-query-replace-choices 'nil '(#$ . -1660) :type 'boolean :group 'ispell)
#@361 *Does not spell check `tib' bibliography references when non-nil.
Skips any text between strings matching regular expressions
`ispell-tib-ref-beginning' and `ispell-tib-ref-end'.

TeX users beware:  Any field starting with [. will skip until a .] -- even
your whole buffer -- unless you set `ispell-skip-tib' to nil.  That includes
a [.5mm] type of number....
(custom-declare-variable 'ispell-skip-tib 'nil '(#$ . -1879) :type 'boolean :group 'ispell)
#@51 Regexp matching the beginning of a Tib reference.
(defvar ispell-tib-ref-beginning "[[<]\\." (#$ . 2337))
#@45 Regexp matching the end of a Tib reference.
(defvar ispell-tib-ref-end "\\.[]>]" (#$ . 2449))
#@105 *When not nil, the `*Choices*' window remains for spelling session.
This minimizes redisplay thrashing.
(custom-declare-variable 'ispell-keep-choices-win 't '(#$ . -2550) :type 'boolean :group 'ispell)
#@93 *The default size of the `*Choices*' window, including status line.
Must be greater than 1.
(custom-declare-variable 'ispell-choices-win-default-height '2 '(#$ . -2758) :type 'integer :group 'ispell)
#@66 Program invoked by \[ispell-word] and \[ispell-region] commands.
(custom-declare-variable 'ispell-program-name '"ispell" '(#$ . 2964) :type 'string :group 'ispell)
#@42 *Alternate dictionary for spelling help.
(custom-declare-variable 'ispell-alternate-dictionary '(cond ((file-exists-p "/usr/dict/web2") "/usr/dict/web2") ((file-exists-p "/usr/share/dict/web2") "/usr/share/dict/web2") ((file-exists-p "/usr/dict/words") "/usr/dict/words") ((file-exists-p "/usr/lib/dict/words") "/usr/lib/dict/words") ((file-exists-p "/usr/share/dict/words") "/usr/share/dict/words") ((file-exists-p "/sys/dict") "/sys/dict") (t "/usr/dict/words")) '(#$ . -3134) :type 'file :group 'ispell)
#@39 *Dictionary used for word completion.
(custom-declare-variable 'ispell-complete-word-dict 'ispell-alternate-dictionary '(#$ . -3647) :type 'file :group 'ispell)
#@381 *List used by `ispell-message' to select a new dictionary.
It consists of pairs (REGEXP . DICTIONARY).  If REGEXP is found
in the message headers, `ispell-local-dictionary' will be set to
DICTIONARY if `ispell-local-dictionary' is not buffer-local.
E.g. you may use the following value:
  '(("^Newsgroups:[ \t]*de\\." . "deutsch8")
    ("^To:[^\n,]+\\.de[ \t\n,>]" . "deutsch8"))
(custom-declare-variable 'ispell-message-dictionary-alist 'nil '(#$ . -3815) :type '(repeat (cons regexp string)) :group 'ispell)
#@48 Name of the grep command for search processes.
(custom-declare-variable 'ispell-grep-command '"egrep" '(#$ . 4331) :type 'string :group 'ispell)
#@159 String of options to use when running the program in `ispell-grep-command'.
Should probably be "-i" or "-e".
Some machines (like the NeXT) don't support "-i"
(custom-declare-variable 'ispell-grep-options '"-i" '(#$ . 4483) :type 'string :group 'ispell)
#@84 Name of the look command for search processes.
This must be an absolute file name.
(custom-declare-variable 'ispell-look-command '(cond ((file-exists-p "/bin/look") "/bin/look") ((file-exists-p "/usr/local/bin/look") "/usr/local/bin/look") ((file-exists-p "/usr/bin/look") "/usr/bin/look") (t "look")) '(#$ . 4742) :type 'file :group 'ispell)
#@105 *Non-nil means use `look' rather than `grep'.
Default is based on whether `look' seems to be available.
(custom-declare-variable 'ispell-look-p '(file-exists-p ispell-look-command) '(#$ . -5092) :type 'boolean :group 'ispell)
#@66 *Non-nil means use the `-r' option (regexp) when running `look'.
(custom-declare-variable 'ispell-have-new-look 'nil '(#$ . -5324) :type 'boolean :group 'ispell)
#@54 String of command options for `ispell-look-command'.
(custom-declare-variable 'ispell-look-options '(if ispell-have-new-look "-dfr" "-df") '(#$ . 5492) :type 'string :group 'ispell)
#@87 When non-nil, Emacs uses ptys to communicate with Ispell.
When nil, Emacs uses pipes.
(custom-declare-variable 'ispell-use-ptys-p 'nil '(#$ . 5680) :type 'boolean :group 'ispell)
#@120 *Non-nil means `ispell-word' checks the word around or after point.
Otherwise `ispell-word' checks the preceding word.
(custom-declare-variable 'ispell-following-word 'nil '(#$ . -5866) :type 'boolean :group 'ispell)
#@450 *Non-nil means display interactive keymap help in a buffer.
The following valued are supported:
  nil        Expand the minibuffer and display a short help message
             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. 
             User can browse and then exit the help mode.
(custom-declare-variable 'ispell-help-in-bufferp 'nil '(#$ . -6090) :type '(choice (const electric) (const nil) (other :tag "t" t)) :group 'ispell)
#@52 *Non-nil means suppress messages in `ispell-word'.
(custom-declare-variable 'ispell-quietly 'nil '(#$ . -6693) :type 'boolean :group 'ispell)
#@127 *Formatting function for displaying word being spell checked.
The function must take one string argument and return a string.
(custom-declare-variable 'ispell-format-word '#'upcase '(#$ . -6842) :type 'function :group 'ispell)
#@295 When non-nil ispell uses framepop to display choices in a dedicated frame.
You can set this variable to dynamically use framepop if you are in a
window system by evaluating the following on startup to set this variable:
  (and window-system (condition-case () (require 'framepop) (error nil)))
(custom-declare-variable 'ispell-use-framepop-p 'nil '(#$ . 7076) :type 'boolean :group 'ispell)
#@184 *File name of your personal spelling dictionary, or nil.
If nil, the default personal dictionary, "~/.ispell_DICTNAME" is used,
where DICTNAME is the name of your default dictionary.
(custom-declare-variable 'ispell-personal-dictionary 'nil '(#$ . -7474) :type '(choice file (const :tag "default" nil)) :group 'ispell)
#@67 *When non-nil, save the personal dictionary without confirmation.
(custom-declare-variable 'ispell-silently-savep 'nil '(#$ . -7799) :type 'boolean :group 'ispell)
#@580 If non-nil, the dictionary to be used for Ispell commands.
The value must be a string dictionary name in `ispell-dictionary-alist'.
This variable becomes buffer-local when set in any fashion.

Setting ispell-local-dictionary to a value has the same effect as
calling \[ispell-change-dictionary] with that value.  This variable
is automatically set when defined in the file with either
`ispell-dictionary-keyword' or the Local Variable syntax.

To create a non-standard default dictionary (not from ispell-dictionary-alist)
call function set-default with the new dictionary name.
(custom-declare-variable 'ispell-local-dictionary 'nil '(#$ . 7970) :type '(choice string (const :tag "default" nil)) :group 'ispell)
(make-variable-buffer-local 'ispell-local-dictionary)
#@240 *If non-nil, a list of extra switches to pass to the Ispell program.
For example, ("-W" "3") to cause it to accept all 1-3 character
words as correct.  See also `ispell-dictionary-alist', which may be used
for language-specific arguments.
(custom-declare-variable 'ispell-extra-args 'nil '(#$ . -8744) :type '(repeat string) :group 'ispell)
#@53 First half of dictionary, shortened for loaddefs.el
(defvar ispell-dictionary-alist-1 '((nil "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil nil) ("american" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil nil) ("british" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil nil) ("castellano" "[A-Z\301\311\315\323\332\334\321a-z\341\351\355\363\372\374\361]" "[^A-Z\301\311\315\323\332\334\321a-z\341\351\355\363\372\374\361]" "[---]" nil ("-B" "-d" "castellano") "~tex" iso-latin-1) ("castellano8" "[A-Z\301\311\315\323\332\334\321a-z\341\351\355\363\372\374\361]" "[^A-Z\301\311\315\323\332\334\321a-z\341\351\355\363\372\374\361]" "[---]" nil ("-B" "-d" "castellano") "~latin1" iso-latin-1) ("czech" "[A-Za-z\301\311\314\315\323\332\331\335\256\251\310\330\317\253\322\341\351\354\355\363\372\371\375\276\271\350\370\357\273\362]" "[^A-Za-z\301\311\314\315\323\332\331\335\256\251\310\330\317\253\322\341\351\354\355\363\372\371\375\276\271\350\370\357\273\362]" "" nil ("-B" "-d" "czech") nil iso-latin-2) ("dansk" "[A-Z\306\330\305a-z\346\370\345]" "[^A-Z\306\330\305a-z\346\370\345]" "[']" nil ("-C") nil iso-latin-1) ("deutsch" "[a-zA-Z\"]" "[^a-zA-Z\"]" "[']" t ("-C") "~tex" nil) ("deutsch8" "[a-zA-Z\304\326\334\344\366\337\374]" "[^a-zA-Z\304\326\334\344\366\337\374]" "[']" t ("-C" "-d" "deutsch") "~latin1" iso-latin-1) ("english" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil nil)) (#$ . 9091))
#@54 Second half of dictionary, shortened for loaddefs.el
(defvar ispell-dictionary-alist-2 '(("esperanto" "[A-Za-z\246\254\266\274\306\330\335\336\346\370\375\376]" "[^A-Za-z\246\254\266\274\306\330\335\336\346\370\375\376]" "[-']" t ("-C") "~latin3" nil) ("esperanto-tex" "[A-Za-z^\\]" "[^A-Za-z^\\]" "[-'`\"]" t ("-C" "-d" "esperanto") "~tex" nil) ("francais7" "[A-Za-z]" "[^A-Za-z]" "[`'^---]" t nil nil nil) ("francais" "[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-latin-1) ("francais-tex" "[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-latin-1) ("nederlands" "[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]" "[']" t ("-C") nil iso-latin-1) ("nederlands8" "[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]" "[']" t ("-C") nil iso-latin-1) ("norsk" "[A-Za-z\351\346\370\345\350\364\362\311\306\330\305\310\324\322]" "[^A-Za-z\351\346\370\345\350\364\362\311\306\330\305\310\324\322]" "[']" nil ("-C" "-d" "norsk") "~list" nil) ("russian" "[\341\342\367\347\344\345\263\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376\373\375\370\371\377\374\340\361\301\302\327\307\304\305\243\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\330\331\337\334\300\321]" "[^\341\342\367\347\344\345\263\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376\373\375\370\371\377\374\340\361\301\302\327\307\304\305\243\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\330\331\337\334\300\321]" "[']" t ("-C" "-d" "russian") "~latin1" iso-latin-1) ("svenska" "[A-Za-z}{|\\133\\135\\\\]" "[^A-Za-z}{|\\133\\135\\\\]" "[']" nil ("-C") nil nil) ("svenska8" "[A-Za-z\345\344\366\305\304\366]" "[^A-Za-z\345\344\366\305\304\366]" "[']" nil ("-C" "-d" "svenska") "~list" iso-latin-1)) (#$ . 10504))
#@2098 An alist of dictionaries and their associated parameters.

Each element of this list is also a list:

(DICTIONARY-NAME CASECHARS NOT-CASECHARS OTHERCHARS MANY-OTHERCHARS-P
        ISPELL-ARGS EXTENDED-CHARACTER-MODE CHARACTER-SET)

DICTIONARY-NAME is a possible string value of variable `ispell-dictionary',
nil means the default dictionary.

CASECHARS is a regular expression of valid characters that comprise a
word.

NOT-CASECHARS is the opposite regexp of CASECHARS.

OTHERCHARS is a regexp of characters in the NOT-CASECHARS set but which can be
used to construct words in some special way.  If OTHERCHARS characters follow
and precede characters from CASECHARS, they are parsed as part of a word,
otherwise they become word-breaks.  As an example in English, assume the
regular expression "[']" for OTHERCHARS.  Then "they're" and
"Steven's" are parsed as single words including the "'" character, but
"Stevens'" does not include the quote character as part of the word.
If you want OTHERCHARS to be empty, use the empty string.
Hint: regexp syntax requires the hyphen to be declared first here.

MANY-OTHERCHARS-P is non-nil when multiple OTHERCHARS are allowed in a word.
Otherwise only a single OTHERCHARS character is allowed to be part of any
single word.

ISPELL-ARGS is a list of additional arguments passed to the ispell
subprocess.

EXTENDED-CHARACTER-MODE should be used when dictionaries are used which
have been configured in an Ispell affix file.  (For example, umlauts
can be encoded as \"a, a\", "a, ...)  Defaults are ~tex and ~nroff
in English.  This has the same effect as the command-line `-T' option.
The buffer Major Mode controls Ispell's parsing in tex or nroff mode,
but the dictionary can control the extended character mode.
Both defaults can be overruled in a buffer-local fashion. See
`ispell-parsing-keyword' for details on this.

CHARACTER-SET used for languages with multibyte characters.

Note that the CASECHARS and OTHERCHARS slots of the alist should
contain the same character set as casechars and otherchars in the
LANGUAGE.aff file (e.g., english.aff).
(custom-declare-variable 'ispell-dictionary-alist '(append ispell-dictionary-alist-1 ispell-dictionary-alist-2) '(#$ . 13015) :type '(repeat (list (choice :tag "Dictionary" (string :tag "Dictionary name") (const :tag "default" nil)) (regexp :tag "Case characters") (regexp :tag "Non case characters") (regexp :tag "Other characters") (boolean :tag "Many other characters") (repeat :tag "Ispell command line args" (string :tag "Arg")) (choice :tag "Extended character mode" (const "~tex") (const "~list") (const "~nroff") (const "~latin3") (const "~latin1") (const :tag "default" nil)) (choice :tag "Character set" (const iso-latin-1) (const iso-latin-2) (const :tag "default" nil)))) :group 'ispell)
#@25 Key map for ispell menu
(defvar ispell-menu-map nil (#$ . 15818))
#@130 Spelling menu for XEmacs.
If nil when package is loaded, a standard menu will be set,
and added as a submenu of the "Edit" menu.
(defvar ispell-menu-xemacs nil (#$ . 15891))
(byte-code "?\205 \306\307	\"?\205 \306\310	\"?\302B\n\203X \311\312\313B\fB!\313@\314\315!@\203W @@@@A@;\203* \316\317\320!!\321\322!P\323\313\324\325DFB#\210\202* *\n\203z \316\326\327#\210\316\330\331#\210\316\332\333#\210\316\334\335#\210\316\336\337#\210\n\203\234 \316\340\341#\210\316\342\343#\210\316\344\345#\210\316\346\347#\210\316\350\351#\210\n\203\267 \316\352\353#\210\316\354\355#\210\356\357\360\361#\210\300\211JM\210\306\307	\"\204.\306\310	\"\203.\362\363!\203.A\204.\364\365!\203\333 5\204.\312\313B\fBB\206\347 C\366\313DB@@\203@@@@A@;\203\360 \367D\317\321\322!P\325D\370#C\"D\202\360 DAB\203-\371\372!\210\373\374\315A#\210,\306\375	\"\203D\376\377!\203D\201E \377M\210\202L\201E \201F M\210\313\207" [ispell-menu-map emacs-version ispell-menu-map-needed current-load-list ispell-dictionary-alist name string-match "18\\.[0-9]+\\.[0-9]+" "Lucid\\|XEmacs" reverse "default" nil make-sparse-keymap "Spell" define-key vector intern "Select " capitalize lambda (interactive) ispell-change-dictionary [ispell-change-dictionary] ("Change Dictionary" . ispell-change-dictionary) [ispell-kill-ispell] ("Kill Process" . ispell-kill-ispell) [ispell-pdict-save] ("Save Dictionary" lambda nil (interactive) (ispell-pdict-save t t)) [ispell-complete-word] ("Complete Word" . ispell-complete-word) [ispell-complete-word-interior-frag] ("Complete Word Frag" . ispell-complete-word-interior-frag) [ispell-continue] ("Continue Check" . ispell-continue) [ispell-word] ("Check Word" . ispell-word) [ispell-comments-and-strings] ("Check Comments" . ispell-comments-and-strings) [ispell-region] ("Check Region" . ispell-region) [ispell-buffer] ("Check Buffer" . ispell-buffer) [ispell-message] ("Check Message" . ispell-message) [ispell-help] ("Help" lambda nil (interactive) (describe-function 'ispell-help)) put ispell-region menu-enable mark-active featurep menubar boundp infodock-version (["Help" (describe-function 'ispell-help) t] ["Check Message" ispell-message t] ["Check Buffer" ispell-buffer t] ["Check Comments" ispell-comments-and-strings t] ["Check Word" ispell-word t] ["Check Region" ispell-region (or (not zmacs-regions) (mark))] ["Continue Check" ispell-continue t] ["Complete Word Frag" ispell-complete-word-interior-frag t] ["Complete Word" ispell-complete-word t] ["Kill Process" ispell-kill-ispell t] "-" ["Save Dictionary" (ispell-pdict-save t t) t] ["Change Dictionary" ispell-change-dictionary t]) append t delete-menu-item ("Edit" "Spell") add-menu ("Edit") "XEmacs" fboundp int-char dicts ispell-menu-xemacs current-menubar default-menubar menu ispell-int-char identity] 9)
#@72 Ispell versions with which this version of ispell.el is known to work.
(defconst ispell-required-version '("3.1." 12) (#$ . 18739))
#@68 Offset that maps protocol differences between ispell 3.1 versions.
(defvar ispell-offset -1 (#$ . 18877))
#@291 The name of the current dictionary, or nil for the default.
When `ispell-local-dictionary' is nil, `ispell-dictionary' is used to select
the dictionary for new buffers.

This is passed to the ispell process using the `-d' switch and is
used as key in `ispell-dictionary-alist' (which see).
(defvar ispell-dictionary nil (#$ . 18990))
#@38 Decodes multibyte character strings.
(defalias 'ispell-decode-string #[(str) "\302\300!\203 \303\304!\203 \203 \305 \203 \304	\305 \"\207	\207" [enable-multibyte-characters str boundp fboundp decode-coding-string ispell-get-coding-system] 3 (#$ . 19330)])
(defalias 'ispell-get-casechars #[nil "\302\303	\"A@!\207" [ispell-dictionary ispell-dictionary-alist ispell-decode-string assoc] 4])
(defalias 'ispell-get-not-casechars #[nil "\302\303\304	\"8!\207" [ispell-dictionary ispell-dictionary-alist ispell-decode-string 2 assoc] 5])
(defalias 'ispell-get-otherchars #[nil "\302\303\304	\"8!\207" [ispell-dictionary ispell-dictionary-alist ispell-decode-string 3 assoc] 5])
(defalias 'ispell-get-many-otherchars-p #[nil "\302\303	\"8\207" [ispell-dictionary ispell-dictionary-alist 4 assoc] 4])
(defalias 'ispell-get-ispell-args #[nil "\302\303	\"8\207" [ispell-dictionary ispell-dictionary-alist 5 assoc] 4])
(defalias 'ispell-get-extended-character-mode #[nil "\302\303	\"8\207" [ispell-dictionary ispell-dictionary-alist 6 assoc] 4])
(defalias 'ispell-get-coding-system #[nil "\302\303	\"8\207" [ispell-dictionary ispell-dictionary-alist 7 assoc] 4])
#@32 The process object for Ispell.
(defvar ispell-process nil (#$ . 20501))
#@66 Non-nil means personal dictionary has modifications to be saved.
(defvar ispell-pdict-modified-p nil (#$ . 20579))
(byte-code "\302\300!\204 \303\300	B\303\207" [ispell-quit current-load-list boundp nil] 2)
#@43 Output filter from piped calls to Ispell.
(defvar ispell-filter nil (#$ . 20795))
#@46 Control variable for Ispell filter function.
(defvar ispell-filter-continue nil (#$ . 20883))
#@51 The directory where `ispell-process' was started.
(defvar ispell-process-directory nil (#$ . 20983))
#@40 Marker for `query-replace' processing.
(defvar ispell-query-replace-marker (make-marker) (#$ . 21090))
#@46 Marker for return point from recursive edit.
(defvar ispell-recursive-edit-marker (make-marker) (#$ . 21199))
#@44 Non-nil when we're checking a mail message
(defvar ispell-checking-message nil (#$ . 21315))
(byte-code "\302\300	B\300\207" [ispell-choices-buffer current-load-list "*Choices*"] 2)
#@43 Overlay variable for Ispell highlighting.
(defvar ispell-overlay nil (#$ . 21505))
#@175 The keyword for local oddly-spelled words to accept.
The keyword will be followed by any number of local word spellings.
There can be multiple of these keywords in the file.
(defconst ispell-words-keyword "LocalWords: " (#$ . 21595))
#@203 The keyword for a local dictionary to use.
The keyword must be followed by a correct dictionary name in
`ispell-dictionary-alist'.  When multiple occurrences exist, the last keyword
definition is used.
(defconst ispell-dictionary-keyword "Local IspellDict: " (#$ . 21836))
#@178 The keyword for defining buffer local dictionaries.
Keyword must be followed by the filename of a personal dictionary.
The last occurring definition in the buffer will be used.
(defconst ispell-pdict-keyword "Local IspellPersDict: " (#$ . 22116))
#@375 The keyword for overriding default Ispell parsing.
The above keyword string should be followed by `latex-mode' or
`nroff-mode' to put the current buffer into the desired parsing mode.

Extended character mode can be changed for this buffer by placing
a `~' followed by an extended-character mode -- such as `~.tex'.
The last occurring definition in the buffer will be used.
(defconst ispell-parsing-keyword "Local IspellParsing: " (#$ . 22370))
#@379 Alist expressing beginning and end of regions not to spell check.
The alist key must be a regular expression.
Valid forms include:
  (KEY) - just skip the key.
  (KEY . REGEXP) - skip to the end of REGEXP.  REGEXP may be string or symbol.
  (KEY REGEXP) - skip to end of REGEXP.  REGEXP must be a string.
  (KEY FUNCTION ARGS) - FUNCTION called with ARGS returns end of region.
(defvar ispell-skip-region-alist '((ispell-words-keyword forward-line) (ispell-dictionary-keyword forward-line) (ispell-pdict-keyword forward-line) (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") ("\\(/\\|\\(\\(\\w\\|-\\)+[.:@]\\)\\)\\(\\w\\|-\\)*\\([.:/@]+\\(\\w\\|-\\|~\\)+\\)+")) (#$ . 22822))
#@207 *Lists of regions to be skipped in TeX mode.
First list is used raw.
Second list has key placed inside \begin{}.

Delete or add any regions you want to be automatically selected
for skipping in latex mode.
(defvar ispell-tex-skip-alists '((("%\\[" . "%\\]") ("\\\\addcontentsline" ispell-tex-arg-end 2) ("\\\\add\\(tocontents\\|vspace\\)" ispell-tex-arg-end) ("\\\\\\([aA]lph\\|arabic\\)" ispell-tex-arg-end) ("\\\\author" ispell-tex-arg-end) ("\\\\bibliographystyle" ispell-tex-arg-end) ("\\\\makebox" ispell-tex-arg-end 0) ("\\\\document\\(class\\|style\\)" . "\\\\begin[ 	\n]*{[ 	\n]*document[ 	\n]*}")) (("\\(figure\\|table\\)\\*?" ispell-tex-arg-end 0) ("list" ispell-tex-arg-end 2) ("program" . "\\\\end[ 	\n]*{[ 	\n]*program[ 	\n]*}") ("verbatim\\*?" . "\\\\end[ 	\n]*{[ 	\n]*verbatim\\*?[ 	\n]*}"))) (#$ . -23643))
#@237 *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.
(custom-declare-variable 'ispell-skip-sgml ''use-mode-name '(#$ . -24473) :type '(choice (const t) (const nil) (other :tag "use-mode-name" use-mode-name)) :group 'ispell)
#@437 A buffer local variable containing the current personal dictionary.
If non-nil, the value must be a string, which is a file name.

If you specify a personal dictionary for the current buffer which is
different from the current personal dictionary, the effect is similar
to calling \[ispell-change-dictionary].  This variable is automatically
set when defined in the file with either `ispell-pdict-keyword' or the
local variable syntax.
(defvar ispell-local-pdict ispell-personal-dictionary (#$ . 24887))
(make-variable-buffer-local 'ispell-local-pdict)
#@128 Contains the buffer name if local word definitions were used.
Ispell is then restarted because the local words could conflict.
(defvar ispell-buffer-local-name nil (#$ . 25447))
#@359 *Indicates whether ispell should parse the current buffer as TeX Code.
Special value `use-mode-name' tries to guess using the name of major-mode.
Default parser is `nroff'.
Currently the only other valid parser is `tex'.

You can set this variable in hooks in your init file -- eg:

(add-hook 'tex-mode-hook (function (lambda () (setq ispell-parser 'tex))))
(defvar ispell-parser 'use-mode-name (#$ . -25632))
#@44 Marker that allows spelling continuations.
(defvar ispell-region-end (make-marker) (#$ . 26048))
#@61 If non-nil, `ispell-word' does not try to correct the word.
(defvar ispell-check-only nil (#$ . 26151))
(byte-code "\302\303\"\204 \304\305!\204 \306\307\310\"\210\311\312!\204 \312\313M\210\314	\315\316#\207" [emacs-version esc-map string-match "18\\.[0-9]+\\.[0-9]+" boundp epoch::version defalias ispell ispell-buffer fboundp buffer-substring-no-properties #[(start end) "	{\207" [start end] 2] define-key "$" ispell-word] 4)
#@812 Check spelling of word under or before the cursor.
If the word is not found in dictionary, display possible corrections
in a window allowing you to choose one.

With a prefix argument (or if CONTINUE is non-nil),
resume interrupted spell-checking of a buffer or region.

If optional argument FOLLOWING is non-nil or if `ispell-following-word'
is non-nil when called interactively, then the following word
(rather than preceding) is checked when the cursor is not over a word.
When the optional argument QUIETLY is non-nil or `ispell-quietly' is non-nil
when called interactively, non-corrective messages are suppressed.

Word syntax described by `ispell-dictionary-alist' (which see).

This will check or reload the dictionary.  Use \[ispell-change-dictionary]
or \[ispell-region] to update the Ispell process.
(defalias 'ispell-word #[(&optional following quietly continue) "\203 \306 \207t\203 	\307 \210`\310\n!\311\211\211\211\211\"#$%&'&A@%&AA@$&@\211&G\312V\205K\f\204N \313\314(&!\"\210\315)\316\"\210\315)\317&\320Q\"\210\321)!\210*@\322\230\203^ *A\211*<\203| \323*@!##\324=\203\223 \f\2049\313\325(&!\"\210\2029#;\203\256 \f\2049\313\326(&!(#!#\210\2029#\204\272 \313\327!\210\2029+\203\316 \330 \210\313\331(&!\"\210\2029\332\213\210\333\232\203\340 \334#@!\210\202-\203-:\204\355 \202\357 @\"&G$%ZZ'\\'\"#@\232\204%$|\210`%\"c\210`$:\203-A@\203&\335\213\210\336%$\"\210\337,!\2039\340,!\210'b\210\341-!\210.\205K\311\211..\207" [continue ispell-following-word following ispell-quietly quietly replace ispell-continue ispell-accept-buffer-local-defs ispell-get-word nil 2 message "Checking spelling of %s..." process-send-string "%\n" "^" "\n" accept-process-output "" ispell-parse-output t "%s is correct" "%s is correct because of root %s" "Error in ispell process" beep "%s is incorrect" ((byte-code "\304AA@AAA@@	\n%\304\207" [poss start end replace ispell-command-loop] 6)) 0 ispell-add-per-file-word-list ((query-replace word new-word t)) ispell-region get-buffer kill-buffer ispell-pdict-save new-word poss end start word cursor-location ispell-format-word ispell-process ispell-filter ispell-check-only ispell-choices-buffer ispell-silently-savep ispell-quit] 8 (#$ . 26592) (list nil nil current-prefix-arg)])
#@420 Return the word for spell-checking according to ispell syntax.
If optional argument FOLLOWING is non-nil or if `ispell-following-word'
is non-nil when called interactively, then the following word
(rather than preceding) is checked when the cursor is not over a word.
Optional second argument contains otherchars that can be included in word
many times.

Word syntax described by `ispell-dictionary-alist' (which see).
(defalias 'ispell-get-word #[(following &optional extra-otherchars) "\306 \307 \310 \311 \312\n\313\230?\205 \n\314P\f\205 \f\314P\315\204) \f\203- \316\202. \314\260\317\317\317\317\317 \320!\204Z !\203T \321d\322#\210\202Z \323e\322#\210\323	e\324#\210\n\313\230\204l \320\n!\204v \f\203\307 \320\f!\203\307 o\204\307 \203\203 \203\307 `=\204\307 \f\203\247 \320\f!\203\247 \325\326!\210\320!\203` \323	e\327#\210\202` \322`\325\326!\210\320!\203\300 \323	e\327#\210\202` \325\330!\210\202` \321d\322#\204\341 \"\203\333 \313``E\202\366 \331\332!\202\366 \333\224`\334\"\211 E.\n\207" [ispell-casechars ispell-not-casechars ispell-otherchars ispell-many-otherchars-p extra-otherchars word-regexp ispell-get-casechars ispell-get-not-casechars ispell-get-otherchars ispell-get-many-otherchars-p "+\\(" "" "?" "+\\)" "*" nil looking-at re-search-forward t re-search-backward start backward-char 1 move -1 error "No word found to check!" 0 buffer-substring-no-properties did-it-once prevpt end word following ispell-check-only] 8 (#$ . 28920)])
#@96 Check to see if the personal dictionary has been modified.
If so, ask if it needs to be saved.
(defalias 'ispell-pdict-save #[(&optional no-query force-save) "\203\f <\203\f @\204 	\203' \n\204 \304\305!\203' \306\307\"\210\310\311!\210\312\211\207" [ispell-pdict-modified-p force-save no-query ispell-process y-or-n-p "Personal dictionary modified.  Save? " process-send-string "#\n" message "Personal dictionary saved." nil] 3 (#$ . 30438) (list ispell-silently-savep t)])
#@671 Display possible corrections from list MISS.
GUESS lists possibly valid affix construction of WORD.
Returns nil to keep word.
Returns 0 to insert locally into buffer-local dictionary.
Returns string for new chosen word.
Returns list for new replacement word (will be rechecked).
  Query-replace when list length is 2.
  Automatic query-replace when second element is `query-replace'.
Highlights the word, which is assumed to run from START to END.
Global `ispell-pdict-modified-p' becomes a list where the only value
indicates whether the dictionary has been modified when option `a' or `i' is
used.
Global `ispell-quit' set to start location to continue spell session.
(defalias 'ispell-command-loop #[(miss guess word start end) "p\306\307\310 \311Z	\n^\312\313\314 !\315\316\211\211\211\211\211@ABCDEFGHIJ\212\317K!q\210\320LPM\321\322!\203L \322Np\316B\"\210\323 \210O\203\230 \324\325\261\210O\203\204 iO@G\\\311\\\326 V\203t \327c\210HTHO@\330\261\210OA\211O\204^ \331\332\261\210HF\203\224 \333\202\225 \307\\HF\203\375 iF@G\\I\334V\203\256 \333\202\257 \315\\\335\\\326 V\203\304 \336c\210HT\211H\202\306 HGW\203\375 IE>\203\343 \337IT!ICTC\202\314 \340I\341F@\342\261\210FAF\337IT!I\202\230 \337ICZ\306Z!I)\343P!\204\344\315!\210D\203!\314 \345\f\316\"\210\346HP\"\210\347\350 \211!\210\351\216Q\203>\352RP\353#\210\354 \210\316S\355\356!\210)\353T\321\357!\203W\357 \202Y\360 B\315CU\204jB\335U\203p\361B\316U)E\211V\203\230V@\306V\203\217V@BW\203\217CTCVA\211V\204yBCZ\306ZA)B\362U\203\255\316\202%B\363U\203\305\364W\365L\336Q\"\210\366X\316\202%B\367U\204\323B\370U\203\362\364W\371L\336Q\"\210X\204\347XCXB\370U\205%\315\202%B\372U\204 B\373U\203E\374Q=\203\352RP\316\353$\210B\373U\204Y\203&\375\376L\"\353D\202-\375\377L\"\316B@\374Q=\203?\352RP\316\374$\210@)\202%B\201d U\204_BZU\204_B\201e U\203\210\374Q=\203o\352RP\316\353$\210\201f  \210\374Q=\203\204\352RP\316\374$\210\353\202%B\201g U\203\245\201h [!\210\355\201i !\210\353\\\316\202%B\361U\203\310\201h [!\210\355\201j \201k \201l !\"\210R\\\316\202%B\201m U\203\365\201n \201o !\203\361\201p \353!\210]?\206\350`\\\316\211X\202%\353\202%B\201q U\2035\374Q=\203\352RP\316\353$\210\375\201r L\"\307^\211_\203 \212\317K!q\210\323 \210\306I\315C\320_PM\201s _!\211FF\203\243iF@G\\I\334V\203T\333\202U\315\\\335\\\326 V\203j\336c\210^T\211^\202l^GW\203\243IE>\203\211\337IT!ICTC\202r\340I\341F@\342\261\210FAF\337IT!I\202>\337ICZ\306Z!I)\347\201t  !\210^HU\204H^]\nV\203\n`H`W\203\333`HZ\202\334\315a^`W\203\356`^Z\202\357\315b^HV\203	\201u ^HZaZ!\210\202\201v H^ZbZ!\210^H+\347\350 !\210*\374Q=\2031\352RP\316\374$\210\353\202%B\201w U\203R\364W\365L\227\336Q\"\210\201x X\316\202%B\201y U\203v\364W\365\375\201z L\"\336Q\"\210\201{ XL\316B\202%A\315Y\203\234AIW\203\234Y\203\225A8\201| D\202%A8\202%B\201} U\203\256\201~  \210\353\202%B\201 U\203	\201\200 c!\203\316\355\201\201 !\210\201\202  \210\202cR\316\223\210Q\203\341\352RP\"\210\201\203 \216\201\204 \213\210\201\205 c!p\232\204\375\201\206 \201\207 !\210cb\210)L\316B\202%B\201\210 U\203\201\211 \201\212 ! \210\353\202%\201\213  \210\353\211@\353=\204>@.\207" [miss window-min-height ispell-choices-win-default-height highlighted dedicated-win textwin 48 2 window-height 4 (32 105 97 65 114 82 63 120 88 113 108 117 109) window-dedicated-p selected-window 0 nil get-buffer-create "--  %b  --  word: " fboundp set-specifier erase-buffer "Affix rules generate and capitalize " "this word as shown below:\n	" window-width "\n	" "    " "\nUse option `i' if this is a correct composition" " from the derivative root.\n" 3 126 7 "\n" ispell-int-char "(" ") " "  " pos-visible-in-window-p sit-for set-window-dedicated-p ispell-show-choices select-window next-window ((byte-code "\203 \303\213\210	\203 \304\n\305\"\210\304\207" [ispell-highlight-p dedicated dedicated-win ((byte-code "\303!\210\304	\n\"\207" [textwin start end select-window ispell-highlight-spelling-error] 3)) set-window-dedicated-p t] 3)) ispell-highlight-spelling-error t undo-boundary message "C-h or ? for more options; SPC to leave unchanged, Character to replace word" read-char-exclusive read-char 88 32 105 process-send-string "*" (t) 97 65 "@" 114 82 block read-string "Query-replacement for: " "Replacement for: " result num char skipped dedicated command-characters choices max-lines line count textbuf ispell-choices-buffer word mode-line-format has-modeline-p guess end ispell-highlight-p start message-log-max inhibit-quit quit-flag com-chars ispell-process ispell-pdict-modified-p ispell-query-replace-choices help-char ispell-silently-savep ispell-quit ispell-checking-message new-line new-word minh gr-bl shr-bl ispell-recursive-edit-marker 63 8 ispell-help 120 ispell-pdict-save "Exited spell-checking" "%s" substitute-command-keys "Spell-checking suspended; use C-u \\[ispell-word] to resume" 113 y-or-n-p "Really kill Ispell process? " ispell-kill-ispell 108 "Lookup string (`*' is wildcard): " lookup-words previous-window enlarge-window shrink-window 117 (t) 109 "Insert: " (t) query-replace 12 redraw-display 18 marker-position "Only one recursive edit session supported" beep ((byte-code "\301\211\223\207" [ispell-recursive-edit-marker nil] 3)) ((byte-code "\212\300 \210)\300\207" [recursive-edit] 1)) marker-buffer error "Cannot continue ispell from this buffer." 26 key-binding "" ding] 16 (#$ . 30929)])
#@47 Shows the choices in another buffer or frame.
(defalias 'ispell-show-choices #[(line end) "\203 \306\307	!!\210\310\311 !\207\312	!\211\203i \313\n!U\203& \310\n!\210\202p \313\n!Z\314\315!\210`W\203@ Z\\\316\317!\210\314!\210\320\321 `\fV\203U \f\202V `\"\210b\210\310\311 !\210\322!\210*\202p \323]!\210\324	!\210eb)\207" [ispell-use-framepop-p ispell-choices-buffer choices-window line visible window-line framepop-display-buffer get-buffer select-window previous-window get-buffer-window window-height vertical-motion -1 move-to-window-line 0 set-window-start selected-window enlarge-window ispell-overlay-window switch-to-buffer ispell-choices-win-default-height end] 5 (#$ . 36598)])
#@1039 Display a list of the options available when a misspelling is encountered.

Selections are:

DIGIT: Replace the word with a digit offered in the *Choices* buffer.
SPC:   Accept word this time.
`i':   Accept word and insert into private dictionary.
`a':   Accept word for this session.
`A':   Accept word and place in `buffer-local dictionary'.
`r':   Replace word with typed-in value.  Rechecked.
`R':   Replace word with typed-in value. Query-replaced in buffer. Rechecked.
`?':   Show these commands.
`x':   Exit spelling buffer.  Move cursor to original point.
`X':   Exit spelling buffer.  Leaves cursor at the current point, and permits
        the aborted check to be completed later.
`q':   Quit spelling session (Kills ispell process).
`l':   Look up typed-in replacement in alternate dictionary.  Wildcards okay.
`u':   Like `i', but the word is lower-cased first.
`m':   Place typed-in value in personal dictionary, then recheck current word.
`C-l':  redraws screen
`C-r':  recursive edit
`C-z':  suspend emacs or iconify frame
(defalias 'ispell-help #[nil "\304\232\203 \305\306!\210\307\310!\207\311\312\313\314\213+\207" [ispell-help-in-bufferp help-3 help-2 help-1 electric require ehelp with-electric-help #[nil "\300 \301W\203 \302\301\300 Z!\210\303\304!\210\305\207" [window-height 15 enlarge-window princ "Selections are:\n\nDIGIT: Replace the word with a digit offered in the *Choices* buffer.\nSPC:   Accept word this time.\n`i':   Accept word and insert into private dictionary.\n`a':   Accept word for this session.\n`A':   Accept word and place in `buffer-local dictionary'.\n`r':   Replace word with typed-in value.  Rechecked.\n`R':   Replace word with typed-in value. Query-replaced in buffer. Rechecked.\n`?':   Show these commands.\n`x':   Exit spelling buffer.  Move cursor to original point.\n`X':   Exit spelling buffer.  Leaves cursor at the current point, and permits\n        the aborted check to be completed later.\n`q':   Quit spelling session (Kills ispell process).\n`l':   Look up typed-in replacement in alternate dictionary.  Wildcards okay.\n`u':   Like `i', but the word is lower-cased first.\n`m':   Place typed-in value in personal dictionary, then recheck current word.\n`C-l':  redraws screen\n`C-r':  recursive edit\n`C-z':  suspend emacs or iconify frame" nil] 3] "[r/R]eplace word; [a/A]ccept for this session; [i]nsert into private dictionary" "[l]ook a word up in alternate dictionary;  e[x/X]it;  [q]uit session" "[u]ncapitalized insert into dict.  Type 'x C-h d ispell-help' for more help" ((byte-code "\203 \305\306!\210\307\310\311!!\210	\312\n\312\260c\210\313\314!\210\315\311!\207\316\317 !\210\320 \210\321\322\f\"\203H \323!\210\324\325!\210\323\n!\210\324\325!\210\323	!\210eb\210\202` \321\326\f\"\204S \323\327!\210\324\330!\210	\312\n\312\260c\210\313\314!\210\320 \207" [ispell-help-in-bufferp help-1 help-2 help-3 emacs-version ispell-overlay-window 4 switch-to-buffer get-buffer-create "*Ispell Help*" "\n" sit-for 5 kill-buffer select-window minibuffer-window erase-buffer string-match "Lucid\\|XEmacs" message enlarge-window 1 "18\\.[0-9]+\\.[0-9]+" nil 2] 5))] 3 (#$ . 37318)])
#@332 Look up word in word-list dictionary.
A `*' serves as a wild card.  If no wild cards, `look' is used if it exists.
Otherwise the variable `ispell-grep-command' contains the command used to
search for the words (usually egrep).

Optional second argument contains the dictionary to use; the default is
`ispell-alternate-dictionary'.
(defalias 'lookup-words #[(word &optional lookup-dict) "\204 	\n\306\307\f\"\205 \206 ?\310\311!\203* \202, \2038 \202: \312\312\312\313\216\314\213\210).	\207" [lookup-dict ispell-alternate-dictionary ispell-use-ptys-p process-connection-type word wild-p string-match "\\*" get-buffer-create "*Ispell-Temp*" nil ((byte-code "\303!\210	\203 \304\305	@\"\203 \306\307\n	@#\210\303\207" [ispell-grep-buffer results ispell-grep-command kill-buffer string-match ".+: " error "%s error: %s"] 4)) ((byte-code "\306\307\310!\"\210	q\210\n\204( \311\312\261\210\313\314\315\316#\203\" \317c\210\202 \320 \321 \210\322\315\316\315\f&\211;\203I \323\324\310!#B\202q db\210o\204Y h\325U\204Y \325c\210o\204q `\326y\210\327`S\"B\202Y \315\207" [prog ispell-grep-buffer look-p word args lookup-dict message "Starting \"%s\" process..." file-name-nondirectory "^" "$" search-backward "*" nil t "." buffer-string erase-buffer call-process format "error: %s exited with signal %s" 10 -1 buffer-substring-no-properties status results loc] 9)) ispell-look-p ispell-have-new-look look-p ispell-grep-buffer ispell-look-command ispell-grep-command prog ispell-look-options ispell-grep-options args status results loc] 3 (#$ . 40489)])
#@52 Output filter function for ispell, grep, and look.
(defalias 'ispell-filter #[(process output) "\306\307\310	\205T \311\312\n#\f\203* \203* <\203* \211@\nOP\240\210\2021 \nOB\204= \307\310\211\202 \310T\211GU\203O \310\211\202 \202 +\207" [end continue start output ispell-filter-continue ispell-filter 0 t nil string-match "\n"] 6 (#$ . 42109)])
#@347 Highlight the word from START to END with a kludge using `inverse-video'.
When the optional third arg HIGHLIGHT is set, the word is highlighted;
otherwise it is displayed normally.
Uses block cursor to highlight one character.
Optional REFRESH will unhighlighted then highlight, using block cursor
 highlighting when REFRESH is equal to `block'.
(defalias 'ispell-highlight-spelling-error-generic #[(start end &optional highlight refresh) "\306=\203 \306	=\204 \nT\307 \310\311\n\"\312\211b\210\n|\210\313\314\nZ\"\210\315\316!\210\203< ?\n|\210c\210\315\316!\210\204S b\210\202b ?\306=\203b \nSb\210\317!\210	\205| \320	\306=\203v \n\202y \n\321Z\312#-\207" [ispell-highlight-p refresh start end buffer-undo-list inhibit-quit block buffer-modified-p nil buffer-substring-no-properties t insert-char 32 sit-for 0 set-buffer-modified-p ispell-highlight-spelling-error-generic 2 text buffer-read-only modified highlight inverse-video] 5 (#$ . 42490)])
#@172 Highlight the word from START to END using `isearch-highlight'.
When the optional third arg HIGHLIGHT is set, the word is highlighted,
otherwise it is displayed normally.
(defalias 'ispell-highlight-spelling-error-xemacs #[(start end &optional highlight) "\203	 \303	\n\"\207\304\305!\207" [highlight start end isearch-highlight isearch-dehighlight t] 3 (#$ . 43483)])
#@240 Highlight the word from START to END using overlays.
When the optional third arg HIGHLIGHT is set, the word is highlighted
otherwise it is displayed normally.

The variable `ispell-highlight-face' selects the face to use for highlighting.
(defalias 'ispell-highlight-spelling-error-overlay #[(start end &optional highlight) "\203 \305	\n\"\306\307\f#\207\310!\207" [highlight start end ispell-overlay ispell-highlight-face make-overlay overlay-put face delete-overlay] 4 (#$ . 43860)])
(defalias 'ispell-highlight-spelling-error #[(start end &optional highlight refresh) "\306\307\"\203 \310	\n#\207\306\311\"\204$ \312\313!\203$ \f\203$ \314	\n#\207\315	\n$\207" [emacs-version start end highlight window-system refresh string-match "Lucid\\|XEmacs" ispell-highlight-spelling-error-xemacs "18\\.[0-9]+\\.[0-9]+" featurep faces ispell-highlight-spelling-error-overlay ispell-highlight-spelling-error-generic] 5])
#@202 Create a window covering the top HEIGHT lines of the current window.
Ensure that the line above point is still visible but otherwise avoid
scrolling the current window.  Leave the new window selected.
(defalias 'ispell-overlay-window #[(height) "\212\212\305y\210`)\212\306!\210`)\211	W\203 \n\307\310\"\203) \307\311\"\203) T\312\313\314 !\236A\203I \314 \315\f\316\"\210\317\320\"\210\315\f\321\"\210)\202N \317\320\"\210\322\323 	\"+\207" [height top oldot emacs-version frame -1 move-to-window-line string-match "Lucid\\|XEmacs" "19\\.9\\.[0-9]+" unsplittable frame-parameters selected-frame modify-frame-parameters ((unsplittable)) split-window nil ((unsplittable . t)) set-window-start next-window] 4 (#$ . 44792)])
#@483 Parse the OUTPUT string from Ispell process and return:
1: t for an exact match.
2: A string containing the root word matched via suffix removal.
3: A list of possible correct spellings of the format:
   ("ORIGINAL-WORD" OFFSET MISS-LIST GUESS-LIST)
   ORIGINAL-WORD is a string of the possibly misspelled word.
   OFFSET is an integer giving the line offset of the word.
   MISS-LIST and GUESS-LIST are possibly null lists of guesses and misses.
4: Nil when an error has occurred.
(defalias 'ispell-parse-output #[(output) "\306\230\203 \307\207\310\230\203 \307\207\311\230\203 \307\207\312\313O\314\230\203& \315\316O\207\317\320\"\312\232\203> \321 \210\322\323P!\210\324\325!\210\316\207\312\313O\315\317\326\315#O\312\316\211\211\211\312\225\316O\327\230\203j \312\202x \330!\317\326\313#T\316O\330!\327\230\203\210 \316\202\222 \317\326\313#T\316O\203\316 \317\331\"T\211\fV\203\260 \312O\nB\202\270 \312OB\313\225\203\302 \316\202\312 \315\\\316O)\202\222 	\nF.\207" [output offset guess-list miss-list count cur-count "" t "*" "-" 0 1 "+" 2 nil string-match "[a-zA-Z]" ding message "Ispell error: " sit-for 5 " " "#" string-to-int ", \\|\\($\\)" original-word type end] 8 (#$ . 45533)])
(defalias 'check-ispell-version #[(&optional interactivep) "\212\306\211\307\310\311\312!q\210\310\313 \210\314\f\306\310\306\315%eb\210\2035 \306\210\316e`\"\317Q\320!\210eb\210\n\321>\204K \322\323\f\n;\203G \324\202H \325\n$\210\326\327\330 @!\331Q\306\310#\204i \322\332\f @ A@$\210\202} \333\316\334\224\334\225\"!@ A@W\203} \335!\336p!\210-\207" [result default-major-mode status case-fold-search ispell-program-name interactivep nil fundamental-mode t get-buffer-create " *ispell-tmp*" erase-buffer call-process "-v" buffer-substring-no-properties ", " message (0 nil) error "%s exited with %s %s" "signal" "code" re-search-forward "\\<\\(" regexp-quote "\\)\\([0-9]*\\)\\>" "%s version 3 release %s%s or greater is required" read-from-string 2 0 kill-buffer ispell-version ispell-required-version ispell-offset] 6 nil "p"])
#@56 Check status of Ispell process and start if necessary.
(defalias 'ispell-init-process #[nil "\203 \306!\307=\203 	\203 \n\232\203 \310\310\211\207\311\312!\210\313\314!\210\315\316!\210\317 \21012\320\321\322\3103\323\324\31045\203C 56\325 46\203V \326\3276D4\"4	\203e \3264\330\331	!D\"4\32647\"\2114)&)\310\310\332\304\"\210\333\334!\203\225 \335\336!\203\225 \203\225 \336\337 \"\210\340\3418\"\204\245 \342\343\"\210\202\251 \342!\210\f\204\262 \342\343\"\210\f\204\277 \344\3453\"\210\202\f@;\203\365 \340\346\f@\"\203\347 \340\3418\"\204\335 \342\343\"\210\202\341 \342!\210\f@;\202\352 \fA?\203\365 \340\347\f@\"\204\350\351!\210\342 \210\344\352\353\354\f\355#\"\210\310\356 \2119\203\3579\355P\"\210)\360!\207" [ispell-process ispell-personal-dictionary ispell-process-directory default-directory ispell-filter ispell-filter-continue process-status run nil ispell-kill-ispell t message "Starting new Ispell process..." sit-for 0 check-ispell-version apply start-process "ispell" "-a" "-m" ispell-get-ispell-args append "-d" "-p" expand-file-name set-process-filter boundp enable-multibyte-characters fboundp set-process-coding-system ispell-get-coding-system string-match "18\\.[0-9]+\\.[0-9]+" accept-process-output 5 error "%s did not output version line" "warning: " "^@(#) " sleep-for 1 "%s" mapconcat identity "\n" ispell-get-extended-character-mode process-send-string process-kill-without-query ispell-use-ptys-p process-connection-type ispell-program-name args ispell-local-dictionary ispell-dictionary ispell-extra-args emacs-version extended-char-mode] 13 (#$ . 47650)])
#@133 Kill current Ispell process (so that you may start a fresh one).
With NO-ERROR, just return non-nil if there was no Ispell running.
(defalias 'ispell-kill-ispell #[(&optional no-error) "\203\f \302!\303=\204 	\206 \304\305!\207\306!\210\307\310\311!\210\307\207" [ispell-process no-error process-status run error "There is no ispell process running!" kill-process nil message "Ispell process killed"] 2 (#$ . 49302) nil])
#@234 Change `ispell-dictionary' (q.v.) and kill old Ispell process.
A new one will be started as soon as necessary.

By just answering RET you can find out what the current dictionary is.

With prefix argument, set the default directory.
(defalias 'ispell-change-dictionary #[(dict &optional arg) "\305\232\203 \306\307\232\203 \310\311	\206 \n\206 \305\"\207\n\232\2038 	\203+ 	\232\2038 t\205\204 \310\312\2066 \305\"\207\313\"\203R \f\204G \204I \f\204W \202W \314\315\"\210\316\317!\210\310\320	\n\232\203g \307\202p \f\203o \321\202p \322	\n\232\204z \f\204~ 	\202 \n\206\203 \305#\207" [dict ispell-local-dictionary ispell-dictionary ispell-dictionary-alist arg "default" nil "" message "Using %s dictionary" "No change, using %s dictionary" assoc error "Undefined dictionary: %s" ispell-kill-ispell t "(Next %sIspell command will use %s dictionary)" "global " "local "] 5 (#$ . 49737) (list (completing-read "Use new dictionary (RET for current, SPC to complete): " (cons (cons "default" nil) ispell-dictionary-alist) nil t) current-prefix-arg)])
#@82 Interactively check a region for spelling errors.
Return non-nil if not aborted.
(defalias 'ispell-region #[(reg-start reg-end) "\304 \210\305\216\212\306\307eU\203 	dU\203 \310 \202 \311\n\206 \312#\210\313\213\210*?\207" [reg-start reg-end ispell-dictionary ispell-quit ispell-accept-buffer-local-defs ((byte-code "\305!\203\n \306!\210	\2032 	\247\204 \n\307\211\223\210\202 	b\210\203- 	\247\203- \307\310\311!\210\307\202? \n\307\211\223\210\312\f!\210\313\314!\210\307\207" [ispell-choices-buffer ispell-quit ispell-region-end ispell-checking-message ispell-silently-savep get-buffer kill-buffer nil error "Message send aborted." ispell-pdict-save message "Spell-checking done"] 3)) message "Spell checking %s using %s dictionary..." buffer-name "region" "default" ((byte-code "b\210\306	\307 \310 \n\306\311=\203' \306\312@A@\f#\306\313\314!\210)\315\316#\203K \317\320\224\320\225\"`GZ\306\223\210b\210\306\313\321\206V \322\"\210)\306\223\210 \204\362 `W\203\362 \323!\203\260 `X\203\260 \324\f\"\210`\211W\203\252 \315\316#\203\252 \317\325 @\325 A@\"`GZ\306\223\210b\210\202\260 \306\211\223\210\323!\203\277 ^\202\303 \323!`!\212\306\210`^)\"\326!\"##`\"#\203\352 \327#!\210\"b\210+\202` .\306\207" [reg-start case-fold-search ispell-skip-region-alist key skip-alist skip-regexp nil make-marker ispell-begin-skip-region-regexp tex append message "searching for regions to skip" re-search-forward t buffer-substring-no-properties 0 "Continuing spelling check using %s dictionary..." "default" marker-position ispell-skip-region match-data ispell-get-line ispell-process-line skip-region-start transient-mark-mode ispell-parser ispell-tex-skip-alists message-log-max reg-end ispell-dictionary ispell-region-end ispell-quit start end string] 7))] 4 (#$ . 50811) "r"])
(defalias 'ispell-begin-skip-region-regexp #[nil "\306 	\204 \n\203 \307\n!\310Q	\311=\203- \n\203- \312\230\203& \313\202) \307!\310Q\f\2036 \310Q\203? \314P\315=\203L \316 \310Q)\207" [skip-regexp ispell-check-comments comment-start comment-end ispell-skip-tib ispell-tib-ref-beginning ispell-begin-skip-region regexp-quote "\\|" exclusive "" "^" "[<&]\\|" tex ispell-begin-tex-skip-regexp ispell-skip-sgml ispell-parser] 3])
(defalias 'ispell-begin-tex-skip-regexp #[nil "\301\302@\303#\303\301\304A@\303#Q\207" [ispell-tex-skip-alists mapconcat #[(lst) "@\207" [lst] 1] "\\|" #[(lst) "\301@\302Q\207" [lst "\\\\begin[ 	\n]*{[ 	\n]*" "[ 	\n]*}"] 3]] 6])
(defalias 'ispell-begin-skip-region #[nil "\301\302\303#\207" [ispell-skip-region-alist mapconcat #[(lst) "@;\203	 @\207\301@!\207" [lst eval] 2] "\\|"] 4])
(defalias 'ispell-tex-arg-end #[(&optional arg) "\300\301\302\217\207" [nil (byte-code "\301\302!\203\f \303 \210\202  \303\206 \304!\207" [arg looking-at "[ 	\n]*\\[" forward-sexp 1] 2) ((error (byte-code "\300\301`\"\210\302 \210\303\304!\207" [message "error skipping s-expressions at point %d." beep sit-for 2] 3)))] 3])
(defalias 'ispell-skip-region #[(key alist) "Gu\210`\306\211\f\2040 \2030 \230\2030 \307\230\203% \306y\210\202\310\311#\210\202\f\312=\203L \203L \230\203L \310#\210\202\203d \313\"\203d \314\311#\210\202\203z \313\315\"\203z \310\316\311#\210\202\203\220 \313\317\"\203\220 \310\320\311#\210\202\203\321@@!\313\n\"\203\373 @A\211\204\262 \311\202\364 :\204\304 \314\321!d\311#\210\202\364 :\203\364 ;\203\332 \314d\311#\210\202\364 \311A:\203\357 \322@A\"\210\202\364 @ \210\306\211\202\222 A\211\204\225 `U\205	?\205\323\324`#\210\325 \210\326\327!+\207" [key null-skip alist-key start ispell-check-comments comment-start nil "" search-forward t exclusive string-match re-search-forward "<" ">" "&" ";" eval apply message "Matching region end for `%s' point %d not found" beep sit-for 2 comment-end ispell-region-end :end ispell-skip-tib ispell-tib-ref-beginning ispell-tib-ref-end ispell-skip-sgml alist] 5])
(defalias 'ispell-get-line #[(start end reg-end) "\304 \305l\203 \305y\210\202< \306\307!\203 \310u\210\202< \311	\n\312#\204+ \311\313\n\312#\2039 \314\315\n\"\316Q\nb\210\202< \nb\210*\207" [string ispell-casechars end start ispell-get-casechars nil looking-at "[---#@*+!%~^]" 1 re-search-forward t "[][()${}]" "^" buffer-substring-no-properties "\n"] 4])
(defalias 'ispell-process-line #[(string) "\306\307	\n\"\210\310	!\210@\311\230\203 A\237\f?\205\345\205\345\312@!\211\203\337<\203\337\313\314\305!\203O \203O \315 \203O \212!\"\\b\210A@u\210`)\202X !\"\\A@\\!@G\313#!\313!!\306\211$%&'(\211)b\210\316 \210()\\b\210\316 \210)b\210\316 \210(`\\\317@(`\\\320#\210`U\204\246 \321\322@\323)!#\210*\203\310 \324AA@AAA@@\323)!(\323)!\\%$\202\313 \325\213\210)b\210\326`(`\\\"@\230\204\347 '`\306\223\210\306\320%$\203)$<\203)\306\320%`(`\\|\210$@c\210$A@\327=\204\330$@G!\210'`\306\223\210$A@\203\200\331\216\332\213\210)\202\200$\2035$\333\232\203b$\333\232\203A\334@!\210+\203\200+<\203\200+@+\306\320%'\323)!\306\223\210\202\200$\203\200`(`\\|\210$c\210&\211$G@GZ\\\306\223\210\f\204\222\306,\335\336-\206\217\337\"\210)\340\333!\210\323&!!\323'!#%\204\271#)(\\W\203\271)(\\#).U\203\313.)(\\\306\223\210&\306\211\223\210)\306\211\223\210'\306\211\223\210.A\202 )\207" [poss ispell-process string ispell-filter ispell-quit enable-multibyte-characters nil process-send-string accept-process-output "" ispell-parse-output copy-marker boundp ispell-get-coding-system ispell-horiz-scroll search-forward t error "Ispell misalignment: word `%s' point %d; probably incompatible versions" marker-position ispell-command-loop ((byte-code "\304AA@AAA@@\305	!\n\305	!\\%\304\207" [poss word-start word-len replace ispell-command-loop marker-position] 8)) buffer-substring-no-properties query-replace backward-char ((goto-char word-start)) ((byte-code "\302 \210\303@	@\304#\207" [poss replace delete-other-windows query-replace t] 4)) 0 ispell-add-per-file-word-list message "Continuing spelling check using %s dictionary..." "default" sit-for start ispell-offset end replace recheck-region line-start line-end word-len word-start ispell-keep-choices-win ispell-pdict-modified-p message-log-max ispell-dictionary ispell-region-end] 9])
#@71 Check comments and strings in the current buffer for spelling errors.
(defalias 'ispell-comments-and-strings #[nil "eb\210\303\211?\205K \304\305`d\303\211	\306&\307	8\204$ \310	8\203 `\305\nd\303\211	\306&\307	8\204< \310	8\203@ \311\312!\210\212\313\n`\"?*\202 *\207" [done state start nil t parse-partial-sexp syntax-table 3 4 error "Unterminated string or comment." ispell-region] 7 (#$ . 57231) nil])
#@61 Check the current buffer for spelling errors interactively.
(defalias 'ispell-buffer #[nil "\300ed\"\207" [ispell-region] 3 (#$ . 57655) nil])
(defalias 'ispell-continue #[nil "\301!\204\n \302\303!\207\304!p\232\204 \302\305\306\304!!\"\207\307\310\311!A@\301!\"\207" [ispell-region-end marker-position message "No session to continue.  Use 'X' command when checking!" marker-buffer "Must continue ispell from buffer %s" buffer-name ispell-region ispell-get-word t] 5 nil nil])
#@67 Places point within the horizontal visibility of its window area.
(defalias 'ispell-horiz-scroll #[nil "\2055 i\302 \303]Z\211\304W\203! \302 \304V\203! \305	[\306]!\2024 	\307 \310ZY\2054 \311	\307 Z\312Z\306]!)\207" [truncate-lines column window-hscroll 1 0 scroll-right 10 window-width 2 scroll-left -3] 4 (#$ . 58145)])
#@244 Look up word before or under point in dictionary (see lookup-words command)
and try to complete it.  If optional INTERIOR-FRAG is non-nil then the word
may be a character sequence inside of a word.

Standard ispell choices are then available.
(defalias 'ispell-complete-word #[(&optional interior-frag) "`\306\307\306\310\"\306\211\211\211\fA@\fAA@\f@\211\311\230\206< \312 \205+ \313\f \2047 !?\2058 \313Q\"\"\211\314=\203J \315\316!\210\202\314 	\204V \315\317\f\"\210\202\314 \320\321\f\"\203e \322\323	\"\202\200 \320\324\f\"\203t \322\325	\"\202\200 \320\326\f\"\203\200 \322\327	\"\330\213\210\331\232\203\220 \332\f!\210\202\300 \203\300 \n|\210:\204\241 \202\243 @\211G\nZZ\\\fc\210:\203\300 b\210\333\306\314\"\210\334#!\203\314 \335#!\210\336$!\210b.\207" [replacement possibilities end start word case-fold-search nil ispell-get-word "\\*" "" lookup-words "*" t message "No word to complete" "No match for \"%s\"" string-match "^[^A-Z]+$" mapcar downcase "^[^a-z]+$" upcase "^[A-Z]" capitalize ((byte-code "\305\306	\n%\306\207" [possibilities word start end replacement ispell-command-loop nil] 6)) 0 ispell-add-per-file-word-list ispell-word get-buffer kill-buffer ispell-pdict-save cursor-location interior-frag ispell-look-p ispell-complete-word-dict ispell-choices-buffer ispell-silently-savep] 8 (#$ . 58478) "P"])
#@59 Completes word matching character sequence inside a word.
(defalias 'ispell-complete-word-interior-frag #[nil "\300\301!\207" [ispell-complete-word t] 2 (#$ . 59859) nil])
#@42 Non-nil if Ispell minor mode is enabled.
(defvar ispell-minor-mode nil (#$ . 60037))
(byte-code "\301\302!\210\302\236\204 \303B\301\207" [minor-mode-alist make-variable-buffer-local ispell-minor-mode (ispell-minor-mode " Spell")] 2)
#@36 Keymap used for Ispell minor mode.
(defvar ispell-minor-keymap (byte-code "\301 \302\303\304#\210\302\305\304#\210)\207" [map make-sparse-keymap define-key " " ispell-minor-check ""] 4) (#$ . 60281))
(byte-code "\302\300!\203 \303\304\"\204 \304	BB\302\207" [minor-mode-map-alist ispell-minor-keymap boundp assoc ispell-minor-mode] 3)
#@325 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.

All the buffer-local variables and dictionaries are ignored -- to read
them into the running ispell process, type \[ispell-word] SPC.
(defalias 'ispell-minor-mode #[(&optional arg) "\204 	\206 \302!\303X?\304 \207" [arg ispell-minor-mode prefix-numeric-value 0 force-mode-line-update] 2 (#$ . 60633) "P"])
#@197 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.
Don't read buffer-local settings or word lists.
(defalias 'ispell-minor-check #[nil "\303\304`Sf\305=\204 \306=\204 \307\213\210\310\311\312 !!+\207" [last-char ispell-check-only ispell-minor-mode nil t 32 10 ((byte-code "\214\212\300y\210`)`}\210\301\302\303\"\210)\302\207" [-1 ispell-word nil t] 3)) call-interactively key-binding this-command-keys] 3 (#$ . 61141) "*"])
#@195 *End of text which will be checked in ispell-message.
If it is a string, limit at first occurrence of that regular expression.
Otherwise, it must be a function which is called to get the limit.
(defvar ispell-message-text-end (mapconcat 'identity '("^-- $" "^%!PS-Adobe-[123].0" "^begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM" "^#! /bin/[ck]?sh" "\\(\\(^cd .*\n\\)?diff -c .*\\)?\n\\*\\*\\* .*\n--- .*\n\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*" "\\(diff -u .*\\)?\n--- .*\n\\+\\+\\+ .*\n@@ [-+][0-9]+,[0-9]+ [-+][0-9]+,[0-9]+ @@\n" "^current state:\n==============\n" "^\\(- \\)?[-=_]+\\s ?\\(cut here\\|Environment Follows\\)") "\\|") (#$ . -61677))
#@887 Check the spelling of a mail message or news post.
Don't check spelling of message headers except the Subject field.
Don't check included messages.

To abort spell checking of a message region and send the message anyway,
use the `x' command.  (Any subsequent regions will be checked.)
The `X' command aborts the message send so that you can edit the buffer.

To spell-check whenever a message is sent, include the appropriate lines
in your .emacs file:
   (add-hook 'message-send-hook 'ispell-message)  ;; GNUS 5
   (add-hook 'news-inews-hook 'ispell-message)    ;; GNUS 4
   (add-hook 'mail-send-hook  'ispell-message)
   (add-hook 'mh-before-send-letter-hook 'ispell-message)

You can bind this to the key C-c i in GNUS or mail by adding to
`news-reply-mode-hook' or `mail-mode-hook' the following lambda expression:
   (function (lambda () (local-set-key "\C-ci" 'ispell-message)))
(defalias 'ispell-message #[nil "\212eb\210\306\307\310!\311Q\312\313#\314	\206 \306\315\312\313#\206 e!\314\204( d\202C \316!\203? \306\312\313#\203; \317\224\202C d\202C d ^!\320\305!\203U \203U \321!\202V \322/\323\324!\203l \325\326 \327\330\3210!\260\202\301 \323\331!\203\200 \325\327\330\3210!\260\202\301 1\332\232\204\216 1\333\232\203\231 \334\330\335\330/\260\202\301 1\336\232\203\247 \3212!\202\301 	\204\257 \337\202\301 \320\340!\203\277 \341\330\321 !Q\202\301 /3\3423\327Q\343D4B456\313578\3139\344\345p\"\2048\203eb\210\3068@@\n\313#\2038@A%\312\2118\202\346 8A\2118\204\351 \346\216eb\210\306\347\n\313#\203C\317\225b\210\350\351!\204C\350\352!\204C65\353`\312\210\350\354!\203?\355\210\2023`\"\210)\nb\210\356y\210\353`\f\".\f\207" [mail-header-separator internal-messagep end-of-headers ispell-message-text-end limit mail-yank-prefix re-search-forward "^" regexp-quote "$" nil t copy-marker "^$" char-or-string-p 0 boundp ispell-non-empty-string "   \\|	" featurep supercite "\\(" sc-cite-regexp "\\)" "\\|" sc news-reply-mode message-mode "In article <" "[^,;&+=]+ <[^,;&+=]+> writes:" mh-letter-mode "In [a-zA-Z.]+ you write:\\|In <[^,;&+=]+> [^,;&+=]+ writes:\\| *> *" vm-included-text-prefix "[^,;&+=]+ writes:" "^\\(" forward-line local-variable-p ispell-local-dictionary ((byte-code "\302\211\223\210	\302\211\223\207" [end-of-headers limit nil] 3)) "^Subject: *" looking-at ".*Re\\>" "\\[" ispell-region "\n[ 	]" 2 1 default-prefix sc-reference-tag-string major-mode mh-ins-buf-prefix cite-regexp ispell-skip-region-alist case-fold-search old-case-fold-search ispell-message-dictionary-alist dictionary-alist ispell-checking-message] 7 (#$ . 62333) nil])
(defalias 'ispell-non-empty-string #[(string) "\203\n \301\230\203\f \302\207\303!\207" [string "" "\\'\\`" regexp-quote] 2])
#@70 Load all buffer-local information, restarting Ispell when necessary.
(defalias 'ispell-accept-buffer-local-defs #[nil "\300 \210\301 \210\302 \207" [ispell-buffer-local-dict ispell-buffer-local-words ispell-buffer-local-parsing] 1 (#$ . 65097)])
#@141 Place Ispell into parsing mode for this buffer.
Overrides the default parsing mode.
Includes Latex/Nroff modes and extended character mode.
(defalias 'ispell-buffer-local-parsing #[nil "\306\307\"\210	\310=\203 \311\312\313\n!\"\204 	\314=\203. \306\315\"\210	\314=\2043 \316\301!\314L\210\2023 \306\317\"\210\203M \320=\204M \316\303!\320\311\321\313\n!\")??L\210\322 \211\203[ \306\323P\"\210)\212db\210\324$\325\320#\205\313 \212\325\210`)\320\325%&\326$!\210\327\330&\320#\205\312 \331\332\224\332\225\"%\311\333%\"\203\234 \306\334\"\210\202{ \311\335%\"\203\254 \306\336\"\210\202{ \311\337%\"\203\277 \306%\323P\"\210\202{ \340\341!\210\342\343!\210\202{ +)\207" [ispell-process ispell-parser major-mode ispell-skip-sgml case-fold-search extended-char-mode process-send-string "!\n" use-mode-name string-match "[Tt][Ee][Xx]-mode" symbol-name tex "+\n" make-local-variable "-\n" t "sgml\\|html" ispell-get-extended-character-mode "\n" search-backward nil search-forward re-search-forward " *\\([^ \"]+\\)" buffer-substring-no-properties 1 "latex-mode" "+\n~tex\n" "nroff-mode" "-\n~nroff" "~" message "Invalid Ispell Parsing argument!" sit-for 2 ispell-parsing-keyword string end] 6 (#$ . 65350)])
#@278 Initializes local dictionary and local personal dictionary.
When a dictionary is defined in the buffer (see variable
`ispell-dictionary-keyword'), it will override the local setting
from \[ispell-change-dictionary].
Both should not be used to define a buffer-local dictionary.
(defalias 'ispell-buffer-local-dict #[nil "\212eb\210\306db\210\307	\306\310#\203+ \311	!\210\212\306\210`)\312\313\310#\203+ \314\315\224\315\225\"db\210\307\306\310#\203P \311!\210\212\306\210`)\312\313\310#\203P \314\315\224\315\225\"*\f\203a \f\232\204a \316\310!\210\f\n\205p \n\232?\205p \317\n!\207" [end ispell-dictionary-keyword ispell-local-dictionary ispell-pdict-keyword ispell-local-pdict ispell-personal-dictionary nil search-backward t search-forward re-search-forward " *\\([^ \"]+\\)" buffer-substring-no-properties 1 ispell-kill-ispell ispell-change-dictionary ispell-dictionary] 4 (#$ . 66587)])
#@58 Loads the buffer-local dictionary in the current buffer.
(defalias 'ispell-buffer-local-words #[nil "\203 \306 \232\204 \307\310!\210\311\312 \210\212eb\210\313	\311\310#\205a \204' \306 \212\311\210`)\314 \311\315\316\f\310#\203] \317\320\224\320\225\"\320\nGW\2033 \321\n\"\322\232\2033 \323\324\n\325Q\"\210\2023 +\202 )\207" [ispell-buffer-local-name ispell-words-keyword string ispell-casechars end ispell-process buffer-name ispell-kill-ispell t nil ispell-init-process search-forward ispell-get-casechars re-search-forward " *\\([^ ]+\\)" buffer-substring-no-properties 1 string-match 0 process-send-string "@" "\n"] 5 (#$ . 67500)])
#@42 Adds new word to the per-file word list.
(defalias 'ispell-add-per-file-word-list #[(word) "\204 \306 \212eb\210\307\211\211\211\211\n?\205p \310\307\311#G\307\210i\\\312\\\313W\2036 \f\204: \204 \314\204g \315\312!\210\316Q\211c\210\203g \317\232\204g \212\315\312!\210\312y\210c\210)\316Pc\210\202 .\207" [ispell-buffer-local-name string done search line-okay case-fold-search buffer-name nil search-forward move 1 80 t open-line " " "" ispell-words-keyword word comment-start comment-end] 6 (#$ . 68162)])
(byte-code "\302\300	B\303\304!\207" [ispell-version current-load-list "ispell.el 3.0 -- Tue Apr 28 14:40:01 PDT 1998" provide ispell] 2)