[Emacs-diffs] /srv/bzr/emacs/trunk r105759: * lisp/emacs-lisp/debug.el (debugger-make-xrefs): Preserve point. (Bug#9462)

[Glenn Morris]

------------------------------------------------------------
revno: 105759
committer: Glenn Morris <address@hidden>
branch nick: trunk
timestamp: Tue 2011-09-13 17:02:27 -0400
message:
  * lisp/emacs-lisp/debug.el (debugger-make-xrefs): Preserve point.  (Bug#9462)
modified:
  lisp/ChangeLog
  lisp/emacs-lisp/debug.el

=== modified file 'lisp/ChangeLog'
--- a/lisp/ChangeLog    2011-09-13 19:10:32 +0000
+++ b/lisp/ChangeLog    2011-09-13 21:02:27 +0000
@@ -1,3 +1,8 @@
+2011-09-13  Glenn Morris  <address@hidden>
+
+       * emacs-lisp/debug.el (debugger-make-xrefs):
+       Preserve point.  (Bug#9462)
+
 2011-09-13  Chong Yidong  <address@hidden>
 
        * window.el (window-deletable-p): Use next-frame.

=== modified file 'lisp/emacs-lisp/debug.el'
--- a/lisp/emacs-lisp/debug.el  2011-08-22 21:16:46 +0000
+++ b/lisp/emacs-lisp/debug.el  2011-09-13 21:02:27 +0000
@@ -342,71 +342,72 @@
   "Attach cross-references to function names in the `*Backtrace*' buffer."
   (interactive "b")
   (with-current-buffer (or buffer (current-buffer))
-    (setq buffer (current-buffer))
-    (let ((inhibit-read-only t)
-         (old-end (point-min)) (new-end (point-min)))
-      ;; If we saved an old backtrace, find the common part
-      ;; between the new and the old.
-      ;; Compare line by line, starting from the end,
-      ;; because that's the part that is likely to be unchanged.
-      (if debugger-previous-backtrace
-         (let (old-start new-start (all-match t))
-           (goto-char (point-max))
-           (with-temp-buffer
-             (insert debugger-previous-backtrace)
-             (while (and all-match (not (bobp)))
-               (setq old-end (point))
-               (forward-line -1)
-               (setq old-start (point))
-               (with-current-buffer buffer
-                 (setq new-end (point))
-                 (forward-line -1)
-                 (setq new-start (point)))
-               (if (not (zerop
-                          (let ((case-fold-search nil))
-                            (compare-buffer-substrings
-                             (current-buffer) old-start old-end
-                             buffer new-start new-end))))
-                   (setq all-match nil))))
-           ;; Now new-end is the position of the start of the
-           ;; unchanged part in the current buffer, and old-end is
-           ;; the position of that same text in the saved old
-           ;; backtrace.  But we must subtract (point-min) since strings are
-           ;; indexed in origin 0.
-
-           ;; Replace the unchanged part of the backtrace
-           ;; with the text from debugger-previous-backtrace,
-           ;; since that already has the proper xrefs.
-           ;; With this optimization, we only need to scan
-           ;; the changed part of the backtrace.
-           (delete-region new-end (point-max))
-           (goto-char (point-max))
-           (insert (substring debugger-previous-backtrace
-                              (- old-end (point-min))))
-           ;; Make the unchanged part of the backtrace inaccessible
-           ;; so it won't be scanned.
-           (narrow-to-region (point-min) new-end)))
-
-      ;; Scan the new part of the backtrace, inserting xrefs.
-      (goto-char (point-min))
-      (while (progn
-              (goto-char (+ (point) 2))
-              (skip-syntax-forward "^w_")
-              (not (eobp)))
-       (let* ((beg (point))
-              (end (progn (skip-syntax-forward "w_") (point)))
-              (sym (intern-soft (buffer-substring-no-properties
-                                 beg end)))
-              (file (and sym (symbol-file sym 'defun))))
-         (when file
-           (goto-char beg)
-           ;; help-xref-button needs to operate on something matched
-           ;; by a regexp, so set that up for it.
-           (re-search-forward "\\(\\sw\\|\\s_\\)+")
-           (help-xref-button 0 'help-function-def sym file)))
-       (forward-line 1))
-      (widen))
-    (setq debugger-previous-backtrace (buffer-string))))
+    (save-excursion
+      (setq buffer (current-buffer))
+      (let ((inhibit-read-only t)
+            (old-end (point-min)) (new-end (point-min)))
+        ;; If we saved an old backtrace, find the common part
+        ;; between the new and the old.
+        ;; Compare line by line, starting from the end,
+        ;; because that's the part that is likely to be unchanged.
+        (if debugger-previous-backtrace
+            (let (old-start new-start (all-match t))
+              (goto-char (point-max))
+              (with-temp-buffer
+                (insert debugger-previous-backtrace)
+                (while (and all-match (not (bobp)))
+                  (setq old-end (point))
+                  (forward-line -1)
+                  (setq old-start (point))
+                  (with-current-buffer buffer
+                    (setq new-end (point))
+                    (forward-line -1)
+                    (setq new-start (point)))
+                  (if (not (zerop
+                            (let ((case-fold-search nil))
+                              (compare-buffer-substrings
+                               (current-buffer) old-start old-end
+                               buffer new-start new-end))))
+                      (setq all-match nil))))
+              ;; Now new-end is the position of the start of the
+              ;; unchanged part in the current buffer, and old-end is
+              ;; the position of that same text in the saved old
+              ;; backtrace.  But we must subtract (point-min) since strings are
+              ;; indexed in origin 0.
+
+              ;; Replace the unchanged part of the backtrace
+              ;; with the text from debugger-previous-backtrace,
+              ;; since that already has the proper xrefs.
+              ;; With this optimization, we only need to scan
+              ;; the changed part of the backtrace.
+              (delete-region new-end (point-max))
+              (goto-char (point-max))
+              (insert (substring debugger-previous-backtrace
+                                 (- old-end (point-min))))
+              ;; Make the unchanged part of the backtrace inaccessible
+              ;; so it won't be scanned.
+              (narrow-to-region (point-min) new-end)))
+
+        ;; Scan the new part of the backtrace, inserting xrefs.
+        (goto-char (point-min))
+        (while (progn
+                 (goto-char (+ (point) 2))
+                 (skip-syntax-forward "^w_")
+                 (not (eobp)))
+          (let* ((beg (point))
+                 (end (progn (skip-syntax-forward "w_") (point)))
+                 (sym (intern-soft (buffer-substring-no-properties
+                                    beg end)))
+                 (file (and sym (symbol-file sym 'defun))))
+            (when file
+              (goto-char beg)
+              ;; help-xref-button needs to operate on something matched
+              ;; by a regexp, so set that up for it.
+              (re-search-forward "\\(\\sw\\|\\s_\\)+")
+              (help-xref-button 0 'help-function-def sym file)))
+          (forward-line 1))
+        (widen))
+      (setq debugger-previous-backtrace (buffer-string)))))
 
 (defun debugger-step-through ()
   "Proceed, stepping through subexpressions of this expression.