Summary: MIME support added for e-mail processing that

skips encoded regions.  Allow user to skip saving Fcc messages with
large attachments.  Fixed region skipping bug with multi-line
comments - e.g.  tex $ regions spanning multiple lines.
Added support for postscript and uuencoded regions.
Redundant dictionary file names purged.
Dictionary definition field name changed from "Character Set"
to "Coding System".  Fixed bug in reloading dictionaries.
Modified headers to reflect new version.  XEmacs menu now adds
customize item.
(ispell-check-version): No longer an aliased function.
Returns library path if not called interactively.
Variable `temporary-file-directory' protected if not loaded.
(check-ispell-version): Now the alias for `ispell-check-version'.
(ispell-message-fcc-skip): New variable that determines if and when
to query about saving Fcc copy of message if an attachment is large.
(ispell-skip-html): Declared buffer-local.
(ispell-local-dictionary-alist): Docstring expanded.
Tag name changed from "Character Set" to "Coding System".
(ispell-dictionary-alist-1): Removed redundant command-line option to
load brasileiro, british, and castellano dictionary files.
(ispell-dictionary-alist-2): Removed redundant command-line option to
load czech dictionary file.
(ispell-dictionary-alist-3): Moved francais-tex here.
(ispell-dictionary-alist-4): Removed german and german8 dictionaries.
The deutsch ones are the correct definitions.  `nederlands'
and `nederlands8' dictionaries moved here.
(ispell-dictionary-alist-5): `polish' and `portugues' dictionaries
moved here.  Removed redundant command-line option to `norsk'
and `portugues'.
(ispell-dictionary-alist-6): Removed redundant command-line option to
load `russian' and `slovak' dictionary files.
(ispell-dictionary-alist): Tag name changed from "Character Set" to
"Coding System".
(ispell-version): Updated to 3.6.
(ispell-library-directory): Calls non-deprecated function.
(ispell-valid-dictionary-list): New function returning all valid
dictionaries on machine.
(ispell-checking-message): Documentation string improved.
(ispell-skip-region-alist): Added uuencoded and postscript region
skipping.  Improved http/e-mail/file regexp to not match `/.\w'.
(ispell-html-skip-alists): New variable for html region support.
(ispell-send-string): Removed redundant xemacs check.
(ispell-word): Fix spelling error in documentation string, added
extent information to support highlighting in ispell-minor-mode.
(ispell-command-loop): Disable horizontal scrollbar in XEmacs
choices buffer.
(ispell-show-choices): Directly select `choices-window'.
(ispell-help): Use default buffer size for electric help.
(ispell-adjusted-window-height): Correct for xemacs detection.
(ispell-start-process): Don't double specify dictionary file name.
(ispell-init-process): Set `ispell-library-path' each call.
(ispell-change-dictionary): Now only completes valid dictionaries.
(ispell-region): Add support for MIME region skipping and Fcc
message query for large attachments.
(ispell-begin-skip-region-regexp): Add documentation string.
Added message support and cleaned up code for generic and html regions.
(ispell-begin-skip-region): Function is now requires alist argument.
(ispell-begin-tex-skip-regexp): Added comments and support
improved html and message regions.
(ispell-skip-region-list): New function for MIME and region skipping.
(ispell-tex-arg-end): Add documentation string.
(ispell-ignore-fcc): New function to query saving Fcc message.
(ispell-skip-region): Calculate alist for key match dynamically,
html skipping pushed to alists.
(ispell-get-line): Add support for multi-line comment regions.
(ispell): Check that variables to continue spelling are bound.
(ispell-message-text-end): Postscript and uuencoded regions now
supported as MIME regions, rather than as end-of-message region.
(ispell-mime-multipartp): New function supporting MIME.
(ispell-mime-skip-part): New function supporting MIME.
(ispell-message): Add MIME support.
(ispell-buffer-local-parsing): Variable `ispell-skip-html' now local.
(ispell-buffer-local-dict): Fixed bug for detecting and reloading
new dictionary.

1 files changed, 493 insertions, 221 deletions

diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index 138a3022627..4772fe8a3c8 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -4,8 +4,8 @@
 
 ;; Author:           Ken Stevens <k.stevens@ieee.org>
 ;; Maintainer:       Ken Stevens <k.stevens@ieee.org>
-;; Stevens Mod Date: Fri Aug  4 09:41:50 PDT 2000
-;; Stevens Revision: 3.4
+;; Stevens Mod Date: Mon Jan  7 12:32:44 PST 2003
+;; Stevens Revision: 3.6
 ;; 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
@@ -129,6 +129,24 @@
 
 ;; Modifications made in latest versions:
 
+;; Revision 3.6 2003/01/07 12:32:44     kss
+;; Removed extra -d LIB in dictionary defs. (Pavel Janik)
+;; Filtered process calls with duplicate dictionary entries.
+;; Fixed bug where message-text-end is inside a mime skipped region.
+;; Minor fixes to get ispell menus right in XEmacs
+;; Fixed skip regexp so it doesn't match stuff like `/.\w'.
+;; Detecting dictionary change not working.  Fixed.  kss
+;; function `ispell-change-dictionary' now only completes valid dicts.
+
+;; Revision 3.5 2001/7/11 18:43:57      kss
+;; Added fix for aspell to work in XEmacs (ispell-check-version).
+;; Added Portuguese dictionary definition.
+;; New feature: MIME mail message support, Fcc support.
+;; Bug fix: retain comment syntax on lines with region skipping. (TeX $ bug...)
+;; Improved allocation for graphic mode lines.  (Miles Bader)
+;; Support -v flag for old versions of aspell.  (Eli Zaretskii)
+;; Clear minibuffer on ^G from ispell-help (Tak Ota)
+
 ;; 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.
@@ -203,7 +221,7 @@
     (defun buffer-substring-no-properties (start end)
       (buffer-substring start end)))
 
-(defalias 'ispell-check-version 'check-ispell-version)
+(defalias 'check-ispell-version 'ispell-check-version)
 
 ;;; **********************************************************************
 ;;; The following variables should be set according to personal preference
@@ -308,6 +326,13 @@ E.g. you may use the following value:
   :group 'ispell)
 
 
+(defcustom ispell-message-fcc-skip 50000
+  "*Query before saving Fcc message copy if attachment larger than this value.
+Always stores Fcc copy of message when nil."
+  :type '(choice integer (const :tag "off" nil))
+  :group 'ispell)
+
+
 (defcustom ispell-grep-command "egrep"
   "Name of the grep command for search processes."
   :type 'string
@@ -445,12 +470,20 @@ buffer's major mode."
                  (const :tag "use-mode-name" use-mode-name))
   :group 'ispell)
 
+(make-variable-buffer-local 'ispell-skip-html)
+
 
 ;;; Define definitions here only for personal dictionaries.
 ;;;###autoload
 (defcustom ispell-local-dictionary-alist nil
   "*Contains local or customized dictionary definitions.
-See `ispell-dictionary-alist'."
+
+These will override the values in `ispell-dictionary-alist'.
+
+Customization changes made to `ispell-dictionary-alist' will not operate
+over emacs sessions.  To make permanent changes to your dictionary
+definitions, you will need to make your changes in this variable, save,
+and then re-start emacs."
   :type '(repeat (list (choice :tag "Dictionary"
                                (string :tag "Dictionary name")
                                (const :tag "default" nil))
@@ -465,7 +498,7 @@ See `ispell-dictionary-alist'."
                                (const "~nroff") (const "~list")
                                (const "~latin1") (const "~latin3")
                                (const :tag "default" nil))
-                       (choice :tag "Character set"
+                       (choice :tag "Coding system"
                                (const iso-8859-1)
                                (const iso-8859-2)
                                (const koi8-r))))
@@ -485,13 +518,13 @@ See `ispell-dictionary-alist'."
    ("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)
+    "[']" nil nil nil iso-8859-1)
    ("british"                           ; British version
-    "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil iso-8859-1)
+    "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1)
    ("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") "~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]"
@@ -505,7 +538,7 @@ See `ispell-dictionary-alist'."
  '(("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-8859-2)
+    "" nil ("-B") nil iso-8859-2)
    ("dansk"                             ; Dansk.aff
     "[A-Z\306\330\305a-z\346\370\345]" "[^A-Z\306\330\305a-z\346\370\345]"
     "[']" nil ("-C") nil iso-8859-1)
@@ -535,76 +568,77 @@ 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)
+   ("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)))
 
 
 ;;; Fourth part of dictionary, shortened for loaddefs.el
 ;;;###autoload
 (setq
  ispell-dictionary-alist-4
- '(("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)
-   ("german"                         ; german.aff
+ '(("german"                            ; german.aff
     "[a-zA-Z\"]" "[^a-zA-Z\"]" "[']" t ("-C") "~tex" iso-8859-1)
-   ("german8"
+   ("german8"                           ; german.aff
     "[a-zA-Z\304\326\334\344\366\337\374]"
     "[^a-zA-Z\304\326\334\344\366\337\374]"
     "[']" t ("-C" "-d" "german") "~latin1" iso-8859-1)
-   ("italiano"                         ; Italian.aff
+   ("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)))
-
-
-;;; Fifth part of dictionary, shortened for loaddefs.el
-;;;###autoload
-(setq
- ispell-dictionary-alist-5
- '(("nederlands"                        ; Nederlands.aff
+    "[-]" 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]"
     "[']" t ("-C") nil iso-8859-1)
    ("nederlands8"                       ; Dutch8.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]"
-    "[']" t ("-C") nil iso-8859-1)
-   ("norsk"                             ; 8 bit Norwegian mode
+    "[']" t ("-C") nil iso-8859-1)))
+
+
+;;; Fifth part of dictionary, shortened for loaddefs.el
+;;;###autoload
+(setq
+ ispell-dictionary-alist-5
+ '(("norsk"                             ; 8 bit Norwegian mode
     "[A-Za-z\305\306\307\310\311\322\324\330\345\346\347\350\351\362\364\370]"
     "[^A-Za-z\305\306\307\310\311\322\324\330\345\346\347\350\351\362\364\370]"
-    "[\"]" nil ("-d" "norsk") "~list" iso-8859-1)
+    "[\"]" nil nil "~list" iso-8859-1)
    ("norsk7-tex"                        ; 7 bit Norwegian TeX mode
     "[A-Za-z{}\\'^`]" "[^A-Za-z{}\\'^`]"
-    "[\"]" nil ("-d" "norsk") "~plaintex" iso-8859-1)))
+    "[\"]" nil ("-d" "norsk") "~plaintex" iso-8859-1)
+   ("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 nil nil iso-8859-2)
+   ("portugues"                         ; Portuguese mode
+    "[a-zA-Z\301\302\311\323\340\341\342\351\352\355\363\343\372]"
+    "[^a-zA-Z\301\302\311\323\340\341\342\351\352\355\363\343\372]"
+    "[']" t ("-C") "~latin1" iso-8859-1)))
 
 
 ;;; Sixth part of dictionary, shortened for loaddefs.el
 ;;;###autoload
 (setq
  ispell-dictionary-alist-6
- ;; include Russian iso character set too?
+ ;; include Russian iso coding system too?
  ;;   "[']" t ("-d" "russian") "~latin1" iso-8859-1
- '(("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)
-   ("russian"                           ; Russian.aff (KOI8-R charset)
+ '(("russian"                           ; Russian.aff (KOI8-R charset)
     "[\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]"
-    "" nil ("-d" "russian") nil koi8-r)
+    "" nil nil nil koi8-r)
+   ("slovak"                            ; Slovakian
+    "[A-Za-z\301\304\311\315\323\332\324\300\305\245\335\256\251\310\317\253\322\341\344\351\355\363\372\364\340\345\265\375\276\271\350\357\273\362]"
+    "[^A-Za-z\301\304\311\315\323\332\324\300\305\245\335\256\251\310\317\253\322\341\344\351\355\363\372\364\340\345\265\375\276\271\350\357\273\362]"
+    "" nil ("-B") nil iso-8859-2)
    ("svenska"                           ; Swedish mode
     "[A-Za-z\345\344\366\351\340\374\350\346\370\347\305\304\326\311\300\334\310\306\330\307]"
     "[^A-Za-z\345\344\366\351\340\374\350\346\370\347\305\304\326\311\300\334\310\306\330\307]"
-    "[']" nil ("-C") "~list" iso-8859-1)
-   ("portugues"
-    "[a-zA-Z\301\302\311\323\340\341\342\351\352\355\363\343\372]"
-    "[^a-zA-Z\301\302\311\323\340\341\342\351\352\355\363\343\372]"
-    "[']" t ("-C" "-d" "portugues") "~latin1" iso-8859-1)
-   ("slovak"
-    "[A-Za-z\301\304\311\315\323\332\324\300\305\245\335\256\251\310\317\253\322\341\344\351\355\363\372\364\340\345\265\375\276\271\350\357\273\362]"
-    "[^A-Za-z\301\304\311\315\323\332\324\300\305\245\335\256\251\310\317\253\322\341\344\351\355\363\372\364\340\345\265\375\276\271\350\357\273\362]"
-    "" nil ("-B" "-d" "slovak") nil iso-8859-2)))
+    "[']" nil ("-C") "~list" iso-8859-1)))
+
 
 ;;;###autoload
 (defcustom ispell-dictionary-alist
@@ -672,7 +706,7 @@ LANGUAGE.aff file \(e.g., english.aff\)."
                                (const "~nroff") (const "~list")
                                (const "~latin1") (const "~latin3")
                                (const :tag "default" nil))
-                       (choice :tag "Character set"
+                       (choice :tag "Coding System"
                                (const iso-8859-1)
                                (const iso-8859-2)
                                (const koi8-r))))
@@ -701,10 +735,10 @@ 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.4 -- Fri Aug  4 09:41:50 PDT 2000")
+(defconst ispell-version "ispell.el 3.6 - 7-Jan-2003")
 
 
-(defun check-ispell-version (&optional interactivep)
+(defun ispell-check-version (&optional interactivep)
   "Ensure that `ispell-program-name' is valid and the correct version.
 Returns version number if called interactively.
 Otherwise returns the library directory name, if that is defined."
@@ -719,7 +753,9 @@ Otherwise returns the library directory name, if that is defined."
   (let ((case-fold-search-val case-fold-search)
         ;; avoid bugs when syntax of `.' changes in various default modes
         (default-major-mode 'fundamental-mode)
-        (default-directory temporary-file-directory)
+        (default-directory (or (and (boundp 'temporary-file-directory)
+                                    temporary-file-directory)
+                               default-directory))
         result status)
     (save-excursion
       (let ((buf (get-buffer " *ispell-tmp*")))
@@ -737,6 +773,7 @@ Otherwise returns the library directory name, if that is defined."
                       (if (string-match "\\`aspell" speller) "-v" "-vv"))))
       (goto-char (point-min))
       (if interactivep
+          ;; report version information of ispell and ispell.el
           (progn
             (end-of-line)
             (setq result (concat (buffer-substring-no-properties (point-min)
@@ -807,7 +844,7 @@ and added as a submenu of the \"Edit\" menu.")
        'reload))
 
 (defvar ispell-library-directory (condition-case ()
-                                     (check-ispell-version)
+                                     (ispell-check-version)
                                    (error nil))
   "Directory where ispell dictionaries reside.")
 
@@ -823,37 +860,55 @@ and added as a submenu of the \"Edit\" menu.")
                                    )
   "Non-nil means that the OS supports asynchronous processes.")
 
+(defun ispell-valid-dictionary-list ()
+  "Returns a list of valid dictionaries.
+The variable `ispell-library-directory' defines the library location."
+  (let ((dicts ispell-dictionary-alist)
+        (dict-list (cons "default" nil))
+        name load-dict)
+    (dolist (dict dicts)
+      (setq name (car dict)
+            load-dict (car (cdr (member "-d" (nth 5 dict)))))
+      ;; Include if the dictionary is in the library, or dir not defined.
+      (if (and
+           name
+           ;; include all dictionaries if lib directory not known.
+           (or (not ispell-library-directory)
+               (file-exists-p (concat ispell-library-directory
+                                      "/" name ".hash"))
+               (file-exists-p (concat ispell-library-directory "/" name ".has"))
+               (and load-dict
+                    (or (file-exists-p (concat ispell-library-directory
+                                               "/" load-dict ".hash"))
+                        (file-exists-p (concat ispell-library-directory
+                                               "/" load-dict ".has"))))))
+          (setq dict-list (cons name dict-list))))
+    dict-list))
+
+
 ;;;###autoload
 (if ispell-menu-map-needed
-    (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist)))
-          (dir (if (boundp 'ispell-library-directory) ispell-library-directory))
-          (dict-map (make-sparse-keymap "Dictionaries"))
-          name load-dict)
+    (let ((dicts (if (fboundp 'ispell-valid-dictionary-list)
+                     (ispell-valid-dictionary-list)
+                   (mapcar (lambda (x) (or (car x) "default"))
+                           ispell-dictionary-alist)))
+          (dict-map (make-sparse-keymap "Dictionaries")))
       (setq ispell-menu-map (make-sparse-keymap "Spell"))
       ;; add the dictionaries to the bottom of the list.
-      (define-key ispell-menu-map [default]
-        '("Select Default Dict"
-          "Dictionary for which Ispell was configured"
-          . (lambda () (interactive)
-              (ispell-change-dictionary "default"))))
+      (if (not dicts)
+          (define-key ispell-menu-map [default]
+            '("Select Default Dict"
+              "Dictionary for which Ispell was configured"
+              . (lambda () (interactive)
+                  (ispell-change-dictionary "default")))))
       (fset 'ispell-dict-map dict-map)
       (define-key ispell-menu-map [dictionaries]
         `(menu-item "Select Dict" ispell-dict-map))
-      (dolist (dict dicts)
-        (setq name (car dict)
-              load-dict (car (cdr (member "-d" (nth 5 dict)))))
-        (cond ((not (stringp name)))
-              ((or (not dir)            ; load all if library dir not defined
-                   (file-exists-p (concat dir "/" name ".hash"))
-                   (file-exists-p (concat dir "/" name ".has"))
-                   (and load-dict
-                        (or (file-exists-p (concat dir "/" load-dict ".hash"))
-                            (file-exists-p (concat dir "/" load-dict ".has")))))
-               (define-key dict-map (vector (intern name))
-                 (cons (concat "Select " (capitalize name) " Dict")
-                       `(lambda () (interactive)
-                          (ispell-change-dictionary ,name)))))))))
-
+      (dolist (name dicts)
+        (define-key dict-map (vector (intern name))
+          (cons (concat "Select " (capitalize name) " Dict")
+                `(lambda () (interactive)
+                   (ispell-change-dictionary ,name)))))))
 
 ;;; define commands in menu in opposite order you want them to appear.
 ;;;###autoload
@@ -928,9 +983,10 @@ and added as a submenu of the \"Edit\" menu.")
 ;;; XEmacs versions 19 & 20
 (if (and (featurep 'xemacs)
          (featurep 'menubar)
-         (null ispell-menu-xemacs)
+         ;;(null ispell-menu-xemacs)
          (not (and (boundp 'infodock-version) infodock-version)))
-    (let ((dicts (cons (cons "default" nil) ispell-dictionary-alist))
+    (let ((dicts (if (fboundp 'ispell-valid-dictionary-list)
+                     (reverse (ispell-valid-dictionary-list))))
           (current-menubar (or current-menubar default-menubar))
           (menu
            '(["Help"            (describe-function 'ispell-help) t]
@@ -944,37 +1000,33 @@ and added as a submenu of the \"Edit\" menu.")
              ["Complete Word Frag"ispell-complete-word-interior-frag t]
              ["Complete Word"   ispell-complete-word            t]
              ["Kill Process"    ispell-kill-ispell              t]
+             ["Customize..."    (customize-group 'ispell)       t]
+             ;; flyspell-mode may not be bound...
+             ;;["flyspell"      flyspell-mode
+             ;;                 :style toggle :selected flyspell-mode ]
              "-"
              ["Save Personal Dict"(ispell-pdict-save t t)       t]
-             ["Change Dictionary" ispell-change-dictionary      t]
-             ["Select Default"  (ispell-change-dictionary "default") t]))
-          name load-dict)
-      (while dicts
-        (setq name (car (car dicts))
-              load-dict (car (cdr (member "-d" (nth 5 (car dicts)))))
-              dicts (cdr dicts))
-        ;; Include if the dictionary is in the library, or dir not defined.
-        (if (and (stringp name)
-                 (or (not ispell-library-directory)
-                     (file-exists-p (concat ispell-library-directory "/"
-                                            name ".hash"))
-                     (file-exists-p (concat ispell-library-directory "/"
-                                            name ".has"))
-                     (and load-dict
-                          (or (file-exists-p (concat ispell-library-directory "/"
-                                                     load-dict ".hash"))
-                              (file-exists-p (concat ispell-library-directory "/"
-                                                     load-dict ".has"))))))
-            (setq menu (append menu
-                               (list
-                                 (vector (concat "Select " (capitalize name))
-                                         (list 'ispell-change-dictionary name)
-                                         t))))))
+             ["Change Dictionary" ispell-change-dictionary      t])))
+      (if (null dicts)
+          (setq dicts (cons "default" nil)))
+      (dolist (name dicts)
+        (setq menu (append menu
+                           (list
+                             (vector
+                              (concat "Select " (capitalize name))
+                              (list 'ispell-change-dictionary name)
+                              t)))))
       (setq ispell-menu-xemacs menu)
       (if current-menubar
           (progn
-            (delete-menu-item '("Edit" "Spell")) ; in case already defined
-            (add-menu '("Edit") "Spell" ispell-menu-xemacs)))))
+            (if (car (find-menu-item current-menubar '("Cmds")))
+                (progn
+                  ;; XEmacs 21.2
+                  (delete-menu-item '("Cmds" "Spell-Check"))
+                  (add-menu '("Cmds") "Spell-Check" ispell-menu-xemacs))
+              ;; previous
+              (delete-menu-item '("Edit" "Spell")) ; in case already defined
+              (add-menu '("Edit") "Spell" ispell-menu-xemacs))))))
 
 ;;; Allow incrementing characters as integers in XEmacs 20
 (if (and (featurep 'xemacs)
@@ -1060,7 +1112,8 @@ Protects against bogus binding of `enable-multibyte-characters' in XEmacs."
   "Marker for return point from recursive edit.")
 
 (defvar ispell-checking-message nil
-  "Non-nil when we're checking a mail message.")
+  "Non-nil when we're checking a mail message.
+Set to the MIME boundary locations when checking messages.")
 
 (defconst ispell-choices-buffer "*Choices*")
 
@@ -1100,10 +1153,16 @@ The last occurring definition in the buffer will be used.")
     (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")
+    ;; assume multiline uuencoded file? "\nM.*$"?
+    ("^begin [0-9][0-9][0-9] [^ \t]+$" . "\nend\n")
+    ("^%!PS-Adobe-[123].0"       . "\n%%EOF\n")
+    ("^---* \\(Start of \\)?[Ff]orwarded [Mm]essage"
+     . "^---* End of [Ff]orwarded [Mm]essage")
     ;; Matches e-mail addresses, file names, http addresses, etc.  The `-+'
     ;; pattern necessary for performance reasons when `-' part of word syntax.
-    ("\\(-+\\|\\(/\\|\\(\\(\\w\\|[-_]\\)+[.:@]\\)\\)\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_]\\|~\\)+\\)+\\)")
+    ("\\(--+\\|\\(/\\w\\|\\(\\(\\w\\|[-_]\\)+[.:@]\\)\\)\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_~=?&]\\)+\\)+\\)")
+    ;; above checks /.\w sequences
+    ;;("\\(--+\\|\\(/\\|\\(\\(\\w\\|[-_]\\)+[.:@]\\)\\)\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_~=?&]\\)+\\)+\\)")
     ;; This is a pretty complex regexp.  It can be simplified to the following:
     ;; "\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_]\\|~\\)+\\)+"
     ;; but some valid text will be skipped, e.g. "his/her".  This could be
@@ -1151,6 +1210,22 @@ Delete or add any regions you want to be automatically selected
 for skipping in latex mode.")
 
 
+;;;###autoload
+(defvar ispell-html-skip-alists
+  '(("<[cC][oO][dD][eE]\\>[^>]*>"         "</[cC][oO][dD][eE]*>")
+    ("<[sS][cC][rR][iI][pP][tT]\\>[^>]*>" "</[sS][cC][rR][iI][pP][tT]>")
+    ("<[aA][pP][pP][lL][eE][tT]\\>[^>]*>" "</[aA][pP][pP][lL][eE][tT]>")
+    ("<[vV][eE][rR][bB]\\>[^>]*>"         "<[vV][eE][rR][bB]\\>[^>]*>")
+    ;;("<[tT][tT]\\>[^>]*>"               "<[tT][tT]\\>[^>]*>")
+    ("<[tT][tT]/"                         "/")
+    ("<[^ \t\n>]"                         ">")
+    ("&[^ \t\n;]"                         "[; \t\n]"))
+  "*Lists of start and end keys to skip in HTML buffers.
+Same format as `ispell-skip-region-alist'
+Note - substrings of other matches must come last
+ (e.g. \"<[tT][tT]/\" and \"<[^ \t\n>]\").")
+
+
 (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.
@@ -1241,9 +1316,8 @@ pass it the output of the last ispell invocation."
         (insert string)
         (if (not (memq cmd cmds-to-defer))
             (let (coding-system-for-read coding-system-for-write status)
-              (if (or (featurep 'xemacs)
-                      (and (boundp 'enable-multibyte-characters)
-                           enable-multibyte-characters))
+              (if (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)
@@ -1313,7 +1387,7 @@ This will check or reload the dictionary.  Use \\[ispell-change-dictionary]
 or \\[ispell-region] to update the Ispell process.
 
 return values:
-nil           word is correct or spelling is accpeted.
+nil           word is correct or spelling is accepted.
 0             word is inserted into buffer-local definitions.
 \"word\"        word corrected from word list.
 \(\"word\" arg\)  word is hand entered.
@@ -1355,16 +1429,26 @@ quit          spell session exited."
         (cond ((eq poss t)
                (or quietly
                    (message "%s is correct"
-                            (funcall ispell-format-word word))))
+                            (funcall ispell-format-word word)))
+               (and (fboundp 'extent-at)
+                    (extent-at start)
+                    (delete-extent (extent-at start))))
               ((stringp poss)
                (or quietly
                    (message "%s is correct because of root %s"
                             (funcall ispell-format-word word)
-                            (funcall ispell-format-word poss))))
+                            (funcall ispell-format-word poss)))
+               (and (fboundp 'extent-at)
+                    (extent-at start)
+                    (delete-extent (extent-at start))))
               ((null poss) (message "Error in ispell process"))
               (ispell-check-only        ; called from ispell minor mode.
-               (beep)
-               (message "%s is incorrect" (funcall ispell-format-word word)))
+               (if (fboundp 'make-extent)
+                   (let ((ext (make-extent start end)))
+                     (set-extent-property ext 'face ispell-highlight-face)
+                     (set-extent-property ext 'priority 2000))
+                 (beep)
+                 (message "%s is incorrect"(funcall ispell-format-word word))))
               (t                        ; prompt for correct word.
                (save-window-excursion
                  (setq replace (ispell-command-loop
@@ -1516,9 +1600,11 @@ Global `ispell-quit' set to start location to continue spell session."
     (save-excursion
       (set-buffer (get-buffer-create ispell-choices-buffer))
       (setq mode-line-format (concat "--  %b  --  word: " word))
-      ;; XEmacs: prevent thick modeline vs increasing height in overlay-window
-      ;;(and (fboundp 'set-specifier)
-      ;;     (set-specifier has-modeline-p (cons (current-buffer) nil)))
+      ;; XEmacs: no need for horizontal scrollbar in choices window
+      (and (fboundp 'set-specifier)
+           (boundp 'horizontal-scrollbar-visible-p)
+           (set-specifier horizontal-scrollbar-visible-p nil
+                          (cons (current-buffer) nil)))
       (erase-buffer)
       (if guess
           (progn
@@ -1789,7 +1875,7 @@ Global `ispell-quit' set to start location to continue spell session."
               (set-window-start (selected-window)
                                 (if (> (point) visible) visible (point)))
               (goto-char end)
-              (select-window (previous-window)) ; *Choices* window
+              (select-window choices-window)
               (enlarge-window window-line)))
         ;; Overlay *Choices* window when it isn't showing
         (ispell-overlay-window (max line ispell-choices-win-default-height)))
@@ -1830,9 +1916,9 @@ SPC:   Accept word this time.
                      ;;This shouldn't be necessary: with-electric-help needs
                      ;; an optional argument telling it about the smallest
                      ;; acceptable window-height of the help buffer.
-                     (if (< (window-height) 15)
-                         (enlarge-window
-                          (- 15 (ispell-adjusted-window-height))))
+                     ;;(if (< (window-height) 15)
+                     ;;  (enlarge-window
+                     ;;   (- 15 (ispell-adjusted-window-height))))
                      (princ "Selections are:
 
 DIGIT: Replace the word with a digit offered in the *Choices* buffer.
@@ -2062,9 +2148,8 @@ text line, the returned value may be smaller than that from
 `window-height'."
   (cond ((fboundp 'window-text-height)
          (1+ (window-text-height window)))
-        ((if (fboundp 'display-graphic-p)
-             (display-graphic-p)
-           (featurep 'xemacs))
+        ((or (and (fboundp 'display-graphic-p) (display-graphic-p))
+             (and (featurep 'xemacs) window-system))
          (1- (window-height window)))
         (t
          (window-height window))))
@@ -2171,7 +2256,8 @@ Keeps argument list for future ispell invocations for no async support."
     (if ispell-local-dictionary
         (setq ispell-dictionary ispell-local-dictionary))
     (setq args (ispell-get-ispell-args))
-    (if ispell-dictionary               ; use specified dictionary
+    (if (and ispell-dictionary          ; use specified dictionary
+             (not (member "-d" args)))  ; only define if not overridden
         (setq args
               (append (list "-d" ispell-dictionary) args)))
     (if ispell-personal-dictionary      ; use specified pers dict
@@ -2209,8 +2295,8 @@ Keeps argument list for future ispell invocations for no async support."
     (ispell-kill-ispell t)
     (message "Starting new Ispell process...")
     (sit-for 0)
-    (check-ispell-version)
-    (setq ispell-process-directory default-directory
+    (setq ispell-library-directory (ispell-check-version)
+          ispell-process-directory default-directory
           ispell-process (ispell-start-process)
           ispell-filter nil
           ispell-filter-continue nil)
@@ -2298,7 +2384,9 @@ With prefix argument, set the default dictionary."
   (interactive
    (list (completing-read
           "Use new dictionary (RET for current, SPC to complete): "
-          (cons (cons "default" nil) ispell-dictionary-alist) nil t)
+          (and (fboundp 'ispell-valid-dictionary-list)
+               (mapcar (lambda (x)(cons x nil)) (ispell-valid-dictionary-list)))
+          nil t)
          current-prefix-arg))
   (if (equal dict "default") (setq dict nil))
   ;; This relies on completing-read's bug of returning "" for no match
@@ -2342,6 +2430,8 @@ Return nil if spell session is quit,
   (interactive "r")                     ; Don't flag errors on read-only bufs.
   (if (not recheckp)
       (ispell-accept-buffer-local-defs)) ; set up dictionary, local words, etc.
+  (let ((skip-region-start (make-marker))
+        (rstart (make-marker)))
   (unwind-protect
       (save-excursion
         (message "Spell checking %s using %s dictionary..."
@@ -2353,19 +2443,11 @@ Return nil if spell session is quit,
           (goto-char reg-start)
           (let ((transient-mark-mode)
                 (case-fold-search case-fold-search)
-                (skip-region-start (make-marker))
-                (skip-regexp (ispell-begin-skip-region-regexp))
-                (skip-alist ispell-skip-region-alist)
-                key)
-            (if (eq ispell-parser 'tex)
-                (setq case-fold-search nil
-                      skip-alist
-                      (append (car ispell-tex-skip-alists)
-                              (car (cdr ispell-tex-skip-alists))
-                              skip-alist)))
+                (query-fcc t)
+                in-comment key)
             (let (message-log-max)
               (message "searching for regions to skip"))
-            (if (re-search-forward skip-regexp reg-end t)
+            (if (re-search-forward (ispell-begin-skip-region-regexp) reg-end t)
                 (progn
                   (setq key (buffer-substring-no-properties
                              (match-beginning 0) (match-end 0)))
@@ -2374,6 +2456,7 @@ Return nil if spell session is quit,
             (let (message-log-max)
               (message "Continuing spelling check using %s dictionary..."
                        (or ispell-dictionary "default")))
+            (set-marker rstart reg-start)
             (set-marker ispell-region-end reg-end)
             (while (and (not ispell-quit)
                         (< (point) ispell-region-end))
@@ -2381,25 +2464,44 @@ Return nil if spell session is quit,
               (if (and (marker-position skip-region-start)
                        (<= skip-region-start (point)))
                   (progn
-                    (ispell-skip-region key skip-alist) ; moves pt past region.
-                    (setq reg-start (point))
-                    (if (and (< reg-start ispell-region-end)
-                             (re-search-forward skip-regexp
-                                                ispell-region-end t))
+                    ;; If region inside line comment, must keep comment start.
+                    (setq in-comment (point)
+                          in-comment
+                          (and comment-start
+                               (or (null comment-end) (string= "" comment-end))
+                               (save-excursion
+                                 (beginning-of-line)
+                                 (re-search-forward comment-start in-comment t))
+                               comment-start))
+                    ;; Can change skip-regexps (in ispell-message)
+                    (ispell-skip-region key) ; moves pt past region.
+                    (set-marker rstart (point))
+                    ;; check for saving large attachments...
+                    (setq query-fcc (and query-fcc
+                                         (ispell-ignore-fcc skip-region-start
+                                                            rstart)))
+                    (if (and (< rstart ispell-region-end)
+                             (re-search-forward
+                              (ispell-begin-skip-region-regexp)
+                              ispell-region-end t))
                         (progn
                           (setq key (buffer-substring-no-properties
                                      (car (match-data))
                                      (car (cdr (match-data)))))
                           (set-marker skip-region-start
                                       (- (point) (length key)))
-                          (goto-char reg-start))
+                          (goto-char rstart))
                       (set-marker skip-region-start nil))))
-              (setq reg-end (if (marker-position skip-region-start)
-                                (min skip-region-start ispell-region-end)
-                              (marker-position ispell-region-end)))
+              (setq reg-end (max (point)
+                                 (if (marker-position skip-region-start)
+                                     (min skip-region-start ispell-region-end)
+                                   (marker-position ispell-region-end))))
               (let* ((start (point))
                      (end (save-excursion (end-of-line) (min (point) reg-end)))
-                     (string (ispell-get-line start end)))
+                     (string (ispell-get-line start end in-comment)))
+                (if in-comment          ; account for comment chars added
+                    (setq start (- start (length in-comment))
+                          in-comment nil))
                 (setq end (point))      ; "end" tracks region retrieved.
                 (if string              ; there is something to spell check!
                     ;; (special start end)
@@ -2413,6 +2515,8 @@ Return nil if spell session is quit,
     (if (and (not (and recheckp ispell-keep-choices-win))
              (get-buffer ispell-choices-buffer))
         (kill-buffer ispell-choices-buffer))
+    (set-marker skip-region-start nil)
+    (set-marker rstart nil)
     (if ispell-quit
         (progn
           ;; preserve or clear the region for ispell-continue.
@@ -2429,48 +2533,70 @@ Return nil if spell session is quit,
       (if (not recheckp) (set-marker ispell-region-end nil))
       ;; Only save if successful exit.
       (ispell-pdict-save ispell-silently-savep)
-      (message "Spell-checking done"))))
+      (message "Spell-checking done")))))
 
 
-;;; Creates the regexp for skipping a region.
-;;; Makes the skip-regexp local for tex buffers adding in the
-;;; tex expressions to skip as well.
-;;; Call AFTER ispell-buffer-local-parsing.
 (defun ispell-begin-skip-region-regexp ()
-  (let ((skip-regexp (ispell-begin-skip-region)))
+  "Returns a regexp of the search keys for region skipping.
+Includes `ispell-skip-region-alist' plus tex, tib, html, and comment keys.
+Must call after ispell-buffer-local-parsing due to dependence on mode."
+  ;; start with regions generic to all buffers
+  (let ((skip-regexp (ispell-begin-skip-region ispell-skip-region-alist)))
+    ;; Comments
     (if (and (null ispell-check-comments) comment-start)
         (setq skip-regexp (concat (regexp-quote comment-start) "\\|"
                                   skip-regexp)))
     (if (and (eq 'exclusive ispell-check-comments) comment-start)
+        ;; search from end of current comment to start of next comment.
         (setq skip-regexp (concat (if (string= "" comment-end) "^"
                                     (regexp-quote comment-end))
                                   "\\|" skip-regexp)))
+    ;; tib
     (if ispell-skip-tib
         (setq skip-regexp (concat ispell-tib-ref-beginning "\\|" skip-regexp)))
+    ;; html stuff
     (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]/" "\\|"
-                                  "<" "\\|"
-                                  "&" "\\|"
-                                  skip-regexp)))
+        (setq skip-regexp (concat
+                           (ispell-begin-skip-region ispell-html-skip-alists)
+                           "\\|"
+                           skip-regexp)))
+    ;; tex
     (if (eq ispell-parser 'tex)
         (setq skip-regexp (concat (ispell-begin-tex-skip-regexp) "\\|"
                                   skip-regexp)))
+    ;; messages
+    (if (and ispell-checking-message
+             (not (eq t ispell-checking-message)))
+        (setq skip-regexp (concat
+                           (mapconcat (lambda (lst) (car lst))
+                                      ispell-checking-message
+                                      "\\|")
+                           "\\|"
+                           skip-regexp)))
+
+    ;; return new regexp
     skip-regexp))
 
 
+(defun ispell-begin-skip-region (skip-alist)
+  "Regular expression for start of regions to skip generated from SKIP-ALIST.
+Each selection should be a key of SKIP-ALIST;
+otherwise, the current line is skipped."
+  (mapconcat (lambda (lst) (if (stringp (car lst)) (car lst) (eval (car lst))))
+             skip-alist
+             "\\|"))
+
+
 (defun ispell-begin-tex-skip-regexp ()
   "Regular expression of tex commands to skip.
 Generated from `ispell-tex-skip-alists'."
   (concat
+   ;; raw tex keys
    (mapconcat (function (lambda (lst) (car lst)))
               (car ispell-tex-skip-alists)
               "\\|")
    "\\|"
+   ;; keys wrapped in begin{}
    (mapconcat (function (lambda (lst)
                           (concat "\\\\begin[ \t\n]*{[ \t\n]*"
                                   (car lst)
@@ -2479,17 +2605,30 @@ Generated from `ispell-tex-skip-alists'."
               "\\|")))
 
 
-(defun ispell-begin-skip-region ()
-  "Regular expression of regions to skip for all buffers.
-Each selection should be a key of `ispell-skip-region-alist';
-otherwise, the current line is skipped."
-  (mapconcat (function (lambda (lst) (if (stringp (car lst)) (car lst)
-                                        (eval (car lst)))))
-             ispell-skip-region-alist
-             "\\|"))
+(defun ispell-skip-region-list ()
+  "Returns a list describing key and body regions to skip for this buffer.
+Includes regions defined by `ispell-skip-region-alist', tex mode,
+`ispell-html-skip-alists', and `ispell-checking-message'.
+Manual checking must include comments and tib references.
+The list is of the form described by variable `ispell-skip-region-alist'.
+Must call after `ispell-buffer-local-parsing' due to dependence on mode."
+  (let ((skip-alist ispell-skip-region-alist))
+    ;; only additional explicit region definition is tex.
+    (if (eq ispell-parser 'tex)
+        (setq case-fold-search nil
+              skip-alist (append (car ispell-tex-skip-alists)
+                                 (car (cdr ispell-tex-skip-alists))
+                                 skip-alist)))
+    (if ispell-skip-html
+        (setq skip-alist (append ispell-html-skip-alists skip-alist)))
+    (if (and ispell-checking-message
+             (not (eq t ispell-checking-message)))
+        (setq skip-alist (append ispell-checking-message skip-alist)))
+    skip-alist))
 
 
 (defun ispell-tex-arg-end (&optional arg)
+  "Skip across ARG number of braces."
   (condition-case nil
       (progn
         (while (looking-at "[ \t\n]*\\[") (forward-sexp))
@@ -2500,12 +2639,42 @@ otherwise, the current line is skipped."
      (sit-for 2))))
 
 
-;;; Skips to region-end from point, or a single line.
-;;; Places point at end of region skipped.
-(defun ispell-skip-region (key alist)
+(defun ispell-ignore-fcc (start end)
+  "Deletes the Fcc: message header when large attachments are included.
+Return value `nil' if file with large attachments are saved.
+This can be used to avoid multiple questions for multiple large attachments.
+Returns point to starting location afterwards."
+  (let ((result t))
+    (if (and ispell-checking-message ispell-message-fcc-skip)
+        (if (< ispell-message-fcc-skip (- end start))
+            (let (case-fold-search head-end)
+              (goto-char (point-min))
+              (setq head-end
+                    (or (re-search-forward
+                         (concat "^" (regexp-quote mail-header-separator) "$")
+                         nil t)
+                        (re-search-forward "^$" nil t)
+                        (point-min)))
+              (goto-char (point-min))
+              (if (re-search-forward "^Fcc:" head-end t)
+                  (if (y-or-n-p
+                       "Save copy of this message with large attachments? ")
+                      (setq result nil)
+                    (beginning-of-line)
+                    (kill-line 1)))
+              (goto-char end))))
+    result))
+
+
+(defun ispell-skip-region (key)
+  "Skips across KEY and then to end of region.
+Key lookup determines region to skip.
+Point is placed at end of skipped region."
   ;; move over key to begin checking.
   (forward-char (length key))
   (let ((start (point))
+        ;; Regenerate each call... This function can change region definition.
+        (alist (ispell-skip-region-list))
         alist-key null-skip)
     (cond
      ;; what about quoted comment, or comment inside strings?
@@ -2519,26 +2688,6 @@ otherwise, the current line is skipped."
       (search-forward comment-start ispell-region-end :end))
      ((and ispell-skip-tib (string-match ispell-tib-ref-beginning key))
       (re-search-forward ispell-tib-ref-end ispell-region-end t))
-     ((and ispell-skip-html (string-match "</" key))
-      (search-forward ">" ispell-region-end t))
-     ((and ispell-skip-html (string-match "<[cC][oO][dD][eE]\\>[^>]*>" key))
-      (search-forward-regexp "</[cC][oO][dD][eE]>" ispell-region-end t))
-     ((and ispell-skip-html
-           (string-match "<[sS][cC][rR][iI][pP][tT]\\>[^>]*>" key))
-      (search-forward-regexp "</[sS][cC][rR][iI][pP][tT]>" ispell-region-end t))
-     ((and ispell-skip-html
-           (string-match "<[aA][pP][pP][lL][eE][tT]\\>[^>]*>" key))
-      (search-forward-regexp "</[aA][pP][pP][lL][eE][tT]>" ispell-region-end t))
-     ((and ispell-skip-html (string-match "<[vV][eE][rR][bB]\\>[^>]*>" key))
-      (search-forward-regexp "</[vV][eE][rR][bB]>" ispell-region-end t))
-     ;;((and ispell-skip-html (string-match "<[tT][tT]\\>[^>]*>" key))
-     ;; (search-forward-regexp "</[tT][tT]>" 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
@@ -2551,13 +2700,14 @@ otherwise, the current line is skipped."
                ((not (consp alist))
                 ;; Search past end of spell region to find this region end.
                 (re-search-forward (eval alist) (point-max) t))
-               ((consp alist)
-                (if (stringp alist)
-                    (re-search-forward alist (point-max) t)
-                  (setq null-skip t)    ; error handling in functions!
-                  (if (consp (cdr alist))
-                      (apply (car alist) (cdr alist))
-                    (funcall (car alist))))))
+               ((and (= 1 (length alist))
+                     (stringp (car alist)))
+                (re-search-forward (car alist) (point-max) t))
+               (t
+                (setq null-skip t)      ; error handling in functions!
+                (if (consp (cdr alist))
+                    (apply (car alist) (cdr alist))
+                  (funcall (car alist)))))
               (setq alist nil))
           (setq alist (cdr alist))))))
     (if (and (= start (point)) (null null-skip))
@@ -2570,7 +2720,7 @@ otherwise, the current line is skipped."
 
 ;;; Grab the next line of data.
 ;;; Returns a string with the line data
-(defun ispell-get-line (start end)
+(defun ispell-get-line (start end in-comment)
   (let ((ispell-casechars (ispell-get-casechars))
         string)
     (cond                               ; LOOK AT THIS LINE AND SKIP OR PROCESS
@@ -2580,7 +2730,8 @@ otherwise, the current line is skipped."
      ;; (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
-      (setq string (concat "^" (buffer-substring-no-properties start end)
+      (setq string (concat "^" in-comment
+                           (buffer-substring-no-properties start end)
                            "\n"))
       (goto-char end))
      (t (goto-char end)))               ; EMPTY LINE, skip it.
@@ -2637,7 +2788,7 @@ Returns the sum shift due to changes in word replacements."
             ;; `query-replace' makes multiple corrections on the starting line.
             (if (/= (+ word-len (point))
                     (progn
-                      ;; NB: Search can fail with Mule character sets that don't
+                      ;; NB: Search can fail with Mule coding systems that don't
                       ;;  display properly.  Ignore the error in this case?
                       (search-forward (car poss) (+ word-len (point)) t)
                       (point)))
@@ -2881,7 +3032,8 @@ looking for a dictionary, please see the distribution of the GNU ispell
 program, or do an Internet search; there are various dictionaries
 available on the net."
   (interactive)
-  (if (and transient-mark-mode mark-active)
+  (if (and (boundp 'transient-mark-mode) transient-mark-mode
+           (boundp 'mark-active) mark-active)
       (ispell-region (region-beginning) (region-end))
     (ispell-buffer)))
 
@@ -2946,8 +3098,6 @@ Don't read buffer-local settings or word lists."
 ;;; **********************************************************************
 ;;;                     Ispell Message
 ;;; **********************************************************************
-;;; Original from D. Quinlan, E. Bradford, A. Albert, and M. Ernst
-
 
 (defvar ispell-message-text-end
   (mapconcat (function identity)
@@ -2955,9 +3105,9 @@ Don't read buffer-local settings or word lists."
                ;; Don't spell check signatures
                "^-- $"
                ;; Matches postscript files.
-               "^%!PS-Adobe-[123].0"
+               ;;"^%!PS-Adobe-[123].0"
                ;; Matches uuencoded text
-               "^begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM"
+               ;;"^begin [0-9][0-9][0-9] .*\nM.*\nM.*\nM"
                ;; Matches shell files (especially auto-decoding)
                "^#! /bin/[ck]?sh"
                ;; Matches context difference listing
@@ -2974,6 +3124,97 @@ 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.")
 
 
+(defun ispell-mime-multipartp (&optional limit)
+  "Return multipart message start boundary or nil if none."
+  ;; caller must ensure `case-fold-search' is set to `t'
+  (and
+   (re-search-forward
+    "Content-Type: *multipart/\\([^ \t\n]*;[ \t]*[\n]?[ \t]*\\)+boundary="
+    limit t)
+   (let (boundary)
+     (if (looking-at "\"")
+         (let (start)
+           (forward-char)
+           (setq start (point))
+           (while (not (looking-at "\""))
+             (forward-char 1))
+           (setq boundary (buffer-substring-no-properties start (point))))
+       (let ((start (point)))
+         (while (looking-at "[-0-9a-zA-Z'()+_,./:=?]")
+           (forward-char))
+         (setq boundary (buffer-substring-no-properties start (point)))))
+     (if (< (length boundary) 1)
+         (setq boundary nil)
+       (concat "--" boundary)))))
+
+
+(defun ispell-mime-skip-part (boundary)
+  "Moves point across header, or entire MIME part if message is encoded.
+All specified types except `7bit' `8bit' and `quoted-printable' are considered
+encoded and therefore skipped.  See rfc 1521, 2183, ...
+If no boundary is given, then entire message is skipped.
+
+This starts one line ABOVE the MIME content messages, on the boundary marker,
+for operation with the generic region-skipping code.
+This places new MIME boundaries into variable `ispell-checking-message'."
+  (forward-line)                        ; skip over boundary to headers
+  (let ((save-case-fold-search case-fold-search)
+        (continuep t)
+        textp)
+    (setq case-fold-search t
+          ispell-skip-html nil)
+    (while continuep
+      (setq continuep nil)
+      (if (looking-at "Content-Type: *text/")
+          (progn
+            (goto-char (match-end 0))
+            (if (looking-at "html")
+                (setq ispell-skip-html t))
+            (setq textp t
+                  continuep t)
+            (re-search-forward "\\(.*;[ \t]*[\n]\\)*.*$" nil t)
+            (forward-line)))
+      (if (looking-at "Content-Transfer-Encoding: *\\([^ \t\n]*\\)")
+          (let ((match (buffer-substring (match-beginning 1) (match-end 1))))
+            (setq textp (member (upcase match)
+                                ;; only spell check the following encodings:
+                                '("7BIT" "8BIT" "QUOTED-PRINTABLE" "BINARY"))
+                  continuep t)
+            (goto-char (match-end 0))
+            (re-search-forward "\\(.*;[ \t]*[\n]\\)*.*$" nil t)
+            (forward-line)))
+      ;; hierarchical boundary definition
+      (if (looking-at "Content-Type: *multipart/")
+          (let ((new-boundary (ispell-mime-multipartp)))
+            (if (string-match new-boundary boundary)
+                (setq continuep t)
+              ;; first pass redefine skip function to include new boundary
+              ;;(re-search-backward boundary nil t)
+              (forward-line)
+              (setq ispell-checking-message
+                    (cons
+                     (list new-boundary 'ispell-mime-skip-part new-boundary)
+                     (if (eq t ispell-checking-message) nil
+                       ispell-checking-message))
+                    textp t
+                    continuep t)))
+        ;; Skip all MIME headers that don't affect spelling
+        (if (looking-at "Content-[^ \t]*: *\\(.*;[ \t]*[\n]\\)*.*$")
+            (progn
+              (setq continuep t)
+              (goto-char (match-end 0))
+              (forward-line)))))
+
+    (setq case-fold-search save-case-fold-search)
+    (if textp
+        (point)
+      ;; encoded message.  Skip to boundary, or entire message.
+      (if (not boundary)
+          (goto-char (point-max))
+        (re-search-forward boundary nil t)
+        (beginning-of-line)
+        (point)))))
+
 
 ;;;###autoload
 (defun ispell-message ()
@@ -2998,7 +3239,8 @@ You can bind this to the key C-c i in GNUS or mail by adding to
   (interactive)
   (save-excursion
     (goto-char (point-min))
-    (let* (
+    (let* (boundary mimep
+           (ispell-skip-region-alist-save ispell-skip-region-alist)
            ;; Nil when message came from outside (eg calling emacs as editor)
            ;; Non-nil marker of end of headers.
            (internal-messagep
@@ -3023,10 +3265,10 @@ You can bind this to the key C-c i in GNUS or mail by adding to
                "   \\|\t"))
            (cite-regexp                 ;Prefix of quoted text
             (cond
-             ((functionp 'sc-cite-regexp) ; sc 3.0
+             ((functionp 'sc-cite-regexp)       ; sc 3.0
               (concat "\\(" (sc-cite-regexp) "\\)" "\\|"
                       (ispell-non-empty-string sc-reference-tag-string)))
-             ((boundp 'sc-cite-regexp)  ; sc 2.3
+             ((boundp 'sc-cite-regexp)          ; sc 2.3
               (concat "\\(" sc-cite-regexp "\\)" "\\|"
                       (ispell-non-empty-string sc-reference-tag-string)))
              ((or (equal major-mode 'news-reply-mode) ;GNUS 4 & below
@@ -3068,7 +3310,9 @@ You can bind this to the key C-c i in GNUS or mail by adding to
           (progn
             ;; Spell check any original Subject:
             (goto-char (point-min))
-            (setq case-fold-search t)
+            (setq case-fold-search t
+                  mimep (re-search-forward "MIME-Version:" end-of-headers t))
+            (goto-char (point-min))
             (if (re-search-forward "^Subject: *" end-of-headers t)
                 (progn
                   (goto-char (match-end 0))
@@ -3082,12 +3326,41 @@ You can bind this to the key C-c i in GNUS or mail by adding to
                                          (while (looking-at "\n[ \t]")
                                            (end-of-line 2))
                                          (point)))))))
-            (setq case-fold-search old-case-fold-search)
-            (goto-char end-of-headers)
+            (if mimep
+                (progn
+                  (goto-char (point-min))
+                  (setq boundary (ispell-mime-multipartp end-of-headers))))
+            ;; Adjust message limit to MIME message if necessary.
+            (and boundary
+                 (re-search-forward (concat boundary "--") nil t)
+                 (re-search-backward boundary nil t)
+                 (< (point) (marker-position limit))
+                 (set-marker limit (point)))
+            (goto-char (point-min))
+            ;; Select type or skip checking if this is a non-multipart message
+            ;; Point moved to end of buffer if region is encoded.
+            (if (and mimep (not boundary))
+                (let (skip-regexp)      ; protect from `ispell-mime-skip-part'
+                  (goto-char (point-min))
+                  (re-search-forward "Content-[^ \t]*:" end-of-headers t)
+                  (forward-line -1)     ; following fn starts one line above
+                  (ispell-mime-skip-part nil)
+                  ;; if message-text-end region, limit may be less than point.
+                  (if (> (point) limit)
+                      (set-marker limit (point)))))
+            (goto-char (max end-of-headers (point)))
             (forward-line 1)
+            (setq case-fold-search old-case-fold-search)
+            ;; Define MIME regions to skip.
+            (if boundary
+                (setq ispell-checking-message
+                      (list (list boundary 'ispell-mime-skip-part boundary))))
             (ispell-region (point) limit))
         (set-marker end-of-headers nil)
-        (set-marker limit nil)))))
+        (set-marker limit nil)
+        (setq ispell-skip-region-alist ispell-skip-region-alist-save
+              ispell-skip-html nil
+              case-fold-search old-case-fold-search)))))
 
 
 (defun ispell-non-empty-string (string)
@@ -3128,9 +3401,9 @@ Includes Latex/Nroff modes and extended character mode."
     (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-html (not (eq ispell-skip-html t)))
-      (set (make-local-variable 'ispell-skip-html)
-           (not (null (string-match "sgml\\|html\\|xml"
-                                    (downcase (symbol-name major-mode)))))))
+      (setq ispell-skip-html
+            (not (null (string-match "sgml\\|html\\|xml"
+                                     (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
@@ -3196,8 +3469,7 @@ Both should not be used to define a buffer-local dictionary."
         (ispell-kill-ispell t)
         (setq ispell-personal-dictionary ispell-local-pdict)))
   ;; Reload if new dictionary defined.
-  (if (and ispell-local-dictionary
-           (not (equal ispell-local-dictionary ispell-dictionary)))
+  (if (not (equal ispell-local-dictionary ispell-dictionary))
       (ispell-change-dictionary ispell-local-dictionary)))