Re: debug performance problem

[Richard Stallman]

I left in some debugging code.  Please try this version.

(defun debugger-make-xrefs (&optional buffer)
  "Attach cross-references to symbol names in the `*Backtrace*' buffer."
  (interactive "b")
  (save-excursion
    (set-buffer (or buffer (current-buffer)))
    (setq buffer (current-buffer))
    (let ((buffer-read-only nil)
          (old-end 1) (new-end 1))
      ;; 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
                          (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 1 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 (1- old-end)))
            ;; 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
               (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))))
          (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 1 'help-function-def sym file))))
      (widen))
    (setq debugger-previous-backtrace (buffer-string))))