Re: debug declaration.

[Lute Kamstra]

Stefan Monnier <address@hidden> writes:

>> (declare (debug (sexp form form form form form &optional stringp)))
>
>> X(define-generic-mode my-mode
>>   (list ?# ?% (+ 50 9))
>>   (list "abba" "ebbe" (concat "ob" "bo"))
>>   nil
>>   X(list "\\.mm\\'")X
>>   nil
>>   "This is My mode.")X
>
> That's because when you execute the call to define-generic-mode, only the
> fourth argument is actually evaluated.  All the others will only be
> evaluated when the defined function is actually called.  I.e. it's normal.
>
> OTOH, with your definition you'll get bugs when you actually call my-mode
> because the instrumented code that's then executed is executed in an
> environment where edebugging is not expected.  To fix this problem, you need
> to use `def-form' instead of `form' for them.

It's dawning on me now...

> Try (debug (sexp def-form def-form def-form form def-form [&optional 
> stringp]))

This does indeed work.  (The brackets are not necessary, are they?)
The node "Specification List" in the lisp manual says that def-form
can only be used after &define, however.  And when I do that, things
seem to break.

I used:

  (declare (debug (&define sexp def-form def-form def-form form def-form 
&optional stringp)))

for define-generic-mode.  Then I did C-u C-M-x on this call:

  (define-generic-mode my-mode
    (list ?# ?% (+ 50 9))
    (list "abba" "ebbe" (concat "ob" "bo"))
    nil
    (list "\\.mm\\'")
    nil
    "This is My mode.")

Now I get an error:

Debugger entered--Lisp error: (wrong-type-argument consp nil)
  edebug-before(8)
  (edebug-after (edebug-before 8) 9 (list "\\.mm\\'"))
  (let ((--dolist-temp-- ...) re) (while --dolist-temp-- (setq re ...) (setq 
--dolist-temp-- ...) (add-to-list ... ...)))
  (dolist (re (edebug-after ... 9 ...)) (add-to-list (quote auto-mode-alist) 
(cons re ...)))
  (progn (add-to-list (quote generic-mode-list) "my-mode") (dolist (re ...) 
(add-to-list ... ...)) (defun my-mode nil "This is My mode." (interactive) 
(generic-mode-internal ... ... ... ... ...)))
  (define-generic-mode my-mode (edebug-enter (quote my-mode) nil (function 
...)) (edebug-enter (quote my-mode) nil (function ...)) (edebug-enter (quote 
my-mode) nil (function ...)) (edebug-after (edebug-before 8) 9 (list 
"\\.mm\\'")) (edebug-enter (quote my-mode) nil (function ...)) "This is My 
mode.")
  eval((define-generic-mode my-mode (edebug-enter (quote my-mode) nil (function 
...)) (edebug-enter (quote my-mode) nil (function ...)) (edebug-enter (quote 
my-mode) nil (function ...)) (edebug-after (edebug-before 8) 9 (list 
"\\.mm\\'")) (edebug-enter (quote my-mode) nil (function ...)) "This is My 
mode."))
  eval-defun((4))
  call-interactively(eval-defun)

> Another option is to evaluate those arguments before you plug them in the
> body of your major mode function, so they're only evaluated once, when
> the major mode is defined, thus reproducing the "pre-macro" behavior.

Considering backward compatibility, that's probably the right thing to do.

Thanks for the help,

Lute.