* lisp/textmodes/ispell.el: Fix commenting convention.

(ispell-parse-output): Simplify, use push.
(ispell-region): Use match-string-no-properties.
(ispell-begin-skip-region-regexp): Use mapconcat to simplify.
(ispell-minor-mode): Use define-minor-mode.
(ispell-message): Remove unused var `skip-regexp'.
(ispell-add-per-file-word-list): Use dynamic let-binding.
Try and use the proper comment marker.

2 files changed, 63 insertions, 85 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index ae4064bc04a..eb85c0dc262 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,5 +1,14 @@
 2010-09-20  Stefan Monnier  <monnier@iro.umontreal.ca>
 
+        * textmodes/ispell.el: Fix commenting convention.
+        (ispell-parse-output): Simplify, use push.
+        (ispell-region): Use match-string-no-properties.
+        (ispell-begin-skip-region-regexp): Use mapconcat to simplify.
+        (ispell-minor-mode): Use define-minor-mode.
+        (ispell-message): Remove unused var `skip-regexp'.
+        (ispell-add-per-file-word-list): Use dynamic let-binding.
+        Try and use the proper comment marker.
+
         * mail/sendmail.el: Fix commenting convention.
         (sendmail-send-it): Use line-beginning-position.
 
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index ad2838adaa9..8fe42b320c6 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -770,8 +770,8 @@ here just for backwards compatibility.")
 
 
 
-;;; The version must be 3.1 or greater for this version of ispell.el
-;;; There is an incompatibility between version 3.1.12 and lower versions.
+;; The version must be 3.1 or greater for this version of ispell.el
+;; There is an incompatibility between version 3.1.12 and lower versions.
 (defconst ispell-required-version '(3 1 12)
   "Ispell versions with which this version of ispell.el is known to work.")
 (defvar ispell-offset -1
@@ -1106,7 +1106,7 @@ aspell is used along with Emacs).")
 
 
 (defun ispell-valid-dictionary-list ()
-  "Returns a list of valid dictionaries.
+  "Return a list of valid dictionaries.
 The variable `ispell-library-directory' defines the library location."
   ;; Initialize variables and dictionaries alists for desired spellchecker.
   ;; Make sure ispell.el is loaded to avoid some autoload loops in XEmacs
@@ -1269,9 +1269,6 @@ The variable `ispell-library-directory' defines the library location."
 
 ;;; **********************************************************************
 
-
-;;; This variable contains the current dictionary being used if the ispell
-;;; process is running.
 (defvar ispell-current-dictionary nil
   "The name of the current dictionary, or nil for the default.
 This is passed to the ispell process using the `-d' switch and is
@@ -1296,6 +1293,7 @@ Protects against bogus binding of `enable-multibyte-characters' in XEmacs."
 
 ;; Return a string decoded from Nth element of the current dictionary.
 (defun ispell-get-decoded-string (n)
+  "Get the decoded string in slot N of the descriptor of the current dict."
   (let* ((slot (or
                 (assoc ispell-current-dictionary ispell-local-dictionary-alist)
                 (assoc ispell-current-dictionary ispell-dictionary-alist)
@@ -2151,7 +2149,7 @@ Global `ispell-quit' set to start location to continue spell session."
   (if (and ispell-use-framepop-p (fboundp 'framepop-display-buffer))
       (progn
         (framepop-display-buffer (get-buffer ispell-choices-buffer))
-;;;     (get-buffer-window ispell-choices-buffer t)
+        ;; (get-buffer-window ispell-choices-buffer t)
         (select-window (previous-window))) ; *Choices* window
     ;; standard selection by splitting a small buffer out of this window.
     (let ((choices-window (get-buffer-window ispell-choices-buffer)))
@@ -2546,18 +2544,18 @@ Optional third arg SHIFT is an offset to apply based on previous corrections."
         (setq count (string-to-number output) ; get number of misses.
               output (substring output (1+ (string-match " " output 1)))))
       (setq offset (string-to-number output))
-      (if (eq type ?#)                  ; No miss or guess list.
-          (setq output nil)
-        (setq output (substring output (1+ (string-match " " output 1)))))
+      (setq output (if (eq type ?#)     ; No miss or guess list.
+                       nil
+                     (substring output (1+ (string-match " " output 1)))))
       (while output
         (let ((end (string-match ", \\|\\($\\)" output))) ; end of miss/guess.
           (setq cur-count (1+ cur-count))
           (if (> cur-count count)
-              (setq guess-list (cons (substring output 0 end) guess-list))
-            (setq miss-list (cons (substring output 0 end) miss-list)))
-          (if (match-end 1)             ; True only when at end of line.
-              (setq output nil)         ; no more misses or guesses
-            (setq output (substring output (+ end 2))))))
+              (push (substring output 0 end) guess-list)
+            (push (substring output 0 end) miss-list))
+          (setq output (if (match-end 1) ; True only when at end of line.
+                           nil           ; No more misses or guesses.
+                         (substring output (+ end 2))))))
       ;; return results.  Accept word if it was already accepted.
       ;; adjust offset.
       (if (member original-word accept-list)
@@ -2849,8 +2847,7 @@ Return nil if spell session is quit,
               (message "searching for regions to skip"))
             (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)))
+                  (setq key (match-string-no-properties 0))
                   (set-marker skip-region-start (- (point) (length key)))
                   (goto-char reg-start)))
             (let (message-log-max)
@@ -2944,42 +2941,30 @@ Return nil if spell session is quit,
   "Return 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
-                           (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))
+  (mapconcat
+   'identity
+   (delq nil
+         (list
+          ;; messages
+          (if (and ispell-checking-message
+                   (not (eq t ispell-checking-message)))
+              (mapconcat #'car ispell-checking-message "\\|"))
+          ;; tex
+          (if (eq ispell-parser 'tex)
+              (ispell-begin-tex-skip-regexp))
+          ;; html stuff
+          (if ispell-skip-html
+              (ispell-begin-skip-region ispell-html-skip-alists))
+          ;; tib
+          (if ispell-skip-tib ispell-tib-ref-beginning)
+          ;; Comments
+          (if (and (eq 'exclusive ispell-check-comments) comment-start)
+              ;; search from end of current comment to start of next comment.
+              (if (string= "" comment-end) "^" (regexp-quote comment-end)))
+          (if (and (null ispell-check-comments) comment-start)
+              (regexp-quote comment-start))
+          (ispell-begin-skip-region ispell-skip-region-alist)))
+   "\\|"))
 
 
 (defun ispell-begin-skip-region (skip-alist)
@@ -3456,15 +3441,6 @@ available on the net."
 ;;;                     Ispell Minor Mode
 ;;; **********************************************************************
 
-(defvar ispell-minor-mode nil
-  "Non-nil if Ispell minor mode is enabled.")
-;; Variable indicating that ispell minor mode is active.
-(make-variable-buffer-local 'ispell-minor-mode)
-
-(or (assq 'ispell-minor-mode minor-mode-alist)
-    (setq minor-mode-alist
-          (cons '(ispell-minor-mode " Spell") minor-mode-alist)))
-
 (defvar ispell-minor-keymap
   (let ((map (make-sparse-keymap)))
     (define-key map " " 'ispell-minor-check)
@@ -3472,14 +3448,8 @@ available on the net."
     map)
   "Keymap used for Ispell minor mode.")
 
-(or (not (boundp 'minor-mode-map-alist))
-    (assoc 'ispell-minor-mode minor-mode-map-alist)
-    (setq minor-mode-map-alist
-          (cons (cons 'ispell-minor-mode ispell-minor-keymap)
-                minor-mode-map-alist)))
-
 ;;;###autoload
-(defun ispell-minor-mode (&optional arg)
+(define-minor-mode ispell-minor-mode
   "Toggle Ispell minor mode.
 With prefix argument ARG, turn Ispell minor mode on if ARG is positive,
 otherwise turn it off.
@@ -3489,11 +3459,7 @@ 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."
-  (interactive "P")
-  (setq ispell-minor-mode
-        (not (or (and (null arg) ispell-minor-mode)
-                 (<= (prefix-numeric-value arg) 0))))
-  (force-mode-line-update))
+  nil " Spell" ispell-minor-keymap)
 
 (defun ispell-minor-check ()
   "Check previous word then continue with the normal binding of this key.
@@ -3759,15 +3725,14 @@ You can bind this to the key C-c i in GNUS or mail by adding to
             (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'
+            (when (and mimep (not boundary))
                   (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)))))
+                  (set-marker limit (point))))
             (goto-char (max end-of-headers (point)))
             (forward-line 1)
             (setq case-fold-search old-case-fold-search)
@@ -3850,7 +3815,7 @@ Includes Latex/Nroff modes and extended character mode."
                      (sit-for 2))))))))
 
 
-;;; Can kill the current ispell process
+;; Can kill the current ispell process
 
 (defun ispell-buffer-local-dict (&optional no-reload)
   "Initializes local dictionary and local personal dictionary.
@@ -3923,16 +3888,14 @@ Both should not be used to define a buffer-local dictionary."
       (setq ispell-buffer-local-name (buffer-name)))
   (save-excursion
     (goto-char (point-min))
-    (let ((old-case-fold-search case-fold-search)
-          line-okay search done found)
+    (let (line-okay search done found)
       (while (not done)
-        (setq case-fold-search nil
-              search (search-forward ispell-words-keyword nil 'move)
+        (let ((case-fold-search nil))
+          (setq search (search-forward ispell-words-keyword nil 'move)
               found (or found search)
               line-okay (< (+ (length word) 1 ; 1 for space after word..
                               (progn (end-of-line) (current-column)))
-                           80)
-              case-fold-search old-case-fold-search)
+                             fill-column)))
         (if (or (and search line-okay)
                 (null search))
             (progn
@@ -3941,7 +3904,13 @@ Both should not be used to define a buffer-local dictionary."
                   (progn
                     (open-line 1)
                     (unless found (newline))
-                    (insert (concat comment-start " " ispell-words-keyword))
+                    (insert (if (fboundp 'comment-padright)
+                                ;; Try and use the proper comment marker,
+                                ;; e.g. ";;" rather than ";".
+                                (comment-padright comment-start
+                                                  (comment-add nil))
+                              comment-start)
+                            " " ispell-words-keyword)
                     (if (> (length comment-end) 0)
                         (save-excursion
                           (newline)