Move all usages of `values' to `values--store-value'

* lisp/simple.el (eval-expression):
* lisp/progmodes/elisp-mode.el (eval-last-sexp):
* lisp/emacs-lisp/pp.el (pp-eval-expression):
* lisp/emacs-lisp/edebug.el (edebug-eval-expression):
* lisp/emacs-lisp/pp.el (pp-eval-expression):
* lisp/emacs-lisp/edebug.el (edebug-eval-expression):
* lisp/cedet/data-debug.el (data-debug-eval-expression): Use it
instead of pushing to `values' directly (bug#22066).

* lisp/subr.el (values--store-value): New function.

diff --git a/lisp/cedet/data-debug.el b/lisp/cedet/data-debug.el
index a062a5a5853d9e118548a9c24bee7644bdf6d58e..f0fa91b3b177e0bc480940e72ae761a76e8e9a0c 100644 (file)
--- a/lisp/cedet/data-debug.el
+++ b/lisp/cedet/data-debug.el
@@ -1045,30 +1045,30 @@ If the result is a list or vector, then use the data debugger to display it."
    (list (let ((minibuffer-completing-symbol t))
           (read-from-minibuffer "Eval: "
                                 nil read-expression-map t
-                                'read-expression-history))
-        ))
-
-  (if (null eval-expression-debug-on-error)
-      (setq values (cons (eval expr) values))
-    (let ((old-value (make-symbol "t")) new-value)
-      ;; Bind debug-on-error to something unique so that we can
-      ;; detect when evalled code changes it.
-      (let ((debug-on-error old-value))
-       (setq values (cons (eval expr) values))
-       (setq new-value debug-on-error))
-      ;; If evalled code has changed the value of debug-on-error,
-      ;; propagate that change to the global binding.
-      (unless (eq old-value new-value)
-       (setq debug-on-error new-value))))
-
-  (if (or (consp (car values)) (vectorp (car values)))
-      (let ((v (car values)))
-       (data-debug-show-stuff v "Expression"))
-    ;; Old style
-    (prog1
-       (prin1 (car values) t)
-      (let ((str (eval-expression-print-format (car values))))
-       (if str (princ str t))))))
+                                'read-expression-history))))
+
+  (let (result)
+    (if (null eval-expression-debug-on-error)
+        (setq result (values--store-value (eval expr)))
+      (let ((old-value (make-symbol "t")) new-value)
+        ;; Bind debug-on-error to something unique so that we can
+        ;; detect when evalled code changes it.
+        (let ((debug-on-error old-value))
+         (setq result (values--store-value (eval expr)))
+         (setq new-value debug-on-error))
+        ;; If evalled code has changed the value of debug-on-error,
+        ;; propagate that change to the global binding.
+        (unless (eq old-value new-value)
+         (setq debug-on-error new-value))))
+
+    (if (or (consp result) (vectorp result))
+        (let ((v result))
+         (data-debug-show-stuff v "Expression"))
+      ;; Old style
+      (prog1
+         (prin1 result t)
+        (let ((str (eval-expression-print-format result)))
+         (if str (princ str t)))))))
 
 (provide 'data-debug)
 

diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 5d595851b9f94eb9dc195e2bd13d82a15d2956dc..41768f26708614c44da857c66007943a93285bf7 100644 (file)
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3801,9 +3801,10 @@ Print result in minibuffer."
   (interactive (list (read--expression "Eval: ")))
   (princ
    (edebug-outside-excursion
-    (setq values (cons (edebug-eval expr) values))
-    (concat (edebug-safe-prin1-to-string (car values))
-            (eval-expression-print-format (car values))))))
+    (let ((result (edebug-eval expr)))
+      (values--store-value result)
+      (concat (edebug-safe-prin1-to-string result)
+              (eval-expression-print-format result))))))
 
 (defun edebug-eval-last-sexp (&optional no-truncate)
   "Evaluate sexp before point in the outside environment.

diff --git a/lisp/emacs-lisp/pp.el b/lisp/emacs-lisp/pp.el
index ef4c9603284d1d0aa16afd30d32049b83755db48..2fd4724aef19e64987add961e8bd79c0dd33beec 100644 (file)
--- a/lisp/emacs-lisp/pp.el
+++ b/lisp/emacs-lisp/pp.el
@@ -127,8 +127,9 @@ Also add the value to the front of the list in the variable `values'."
   (interactive
    (list (read--expression "Eval: ")))
   (message "Evaluating...")
-  (push (eval expression lexical-binding) values)
-  (pp-display-expression (car values) "*Pp Eval Output*"))
+  (let ((result (eval expression lexical-binding)))
+    (values--store-value result)
+    (pp-display-expression result "*Pp Eval Output*")))
 
 ;;;###autoload
 (defun pp-macroexpand-expression (expression)

diff --git a/lisp/progmodes/elisp-mode.el b/lisp/progmodes/elisp-mode.el
index 9a36206bfda2a3d91c03c136d03ed8cb1b9a9600..0325d4ea7560a93f3b98db5f1218696a07eb8e16 100644 (file)
--- a/lisp/progmodes/elisp-mode.el
+++ b/lisp/progmodes/elisp-mode.el
@@ -1268,9 +1268,8 @@ If `eval-expression-debug-on-error' is non-nil, which is the default,
 this command arranges for all errors to enter the debugger."
   (interactive "P")
   (if (null eval-expression-debug-on-error)
-      (let ((value (elisp--eval-last-sexp eval-last-sexp-arg-internal)))
-        (push value values)
-        value)
+      (values--store-values
+       (elisp--eval-last-sexp eval-last-sexp-arg-internal))
     (let ((value
           (let ((debug-on-error elisp--eval-last-sexp-fake-value))
             (cons (elisp--eval-last-sexp eval-last-sexp-arg-internal)

diff --git a/lisp/simple.el b/lisp/simple.el
index 568debaa6129eaecc72e36579521d63bb5f2abb2..0c5bcb6672467401c6ebc4d60a22ea0f0de4764e 100644 (file)
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -1809,31 +1809,34 @@ this command arranges for all errors to enter the debugger."
    (cons (read--expression "Eval: ")
          (eval-expression-get-print-arguments current-prefix-arg)))
 
-  (if (null eval-expression-debug-on-error)
-      (push (eval (let ((lexical-binding t)) (macroexpand-all exp)) t)
-            values)
-    (let ((old-value (make-symbol "t")) new-value)
-      ;; Bind debug-on-error to something unique so that we can
-      ;; detect when evalled code changes it.
-      (let ((debug-on-error old-value))
-       (push (eval (let ((lexical-binding t)) (macroexpand-all exp)) t)
-              values)
-       (setq new-value debug-on-error))
-      ;; If evalled code has changed the value of debug-on-error,
-      ;; propagate that change to the global binding.
-      (unless (eq old-value new-value)
-       (setq debug-on-error new-value))))
-
-  (let ((print-length (unless no-truncate eval-expression-print-length))
-        (print-level  (unless no-truncate eval-expression-print-level))
-        (eval-expression-print-maximum-character char-print-limit)
-        (deactivate-mark))
-    (let ((out (if insert-value (current-buffer) t)))
-      (prog1
-          (prin1 (car values) out)
-        (let ((str (and char-print-limit
-                        (eval-expression-print-format (car values)))))
-          (when str (princ str out)))))))
+  (let (result)
+    (if (null eval-expression-debug-on-error)
+        (setq result
+              (values--store-value
+               (eval (let ((lexical-binding t)) (macroexpand-all exp)) t)))
+      (let ((old-value (make-symbol "t")) new-value)
+        ;; Bind debug-on-error to something unique so that we can
+        ;; detect when evalled code changes it.
+        (let ((debug-on-error old-value))
+          (setq result
+               (values--store-value
+                 (eval (let ((lexical-binding t)) (macroexpand-all exp)) t)))
+         (setq new-value debug-on-error))
+        ;; If evalled code has changed the value of debug-on-error,
+        ;; propagate that change to the global binding.
+        (unless (eq old-value new-value)
+         (setq debug-on-error new-value))))
+
+    (let ((print-length (unless no-truncate eval-expression-print-length))
+          (print-level  (unless no-truncate eval-expression-print-level))
+          (eval-expression-print-maximum-character char-print-limit)
+          (deactivate-mark))
+      (let ((out (if insert-value (current-buffer) t)))
+        (prog1
+            (prin1 result out)
+          (let ((str (and char-print-limit
+                          (eval-expression-print-format result))))
+            (when str (princ str out))))))))
 
 (defun edit-and-eval-command (prompt command)
   "Prompting with PROMPT, let user edit COMMAND and eval result.

diff --git a/lisp/subr.el b/lisp/subr.el
index f0de6d5ac92df3c321d67f9f7590a6863b1b9898..6573090ebe311dcdc91fc616f399acbf3b2e53f2 100644 (file)
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1655,6 +1655,12 @@ The return value has the form (WIDTH . HEIGHT).  POSITION should
 be a list of the form returned by `event-start' and `event-end'."
   (nth 9 position))
 
+(defun values--store-value (value)
+  "Store VALUE in the obsolete `values' variable."
+  (with-suppressed-warnings ((obsolete values))
+    (push value values))
+  value)
+
 \f
 ;;;; Obsolescent names for functions.
 
@@ -1721,6 +1727,10 @@ be a list of the form returned by `event-start' and `event-end'."
 (make-obsolete-variable 'load-dangerous-libraries
                         "no longer used." "27.1")
 
+;; We can't actually make `values' obsolete, because that will result
+;; in warnings when using `values' in let-bindings.
+;;(make-obsolete-variable 'values "no longer used" "28.1")
+
 \f
 ;;;; Alternate names for functions - these are not being phased out.