* lisp/vc/emerge.el: Use lexical-binding

Replace all `(lambda ...) with closures.  Use inhibit-read-only.
(emerge-mode): Use define-minor-mode.
(emerge-setup, emerge-setup-with-ancestor):
Don't use 'run-hooks' on local var.
(emerge-files, emerge-files-with-ancestor):
Don't use 'add-hook' on local var.
(emerge-convert-diffs-to-markers): Remove unused var 'B-point-min'.
Simplify 'offset'.
(emerge--current-beg, emerge--current-end): New macros.
(emerge-select-version): Pass 'diff-vector' to the function it calls.
Change all callers to use it instead of dyn-bound vars.

1 files changed, 250 insertions, 352 deletions

diff --git a/lisp/vc/emerge.el b/lisp/vc/emerge.el
index 0da14d07fd3..fc8c318e3af 100644
--- a/lisp/vc/emerge.el
+++ b/lisp/vc/emerge.el
@@ -1,6 +1,6 @@
-;;; emerge.el --- merge diffs under Emacs control
+;;; emerge.el --- merge diffs under Emacs control  -*- lexical-binding:t -*-
 
-;;; The author has placed this file in the public domain.
+;; The author has placed this file in the public domain.
 
 ;; This file is part of GNU Emacs.
 
@@ -24,42 +24,20 @@
 
 ;;; Code:
 
-;; There aren't really global variables, just dynamic bindings
-(defvar A-begin)
-(defvar A-end)
-(defvar B-begin)
-(defvar B-end)
-(defvar diff-vector)
-(defvar merge-begin)
-(defvar merge-end)
-(defvar valid-diff)
-
 ;;; Macros
 
 (defmacro emerge-defvar-local (var value doc)
-  "Defines SYMBOL as an advertised variable.
+  "Define SYMBOL as an advertised buffer-local variable.
 Performs a defvar, then executes `make-variable-buffer-local' on
 the variable.  Also sets the `permanent-local' property, so that
 `kill-all-local-variables' (called by major-mode setting commands)
 won't destroy Emerge control variables."
   `(progn
-    (defvar ,var ,value ,doc)
-    (make-variable-buffer-local ',var)
-    (put ',var 'permanent-local t)))
-
-;; Add entries to minor-mode-alist so that emerge modes show correctly
-(defvar emerge-minor-modes-list
-  '((emerge-mode " Emerge")
-    (emerge-fast-mode " F")
-    (emerge-edit-mode " E")
-    (emerge-auto-advance " A")
-    (emerge-skip-prefers " S")))
-(if (not (assq 'emerge-mode minor-mode-alist))
-    (setq minor-mode-alist (append emerge-minor-modes-list
-                                   minor-mode-alist)))
+     (defvar-local ,var ,value ,doc)
+     (put ',var 'permanent-local t)))
 
 ;; We need to define this function so describe-mode can describe Emerge mode.
-(defun emerge-mode ()
+(define-minor-mode emerge-mode
   "Emerge mode is used by the Emerge file-merging package.
 It is entered only through one of the functions:
         `emerge-files'
@@ -74,7 +52,13 @@ It is entered only through one of the functions:
 Commands:
 \\{emerge-basic-keymap}
 Commands must be prefixed by \\<emerge-fast-keymap>\\[emerge-basic-keymap] in `edit' mode,
-but can be invoked directly in `fast' mode.")
+but can be invoked directly in `fast' mode."
+  :lighter (" Emerge"
+            (emerge-fast-mode " F")
+            (emerge-edit-mode " E")
+            (emerge-auto-advance " A")
+            (emerge-skip-prefers " S")))
+(put 'emerge-mode 'permanent-local t)
 
 ;;; Emerge configuration variables
 
@@ -453,8 +437,6 @@ Must be set before Emerge is loaded."
 ;; Variables which control each merge.  They are local to the merge buffer.
 
 ;; Mode variables
-(emerge-defvar-local emerge-mode nil
-  "Indicator for emerge-mode.")
 (emerge-defvar-local emerge-fast-mode nil
   "Indicator for emerge-mode fast submode.")
 (emerge-defvar-local emerge-edit-mode nil
@@ -556,7 +538,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
        (if temp
            (setq file-A temp
                  startup-hooks
-                 (cons `(lambda () (delete-file ,file-A))
+                 (cons (lambda () (delete-file file-A))
                        startup-hooks))
            ;; Verify that the file matches the buffer
            (emerge-verify-file-buffer))))
@@ -567,7 +549,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
        (if temp
            (setq file-B temp
                  startup-hooks
-                 (cons `(lambda () (delete-file ,file-B))
+                 (cons (lambda () (delete-file file-B))
                        startup-hooks))
            ;; Verify that the file matches the buffer
            (emerge-verify-file-buffer))))
@@ -584,48 +566,49 @@ This is *not* a user option, since Emerge uses it for its own processing.")
          ;; create the merge buffer from buffer A, so it inherits buffer A's
          ;; default directory, etc.
          (merge-buffer (with-current-buffer
-                        buffer-A
-                        (get-buffer-create merge-buffer-name))))
+                           buffer-A
+                         (get-buffer-create merge-buffer-name))))
     (with-current-buffer
-     merge-buffer
-     (emerge-copy-modes buffer-A)
-     (setq buffer-read-only nil)
-     (auto-save-mode 1)
-     (setq emerge-mode t)
-     (setq emerge-A-buffer buffer-A)
-     (setq emerge-B-buffer buffer-B)
-     (setq emerge-ancestor-buffer nil)
-     (setq emerge-merge-buffer merge-buffer)
-     (setq emerge-output-description
-           (if output-file
-               (concat "Output to file: " output-file)
-             (concat "Output to buffer: " (buffer-name merge-buffer))))
-     (save-excursion (insert-buffer-substring emerge-A-buffer))
-     (emerge-set-keys)
-     (setq emerge-difference-list (emerge-make-diff-list file-A file-B))
-     (setq emerge-number-of-differences (length emerge-difference-list))
-     (setq emerge-current-difference -1)
-     (setq emerge-quit-hook quit-hooks)
-     (emerge-remember-buffer-characteristics)
-     (emerge-handle-local-variables))
+        merge-buffer
+      (emerge-copy-modes buffer-A)
+      (setq buffer-read-only nil)
+      (auto-save-mode 1)
+      (setq emerge-mode t)
+      (setq emerge-A-buffer buffer-A)
+      (setq emerge-B-buffer buffer-B)
+      (setq emerge-ancestor-buffer nil)
+      (setq emerge-merge-buffer merge-buffer)
+      (setq emerge-output-description
+            (if output-file
+                (concat "Output to file: " output-file)
+              (concat "Output to buffer: " (buffer-name merge-buffer))))
+      (save-excursion (insert-buffer-substring emerge-A-buffer))
+      (emerge-set-keys)
+      (setq emerge-difference-list (emerge-make-diff-list file-A file-B))
+      (setq emerge-number-of-differences (length emerge-difference-list))
+      (setq emerge-current-difference -1)
+      (setq emerge-quit-hook quit-hooks)
+      (emerge-remember-buffer-characteristics)
+      (emerge-handle-local-variables))
     (emerge-setup-windows buffer-A buffer-B merge-buffer t)
     (with-current-buffer merge-buffer
-                           (run-hooks 'startup-hooks 'emerge-startup-hook)
-                           (setq buffer-read-only t))))
+      (mapc #'funcall startup-hooks)
+      (run-hooks 'emerge-startup-hook)
+      (setq buffer-read-only t))))
 
 ;; Generate the Emerge difference list between two files
 (defun emerge-make-diff-list (file-A file-B)
   (setq emerge-diff-buffer (get-buffer-create "*emerge-diff*"))
   (with-current-buffer
-   emerge-diff-buffer
-   (erase-buffer)
-   (shell-command
-    (format "%s %s %s %s"
-            (shell-quote-argument emerge-diff-program)
-            emerge-diff-options
-            (shell-quote-argument file-A)
-            (shell-quote-argument file-B))
-    t))
+      emerge-diff-buffer
+    (erase-buffer)
+    (shell-command
+     (format "%s %s %s %s"
+             (shell-quote-argument emerge-diff-program)
+             emerge-diff-options
+             (shell-quote-argument file-A)
+             (shell-quote-argument file-B))
+     t))
   (emerge-prepare-error-list emerge-diff-ok-lines-regexp)
   (emerge-convert-diffs-to-markers
    emerge-A-buffer emerge-B-buffer emerge-merge-buffer
@@ -711,7 +694,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
        (if temp
            (setq file-A temp
                  startup-hooks
-                 (cons `(lambda () (delete-file ,file-A))
+                 (cons (lambda () (delete-file file-A))
                        startup-hooks))
            ;; Verify that the file matches the buffer
            (emerge-verify-file-buffer))))
@@ -722,7 +705,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
        (if temp
            (setq file-B temp
                  startup-hooks
-                 (cons `(lambda () (delete-file ,file-B))
+                 (cons (lambda () (delete-file file-B))
                        startup-hooks))
            ;; Verify that the file matches the buffer
            (emerge-verify-file-buffer))))
@@ -733,7 +716,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
        (if temp
            (setq file-ancestor temp
                  startup-hooks
-                 (cons `(lambda () (delete-file ,file-ancestor))
+                 (cons (lambda () (delete-file file-ancestor))
                        startup-hooks))
            ;; Verify that the file matches the buffer
            (emerge-verify-file-buffer))))
@@ -746,6 +729,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
                                             buffer-ancestor file-ancestor
                                             &optional startup-hooks quit-hooks
                                             output-file)
+  ;; FIXME: Duplicated code!
   (setq file-A (expand-file-name file-A))
   (setq file-B (expand-file-name file-B))
   (setq file-ancestor (expand-file-name file-ancestor))
@@ -754,36 +738,37 @@ This is *not* a user option, since Emerge uses it for its own processing.")
          ;; create the merge buffer from buffer A, so it inherits buffer A's
          ;; default directory, etc.
          (merge-buffer (with-current-buffer
-                        buffer-A
-                        (get-buffer-create merge-buffer-name))))
+                           buffer-A
+                         (get-buffer-create merge-buffer-name))))
     (with-current-buffer
-     merge-buffer
-     (emerge-copy-modes buffer-A)
-     (setq buffer-read-only nil)
-     (auto-save-mode 1)
-     (setq emerge-mode t)
-     (setq emerge-A-buffer buffer-A)
-     (setq emerge-B-buffer buffer-B)
-     (setq emerge-ancestor-buffer buffer-ancestor)
-     (setq emerge-merge-buffer merge-buffer)
-     (setq emerge-output-description
-           (if output-file
-               (concat "Output to file: " output-file)
-             (concat "Output to buffer: " (buffer-name merge-buffer))))
-     (save-excursion (insert-buffer-substring emerge-A-buffer))
-     (emerge-set-keys)
-     (setq emerge-difference-list
-           (emerge-make-diff3-list file-A file-B file-ancestor))
-     (setq emerge-number-of-differences (length emerge-difference-list))
-     (setq emerge-current-difference -1)
-     (setq emerge-quit-hook quit-hooks)
-     (emerge-remember-buffer-characteristics)
-     (emerge-select-prefer-Bs)
-     (emerge-handle-local-variables))
+        merge-buffer
+      (emerge-copy-modes buffer-A)
+      (setq buffer-read-only nil)
+      (auto-save-mode 1)
+      (setq emerge-mode t)
+      (setq emerge-A-buffer buffer-A)
+      (setq emerge-B-buffer buffer-B)
+      (setq emerge-ancestor-buffer buffer-ancestor)
+      (setq emerge-merge-buffer merge-buffer)
+      (setq emerge-output-description
+            (if output-file
+                (concat "Output to file: " output-file)
+              (concat "Output to buffer: " (buffer-name merge-buffer))))
+      (save-excursion (insert-buffer-substring emerge-A-buffer))
+      (emerge-set-keys)
+      (setq emerge-difference-list
+            (emerge-make-diff3-list file-A file-B file-ancestor))
+      (setq emerge-number-of-differences (length emerge-difference-list))
+      (setq emerge-current-difference -1)
+      (setq emerge-quit-hook quit-hooks)
+      (emerge-remember-buffer-characteristics)
+      (emerge-select-prefer-Bs)
+      (emerge-handle-local-variables))
     (emerge-setup-windows buffer-A buffer-B merge-buffer t)
     (with-current-buffer merge-buffer
-                           (run-hooks 'startup-hooks 'emerge-startup-hook)
-                           (setq buffer-read-only t))))
+      (mapc #'funcall startup-hooks)
+      (run-hooks 'emerge-startup-hook)
+      (setq buffer-read-only t))))
 
 ;; Generate the Emerge difference list between two files with an ancestor
 (defun emerge-make-diff3-list (file-A file-B file-ancestor)
@@ -872,7 +857,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
                 (emerge-read-file-name "Output file" emerge-last-dir-output
                                        f f nil)))))
   (if file-out
-      (add-hook 'quit-hooks `(lambda () (emerge-files-exit ,file-out))))
+      (push (lambda () (emerge-files-exit file-out)) quit-hooks))
   (emerge-files-internal
    file-A file-B startup-hooks
    quit-hooks
@@ -894,7 +879,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
                 (emerge-read-file-name "Output file" emerge-last-dir-output
                                        f f nil)))))
   (if file-out
-      (add-hook 'quit-hooks `(lambda () (emerge-files-exit ,file-out))))
+      (push (lambda () (emerge-files-exit file-out)) quit-hooks))
   (emerge-files-with-ancestor-internal
    file-A file-B file-ancestor startup-hooks
    quit-hooks
@@ -922,9 +907,9 @@ This is *not* a user option, since Emerge uses it for its own processing.")
      (write-region (point-min) (point-max) emerge-file-B nil 'no-message))
     (emerge-setup (get-buffer buffer-A) emerge-file-A
                   (get-buffer buffer-B) emerge-file-B
-                  (cons `(lambda ()
-                          (delete-file ,emerge-file-A)
-                          (delete-file ,emerge-file-B))
+                  (cons (lambda ()
+                          (delete-file emerge-file-A)
+                          (delete-file emerge-file-B))
                         startup-hooks)
                   quit-hooks
                   nil)))
@@ -953,11 +938,10 @@ This is *not* a user option, since Emerge uses it for its own processing.")
                                 (get-buffer buffer-B) emerge-file-B
                                 (get-buffer buffer-ancestor)
                                 emerge-file-ancestor
-                                (cons `(lambda ()
-                                        (delete-file ,emerge-file-A)
-                                        (delete-file ,emerge-file-B)
-                                        (delete-file
-                                         ,emerge-file-ancestor))
+                                (cons (lambda ()
+                                        (delete-file emerge-file-A)
+                                        (delete-file emerge-file-B)
+                                        (delete-file emerge-file-ancestor))
                                       startup-hooks)
                                 quit-hooks
                                 nil)))
@@ -972,7 +956,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
     (setq command-line-args-left (nthcdr 3 command-line-args-left))
     (emerge-files-internal
      file-a file-b nil
-     (list `(lambda () (emerge-command-exit ,file-out))))))
+     (list (lambda () (emerge-command-exit file-out))))))
 
 ;;;###autoload
 (defun emerge-files-with-ancestor-command ()
@@ -994,7 +978,7 @@ This is *not* a user option, since Emerge uses it for its own processing.")
         (setq command-line-args-left (nthcdr 4 command-line-args-left)))
     (emerge-files-with-ancestor-internal
      file-a file-b file-anc nil
-     (list `(lambda () (emerge-command-exit ,file-out))))))
+     (list (lambda () (emerge-command-exit file-out))))))
 
 (defun emerge-command-exit (file-out)
   (emerge-write-and-delete file-out)
@@ -1007,7 +991,8 @@ This is *not* a user option, since Emerge uses it for its own processing.")
   (setq emerge-file-out file-out)
   (emerge-files-internal
    file-a file-b nil
-   (list `(lambda () (emerge-remote-exit ,file-out ',emerge-exit-func)))
+   (let ((f emerge-exit-func))
+     (list (lambda () (emerge-remote-exit file-out f))))
    file-out)
   (throw 'client-wait nil))
 
@@ -1016,14 +1001,15 @@ This is *not* a user option, since Emerge uses it for its own processing.")
   (setq emerge-file-out file-out)
   (emerge-files-with-ancestor-internal
    file-a file-b file-anc nil
-   (list `(lambda () (emerge-remote-exit ,file-out ',emerge-exit-func)))
+   (let ((f emerge-exit-func))
+     (list (lambda () (emerge-remote-exit file-out f))))
    file-out)
   (throw 'client-wait nil))
 
-(defun emerge-remote-exit (file-out emerge-exit-func)
+(defun emerge-remote-exit (file-out exit-func)
   (emerge-write-and-delete file-out)
   (kill-buffer emerge-merge-buffer)
-  (funcall emerge-exit-func (if emerge-prefix-argument 1 0)))
+  (funcall exit-func (if emerge-prefix-argument 1 0)))
 
 ;;; Functions to start Emerge on RCS versions
 
@@ -1041,10 +1027,9 @@ This is *not* a user option, since Emerge uses it for its own processing.")
   (emerge-revisions-internal
    file revision-A revision-B startup-hooks
    (if arg
-       (cons `(lambda ()
-               (shell-command
-                ,(format "%s %s" emerge-rcs-ci-program file)))
-             quit-hooks)
+       (let ((cmd (format "%s %s" emerge-rcs-ci-program file)))
+         (cons (lambda () (shell-command cmd))
+               quit-hooks))
        quit-hooks)))
 
 ;;;###autoload
@@ -1065,12 +1050,10 @@ This is *not* a user option, since Emerge uses it for its own processing.")
   (emerge-revision-with-ancestor-internal
    file revision-A revision-B ancestor startup-hooks
    (if arg
-       (let ((cmd ))
-         (cons `(lambda ()
-                 (shell-command
-                  ,(format "%s %s" emerge-rcs-ci-program file)))
+       (let ((cmd (format "%s %s" emerge-rcs-ci-program file)))
+         (cons (lambda () (shell-command cmd))
                quit-hooks))
-       quit-hooks)))
+     quit-hooks)))
 
 (defun emerge-revisions-internal (file revision-A revision-B &optional
                                   startup-hooks quit-hooks _output-file)
@@ -1098,11 +1081,11 @@ This is *not* a user option, since Emerge uses it for its own processing.")
     ;; Do the merge
     (emerge-setup buffer-A emerge-file-A
                   buffer-B emerge-file-B
-                  (cons `(lambda ()
-                          (delete-file ,emerge-file-A)
-                          (delete-file ,emerge-file-B))
+                  (cons (lambda ()
+                          (delete-file emerge-file-A)
+                          (delete-file emerge-file-B))
                         startup-hooks)
-                  (cons `(lambda () (emerge-files-exit ,file))
+                  (cons (lambda () (emerge-files-exit file))
                         quit-hooks)
                   nil)))
 
@@ -1146,12 +1129,12 @@ This is *not* a user option, since Emerge uses it for its own processing.")
     (emerge-setup-with-ancestor
      buffer-A emerge-file-A buffer-B emerge-file-B
      buffer-ancestor emerge-ancestor
-     (cons `(lambda ()
-             (delete-file ,emerge-file-A)
-             (delete-file ,emerge-file-B)
-             (delete-file ,emerge-ancestor))
+     (cons (lambda ()
+             (delete-file emerge-file-A)
+             (delete-file emerge-file-B)
+             (delete-file emerge-ancestor))
            startup-hooks)
-     (cons `(lambda () (emerge-files-exit ,file))
+     (cons (lambda () (emerge-files-exit file))
            quit-hooks)
      output-file)))
 
@@ -1233,20 +1216,20 @@ Otherwise, the A or B file present is copied to the output file."
                                    file-ancestor file-out
                                    nil
                                    ;; When done, return to this buffer.
-                                   (list
-                                    `(lambda ()
-                                      (switch-to-buffer ,(current-buffer))
-                                      (message "Merge done.")))))
+                                   (let ((buf (current-buffer)))
+                                     (list (lambda ()
+                                             (switch-to-buffer buf)
+                                             (message "Merge done"))))))
       ;; Merge of two files without ancestor
       ((and file-A file-B)
        (message "Merging %s and %s..." file-A file-B)
        (emerge-files (not (not file-out)) file-A file-B file-out
                      nil
                      ;; When done, return to this buffer.
-                     (list
-                      `(lambda ()
-                        (switch-to-buffer ,(current-buffer))
-                        (message "Merge done.")))))
+                      (let ((buf (current-buffer)))
+                     (list (lambda ()
+                             (switch-to-buffer buf)
+                             (message "Merge done"))))))
       ;; There is an output file (or there would have been an error above),
       ;; but only one input file.
       ;; The file appears to have been deleted in one version; do nothing.
@@ -1456,9 +1439,8 @@ These characteristics are restored by `emerge-restore-buffer-characteristics'."
                                         merge-buffer
                                         lineno-list)
   (let* (marker-list
-         (A-point-min (with-current-buffer A-buffer (point-min)))
-         (offset (1- A-point-min))
-         (B-point-min (with-current-buffer B-buffer (point-min)))
+         (offset (with-current-buffer A-buffer
+                   (- (point-min) (save-restriction (widen) (point-min)))))
          ;; Record current line number in each buffer
          ;; so we don't have to count from the beginning.
          (a-line 1)
@@ -1480,17 +1462,17 @@ These characteristics are restored by `emerge-restore-buffer-characteristics'."
              (state (aref list-element 4)))
         ;; place markers at the appropriate places in the buffers
         (with-current-buffer
-         A-buffer
-         (setq a-line (emerge-goto-line a-begin a-line))
-         (setq a-begin-marker (point-marker))
-         (setq a-line (emerge-goto-line a-end a-line))
-         (setq a-end-marker (point-marker)))
+            A-buffer
+          (setq a-line (emerge-goto-line a-begin a-line))
+          (setq a-begin-marker (point-marker))
+          (setq a-line (emerge-goto-line a-end a-line))
+          (setq a-end-marker (point-marker)))
         (with-current-buffer
-         B-buffer
-         (setq b-line (emerge-goto-line b-begin b-line))
-         (setq b-begin-marker (point-marker))
-         (setq b-line (emerge-goto-line b-end b-line))
-         (setq b-end-marker (point-marker)))
+            B-buffer
+          (setq b-line (emerge-goto-line b-begin b-line))
+          (setq b-begin-marker (point-marker))
+          (setq b-line (emerge-goto-line b-end b-line))
+          (setq b-end-marker (point-marker)))
         (setq merge-begin-marker (set-marker
                                   (make-marker)
                                   (- (marker-position a-begin-marker)
@@ -1502,15 +1484,15 @@ These characteristics are restored by `emerge-restore-buffer-characteristics'."
                                    offset)
                                 merge-buffer))
         ;; record all the markers for this difference
-        (setq marker-list (cons (vector a-begin-marker a-end-marker
-                                        b-begin-marker b-end-marker
-                                        merge-begin-marker merge-end-marker
-                                        state)
-                                marker-list)))
+        (push (vector a-begin-marker a-end-marker
+                      b-begin-marker b-end-marker
+                      merge-begin-marker merge-end-marker
+                      state)
+              marker-list))
       (setq lineno-list (cdr lineno-list)))
     ;; convert the list of difference information into a vector for
     ;; fast access
-    (setq emerge-difference-list (apply 'vector (nreverse marker-list)))))
+    (setq emerge-difference-list (apply #'vector (nreverse marker-list)))))
 
 ;; If we have an ancestor, select all B variants that we prefer
 (defun emerge-select-prefer-Bs ()
@@ -1636,7 +1618,7 @@ the height of the merge window.
 `C-u -' alone as argument scrolls half the height of the merge window."
   (interactive "P")
   (emerge-operate-on-windows
-   'scroll-up
+   #'scroll-up
    ;; calculate argument to scroll-up
    ;; if there is an explicit argument
    (if (and arg (not (equal arg '-)))
@@ -1663,7 +1645,7 @@ the height of the merge window.
 `C-u -' alone as argument scrolls half the height of the merge window."
   (interactive "P")
   (emerge-operate-on-windows
-   'scroll-down
+   #'scroll-down
    ;; calculate argument to scroll-down
    ;; if there is an explicit argument
    (if (and arg (not (equal arg '-)))
@@ -1690,7 +1672,7 @@ the width of the A and B windows.  `C-u -' alone as argument scrolls half the
 width of the A and B windows."
   (interactive "P")
   (emerge-operate-on-windows
-   'scroll-left
+   #'scroll-left
    ;; calculate argument to scroll-left
    ;; if there is an explicit argument
    (if (and arg (not (equal arg '-)))
@@ -1718,7 +1700,7 @@ the width of the A and B windows.  `C-u -' alone as argument scrolls half the
 width of the A and B windows."
   (interactive "P")
   (emerge-operate-on-windows
-   'scroll-right
+   #'scroll-right
    ;; calculate argument to scroll-right
    ;; if there is an explicit argument
    (if (and arg (not (equal arg '-)))
@@ -1745,18 +1727,18 @@ This resets the horizontal scrolling of all three merge buffers
 to the left margin, if they are in windows."
   (interactive)
   (emerge-operate-on-windows
-   (lambda (x) (set-window-hscroll (selected-window) 0))
+   (lambda (_) (set-window-hscroll (selected-window) 0))
    nil))
 
-;; Attempt to show the region nicely.
-;; If there are min-lines lines above and below the region, then don't do
-;; anything.
-;; If not, recenter the region to make it so.
-;; If that isn't possible, remove context lines evenly from top and bottom
-;; so the entire region shows.
-;; If that isn't possible, show the top of the region.
-;; BEG must be at the beginning of a line.
 (defun emerge-position-region (beg end pos)
+  "Attempt to show the region nicely.
+If there are min-lines lines above and below the region, then don't do
+anything.
+If not, recenter the region to make it so.
+If that isn't possible, remove context lines evenly from top and bottom
+so the entire region shows.
+If that isn't possible, show the top of the region.
+BEG must be at the beginning of a line."
   ;; First test whether the entire region is visible with
   ;; emerge-min-visible-lines above and below it
   (if (not (and (<= (progn
@@ -1795,7 +1777,7 @@ to the left margin, if they are in windows."
                     (memq (aref (aref emerge-difference-list n) 6)
                           '(prefer-A prefer-B)))
           (setq n (1+ n)))
-        (let ((buffer-read-only nil))
+        (let ((inhibit-read-only t))
           (emerge-unselect-and-select-difference n)))
     (error "At end")))
 
@@ -1809,14 +1791,14 @@ to the left margin, if they are in windows."
                     (memq (aref (aref emerge-difference-list n) 6)
                           '(prefer-A prefer-B)))
           (setq n (1- n)))
-        (let ((buffer-read-only nil))
+        (let ((inhibit-read-only t))
           (emerge-unselect-and-select-difference n)))
     (error "At beginning")))
 
 (defun emerge-jump-to-difference (difference-number)
   "Go to the N-th difference."
   (interactive "p")
-  (let ((buffer-read-only nil))
+  (let ((inhibit-read-only t))
     (setq difference-number (1- difference-number))
     (if (and (>= difference-number -1)
              (< difference-number (1+ emerge-number-of-differences)))
@@ -1878,6 +1860,13 @@ buffer after this will cause serious problems."
   (let ((emerge-prefix-argument arg))
     (run-hooks 'emerge-quit-hook)))
 
+(defmacro emerge--current-beg (diff-vector side)
+  ;; +1 because emerge-place-flags-in-buffer1 moved the marker by 1.
+  `(1+ (aref ,diff-vector ,(pcase-exhaustive side ('A 0) ('B 2) ('merge 4)))))
+(defmacro emerge--current-end (diff-vector side)
+  ;; -1 because emerge-place-flags-in-buffer1 moved the marker by 1.
+  `(1- (aref ,diff-vector ,(pcase-exhaustive side ('A 1) ('B 3) ('merge 5)))))
+
 (defun emerge-select-A (&optional force)
   "Select the A variant of this difference.
 Refuses to function if this difference has been edited, i.e., if it
@@ -1885,26 +1874,25 @@ is neither the A nor the B variant.
 A prefix argument forces the variant to be selected
 even if the difference has been edited."
   (interactive "P")
-  (let ((operate
-         (lambda ()
-           (emerge-select-A-edit merge-begin merge-end A-begin A-end)
-           (if emerge-auto-advance
-               (emerge-next-difference))))
+  (let ((operate #'emerge-select-A-edit)
         (operate-no-change
-         (lambda () (if emerge-auto-advance
-                        (emerge-next-difference)))))
+         (lambda (_diff-vector)
+           (if emerge-auto-advance (emerge-next-difference)))))
     (emerge-select-version force operate-no-change operate operate)))
 
 ;; Actually select the A variant
-(defun emerge-select-A-edit (merge-begin merge-end A-begin A-end)
+(defun emerge-select-A-edit (diff-vector)
   (with-current-buffer
-   emerge-merge-buffer
-   (delete-region merge-begin merge-end)
-   (goto-char merge-begin)
-   (insert-buffer-substring emerge-A-buffer A-begin A-end)
-   (goto-char merge-begin)
-   (aset diff-vector 6 'A)
-   (emerge-refresh-mode-line)))
+      emerge-merge-buffer
+    (goto-char (emerge--current-beg diff-vector merge))
+    (delete-region (point) (emerge--current-end diff-vector merge))
+    (save-excursion
+      (insert-buffer-substring emerge-A-buffer
+                               (emerge--current-beg diff-vector A)
+                               (emerge--current-end diff-vector A)))
+    (aset diff-vector 6 'A)
+    (emerge-refresh-mode-line)
+    (if emerge-auto-advance (emerge-next-difference))))
 
 (defun emerge-select-B (&optional force)
   "Select the B variant of this difference.
@@ -1913,26 +1901,25 @@ is neither the A nor the B variant.
 A prefix argument forces the variant to be selected
 even if the difference has been edited."
   (interactive "P")
-  (let ((operate
-         (lambda ()
-           (emerge-select-B-edit merge-begin merge-end B-begin B-end)
-           (if emerge-auto-advance
-               (emerge-next-difference))))
+  (let ((operate #'emerge-select-B-edit)
         (operate-no-change
-         (lambda () (if emerge-auto-advance
-                        (emerge-next-difference)))))
+         (lambda (_diff-vector)
+           (if emerge-auto-advance (emerge-next-difference)))))
     (emerge-select-version force operate operate-no-change operate)))
 
 ;; Actually select the B variant
-(defun emerge-select-B-edit (merge-begin merge-end B-begin B-end)
+(defun emerge-select-B-edit (diff-vector)
   (with-current-buffer
-   emerge-merge-buffer
-   (delete-region merge-begin merge-end)
-   (goto-char merge-begin)
-   (insert-buffer-substring emerge-B-buffer B-begin B-end)
-   (goto-char merge-begin)
-   (aset diff-vector 6 'B)
-   (emerge-refresh-mode-line)))
+      emerge-merge-buffer
+    (goto-char (emerge--current-beg diff-vector merge))
+    (delete-region (point) (emerge--current-end diff-vector merge))
+    (save-excursion
+      (insert-buffer-substring emerge-B-buffer
+                               (emerge--current-beg diff-vector B)
+                               (emerge--current-end diff-vector B)))
+    (aset diff-vector 6 'B)
+    (emerge-refresh-mode-line)
+    (if emerge-auto-advance (emerge-next-difference))))
 
 (defun emerge-default-A ()
   "Make the A variant the default from here down.
@@ -1940,7 +1927,7 @@ This selects the A variant for all differences from here down in the buffer
 which are still defaulted, i.e., which the user has not selected and for
 which there is no preference."
   (interactive)
-  (let ((buffer-read-only nil))
+  (let ((inhibit-read-only t))
     (let ((selected-difference emerge-current-difference)
           (n (max emerge-current-difference 0)))
       (while (< n emerge-number-of-differences)
@@ -1962,7 +1949,7 @@ This selects the B variant for all differences from here down in the buffer
 which are still defaulted, i.e., which the user has not selected and for
 which there is no preference."
   (interactive)
-  (let ((buffer-read-only nil))
+  (let ((inhibit-read-only t))
     (let ((selected-difference emerge-current-difference)
           (n (max emerge-current-difference 0)))
       (while (< n emerge-number-of-differences)
@@ -2071,7 +2058,7 @@ With prefix argument, puts point before, mark after."
          (A-begin (1+ (aref diff-vector 0)))
          (A-end (1- (aref diff-vector 1)))
          (opoint (point))
-         (buffer-read-only nil))
+         (inhibit-read-only t))
     (insert-buffer-substring emerge-A-buffer A-begin A-end)
     (if (not arg)
         (set-mark opoint)
@@ -2089,7 +2076,7 @@ With prefix argument, puts point before, mark after."
          (B-begin (1+ (aref diff-vector 2)))
          (B-end (1- (aref diff-vector 3)))
          (opoint (point))
-         (buffer-read-only nil))
+         (inhibit-read-only t))
     (insert-buffer-substring emerge-B-buffer B-begin B-end)
     (if (not arg)
         (set-mark opoint)
@@ -2450,28 +2437,28 @@ the nearest previous difference."
            (1- index)
          (error "No difference contains or precedes point")))))))
 
+(defvar emerge-line-diff)
+
 (defun emerge-line-numbers ()
   "Display the current line numbers.
 This function displays the line numbers of the points in the A, B, and
 merge buffers."
   (interactive)
   (let* ((valid-diff
-         (and (>= emerge-current-difference 0)
-              (< emerge-current-difference emerge-number-of-differences)))
+          (and (>= emerge-current-difference 0)
+               (< emerge-current-difference emerge-number-of-differences)))
          (emerge-line-diff (and valid-diff
                                 (aref emerge-difference-list
                                       emerge-current-difference)))
-         (merge-line (emerge-line-number-in-buf 4 5))
+         (merge-line (emerge-line-number-in-buf valid-diff 4 5))
          (A-line (with-current-buffer emerge-A-buffer
-                                        (emerge-line-number-in-buf 0 1)))
+                   (emerge-line-number-in-buf valid-diff 0 1)))
          (B-line (with-current-buffer emerge-B-buffer
-                                        (emerge-line-number-in-buf 2 3))))
+                   (emerge-line-number-in-buf valid-diff 2 3))))
     (message "At lines: merge = %d, A = %d, B = %d"
              merge-line A-line B-line)))
 
-(defvar emerge-line-diff)
-
-(defun emerge-line-number-in-buf (begin-marker end-marker)
+(defun emerge-line-number-in-buf (valid-diff begin-marker end-marker)
   ;; FIXME point-min rather than 1? widen?
   (let ((temp (1+ (count-lines 1 (line-beginning-position)))))
     (if valid-diff
@@ -2537,46 +2524,41 @@ Interactively, reads the register using `register-read-with-preview'."
         (error "Register does not contain text"))
     (emerge-combine-versions-internal template force)))
 
-(defun emerge-combine-versions-internal (emerge-combine-template force)
-  (let ((operate
-         (lambda ()
-           (emerge-combine-versions-edit merge-begin merge-end
-                                         A-begin A-end B-begin B-end)
-           (if emerge-auto-advance
-               (emerge-next-difference)))))
+(defun emerge-combine-versions-internal (combine-template force)
+  (let ((operate (lambda (diff-vector)
+                   (emerge-combine-versions-edit diff-vector
+                                                 combine-template))))
     (emerge-select-version force operate operate operate)))
 
-(defvar emerge-combine-template)
-
-(defun emerge-combine-versions-edit (merge-begin merge-end
-                                     A-begin A-end B-begin B-end)
+(defun emerge-combine-versions-edit (diff-vector combine-template)
   (with-current-buffer
-   emerge-merge-buffer
-   (delete-region merge-begin merge-end)
-   (goto-char merge-begin)
-   (let ((i 0))
-     (while (< i (length emerge-combine-template))
-       (let ((c (aref emerge-combine-template i)))
-         (if (= c ?%)
-             (progn
-               (setq i (1+ i))
-               (setq c
-                     (condition-case nil
-                         (aref emerge-combine-template i)
-                       (error ?%)))
-               (cond ((= c ?a)
-                      (insert-buffer-substring emerge-A-buffer A-begin A-end))
-                     ((= c ?b)
-                      (insert-buffer-substring emerge-B-buffer B-begin B-end))
-                     ((= c ?%)
-                      (insert ?%))
-                     (t
-                      (insert c))))
-           (insert c)))
-       (setq i (1+ i))))
-   (goto-char merge-begin)
-   (aset diff-vector 6 'combined)
-   (emerge-refresh-mode-line)))
+      emerge-merge-buffer
+    (goto-char (emerge--current-beg diff-vector merge))
+    (delete-region (point) (emerge--current-end diff-vector merge))
+    (save-excursion
+      (let ((i 0))
+        (while (< i (length combine-template))
+          (let ((c (aref combine-template i)))
+            (if (not (= c ?%))
+                (insert c)
+              (setq i (1+ i))
+              (pcase (condition-case nil
+                         (aref combine-template i)
+                       (error ?%))
+                (?a
+                 (insert-buffer-substring emerge-A-buffer
+                                          (emerge--current-beg diff-vector A)
+                                          (emerge--current-end diff-vector A)))
+                (?b
+                 (insert-buffer-substring emerge-B-buffer
+                                          (emerge--current-beg diff-vector B)
+                                          (emerge--current-end diff-vector B)))
+                (?% (insert ?%))
+                (c (insert c)))))
+          (setq i (1+ i)))))
+    (aset diff-vector 6 'combined)
+    (emerge-refresh-mode-line)
+    (if emerge-auto-advance (emerge-next-difference))))
 
 (defun emerge-set-merge-mode (mode)
   "Set the major mode in a merge buffer.
@@ -2617,7 +2599,7 @@ keymap.  Leaves merge in fast mode."
     (emerge-place-flags-in-buffer1 difference before-index after-index)))
 
 (defun emerge-place-flags-in-buffer1 (difference before-index after-index)
-  (let ((buffer-read-only nil))
+  (let ((inhibit-read-only t))
     ;; insert the flag before the difference
     (let ((before (aref (aref emerge-globalized-difference-list difference)
                         before-index))
@@ -2682,7 +2664,7 @@ keymap.  Leaves merge in fast mode."
 (defun emerge-remove-flags-in-buffer (buffer before after)
   (with-current-buffer
    buffer
-   (let ((buffer-read-only nil))
+   (let ((inhibit-read-only t))
      ;; remove the flags, if they're there
      (goto-char (- before (1- emerge-before-flag-length)))
      (if (looking-at emerge-before-flag-match)
@@ -2717,18 +2699,18 @@ keymap.  Leaves merge in fast mode."
         (emerge-recenter)
         (emerge-refresh-mode-line))))
 
-;; Perform tests to see whether user should be allowed to select a version
-;; of this difference:
-;;   a valid difference has been selected; and
-;;   the difference text in the merge buffer is:
-;;     the A version (execute a-version), or
-;;     the B version (execute b-version), or
-;;     empty (execute neither-version), or
-;;     argument FORCE is true (execute neither-version)
-;; Otherwise, signal an error.
 (defun emerge-select-version (force a-version b-version neither-version)
+  "Perform tests to see whether user should be allowed to select a version
+of this difference:
+  a valid difference has been selected; and
+  the difference text in the merge buffer is:
+    the A version (execute a-version), or
+    the B version (execute b-version), or
+    empty (execute neither-version), or
+    argument FORCE is true (execute neither-version)
+Otherwise, signal an error."
   (emerge-validate-difference)
-  (let ((buffer-read-only nil))
+  (let ((inhibit-read-only t))
     (let* ((diff-vector
             (aref emerge-difference-list emerge-current-difference))
            (A-begin (1+ (aref diff-vector 0)))
@@ -2740,13 +2722,13 @@ keymap.  Leaves merge in fast mode."
       (if (emerge-compare-buffers emerge-A-buffer A-begin A-end
                                   emerge-merge-buffer merge-begin
                                   merge-end)
-          (funcall a-version)
+          (funcall a-version diff-vector)
         (if (emerge-compare-buffers emerge-B-buffer B-begin B-end
                                     emerge-merge-buffer merge-begin
                                     merge-end)
-            (funcall b-version)
+            (funcall b-version diff-vector)
           (if (or force (= merge-begin merge-end))
-              (funcall neither-version)
+              (funcall neither-version diff-vector)
             (error "This difference region has been edited")))))))
 
 ;; Read a file name, handling all of the various defaulting rules.
@@ -2972,78 +2954,6 @@ If some prefix of KEY has a non-prefix definition, it is redefined."
   ;; Now define the key
   (define-key keymap key definition))
 
-;;;;; Improvements to describe-mode, so that it describes minor modes as well
-;;;;; as the major mode
-;;(defun describe-mode (&optional minor)
-;;  "Display documentation of current major mode.
-;;If optional arg MINOR is non-nil (or prefix argument is given if interactive),
-;;display documentation of active minor modes as well.
-;;For this to work correctly for a minor mode, the mode's indicator variable
-;;\(listed in `minor-mode-alist') must also be a function whose documentation
-;;describes the minor mode."
-;;  (interactive)
-;;  (with-output-to-temp-buffer "*Help*"
-;;    (princ mode-name)
-;;    (princ " Mode:\n")
-;;    (princ (documentation major-mode))
-;;    (let ((minor-modes minor-mode-alist)
-;;        (locals (buffer-local-variables)))
-;;      (while minor-modes
-;;      (let* ((minor-mode (car (car minor-modes)))
-;;             (indicator (car (cdr (car minor-modes))))
-;;             (local-binding (assq minor-mode locals)))
-;;        ;; Document a minor mode if it is listed in minor-mode-alist,
-;;        ;; bound locally in this buffer, non-nil, and has a function
-;;        ;; definition.
-;;        (if (and local-binding
-;;                 (cdr local-binding)
-;;                 (fboundp minor-mode))
-;;            (progn
-;;              (princ (format "\n\n\n%s minor mode (indicator%s):\n"
-;;                             minor-mode indicator))
-;;              (princ (documentation minor-mode)))))
-;;      (setq minor-modes (cdr minor-modes))))
-;;    (with-current-buffer standard-output
-;;      (help-mode))
-;;    (help-print-return-message)))
-
-;; This goes with the redefinition of describe-mode.
-;;;; Adjust things so that keyboard macro definitions are documented correctly.
-;;(fset 'defining-kbd-macro (symbol-function 'start-kbd-macro))
-
-;; substitute-key-definition should work now.
-;;;; Function to shadow a definition in a keymap with definitions in another.
-;;(defun emerge-shadow-key-definition (olddef newdef keymap shadowmap)
-;;  "Shadow OLDDEF with NEWDEF for any keys in KEYMAP with entries in SHADOWMAP.
-;;In other words, SHADOWMAP will now shadow all definitions of OLDDEF in KEYMAP
-;;with NEWDEF.  Does not affect keys that are already defined in SHADOWMAP,
-;;including those whose definition is OLDDEF."
-;;  ;; loop through all keymaps accessible from keymap
-;;  (let ((maps (accessible-keymaps keymap)))
-;;    (while maps
-;;      (let ((prefix (car (car maps)))
-;;          (map (cdr (car maps))))
-;;      ;; examine a keymap
-;;      (if (arrayp map)
-;;          ;; array keymap
-;;          (let ((len (length map))
-;;                (i 0))
-;;            (while (< i len)
-;;              (if (eq (aref map i) olddef)
-;;                  ;; set the shadowing definition
-;;                  (let ((key (concat prefix (char-to-string i))))
-;;                    (emerge-define-key-if-possible shadowmap key newdef)))
-;;              (setq i (1+ i))))
-;;        ;; sparse keymap
-;;        (while map
-;;          (if (eq (cdr-safe (car-safe map)) olddef)
-;;              ;; set the shadowing definition
-;;              (let ((key
-;;                     (concat prefix (char-to-string (car (car map))))))
-;;                    (emerge-define-key-if-possible shadowmap key newdef)))
-;;          (setq map (cdr map)))))
-;;      (setq maps (cdr maps)))))
-
 ;; Define a key if it (or a prefix) is not already defined in the map.
 (defun emerge-define-key-if-possible (keymap key definition)
   ;; look up the present definition of the key
@@ -3057,18 +2967,6 @@ If some prefix of KEY has a non-prefix definition, it is redefined."
       (if (not present)
           (define-key keymap key definition)))))
 
-;; Ordinary substitute-key-definition should do this now.
-;;(defun emerge-recursively-substitute-key-definition (olddef newdef keymap)
-;;  "Like `substitute-key-definition', but act recursively on subkeymaps.
-;;Make sure that subordinate keymaps aren't shared with other keymaps!
-;;\(`copy-keymap' will suffice.)"
-;;  ;; Loop through all keymaps accessible from keymap
-;;  (let ((maps (accessible-keymaps keymap)))
-;;    (while maps
-;;      ;; Substitute in this keymap
-;;      (substitute-key-definition olddef newdef (cdr (car maps)))
-;;      (setq maps (cdr maps)))))
-
 ;; Show the name of the file in the buffer.
 (defun emerge-show-file-name ()
   "Displays the name of the file loaded into the current buffer.