* lisp/calc/calc-yank.el (calc-edit-mode): Make it into a proper major mode

Also make `calc-edit-handler` hold a function instead of an expression.

(calc-original-buffer, calc-return-buffer, calc-one-window)
(calc-edit-handler, calc-restore-trail, calc-allow-ret)
(calc-edit-top): Give them a default value.
(calc--edit-mode): New function extracted from old `calc-edit-mode`.
(calc-edit-return, calc-edit-finish): Don't need to test `boundp` any more.
(calc-edit-finish): Allow `calc-edit-handler` to be a function.

(calc-edit, calc-alg-edit):

* lisp/calc/calc-prog.el (calc-edit-user-syntax, calc-user-define-edit):
* lisp/calc/calc-embed.el (calc-embedded-edit):
* lisp/calc/calc-sel.el (calc-edit-selection):
* lisp/calc/calc-store.el (calc-edit-variable):
Use `calc--edit-mode` and make first arg into a function.

* lisp/calc/calc-ext.el (calc-init-extensions): Autoload `calc--edit-mode`
instead of `calc-edit-mode`.

6 files changed, 64 insertions, 73 deletions

diff --git a/lisp/calc/calc-embed.el b/lisp/calc/calc-embed.el
index a1135726108..ea79bfa69a0 100644
--- a/lisp/calc/calc-embed.el
+++ b/lisp/calc/calc-embed.el
@@ -396,7 +396,7 @@
     (calc-wrapper
      (setq str (math-showing-full-precision
 		(math-format-nice-expr (aref info 8) (frame-width))))
-     (calc-edit-mode (list 'calc-embedded-finish-edit info))
+     (calc--edit-mode (lambda () (calc-embedded-finish-edit info)))
      (insert str "\n")))
   (calc-show-edit-buffer)))
 
diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index 7c319c4d654..f4ddb840b50 100644
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -1195,7 +1195,7 @@ calc-set-xor calc-sort calc-subvector calc-tail calc-transpose
 calc-unpack calc-unpack-bits calc-vector-find calc-vlength)
 
  ("calc-yank" calc-copy-as-kill calc-copy-region-as-kill
-calc-copy-to-buffer calc-edit calc-edit-cancel calc-edit-mode
+calc-copy-to-buffer calc-edit calc-edit-cancel calc--edit-mode
 calc-kill calc-kill-region calc-yank))))
 
 (defun calc-init-prefixes ()
diff --git a/lisp/calc/calc-prog.el b/lisp/calc/calc-prog.el
index 6ac554ed69c..3097b09b013 100644
--- a/lisp/calc/calc-prog.el
+++ b/lisp/calc/calc-prog.el
@@ -483,13 +483,13 @@
   (interactive)
   (calc-wrapper
    (let ((lang calc-language))
-     (calc-edit-mode (list 'calc-finish-user-syntax-edit (list 'quote lang))
-		     t
-		     (format "Editing %s-Mode Syntax Table. "
-			     (cond ((null lang) "Normal")
-				   ((eq lang 'tex) "TeX")
-                                   ((eq lang 'latex) "LaTeX")
-				   (t (capitalize (symbol-name lang))))))
+     (calc--edit-mode (lambda () (calc-finish-user-syntax-edit lang))
+		      t
+		      (format "Editing %s-Mode Syntax Table. "
+			      (cond ((null lang) "Normal")
+				    ((eq lang 'tex) "TeX")
+                                    ((eq lang 'latex) "LaTeX")
+				    (t (capitalize (symbol-name lang))))))
      (calc-write-parse-table (cdr (assq lang calc-user-parse-tables))
 			     lang)))
   (calc-show-edit-buffer))
@@ -696,12 +696,13 @@
       (setq cmd (symbol-function cmd)))
     (cond ((or (stringp cmd)
 	       (and (consp cmd)
-		    (eq (car-safe (nth 3 cmd)) 'calc-execute-kbd-macro)))
+		    (eq (car-safe (nth 3 cmd)) #'calc-execute-kbd-macro)))
+           ;; FIXME: Won't (nth 3 cmd) fail when (stringp cmd)?
            (let* ((mac (elt (nth 1 (nth 3 cmd)) 1))
                   (str (edmacro-format-keys mac t))
                   (kys (nth 3 (nth 3 cmd))))
-             (calc-edit-mode
-              (list 'calc-edit-macro-finish-edit cmdname kys)
+             (calc--edit-mode
+              (lambda () (calc-edit-macro-finish-edit cmdname kys))
               t (format (concat
                          "Editing keyboard macro (%s, bound to %s).\n"
                          "Original keys: %s \n")
@@ -719,8 +720,8 @@
 	       (if (and defn (calc-valid-formula-func func))
 		   (let ((niceexpr (math-format-nice-expr defn (frame-width))))
 		     (calc-wrapper
-		      (calc-edit-mode
-                       (list 'calc-finish-formula-edit (list 'quote func))
+		      (calc--edit-mode
+                       (lambda () (calc-finish-formula-edit func))
                        nil
                        (format (concat
                                 "Editing formula (%s, %s, bound to %s).\n"
diff --git a/lisp/calc/calc-sel.el b/lisp/calc/calc-sel.el
index e6c6337f969..2b317ac3696 100644
--- a/lisp/calc/calc-sel.el
+++ b/lisp/calc/calc-sel.el
@@ -675,12 +675,12 @@
 	  (entry (calc-top num 'entry))
 	  (expr (car entry))
 	  (sel (or (calc-auto-selection entry) expr))
-	  ) ;; alg
-     (let ((str (math-showing-full-precision
-		 (math-format-nice-expr sel (frame-width)))))
-       (calc-edit-mode (list 'calc-finish-selection-edit
-			     num (list 'quote sel) calc-sel-reselect))
-       (insert str "\n"))))
+	  ;; alg
+	  (str (math-showing-full-precision
+		(math-format-nice-expr sel (frame-width))))
+	  (csr calc-sel-reselect))
+     (calc--edit-mode (lambda () (calc-finish-selection-edit num sel csr)))
+     (insert str "\n")))
   (calc-show-edit-buffer))
 
 (defvar calc-original-buffer)
diff --git a/lisp/calc/calc-store.el b/lisp/calc/calc-store.el
index a5e9012dec6..ee29c440fe4 100644
--- a/lisp/calc/calc-store.el
+++ b/lisp/calc/calc-store.el
@@ -437,10 +437,10 @@
 	 (if (eq (car-safe value) 'special-const)
 	     (error "%s is a special constant" var))
 	 (setq calc-last-edited-variable var)
-	 (calc-edit-mode (list 'calc-finish-stack-edit (list 'quote var))
-			 t
-			 (format-message
-                          "Editing variable `%s'" (calc-var-name var)))
+	 (calc--edit-mode (lambda () (calc-finish-stack-edit var))
+			  t
+			  (format-message
+                           "Editing variable `%s'" (calc-var-name var)))
 	 (and value
 	      (insert (math-format-nice-expr value (frame-width)) "\n")))))
   (calc-show-edit-buffer))
diff --git a/lisp/calc/calc-yank.el b/lisp/calc/calc-yank.el
index 8267340a3ec..e5f05236f3a 100644
--- a/lisp/calc/calc-yank.el
+++ b/lisp/calc/calc-yank.el
@@ -651,14 +651,14 @@ Interactively, reads the register using `register-read-with-preview'."
 			 (if (> n 0)
 			     (calc-top-list n)
 			   (calc-top-list 1 (- n)))))))
-     (calc-edit-mode (list 'calc-finish-stack-edit (or flag n)) allow-ret)
+     (calc--edit-mode (lambda () (calc-finish-stack-edit (or flag n))) allow-ret)
      (while list
        (insert (car list) "\n")
        (setq list (cdr list)))))
   (calc-show-edit-buffer))
 
 (defun calc-alg-edit (str)
-  (calc-edit-mode '(calc-finish-stack-edit 0))
+  (calc--edit-mode (lambda () (calc-finish-stack-edit 0)))
   (calc-show-edit-buffer)
   (insert str "\n")
   (backward-char 1)
@@ -666,54 +666,47 @@ Interactively, reads the register using `register-read-with-preview'."
 
 (defvar calc-edit-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "\n" 'calc-edit-finish)
-    (define-key map "\r" 'calc-edit-return)
-    (define-key map "\C-c\C-c" 'calc-edit-finish)
+    (define-key map "\n" #'calc-edit-finish)
+    (define-key map "\r" #'calc-edit-return)
+    (define-key map "\C-c\C-c" #'calc-edit-finish)
     map)
-  "Keymap for use by the calc-edit command.")
+  "Keymap for use by the `calc-edit' command.")
 
-(defvar calc-original-buffer)
-(defvar calc-return-buffer)
-(defvar calc-one-window)
-(defvar calc-edit-handler)
-(defvar calc-restore-trail)
-(defvar calc-allow-ret)
-(defvar calc-edit-top)
+(defvar calc-original-buffer nil)
+(defvar calc-return-buffer nil)
+(defvar calc-one-window nil)
+(defvar calc-edit-handler nil)
+(defvar calc-restore-trail nil)
+(defvar calc-allow-ret nil)
+(defvar calc-edit-top nil)
 
-(defun calc-edit-mode (&optional handler allow-ret title)
+(put 'calc-edit-mode 'mode-class 'special)
+(define-derived-mode calc-edit-mode nil "Calc Edit"
   "Calculator editing mode.  Press RET, LFD, or C-c C-c to finish.
 To cancel the edit, simply kill the *Calc Edit* buffer."
-  (interactive)
+  (setq-local buffer-read-only nil)
+  (setq-local truncate-lines nil))
+
+(defun calc--edit-mode (handler &optional allow-ret title)
   (unless handler
     (error "This command can be used only indirectly through calc-edit"))
   (let ((oldbuf (current-buffer))
 	(buf (get-buffer-create "*Calc Edit*")))
     (set-buffer buf)
-    (kill-all-local-variables)
-    (use-local-map calc-edit-mode-map)
-    (setq buffer-read-only nil)
-    (setq truncate-lines nil)
-    (setq major-mode 'calc-edit-mode)
-    (setq mode-name "Calc Edit")
-    (run-mode-hooks 'calc-edit-mode-hook)
-    (make-local-variable 'calc-original-buffer)
-    (setq calc-original-buffer oldbuf)
-    (make-local-variable 'calc-return-buffer)
-    (setq calc-return-buffer oldbuf)
-    (make-local-variable 'calc-one-window)
-    (setq calc-one-window (and (one-window-p t) pop-up-windows))
-    (make-local-variable 'calc-edit-handler)
-    (setq calc-edit-handler handler)
-    (make-local-variable 'calc-restore-trail)
-    (setq calc-restore-trail (get-buffer-window (calc-trail-buffer)))
-    (make-local-variable 'calc-allow-ret)
-    (setq calc-allow-ret allow-ret)
+    (calc-edit-mode)
+    (setq-local calc-original-buffer oldbuf)
+    (setq-local calc-return-buffer oldbuf)
+    (setq-local calc-one-window (and (one-window-p t) pop-up-windows))
+    (setq-local calc-edit-handler handler)
+    (setq-local calc-restore-trail (get-buffer-window (calc-trail-buffer)))
+    (setq-local calc-allow-ret allow-ret)
     (let ((inhibit-read-only t))
       (erase-buffer))
     (add-hook 'kill-buffer-hook (lambda ()
                                   (let ((calc-edit-handler nil))
                                     (calc-edit-finish t))
-                                  (message "(Canceled)")) t t)
+                                  (message "(Canceled)"))
+              t t)
     (insert (propertize
              (concat
               (or title title "Calc Edit Mode. ")
@@ -721,9 +714,7 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
               (if allow-ret "" " or RET")
               (format-message " to finish, `C-x k RET' to cancel.\n\n"))
              'font-lock-face 'italic 'read-only t 'rear-nonsticky t 'front-sticky t))
-    (make-local-variable 'calc-edit-top)
-    (setq calc-edit-top (point))))
-(put 'calc-edit-mode 'mode-class 'special)
+    (setq-local calc-edit-top (point))))
 
 (defun calc-show-edit-buffer ()
   (let ((buf (current-buffer)))
@@ -743,24 +734,19 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
 
 (defun calc-edit-return ()
   (interactive)
-  (if (and (boundp 'calc-allow-ret) calc-allow-ret)
+  (if calc-allow-ret
       (newline)
     (calc-edit-finish)))
 
-;; The variable calc-edit-disp-trail is local to calc-edit finish, but
-;; is used by calc-finish-selection-edit and calc-finish-stack-edit.
+;; The variable `calc-edit-disp-trail' is local to `calc-edit-finish', but
+;; is used by `calc-finish-selection-edit' and `calc-finish-stack-edit'.
 (defvar calc-edit-disp-trail)
 
 (defun calc-edit-finish (&optional keep)
-  "Finish calc-edit mode.  Parse buffer contents and push them on the stack."
+  "Finish `calc-edit' mode.  Parse buffer contents and push them on the stack."
   (interactive "P")
   (message "Working...")
-  (or (and (boundp 'calc-original-buffer)
-	   (boundp 'calc-return-buffer)
-	   (boundp 'calc-one-window)
-	   (boundp 'calc-edit-handler)
-	   (boundp 'calc-restore-trail)
-	   (eq major-mode 'calc-edit-mode))
+  (or (derived-mode-p 'calc-edit-mode)
       (error "This command is valid only in buffers created by calc-edit"))
   (let ((buf (current-buffer))
 	(original calc-original-buffer)
@@ -775,7 +761,11 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
 	(error "Original calculator buffer has been corrupted")))
     (goto-char calc-edit-top)
     (if (buffer-modified-p)
-	(eval calc-edit-handler t))
+	(if (functionp calc-edit-handler)
+	    (funcall calc-edit-handler)
+	  (message "Deprecated handler expression in calc-edit-handler: %S"
+	           calc-edit-handler)
+	  (eval calc-edit-handler t)))
     (if (and one-window (not (one-window-p t)))
 	(delete-window))
     (if (get-buffer-window return)