debug-on-entry

debug-on-entry

[Luc Teirlinck]

Are the claims in the Elisp manual and in the debug-on-entry docstring
that debug-on-entry does not work for primitive functions still valid?

I tried it on select-frame, a primitive function, and possibly one can
not get all features, but a least I got a backtrace buffer.

Sincerely,

Luc.

Re: debug-on-entry

[Lute Kamstra]

Luc Teirlinck <teirllm@dms.auburn.edu> writes:

> Are the claims in the Elisp manual and in the debug-on-entry docstring
> that debug-on-entry does not work for primitive functions still valid?
>
> I tried it on select-frame, a primitive function, and possibly one can
> not get all features, but a least I got a backtrace buffer.

You can use debug-on-entry for primitive functions that are not
specials forms.  You just can't step through them.  I'll fix the
docs.

Thanks for noticing,

  Lute.

Re: debug-on-entry

[Stefan Monnier]

> You can use debug-on-entry for primitive functions that are not
> specials forms.  You just can't step through them.  I'll fix the
> docs.

Also they may be called without triggering the debugger, if they're called
directly from C rather than from elisp.  I.e. it's unreliable (but can
still be useful, I guess).


        Stefan

Re: debug-on-entry

[Lute Kamstra]

Stefan Monnier <monnier@iro.umontreal.ca> writes:

>> You can use debug-on-entry for primitive functions that are not
>> specials forms.  You just can't step through them.  I'll fix the
>> docs.
>
> Also they may be called without triggering the debugger, if they're called
> directly from C rather than from elisp.  I.e. it's unreliable (but can
> still be useful, I guess).

I'll point that out.

Thanks,

  Lute.

Re: debug-on-entry

[Lute Kamstra]

Lute Kamstra <Lute.Kamstra.lists@xs4all.nl> writes:

>>> You can use debug-on-entry for primitive functions that are not
>>> specials forms.  You just can't step through them.  I'll fix the
>>> docs.
>>
>> Also they may be called without triggering the debugger, if they're called
>> directly from C rather than from elisp.  I.e. it's unreliable (but can
>> still be useful, I guess).
>
> I'll point that out.

What about the patch below?

Lute.


Index: lisp/emacs-lisp/debug.el
===================================================================
RCS file: /cvsroot/emacs/emacs/lisp/emacs-lisp/debug.el,v
retrieving revision 1.85
diff -c -r1.85 debug.el
*** lisp/emacs-lisp/debug.el	13 Jun 2005 08:13:16 -0000	1.85
--- lisp/emacs-lisp/debug.el	13 Jun 2005 09:23:19 -0000
***************
*** 656,665 ****
  ;;;###autoload
  (defun debug-on-entry (function)
    "Request FUNCTION to invoke debugger each time it is called.
  When called interactively, prompt for FUNCTION in the minibuffer.
! If you tell the debugger to continue, FUNCTION's execution proceeds.
! This works by modifying the definition of FUNCTION,
! which must be written in Lisp, not predefined.
  Use \\[cancel-debug-on-entry] to cancel the effect of this command.
  Redefining FUNCTION also cancels it."
    (interactive "aDebug on entry (to function): ")
--- 656,671 ----
  ;;;###autoload
  (defun debug-on-entry (function)
    "Request FUNCTION to invoke debugger each time it is called.
+ 
  When called interactively, prompt for FUNCTION in the minibuffer.
! 
! 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.
! 
  Use \\[cancel-debug-on-entry] to cancel the effect of this command.
  Redefining FUNCTION also cancels it."
    (interactive "aDebug on entry (to function): ")
Index: lispref/debugging.texi
===================================================================
RCS file: /cvsroot/emacs/emacs/lispref/debugging.texi,v
retrieving revision 1.31
diff -c -r1.31 debugging.texi
*** lispref/debugging.texi	11 Jun 2005 23:42:13 -0000	1.31
--- lispref/debugging.texi	13 Jun 2005 09:23:20 -0000
***************
*** 210,224 ****
  function, and then step through its caller.
  
  @deffn Command debug-on-entry function-name
! This function requests @var{function-name} to invoke the debugger each time
! it is called.  It works by inserting the form @code{(debug 'debug)} into
! the function definition as the first form.
! 
! Any function defined as Lisp code may be set to break on entry,
! regardless of whether it is interpreted code or compiled code.  If the
! function is a command, it will enter the debugger when called from Lisp
! and when called interactively (after the reading of the arguments).  You
! can't debug primitive functions (i.e., those written in C) this way.
  
  When @code{debug-on-entry} is called interactively, it prompts for
  @var{function-name} in the minibuffer.  If the function is already set
--- 210,227 ----
  function, and then step through its caller.
  
  @deffn Command debug-on-entry function-name
! This function requests @var{function-name} to invoke the debugger each
! time it is called.  It works by inserting the form
! @code{(implement-debug-on-entry)} into the function definition as the
! first form.
! 
! Any function or macro defined as Lisp code may be set to break on
! entry, regardless of whether it is interpreted code or compiled code.
! If the function is a command, it will enter the debugger when called
! from Lisp and when called interactively (after the reading of the
! arguments).  You can also debug primitive functions (i.e., those
! written in C) that are not special forms this way, but the primitive
! will only break on entry when it is called from Lisp.
  
  When @code{debug-on-entry} is called interactively, it prompts for
  @var{function-name} in the minibuffer.  If the function is already set

Re: debug-on-entry

[Richard Stallman]

These doc changes are good overall, except.

      You can also debug primitive functions (i.e., those
    ! written in C) that are not special forms this way, but the primitive
    ! will only break on entry when it is called from Lisp.

That's not very clear about how special forms are treated.  This is
clearer:

      You can also set debug-on-entry for primitive functions (i.e., those
      written in C) this way, but it only takes effect when the primitive
      is called from Lisp code.  Debug-on-entry is not allowed for 
      special forms.

With that change, please install it.

Re: debug-on-entry

[Lute Kamstra]

Richard Stallman <rms@gnu.org> writes:

> With that change, please install it.

Done.

Lute.