Emacs Lisp调试器中继续和退出之间的区别

Question

(progn
  (print 11)
  (/ 1 0)
  (print 22)
  (/ 2 0)
  (print 33))

When I press CMx on that expression, Emacs invokes debugger when it fails at (/ 1 0). When I press c for continue instead of q for quit, debugger still exits without executing (print 22) or (/ 2 0). The only difference here is that c exits with the message

progn: Arithmetic error

What is an example code where c and q make big difference and when should I type c rather than q?

Answer 1

可以在不停止执行的任何代码中显示差异，即不包含错误（例如，在debug调用时）。

Answer 2

The difference is easiest to see when you use debug-on-signal . With this setting, the debugger gets called when an error is signalled, even if that error is handled by an enclosing condition-case . In such a situation c will continue the normal execution (ie signal the error, which in turn causes the handler code to be run, which may then continue execution normally).

Answer 3

At first it seemed to me like a very obvious question, but after trying to build an example, I actually had to look in the info . So let me summarize what I've clarified for myself:

c in edebug is not the same as c in gdb . This one just stops for one second at each breakpoint and eventually quits. I don't see at the moment how it can be useful to anyone. The equivalent is instead g : this one will continue until next breakpoint and stop there.

Here's a code example:

(defun foo ()
  (setq x (loop for i from 1 to 100
             collecting (* i i)))
  (setq y (nth 5 x))
  (incf y))

(foo)

To edebug it:

1. Paste this code into *scratch*
2. Move point inside foo and Cu CMx (calls edebug-defun )
3. Move point to y in setq y and Mx edebug-set-breakpoint
4. Move point to the closing paren in (foo) and Cj
5. You're now in edebug . Here you could do step 3 with the shortcut b instead of Mx ...
6. You'll find that proceeding with SPC is tedious, since it will move though each statement of the loop each time.
7. But if you press g you'll skip past the whole loop, ending up in the statement that you're supposedly interested in.

Answer 4

Another difference is with respect to recursive edit. For example, I could invoke query-replace and then enter recursive edit and then type (/ 1 0) and evaluate it to enter debugger. Now if I press q, we are back to top level and no longer running query-replace. But if I press c instead, I am still inside recursive edit.

Update another difference. While in debugger, c is bound to debugger-continue which is a wrapper around exit-recursive-edit and q is bound to top-level . That means any difference known about exit-recursive-edit vs top-level applies. See Recursive Edit - Emacs Manual for difference.

Here's an example adapted from an example in Recursive Editing - Emacs Lisp Manual to test differences.

(defun simple-rec ()
  (forward-word 1)
  (message "111")
  (debug)
  (message "222")
  (forward-word 1))