debug.el 36.7 KB
Newer Older
Eric S. Raymond's avatar
Eric S. Raymond committed
1 2
;;; debug.el --- debuggers and related commands for Emacs

3
;; Copyright (C) 1985-1986, 1994, 2001-2012 Free Software Foundation, Inc.
Eric S. Raymond's avatar
Eric S. Raymond committed
4

Eric S. Raymond's avatar
Eric S. Raymond committed
5
;; Maintainer: FSF
Eric S. Raymond's avatar
Eric S. Raymond committed
6
;; Keywords: lisp, tools, maint
Eric S. Raymond's avatar
Eric S. Raymond committed
7

Jim Blandy's avatar
Jim Blandy committed
8 9
;; This file is part of GNU Emacs.

10
;; GNU Emacs is free software: you can redistribute it and/or modify
Jim Blandy's avatar
Jim Blandy committed
11
;; it under the terms of the GNU General Public License as published by
12 13
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
Jim Blandy's avatar
Jim Blandy committed
14 15 16 17 18 19 20

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
21
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
Jim Blandy's avatar
Jim Blandy committed
22

23 24
;;; Commentary:

25
;; This is a major mode documented in the Emacs Lisp manual.
26

Eric S. Raymond's avatar
Eric S. Raymond committed
27
;;; Code:
Jim Blandy's avatar
Jim Blandy committed
28

Miles Bader's avatar
Miles Bader committed
29 30
(require 'button)

Stephen Eglen's avatar
Stephen Eglen committed
31 32 33 34
(defgroup debugger nil
  "Debuggers and related commands for Emacs."
  :prefix "debugger-"
  :group 'debug)
35

Stephen Eglen's avatar
Stephen Eglen committed
36
(defcustom debugger-mode-hook nil
37
  "Hooks run when `debugger-mode' is turned on."
Stephen Eglen's avatar
Stephen Eglen committed
38
  :type 'hook
Dan Nicolaescu's avatar
Dan Nicolaescu committed
39 40
  :group 'debugger
  :version "20.3")
41

42
(defcustom debugger-batch-max-lines 40
43
  "Maximum lines to show in debugger buffer in a noninteractive Emacs.
44 45 46 47 48 49
When the debugger is entered and Emacs is running in batch mode,
if the backtrace text has more than this many lines,
the middle is discarded, and just the beginning and end are displayed."
  :type 'integer
  :group 'debugger
  :version "21.1")
Jim Blandy's avatar
Jim Blandy committed
50

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
(defcustom debugger-bury-or-kill 'bury
  "How to proceed with the debugger buffer when exiting `debug'.
The value used here affects the behavior of operations on any
window previously showing the debugger buffer.

`nil' means that if its window is not deleted when exiting the
  debugger, invoking `switch-to-prev-buffer' will usually show
  the debugger buffer again.

`append' means that if the window is not deleted, the debugger
  buffer moves to the end of the window's previous buffers so
  it's less likely that a future invocation of
  `switch-to-prev-buffer' will switch to it.  Also, it moves the
  buffer to the end of the frame's buffer list.

`bury' means that if the window is not deleted, its buffer is
  removed from the window's list of previous buffers.  Also, it
  moves the buffer to the end of the frame's buffer list.  This
  value provides the most reliable remedy to not have
  `switch-to-prev-buffer' switch to the debugger buffer again
  without killing the buffer.

`kill' means to kill the debugger buffer.

The value used here is passed to `quit-restore-window'."
  :type '(choice
	  (const :tag "Keep alive" nil)
	  (const :tag "Append" 'append)
	  (const :tag "Bury" 'bury)
	  (const :tag "Kill" 'kill))
  :group 'debugger
  :version "24.2")

84 85 86 87 88
(defvar debug-function-list nil
  "List of functions currently set for debug on entry.")

(defvar debugger-step-after-exit nil
  "Non-nil means \"single-step\" after the debugger exits.")
89 90 91 92 93 94 95

(defvar debugger-value nil
  "This is the value for the debugger to return, when it returns.")

(defvar debugger-old-buffer nil
  "This is the buffer that was current when the debugger was entered.")

96 97 98
(defvar debugger-previous-window nil
  "This is the window last showing the debugger buffer.")

99 100 101
(defvar debugger-previous-window-height nil
  "The last recorded height of `debugger-previous-window'.")

102 103 104 105
(defvar debugger-previous-backtrace nil
  "The contents of the previous backtrace (including text properties).
This is to optimize `debugger-make-xrefs'.")

106
(defvar debugger-outer-match-data)
107 108
(defvar debugger-outer-load-read-function)
(defvar debugger-outer-overriding-local-map)
109
(defvar debugger-outer-overriding-terminal-local-map)
110 111 112
(defvar debugger-outer-track-mouse)
(defvar debugger-outer-last-command)
(defvar debugger-outer-this-command)
Richard M. Stallman's avatar
Richard M. Stallman committed
113 114 115
;; unread-command-char is obsolete,
;; but we still save and restore it
;; in case some user program still tries to set it.
116 117
(defvar debugger-outer-unread-command-char)
(defvar debugger-outer-unread-command-events)
118
(defvar debugger-outer-unread-post-input-method-events)
119 120 121 122 123 124
(defvar debugger-outer-last-input-event)
(defvar debugger-outer-last-command-event)
(defvar debugger-outer-last-nonmenu-event)
(defvar debugger-outer-last-event-frame)
(defvar debugger-outer-standard-input)
(defvar debugger-outer-standard-output)
125
(defvar debugger-outer-inhibit-redisplay)
126
(defvar debugger-outer-cursor-in-echo-area)
127 128
(defvar debugger-will-be-back nil
  "Non-nil if we expect to get back in the debugger soon.")
129

130 131 132 133 134
(defvar inhibit-debug-on-entry nil
  "Non-nil means that debug-on-entry is disabled.")

(defvar debugger-jumping-flag nil
  "Non-nil means that debug-on-entry is disabled.
135 136
This variable is used by `debugger-jump', `debugger-step-through',
and `debugger-reenable' to temporarily disable debug-on-entry.")
137

138
(defvar inhibit-trace)                  ;Not yet implemented.
139

140 141 142 143 144 145 146 147 148 149
(defvar debugger-args nil
  "Arguments with which the debugger was called.
It is a list expected to take the form (CAUSE . REST)
where CAUSE can be:
- debug: called for entry to a flagged function.
- t: called because of debug-on-next-call.
- lambda: same thing but via `funcall'.
- exit: called because of exit of a flagged function.
- error: called because of `debug-on-error'.")

Jim Blandy's avatar
Jim Blandy committed
150 151 152 153
;;;###autoload
(setq debugger 'debug)
;;;###autoload
(defun debug (&rest debugger-args)
154
  "Enter debugger.  \\<debugger-mode-map>`\\[debugger-continue]' returns from the debugger.
Jim Blandy's avatar
Jim Blandy committed
155 156 157 158 159 160
Arguments are mainly for use when this is called from the internals
of the evaluator.

You may call with no args, or you may pass nil as the first arg and
any other args you like.  In that case, the list of args after the
first will be printed into the backtrace buffer."
161
  (interactive)
162 163 164 165 166 167
  (if inhibit-redisplay
      ;; Don't really try to enter debugger within an eval from redisplay.
      debugger-value
    (unless noninteractive
      (message "Entering debugger..."))
    (let (debugger-value
168 169 170 171
	  (debugger-previous-state
           (if (get-buffer "*Backtrace*")
               (with-current-buffer (get-buffer "*Backtrace*")
                 (list major-mode (buffer-string)))))
172
	  (debugger-buffer (get-buffer-create "*Backtrace*"))
173
	  (debugger-window nil)
174
	  (debugger-step-after-exit nil)
175
          (debugger-will-be-back nil)
176 177 178 179 180 181 182 183 184 185 186 187
	  ;; Don't keep reading from an executing kbd macro!
	  (executing-kbd-macro nil)
	  ;; Save the outer values of these vars for the `e' command
	  ;; before we replace the values.
	  (debugger-outer-match-data (match-data))
	  (debugger-outer-load-read-function load-read-function)
	  (debugger-outer-overriding-local-map overriding-local-map)
	  (debugger-outer-overriding-terminal-local-map
	   overriding-terminal-local-map)
	  (debugger-outer-track-mouse track-mouse)
	  (debugger-outer-last-command last-command)
	  (debugger-outer-this-command this-command)
188 189
	  (debugger-outer-unread-command-char
	   (with-no-warnings unread-command-char))
190 191 192 193 194 195 196 197 198 199
	  (debugger-outer-unread-command-events unread-command-events)
	  (debugger-outer-unread-post-input-method-events
	   unread-post-input-method-events)
	  (debugger-outer-last-input-event last-input-event)
	  (debugger-outer-last-command-event last-command-event)
	  (debugger-outer-last-nonmenu-event last-nonmenu-event)
	  (debugger-outer-last-event-frame last-event-frame)
	  (debugger-outer-standard-input standard-input)
	  (debugger-outer-standard-output standard-output)
	  (debugger-outer-inhibit-redisplay inhibit-redisplay)
200 201
	  (debugger-outer-cursor-in-echo-area cursor-in-echo-area)
	  (debugger-with-timeout-suspend (with-timeout-suspend)))
202 203 204 205 206
      ;; Set this instead of binding it, so that `q'
      ;; will not restore it.
      (setq overriding-terminal-local-map nil)
      ;; Don't let these magic variables affect the debugger itself.
      (let ((last-command nil) this-command track-mouse
207 208
	    (inhibit-trace t)
	    (inhibit-debug-on-entry t)
209
	    unread-command-events
210 211 212 213 214 215 216 217 218 219 220 221 222 223
	    unread-post-input-method-events
	    last-input-event last-command-event last-nonmenu-event
	    last-event-frame
	    overriding-local-map
	    load-read-function
	    ;; If we are inside a minibuffer, allow nesting
	    ;; so that we don't get an error from the `e' command.
	    (enable-recursive-minibuffers
	     (or enable-recursive-minibuffers (> (minibuffer-depth) 0)))
	    (standard-input t) (standard-output t)
	    inhibit-redisplay
	    (cursor-in-echo-area nil))
	(unwind-protect
	    (save-excursion
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
	      (with-no-warnings
		(setq unread-command-char -1))
	      (when (eq (car debugger-args) 'debug)
		;; Skip the frames for backtrace-debug, byte-code,
		;; and implement-debug-on-entry.
		(backtrace-debug 4 t)
		;; Place an extra debug-on-exit for macro's.
		(when (eq 'lambda (car-safe (cadr (backtrace-frame 4))))
		  (backtrace-debug 5 t)))
	      (pop-to-buffer
	       debugger-buffer
	       `((display-buffer-reuse-window
		  display-buffer-in-previous-window)
		  . (,(when debugger-previous-window
			`(previous-window . ,debugger-previous-window)))))
	      (setq debugger-window (selected-window))
240 241 242 243 244 245 246 247 248 249 250
	      (if (eq debugger-previous-window debugger-window)
		  (when debugger-jumping-flag
		    ;; Try to restore previous height of debugger
		    ;; window.
		    (condition-case nil
			(window-resize
			 debugger-window
			 (- debugger-previous-window-height
			    (window-total-size debugger-window)))
		      (error nil)))
		(setq debugger-previous-window debugger-window))
251 252 253 254 255 256 257
	      (debugger-mode)
	      (debugger-setup-buffer debugger-args)
	      (when noninteractive
		;; If the backtrace is long, save the beginning
		;; and the end, but discard the middle.
		(when (> (count-lines (point-min) (point-max))
			 debugger-batch-max-lines)
258
		  (goto-char (point-min))
259 260 261 262 263 264 265 266 267 268 269 270 271
		  (forward-line (/ 2 debugger-batch-max-lines))
		  (let ((middlestart (point)))
		    (goto-char (point-max))
		    (forward-line (- (/ 2 debugger-batch-max-lines)
				     debugger-batch-max-lines))
		    (delete-region middlestart (point)))
		  (insert "...\n"))
		(goto-char (point-min))
		(message "%s" (buffer-string))
		(kill-emacs -1))
	      (message "")
	      (let ((standard-output nil)
		    (buffer-read-only t))
272
		(message "")
273 274 275 276 277
		;; Make sure we unbind buffer-read-only in the right buffer.
		(save-excursion
		  (recursive-edit))))
	  (when (and (window-live-p debugger-window)
		     (eq (window-buffer debugger-window) debugger-buffer))
278 279 280
	    ;; Record height of debugger window.
	    (setq debugger-previous-window-height
		  (window-total-size debugger-window))
281 282 283 284 285 286 287 288 289 290 291 292 293
	    ;; Unshow debugger-buffer.
	    (quit-restore-window debugger-window debugger-bury-or-kill))
          ;; Restore previous state of debugger-buffer in case we were
          ;; in a recursive invocation of the debugger, otherwise just
          ;; erase the buffer and put it into fundamental mode.
	  (when (buffer-live-p debugger-buffer)
	    (with-current-buffer debugger-buffer
	      (let ((inhibit-read-only t))
		(erase-buffer)
		(if (null debugger-previous-state)
		    (fundamental-mode)
		  (insert (nth 1 debugger-previous-state))
		  (funcall (nth 0 debugger-previous-state))))))
294
	  (with-timeout-unsuspend debugger-with-timeout-suspend)
295 296 297 298 299 300 301 302 303 304
	  (set-match-data debugger-outer-match-data)))
      ;; Put into effect the modified values of these variables
      ;; in case the user set them with the `e' command.
      (setq load-read-function debugger-outer-load-read-function)
      (setq overriding-local-map debugger-outer-overriding-local-map)
      (setq overriding-terminal-local-map
	    debugger-outer-overriding-terminal-local-map)
      (setq track-mouse debugger-outer-track-mouse)
      (setq last-command debugger-outer-last-command)
      (setq this-command debugger-outer-this-command)
305
      (with-no-warnings
306
	(setq unread-command-char debugger-outer-unread-command-char))
307 308 309 310 311 312 313 314 315 316 317 318 319
      (setq unread-command-events debugger-outer-unread-command-events)
      (setq unread-post-input-method-events
	    debugger-outer-unread-post-input-method-events)
      (setq last-input-event debugger-outer-last-input-event)
      (setq last-command-event debugger-outer-last-command-event)
      (setq last-nonmenu-event debugger-outer-last-nonmenu-event)
      (setq last-event-frame debugger-outer-last-event-frame)
      (setq standard-input debugger-outer-standard-input)
      (setq standard-output debugger-outer-standard-output)
      (setq inhibit-redisplay debugger-outer-inhibit-redisplay)
      (setq cursor-in-echo-area debugger-outer-cursor-in-echo-area)
      (setq debug-on-next-call debugger-step-after-exit)
      debugger-value)))
Jim Blandy's avatar
Jim Blandy committed
320

321 322 323 324 325
(defun debugger-setup-buffer (debugger-args)
  "Initialize the `*Backtrace*' buffer for entry to the debugger.
That buffer should be current already."
  (setq buffer-read-only nil)
  (erase-buffer)
326
  (set-buffer-multibyte t)		;Why was it nil ?  -stef
327
  (setq buffer-undo-list t)
328 329 330 331 332 333 334 335 336
  (let ((standard-output (current-buffer))
	(print-escape-newlines t)
	(print-level 8)
	(print-length 50))
    (backtrace))
  (goto-char (point-min))
  (delete-region (point)
		 (progn
		   (search-forward "\n  debug(")
337
		   (forward-line (if (eq (car debugger-args) 'debug)
Lute Kamstra's avatar
Lute Kamstra committed
338
				     2	; Remove implement-debug-on-entry frame.
339
				   1))
340 341 342 343
		   (point)))
  (insert "Debugger entered")
  ;; lambda is for debug-on-call when a function call is next.
  ;; debug is for debug-on-entry function called.
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
  (pcase (car debugger-args)
    ((or `lambda `debug)
     (insert "--entering a function:\n"))
    ;; Exiting a function.
    (`exit
     (insert "--returning value: ")
     (setq debugger-value (nth 1 debugger-args))
     (prin1 debugger-value (current-buffer))
     (insert ?\n)
     (delete-char 1)
     (insert ? )
     (beginning-of-line))
    ;; Debugger entered for an error.
    (`error
     (insert "--Lisp error: ")
     (prin1 (nth 1 debugger-args) (current-buffer))
     (insert ?\n))
    ;; debug-on-call, when the next thing is an eval.
    (`t
     (insert "--beginning evaluation of function call form:\n"))
    ;; User calls debug directly.
    (_
     (insert ": ")
     (prin1 (if (eq (car debugger-args) 'nil)
                (cdr debugger-args) debugger-args)
            (current-buffer))
     (insert ?\n)))
371 372 373
  ;; After any frame that uses eval-buffer,
  ;; insert a line that states the buffer position it's reading at.
  (save-excursion
374 375 376 377 378 379 380 381 382 383 384
    (let ((tem eval-buffer-list))
      (while (and tem
		  (re-search-forward "^  eval-\\(buffer\\|region\\)(" nil t))
	(end-of-line)
	(insert (format "  ; Reading at buffer position %d"
			;; This will get the wrong result
			;; if there are two nested eval-region calls
			;; for the same buffer.  That's not a very useful case.
			(with-current-buffer (car tem)
			  (point))))
	(pop tem))))
385 386 387
  (debugger-make-xrefs))

(defun debugger-make-xrefs (&optional buffer)
388
  "Attach cross-references to function names in the `*Backtrace*' buffer."
389
  (interactive "b")
390
  (with-current-buffer (or buffer (current-buffer))
391 392 393
    (save-excursion
      (setq buffer (current-buffer))
      (let ((inhibit-read-only t)
Glenn Morris's avatar
Glenn Morris committed
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
	    (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.
423

Glenn Morris's avatar
Glenn Morris committed
424 425 426 427 428 429 430 431 432 433 434 435
	      ;; 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)))
436

Glenn Morris's avatar
Glenn Morris committed
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
	;; 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))
456
      (setq debugger-previous-backtrace (buffer-string)))))
457

Jim Blandy's avatar
Jim Blandy committed
458 459 460 461 462
(defun debugger-step-through ()
  "Proceed, stepping through subexpressions of this expression.
Enter another debugger on next entry to eval, apply or funcall."
  (interactive)
  (setq debugger-step-after-exit t)
463
  (setq debugger-jumping-flag t)
464
  (setq debugger-will-be-back t)
465
  (add-hook 'post-command-hook 'debugger-reenable)
Jim Blandy's avatar
Jim Blandy committed
466 467 468 469 470 471
  (message "Proceeding, will debug on next eval or call.")
  (exit-recursive-edit))

(defun debugger-continue ()
  "Continue, evaluating this expression without stopping."
  (interactive)
472 473
  (unless debugger-may-continue
    (error "Cannot continue"))
Jim Blandy's avatar
Jim Blandy committed
474
  (message "Continuing.")
475 476 477 478 479 480
  (save-excursion
    ;; Check to see if we've flagged some frame for debug-on-exit, in which
    ;; case we'll probably come back to the debugger soon.
    (goto-char (point-min))
    (if (re-search-forward "^\\* " nil t)
        (setq debugger-will-be-back t)))
Jim Blandy's avatar
Jim Blandy committed
481 482 483 484 485 486 487
  (exit-recursive-edit))

(defun debugger-return-value (val)
  "Continue, specifying value to return.
This is only useful when the value returned from the debugger
will be used, such as in a debug on exit from a frame."
  (interactive "XReturn value (evaluated): ")
488 489 490 491
  (when (memq (car debugger-args) '(t lambda error debug))
    (error "Cannot return a value %s"
           (if (eq (car debugger-args) 'error)
               "from an error" "at function entrance")))
Jim Blandy's avatar
Jim Blandy committed
492 493 494
  (setq debugger-value val)
  (princ "Returning " t)
  (prin1 debugger-value)
495 496 497 498 499 500
  (save-excursion
    ;; Check to see if we've flagged some frame for debug-on-exit, in which
    ;; case we'll probably come back to the debugger soon.
    (goto-char (point-min))
    (if (re-search-forward "^\\* " nil t)
        (setq debugger-will-be-back t)))
Jim Blandy's avatar
Jim Blandy committed
501 502 503 504 505
  (exit-recursive-edit))

(defun debugger-jump ()
  "Continue to exit from this frame, with all debug-on-entry suspended."
  (interactive)
506
  (debugger-frame)
507 508
  (setq debugger-jumping-flag t)
  (add-hook 'post-command-hook 'debugger-reenable)
Jim Blandy's avatar
Jim Blandy committed
509
  (message "Continuing through this frame")
510
  (setq debugger-will-be-back t)
Jim Blandy's avatar
Jim Blandy committed
511 512 513
  (exit-recursive-edit))

(defun debugger-reenable ()
514 515 516 517 518
  "Turn all debug-on-entry functions back on.
This function is put on `post-command-hook' by `debugger-jump' and
removes itself from that hook."
  (setq debugger-jumping-flag nil)
  (remove-hook 'post-command-hook 'debugger-reenable))
Jim Blandy's avatar
Jim Blandy committed
519 520 521 522 523 524 525

(defun debugger-frame-number ()
  "Return number of frames in backtrace before the one point points at."
  (save-excursion
    (beginning-of-line)
    (let ((opoint (point))
	  (count 0))
526 527
      (while (not (eq (cadr (backtrace-frame count)) 'debug))
	(setq count (1+ count)))
Lute Kamstra's avatar
Lute Kamstra committed
528 529
      ;; Skip implement-debug-on-entry frame.
      (when (eq 'implement-debug-on-entry (cadr (backtrace-frame (1+ count))))
530
	(setq count (1+ count)))
Jim Blandy's avatar
Jim Blandy committed
531
      (goto-char (point-min))
532 533 534
      (when (looking-at "Debugger entered--\\(Lisp error\\|returning value\\):")
	(goto-char (match-end 0))
	(forward-sexp 1))
Jim Blandy's avatar
Jim Blandy committed
535 536 537 538 539 540 541 542
      (forward-line 1)
      (while (progn
	       (forward-char 2)
	       (if (= (following-char) ?\()
		   (forward-sexp 1)
		 (forward-sexp 2))
	       (forward-line 1)
	       (<= (point) opoint))
543 544
	(if (looking-at " *;;;")
	    (forward-line 1))
Jim Blandy's avatar
Jim Blandy committed
545 546 547 548 549 550 551
	(setq count (1+ count)))
      count)))

(defun debugger-frame ()
  "Request entry to debugger when this frame exits.
Applies to the frame whose line point is on in the backtrace."
  (interactive)
552 553 554 555
  (save-excursion
    (beginning-of-line)
    (if (looking-at " *;;;\\|[a-z]")
	(error "This line is not a function call")))
Jim Blandy's avatar
Jim Blandy committed
556
  (beginning-of-line)
557
  (backtrace-debug (debugger-frame-number) t)
Jim Blandy's avatar
Jim Blandy committed
558
  (if (= (following-char) ? )
559
      (let ((inhibit-read-only t))
Jim Blandy's avatar
Jim Blandy committed
560 561 562 563 564
	(delete-char 1)
	(insert ?*)))
  (beginning-of-line))

(defun debugger-frame-clear ()
565
  "Do not enter debugger when this frame exits.
Jim Blandy's avatar
Jim Blandy committed
566 567
Applies to the frame whose line point is on in the backtrace."
  (interactive)
568 569 570 571
  (save-excursion
    (beginning-of-line)
    (if (looking-at " *;;;\\|[a-z]")
	(error "This line is not a function call")))
Jim Blandy's avatar
Jim Blandy committed
572
  (beginning-of-line)
573
  (backtrace-debug (debugger-frame-number) nil)
Jim Blandy's avatar
Jim Blandy committed
574
  (if (= (following-char) ?*)
575
      (let ((inhibit-read-only t))
Jim Blandy's avatar
Jim Blandy committed
576 577 578 579
	(delete-char 1)
	(insert ? )))
  (beginning-of-line))

580 581
(defmacro debugger-env-macro (&rest body)
  "Run BODY in original environment."
Stefan Monnier's avatar
Stefan Monnier committed
582
  (declare (indent 0))
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
  `(save-excursion
    (if (null (buffer-name debugger-old-buffer))
        ;; old buffer deleted
        (setq debugger-old-buffer (current-buffer)))
    (set-buffer debugger-old-buffer)
    (let ((load-read-function debugger-outer-load-read-function)
          (overriding-terminal-local-map
           debugger-outer-overriding-terminal-local-map)
          (overriding-local-map debugger-outer-overriding-local-map)
          (track-mouse debugger-outer-track-mouse)
          (last-command debugger-outer-last-command)
          (this-command debugger-outer-this-command)
          (unread-command-events debugger-outer-unread-command-events)
          (unread-post-input-method-events
           debugger-outer-unread-post-input-method-events)
          (last-input-event debugger-outer-last-input-event)
          (last-command-event debugger-outer-last-command-event)
          (last-nonmenu-event debugger-outer-last-nonmenu-event)
          (last-event-frame debugger-outer-last-event-frame)
          (standard-input debugger-outer-standard-input)
          (standard-output debugger-outer-standard-output)
          (inhibit-redisplay debugger-outer-inhibit-redisplay)
          (cursor-in-echo-area debugger-outer-cursor-in-echo-area))
      (set-match-data debugger-outer-match-data)
607 608 609 610 611
      (prog1
	  (let ((save-ucc (with-no-warnings unread-command-char)))
	    (unwind-protect
		(progn
		  (with-no-warnings
612
		    (setq unread-command-char debugger-outer-unread-command-char))
613 614
		  (prog1 (progn ,@body)
		    (with-no-warnings
615
		      (setq debugger-outer-unread-command-char unread-command-char))))
616
	      (with-no-warnings
617
		(setq unread-command-char save-ucc))))
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
        (setq debugger-outer-match-data (match-data))
        (setq debugger-outer-load-read-function load-read-function)
        (setq debugger-outer-overriding-terminal-local-map
              overriding-terminal-local-map)
        (setq debugger-outer-overriding-local-map overriding-local-map)
        (setq debugger-outer-track-mouse track-mouse)
        (setq debugger-outer-last-command last-command)
        (setq debugger-outer-this-command this-command)
        (setq debugger-outer-unread-command-events unread-command-events)
        (setq debugger-outer-unread-post-input-method-events
              unread-post-input-method-events)
        (setq debugger-outer-last-input-event last-input-event)
        (setq debugger-outer-last-command-event last-command-event)
        (setq debugger-outer-last-nonmenu-event last-nonmenu-event)
        (setq debugger-outer-last-event-frame last-event-frame)
        (setq debugger-outer-standard-input standard-input)
        (setq debugger-outer-standard-output standard-output)
        (setq debugger-outer-inhibit-redisplay inhibit-redisplay)
        (setq debugger-outer-cursor-in-echo-area cursor-in-echo-area)
        ))))
638

Jim Blandy's avatar
Jim Blandy committed
639
(defun debugger-eval-expression (exp)
640 641 642 643 644
  "Eval an expression, in an environment like that outside the debugger."
  (interactive
   (list (read-from-minibuffer "Eval: "
			       nil read-expression-map t
			       'read-expression-history)))
645
  (debugger-env-macro (eval-expression exp)))
Jim Blandy's avatar
Jim Blandy committed
646

647
(defvar debugger-mode-map
648 649
  (let ((map (make-keymap))
	(menu-map (make-sparse-keymap)))
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
    (set-keymap-parent map button-buffer-map)
    (suppress-keymap map)
    (define-key map "-" 'negative-argument)
    (define-key map "b" 'debugger-frame)
    (define-key map "c" 'debugger-continue)
    (define-key map "j" 'debugger-jump)
    (define-key map "r" 'debugger-return-value)
    (define-key map "u" 'debugger-frame-clear)
    (define-key map "d" 'debugger-step-through)
    (define-key map "l" 'debugger-list-functions)
    (define-key map "h" 'describe-mode)
    (define-key map "q" 'top-level)
    (define-key map "e" 'debugger-eval-expression)
    (define-key map " " 'next-line)
    (define-key map "R" 'debugger-record-expression)
665
    (define-key map "\C-m" 'debug-help-follow)
666
    (define-key map [mouse-2] 'push-button)
667 668 669
    (define-key map [menu-bar debugger] (cons "Debugger" menu-map))
    (define-key menu-map [deb-top]
      '(menu-item "Quit" top-level
Dan Nicolaescu's avatar
Dan Nicolaescu committed
670
		  :help "Quit debugging and return to top level"))
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
    (define-key menu-map [deb-s0] '("--"))
    (define-key menu-map [deb-descr]
      '(menu-item "Describe Debugger Mode" describe-mode
		  :help "Display documentation for debugger-mode"))
    (define-key menu-map [deb-hfol]
      '(menu-item "Help Follow" debug-help-follow
		  :help "Follow cross-reference"))
    (define-key menu-map [deb-nxt]
      '(menu-item "Next Line" next-line
		  :help "Move cursor down"))
    (define-key menu-map [deb-s1] '("--"))
    (define-key menu-map [deb-lfunc]
      '(menu-item "List debug on entry functions" debugger-list-functions
		  :help "Display a list of all the functions now set to debug on entry"))
    (define-key menu-map [deb-fclear]
      '(menu-item "Cancel debug frame" debugger-frame-clear
		  :help "Do not enter debugger when this frame exits"))
    (define-key menu-map [deb-frame]
      '(menu-item "Debug frame" debugger-frame
		  :help "Request entry to debugger when this frame exits"))
    (define-key menu-map [deb-s2] '("--"))
    (define-key menu-map [deb-ret]
      '(menu-item "Return value..." debugger-return-value
		  :help "Continue, specifying value to return."))
    (define-key menu-map [deb-rec]
      '(menu-item "Display and Record Expression" debugger-record-expression
		  :help "Display a variable's value and record it in `*Backtrace-record*' buffer"))
    (define-key menu-map [deb-eval]
      '(menu-item "Eval Expression..." debugger-eval-expression
		  :help "Eval an expression, in an environment like that outside the debugger"))
    (define-key menu-map [deb-jump]
      '(menu-item "Jump" debugger-jump
		  :help "Continue to exit from this frame, with all debug-on-entry suspended"))
    (define-key menu-map [deb-cont]
      '(menu-item "Continue" debugger-continue
		  :help "Continue, evaluating this expression without stopping"))
    (define-key menu-map [deb-step]
      '(menu-item "Step through" debugger-step-through
		  :help "Proceed, stepping through subexpressions of this expression"))
710
    map))
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735

(put 'debugger-mode 'mode-class 'special)

(defun debugger-mode ()
  "Mode for backtrace buffers, selected in debugger.
\\<debugger-mode-map>
A line starts with `*' if exiting that frame will call the debugger.
Type \\[debugger-frame] or \\[debugger-frame-clear] to set or remove the `*'.

When in debugger due to frame being exited,
use the \\[debugger-return-value] command to override the value
being returned from that frame.

Use \\[debug-on-entry] and \\[cancel-debug-on-entry] to control
which functions will enter the debugger when called.

Complete list of commands:
\\{debugger-mode-map}"
  (kill-all-local-variables)
  (setq major-mode 'debugger-mode)
  (setq mode-name "Debugger")
  (setq truncate-lines t)
  (set-syntax-table emacs-lisp-mode-syntax-table)
  (use-local-map debugger-mode-map)
  (run-mode-hooks 'debugger-mode-hook))
736

Stephen Eglen's avatar
Stephen Eglen committed
737
(defcustom debugger-record-buffer "*Debugger-record*"
738
  "Buffer name for expression values, for \\[debugger-record-expression]."
Stephen Eglen's avatar
Stephen Eglen committed
739
  :type 'string
Dan Nicolaescu's avatar
Dan Nicolaescu committed
740 741
  :group 'debugger
  :version "20.3")
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757

(defun debugger-record-expression  (exp)
  "Display a variable's value and record it in `*Backtrace-record*' buffer."
  (interactive
   (list (read-from-minibuffer
	  "Record Eval: "
	  nil
	  read-expression-map t
	  'read-expression-history)))
  (let* ((buffer (get-buffer-create debugger-record-buffer))
	 (standard-output buffer))
    (princ (format "Debugger Eval (%s): " exp))
    (princ (debugger-eval-expression exp))
    (terpri))

  (with-current-buffer (get-buffer debugger-record-buffer)
758
    (message "%s"
759 760
	     (buffer-substring (line-beginning-position 0)
			       (line-end-position 0)))))
Jim Blandy's avatar
Jim Blandy committed
761

Glenn Morris's avatar
Glenn Morris committed
762 763
(declare-function help-xref-interned "help-mode" (symbol))

764 765 766 767 768 769
(defun debug-help-follow (&optional pos)
  "Follow cross-reference at POS, defaulting to point.

For the cross-reference format, see `help-make-xrefs'."
  (interactive "d")
  (require 'help-mode)
770 771 772
  ;; Ideally we'd just do (call-interactively 'help-follow) except that this
  ;; assumes we're already in a *Help* buffer and reuses it, so it ends up
  ;; incorrectly "reusing" the *Backtrace* buffer to show the help info.
773 774 775 776 777 778 779 780 781 782 783 784
  (unless pos
    (setq pos (point)))
  (unless (push-button pos)
    ;; check if the symbol under point is a function or variable
    (let ((sym
	   (intern
	    (save-excursion
	      (goto-char pos) (skip-syntax-backward "w_")
	      (buffer-substring (point)
				(progn (skip-syntax-forward "w_")
				       (point)))))))
      (when (or (boundp sym) (fboundp sym) (facep sym))
785
        (help-xref-interned sym)))))
Jim Blandy's avatar
Jim Blandy committed
786

Lute Kamstra's avatar
Lute Kamstra committed
787 788 789 790 791 792 793 794 795 796
;; When you change this, you may also need to change the number of
;; frames that the debugger skips.
(defun implement-debug-on-entry ()
  "Conditionally call the debugger.
A call to this function is inserted by `debug-on-entry' to cause
functions to break on entry."
  (if (or inhibit-debug-on-entry debugger-jumping-flag)
      nil
    (funcall debugger 'debug)))

797 798 799 800 801 802
(defun debugger-special-form-p (symbol)
  "Return whether SYMBOL is a special form."
  (and (fboundp symbol)
       (subrp (symbol-function symbol))
       (eq (cdr (subr-arity (symbol-function symbol))) 'unevalled)))

Jim Blandy's avatar
Jim Blandy committed
803 804 805
;;;###autoload
(defun debug-on-entry (function)
  "Request FUNCTION to invoke debugger each time it is called.
806

807
When called interactively, prompt for FUNCTION in the minibuffer.
808 809 810 811 812 813 814 815

This works by modifying the definition of FUNCTION.  If you tell the
debugger to continue, FUNCTION's execution proceeds.  If FUNCTION is a
normal function or a macro written in Lisp, you can also step through
its execution.  FUNCTION can also be a primitive that is not a special
form, in which case stepping is not possible.  Break-on-entry for
primitive functions only works when that function is called from Lisp.

Jim Blandy's avatar
Jim Blandy committed
816
Use \\[cancel-debug-on-entry] to cancel the effect of this command.
817
Redefining FUNCTION also cancels it."
818 819 820 821
  (interactive
   (let ((fn (function-called-at-point)) val)
     (when (debugger-special-form-p fn)
       (setq fn nil))
822
     (setq val (completing-read
823 824 825 826 827 828 829 830 831
		(if fn
		    (format "Debug on entry to function (default %s): " fn)
		  "Debug on entry to function: ")
		obarray
		#'(lambda (symbol)
		    (and (fboundp symbol)
			 (not (debugger-special-form-p symbol))))
		t nil nil (symbol-name fn)))
     (list (if (equal val "") fn (intern val)))))
832
  ;; FIXME: Use advice.el.
833
  (when (debugger-special-form-p function)
834
    (error "Function %s is a special form" function))
835
  (if (or (symbolp (symbol-function function))
836
	  (subrp (symbol-function function)))
837 838
      ;; The function is built-in or aliased to another function.
      ;; Create a wrapper in which we can add the debug call.
839
      (fset function `(lambda (&rest debug-on-entry-args)
840
			,(interactive-form (symbol-function function))
841
			(apply ',(symbol-function function)
842
			       debug-on-entry-args)))
843
    (when (autoloadp (symbol-function function))
844
      ;; The function is autoloaded.  Load its real definition.
845
      (autoload-do-load (symbol-function function) function))
846 847 848 849 850 851 852 853
    (when (or (not (consp (symbol-function function)))
	      (and (eq (car (symbol-function function)) 'macro)
		   (not (consp (cdr (symbol-function function))))))
      ;; The function is byte-compiled.  Create a wrapper in which
      ;; we can add the debug call.
      (debug-convert-byte-code function)))
  (unless (consp (symbol-function function))
    (error "Definition of %s is not a list" function))
Lute Kamstra's avatar
Lute Kamstra committed
854
  (fset function (debug-on-entry-1 function t))
855 856
  (unless (memq function debug-function-list)
    (push function debug-function-list))
Jim Blandy's avatar
Jim Blandy committed
857 858 859 860 861
  function)

;;;###autoload
(defun cancel-debug-on-entry (&optional function)
  "Undo effect of \\[debug-on-entry] on FUNCTION.
862
If FUNCTION is nil, cancel debug-on-entry for all functions.
863 864
When called interactively, prompt for FUNCTION in the minibuffer.
To specify a nil argument interactively, exit with an empty minibuffer."
Jim Blandy's avatar
Jim Blandy committed
865 866
  (interactive
   (list (let ((name
867
		(completing-read
868
		 "Cancel debug on entry to function (default all functions): "
869
		 (mapcar 'symbol-name debug-function-list) nil t)))
870 871 872 873 874
	   (when name
	     (unless (string= name "")
	       (intern name))))))
  (if (and function
	   (not (string= function ""))) ; Pre 22.1 compatibility test.
Jim Blandy's avatar
Jim Blandy committed
875
      (progn
876
	(let ((defn (debug-on-entry-1 function nil)))
877
	  (condition-case nil
878 879 880 881 882
	      (when (and (equal (nth 1 defn) '(&rest debug-on-entry-args))
			 (eq (car (nth 3 defn)) 'apply))
		;; `defn' is a wrapper introduced in debug-on-entry.
		;; Get rid of it since we don't need it any more.
		(setq defn (nth 1 (nth 1 (nth 3 defn)))))
883
	    (error nil))
884
	  (fset function defn))
Jim Blandy's avatar
Jim Blandy committed
885 886 887 888 889
	(setq debug-function-list (delq function debug-function-list))
	function)
    (message "Cancelling debug-on-entry for all functions")
    (mapcar 'cancel-debug-on-entry debug-function-list)))

890 891 892 893 894 895
(defun debug-arglist (definition)
  ;; FIXME: copied from ad-arglist.
  "Return the argument list of DEFINITION."
  (require 'help-fns)
  (help-function-arglist definition 'preserve-names))

Jim Blandy's avatar
Jim Blandy committed
896
(defun debug-convert-byte-code (function)
897 898 899
  (let* ((defn (symbol-function function))
	 (macro (eq (car-safe defn) 'macro)))
    (when macro (setq defn (cdr defn)))
900 901
    (when (byte-code-function-p defn)
      (let* ((args (debug-arglist defn))
902
	     (body
903 904 905 906
              `((,(if (memq '&rest args) #'apply #'funcall)
                 ,defn
                 ,@(remq '&rest (remq '&optional args))))))
	(if (> (length defn) 5)
907 908
            ;; The mere presence of field 5 is sufficient to make
            ;; it interactive.
909
	    (push `(interactive ,(aref defn 5)) body))
910
	(if (and (> (length defn) 4) (aref defn 4))
911 912 913 914
	    ;; Use `documentation' here, to get the actual string,
	    ;; in case the compiled function has a reference
	    ;; to the .elc file.
	    (setq body (cons (documentation function) body)))
915
	(setq defn `(closure (t) ,args ,@body)))
916 917
      (when macro (setq defn (cons 'macro defn)))
      (fset function defn))))
Jim Blandy's avatar
Jim Blandy committed
918

Lute Kamstra's avatar
Lute Kamstra committed
919 920 921
(defun debug-on-entry-1 (function flag)
  (let* ((defn (symbol-function function))
	 (tail defn))
922
    (when (eq (car-safe tail) 'macro)
923
      (setq tail (cdr tail)))
924
    (if (not (memq (car-safe tail) '(closure lambda)))
925 926 927 928
	;; Only signal an error when we try to set debug-on-entry.
	;; When we try to clear debug-on-entry, we are now done.
	(when flag
	  (error "%s is not a user-defined Lisp function" function))
929
      (if (eq (car tail) 'closure) (setq tail (cdr tail)))
930
      (setq tail (cdr tail))
931 932 933 934 935 936
      ;; Skip the docstring.
      (when (and (stringp (cadr tail)) (cddr tail))
	(setq tail (cdr tail)))
      ;; Skip the interactive form.
      (when (eq 'interactive (car-safe (cadr tail)))
	(setq tail (cdr tail)))
Lute Kamstra's avatar
Lute Kamstra committed
937
      (unless (eq flag (equal (cadr tail) '(implement-debug-on-entry)))
938
	;; Add/remove debug statement as needed.
939 940 941
	(setcdr tail (if flag
                         (cons '(implement-debug-on-entry) (cdr tail))
                       (cddr tail)))))
942
    defn))
Jim Blandy's avatar
Jim Blandy committed
943 944 945 946

(defun debugger-list-functions ()
  "Display a list of all the functions now set to debug on entry."
  (interactive)
947
  (require 'help-mode)
948 949
  (help-setup-xref '(debugger-list-functions)
		   (called-interactively-p 'interactive))
950 951 952 953 954 955 956 957 958 959 960 961 962
  (with-output-to-temp-buffer (help-buffer)
    (with-current-buffer standard-output
      (if (null debug-function-list)
	  (princ "No debug-on-entry functions now\n")
	(princ "Functions set to debug on entry:\n\n")
	(dolist (fun debug-function-list)
	  (make-text-button (point) (progn (prin1 fun) (point))
			    'type 'help-function
			    'help-args (list fun))
	  (terpri))
	(terpri)
	(princ "Note: if you have redefined a function, then it may no longer\n")
	(princ "be set to debug on entry, even if it is in the list.")))))
Eric S. Raymond's avatar
Eric S. Raymond committed
963

Richard M. Stallman's avatar
Richard M. Stallman committed
964 965
(provide 'debug)

Eric S. Raymond's avatar
Eric S. Raymond committed
966
;;; debug.el ends here