* lisp/mail/footnote.el: Use dolist and hoist regexps out of loops

(footnote--refresh-footnotes): Use pcase-dolist; compute regexp once
outside of the loops.  Use less confusing `literal` arg to `replace-match`
and specify `fixedcase` since footnote--index-to-string already chose
the proper case for us.
(footnote--renumber): Use dolist; compute regexp once
outside of the loops; shortcircuit when number is unchanged.
(footnote--text-under-cursor): Rewrite.
(footnote--make-hole): Use dolist.
(footnote-add-footnote): CSE.
(footnote-delete-footnote): Use dolist; compute regexp once
outside of the loop.
(footnote-delete-footnote): Don't renumber if there's no footnote left.
(footnote-renumber-footnotes): Use dolist.

diff --git a/lisp/mail/footnote.el b/lisp/mail/footnote.el
index ef359b62b40cdd936872b6f7bcd6c774d56c373c..9a918376e679736e0dd23c9a7c7dbec749ca90bb 100644 (file)
--- a/lisp/mail/footnote.el
+++ b/lisp/mail/footnote.el
@@ -164,7 +164,9 @@ left with the first character of footnote text."
   "List of (FN TEXT . POINTERS).
 Where FN is the footnote number, TEXT is a marker pointing to
 the footnote's text, and POINTERS is a list of markers pointing
-to the places from which the footnote is referenced.")
+to the places from which the footnote is referenced.
+TEXT points right *before* the [...] and POINTERS point right
+*after* the [...].")
 
 (defvar footnote-mouse-highlight 'highlight
   ;; FIXME: This `highlight' property is not currently used.
@@ -452,52 +454,41 @@ Conversion is done based upon the current selected style."
 
 (defun footnote--refresh-footnotes (&optional index-regexp)
   "Redraw all footnotes.
-You must call this or arrange to have this called after changing footnote
-styles."
-  (unless index-regexp
-    (setq index-regexp (footnote--current-regexp)))
-  (save-excursion
-    ;; Take care of the pointers first
-    (let ((i 0) locn alist)
-      (while (setq alist (nth i footnote--markers-alist))
-       (setq locn (cddr alist))
-       (while locn
-         (goto-char (car locn))
+You must call this or arrange to have this called after changing
+footnote styles."
+  (let ((fn-regexp (concat
+                   (regexp-quote footnote-start-tag)
+                   "\\(" (or index-regexp (footnote--current-regexp)) "+\\)"
+                   (regexp-quote footnote-end-tag))))
+    (save-excursion
+      (pcase-dolist (`(,fn ,text . ,pointers) footnote--markers-alist)
+        ;; Take care of the pointers first
+       (dolist (locn pointers)
+         (goto-char locn)
          ;; Try to handle the case where `footnote-start-tag' and
          ;; `footnote-end-tag' are the same string.
-         (when (looking-back (concat
-                              (regexp-quote footnote-start-tag)
-                              "\\(" index-regexp "+\\)"
-                              (regexp-quote footnote-end-tag))
+         (when (looking-back fn-regexp
                              (line-beginning-position))
            (replace-match
             (propertize
              (concat
               footnote-start-tag
-              (footnote--index-to-string (1+ i))
+              (footnote--index-to-string fn)
               footnote-end-tag)
-             'footnote-number (1+ i) footnote-mouse-highlight t)
-            nil "\\1"))
-         (setq locn (cdr locn)))
-       (setq i (1+ i))))
-
-    ;; Now take care of the text section
-    (let ((i 0) alist)
-      (while (setq alist (nth i footnote--markers-alist))
-       (goto-char (cadr alist))
-       (when (looking-at (concat
-                          (regexp-quote footnote-start-tag)
-                          "\\(" index-regexp "+\\)"
-                          (regexp-quote footnote-end-tag)))
+             'footnote-number fn footnote-mouse-highlight t)
+            t t)))
+
+        ;; Now take care of the text section
+       (goto-char text)
+       (when (looking-at fn-regexp)
          (replace-match
           (propertize
            (concat
             footnote-start-tag
-            (footnote--index-to-string (1+ i))
+            (footnote--index-to-string fn)
             footnote-end-tag)
-           'footnote-number (1+ i))
-          nil "\\1"))
-       (setq i (1+ i))))))
+           'footnote-number fn)
+          t t))))))
 
 (defun footnote-cycle-style ()
   "Select next defined footnote style."
@@ -532,31 +523,28 @@ styles."
 
 (defun footnote--renumber (to alist-elem)
   "Renumber a single footnote."
-  (let* ((posn-list (cddr alist-elem)))
-    (setcar alist-elem to)
-    (while posn-list
-      (goto-char (car posn-list))
-      (when (looking-back (concat (regexp-quote footnote-start-tag)
-                                 (footnote--current-regexp)
-                                 (regexp-quote footnote-end-tag))
-                         (line-beginning-position))
-       (replace-match
-        (propertize
+  (unless (equal to (car alist-elem))   ;Nothing to do.
+    (let* ((fn-regexp (concat (regexp-quote footnote-start-tag)
+                             (footnote--current-regexp)
+                             (regexp-quote footnote-end-tag))))
+      (setcar alist-elem to)
+      (dolist (posn (cddr alist-elem))
+        (goto-char posn)
+        (when (looking-back fn-regexp (line-beginning-position))
+         (replace-match
+          (propertize
+           (concat footnote-start-tag
+                   (footnote--index-to-string to)
+                   footnote-end-tag)
+           'footnote-number to footnote-mouse-highlight t))))
+      (goto-char (cadr alist-elem))
+      (when (looking-at fn-regexp)
+        (replace-match
+         (propertize
          (concat footnote-start-tag
                  (footnote--index-to-string to)
                  footnote-end-tag)
-         'footnote-number to footnote-mouse-highlight t)))
-      (setq posn-list (cdr posn-list)))
-    (goto-char (cadr alist-elem))
-    (when (looking-at (concat (regexp-quote footnote-start-tag)
-                             (footnote--current-regexp)
-                             (regexp-quote footnote-end-tag)))
-      (replace-match
-       (propertize
-       (concat footnote-start-tag
-               (footnote--index-to-string to)
-               footnote-end-tag)
-       'footnote-number to)))))
+         'footnote-number to))))))
 
 (defun footnote--narrow-to-footnotes ()
   "Restrict text in buffer to show only text of footnotes."
@@ -652,18 +640,11 @@ Presumes we're within the footnote area already."
   "Return the number of the current footnote if in footnote text.
 Return nil if the cursor is not positioned over the text of
 a footnote."
-  (when (and footnote--markers-alist
-             (<= (footnote--get-area-point-min)
-                 (point)
-                 (footnote--get-area-point-max)))
-    (let ((i 1) alist-txt result)
-      (while (and (setq alist-txt (nth i footnote--markers-alist))
-                  (null result))
-        (when (< (point) (cadr alist-txt))
-          (setq result (car (nth (1- i) footnote--markers-alist))))
-        (setq i (1+ i)))
-      (when (and (null result) (null alist-txt))
-        (setq result (car (nth (1- i) footnote--markers-alist))))
+  (when (<= (point) (footnote--get-area-point-max))
+    (let ((result nil))
+      (pcase-dolist (`(,fn ,text . ,_) footnote--markers-alist)
+        (if (<= text (point))
+            (setq result fn)))
       result)))
 
 (defun footnote--under-cursor ()
@@ -750,11 +731,8 @@ footnote area, returns `point-max'."
 
 (defun footnote--make-hole ()
   (save-excursion
-    (let ((i 0)
-         (notes (length footnote--markers-alist))
-         alist-elem rc)
-      (while (< i notes)
-       (setq alist-elem (nth i footnote--markers-alist))
+    (let (rc)
+      (dolist (alist-elem footnote--markers-alist)
        (when (< (point) (- (cl-caddr alist-elem) 3))
          (unless rc
            (setq rc (car alist-elem)))
@@ -764,8 +742,7 @@ footnote area, returns `point-max'."
                     (footnote--index-to-string
                      (1+ (car alist-elem))))
            (footnote--renumber (1+ (car alist-elem))
-                               alist-elem)))
-       (setq i (1+ i)))
+                               alist-elem))))
       rc)))
 
 (defun footnote-add-footnote ()
@@ -778,9 +755,10 @@ by using `footnote-back-to-message'."
   (interactive "*")
   (let ((num
          (if footnote--markers-alist
-             (if (< (point) (cl-caddar (last footnote--markers-alist)))
-                 (footnote--make-hole)
-               (1+ (caar (last footnote--markers-alist))))
+             (let ((last (car (last footnote--markers-alist))))
+               (if (< (point) (cl-caddr last))
+                   (footnote--make-hole)
+                 (1+ (car last))))
            1)))
     (message "Adding footnote %d" num)
     (footnote--insert-footnote num)
@@ -807,20 +785,17 @@ delete the footnote with that number."
   (when (and arg
             (or (not footnote-prompt-before-deletion)
                 (y-or-n-p (format "Really delete footnote %d?" arg))))
-    (let (alist-elem locn)
-      (setq alist-elem (assq arg footnote--markers-alist))
-      (unless alist-elem
-       (error "Can't delete footnote %d" arg))
-      (setq locn (cddr alist-elem))
-      (while (car locn)
+    (let ((alist-elem (or (assq arg footnote--markers-alist)
+                          (error "Can't delete footnote %d" arg)))
+          (fn-regexp (concat (regexp-quote footnote-start-tag)
+                            (footnote--current-regexp)
+                            (regexp-quote footnote-end-tag))))
+      (dolist (locn (cddr alist-elem))
        (save-excursion
-         (goto-char (car locn))
-         (when (looking-back (concat (regexp-quote footnote-start-tag)
-                                     (footnote--current-regexp)
-                                     (regexp-quote footnote-end-tag))
+         (goto-char locn)
+         (when (looking-back fn-regexp
                              (line-beginning-position))
-           (delete-region (match-beginning 0) (match-end 0))))
-       (setq locn (cdr locn)))
+           (delete-region (match-beginning 0) (match-end 0)))))
       (save-excursion
        (goto-char (cadr alist-elem))
        (delete-region
@@ -833,8 +808,8 @@ delete the footnote with that number."
              (point) 'footnote-number nil (footnote--goto-char-point-max))))))
       (setq footnote--markers-alist
            (delq alist-elem footnote--markers-alist))
-      (footnote-renumber-footnotes)
-      (when (null footnote--markers-alist)
+      (if footnote--markers-alist
+          (footnote-renumber-footnotes)
        (save-excursion
          (if (not (string-equal footnote-section-tag ""))
              (let* ((end (footnote--goto-char-point-max))
@@ -855,13 +830,9 @@ delete the footnote with that number."
   "Renumber footnotes, starting from 1."
   (interactive "*")
   (save-excursion
-    (let ((i 0)
-         (notes (length footnote--markers-alist))
-         alist-elem)
-      (while (< i notes)
-       (setq alist-elem (nth i footnote--markers-alist))
-       (unless (= (1+ i) (car alist-elem))
-         (footnote--renumber (1+ i) alist-elem))
+    (let ((i 1))
+      (dolist (alist-elem footnote--markers-alist)
+       (footnote--renumber i alist-elem)
        (setq i (1+ i))))))
 
 (defun footnote-goto-footnote (&optional arg)
@@ -900,13 +871,13 @@ being set it is automatically widened."
 
 (defvar footnote-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "a" 'footnote-add-footnote)
-    (define-key map "b" 'footnote-back-to-message)
-    (define-key map "c" 'footnote-cycle-style)
-    (define-key map "d" 'footnote-delete-footnote)
-    (define-key map "g" 'footnote-goto-footnote)
-    (define-key map "r" 'footnote-renumber-footnotes)
-    (define-key map "s" 'footnote-set-style)
+    (define-key map "a" #'footnote-add-footnote)
+    (define-key map "b" #'footnote-back-to-message)
+    (define-key map "c" #'footnote-cycle-style)
+    (define-key map "d" #'footnote-delete-footnote)
+    (define-key map "g" #'footnote-goto-footnote)
+    (define-key map "r" #'footnote-renumber-footnotes)
+    (define-key map "s" #'footnote-set-style)
     map))
 
 (defvar footnote-minor-mode-map