preceding-sexp

2 files changed, 61 insertions, 52 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index e5390ccf057..eefd54257a4 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,9 @@
+2007-08-20  Johannes Weiner  <hannes@saeurebad.de>  (tiny change)
+
+        * emacs-lisp/lisp-mode.el (preceding-sexp): New fun, the code was
+        extracted from `eval-last-sexp-1'.
+        (eval-last-sexp-1): Call `preceding-sexp'.
+
 2007-08-19  Glenn Morris  <rgm@gnu.org>
 
         * Makefile.in (custom-deps, finder-data, autoloads, recompile)
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index d41c0af3d73..8b3e5a71c61 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -537,62 +537,65 @@ If CHAR is not a character, return nil."
               string))))
 
 
+(defun preceding-sexp ()
+  "Return sexp before the point."
+  (let ((opoint (point))
+        ignore-quotes
+        expr)
+    (save-excursion
+      (with-syntax-table emacs-lisp-mode-syntax-table
+        ;; If this sexp appears to be enclosed in `...'
+        ;; then ignore the surrounding quotes.
+        (setq ignore-quotes
+              (or (eq (following-char) ?\')
+                  (eq (preceding-char) ?\')))
+        (forward-sexp -1)
+        ;; If we were after `?\e' (or similar case),
+        ;; use the whole thing, not just the `e'.
+        (when (eq (preceding-char) ?\\)
+          (forward-char -1)
+          (when (eq (preceding-char) ??)
+            (forward-char -1)))
+
+        ;; Skip over `#N='s.
+        (when (eq (preceding-char) ?=)
+          (let (labeled-p)
+            (save-excursion
+              (skip-chars-backward "0-9#=")
+              (setq labeled-p (looking-at "\\(#[0-9]+=\\)+")))
+            (when labeled-p
+              (forward-sexp -1))))
+
+        (save-restriction
+          ;; vladimir@cs.ualberta.ca 30-Jul-1997: skip ` in
+          ;; `variable' so that the value is returned, not the
+          ;; name
+          (if (and ignore-quotes
+                   (eq (following-char) ?`))
+              (forward-char))
+          (narrow-to-region (point-min) opoint)
+          (setq expr (read (current-buffer)))
+          ;; If it's an (interactive ...) form, it's more
+          ;; useful to show how an interactive call would
+          ;; use it.
+          (and (consp expr)
+               (eq (car expr) 'interactive)
+               (setq expr
+                     (list 'call-interactively
+                           (list 'quote
+                                 (list 'lambda
+                                       '(&rest args)
+                                       expr
+                                       'args)))))
+          expr)))))
+
+
 (defun eval-last-sexp-1 (eval-last-sexp-arg-internal)
   "Evaluate sexp before point; print value in minibuffer.
 With argument, print output into current buffer."
   (let ((standard-output (if eval-last-sexp-arg-internal (current-buffer) t)))
-    (let ((value
-           (eval (let ((stab (syntax-table))
-                       (opoint (point))
-                       ignore-quotes
-                       expr)
-                   (save-excursion
-                     (with-syntax-table emacs-lisp-mode-syntax-table
-                       ;; If this sexp appears to be enclosed in `...'
-                       ;; then ignore the surrounding quotes.
-                       (setq ignore-quotes
-                             (or (eq (following-char) ?\')
-                                 (eq (preceding-char) ?\')))
-                       (forward-sexp -1)
-                       ;; If we were after `?\e' (or similar case),
-                       ;; use the whole thing, not just the `e'.
-                       (when (eq (preceding-char) ?\\)
-                         (forward-char -1)
-                         (when (eq (preceding-char) ??)
-                           (forward-char -1)))
-
-                       ;; Skip over `#N='s.
-                       (when (eq (preceding-char) ?=)
-                         (let (labeled-p)
-                           (save-excursion
-                             (skip-chars-backward "0-9#=")
-                             (setq labeled-p (looking-at "\\(#[0-9]+=\\)+")))
-                           (when labeled-p
-                             (forward-sexp -1))))
-
-                       (save-restriction
-                         ;; vladimir@cs.ualberta.ca 30-Jul-1997: skip ` in
-                         ;; `variable' so that the value is returned, not the
-                         ;; name
-                         (if (and ignore-quotes
-                                  (eq (following-char) ?`))
-                             (forward-char))
-                         (narrow-to-region (point-min) opoint)
-                         (setq expr (read (current-buffer)))
-                         ;; If it's an (interactive ...) form, it's more
-                         ;; useful to show how an interactive call would
-                         ;; use it.
-                         (and (consp expr)
-                              (eq (car expr) 'interactive)
-                              (setq expr
-                                    (list 'call-interactively
-                                          (list 'quote
-                                                (list 'lambda
-                                                      '(&rest args)
-                                                      expr
-                                                      'args)))))
-                         expr)))))))
-      (eval-last-sexp-print-value value))))
+    (eval-last-sexp-print-value (eval (preceding-sexp)))))
+
 
 (defun eval-last-sexp-print-value (value)
   (let ((unabbreviated (let ((print-length nil) (print-level nil))