From: Glenn Morris <rgm@gnu.org>
Date: Tue, 13 Sep 2011 21:13:10 +0000 (-0400)
Subject: Tabify previous change.
X-Git-Tag: emacs-pretest-24.0.90~104^2~58
X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=5f66aa05d482ebb786d5941e78d95b74e4561465;p=emacs.git

Tabify previous change.
---

diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index 6533721054c..16258a5a3a1 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -345,68 +345,68 @@ That buffer should be current already."
     (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))
+	    (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 ()